@qwen-code/qwen-code 0.21.12-preview.3 → 0.21.12

package/chunks/{chunk-SAQHDAUJ.js → chunk-DPTMKFIH.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runSideQuery
-} from "./chunk-CTQE2NB2.js";
+} from "./chunk-LSRI3ND3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -89,6 +89,7 @@ var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
   "rewind",
   "agent_bootstrap",
   "agent_launch_prompt",
+  "agent_retry",
   "file_history_snapshot",
   "session_source",
   "goal_state",
@@ -477,6 +478,278 @@ var InvalidGoalEvidenceReferenceError = class extends Error {
     __name(this, "InvalidGoalEvidenceReferenceError");
   }
 };
+var GoalEvidenceRecordIndexAccumulator = class {
+  static {
+    __name(this, "GoalEvidenceRecordIndexAccumulator");
+  }
+  uuid;
+  parsedGoalContext;
+  claimedGoalId;
+  claimedRevision;
+  provenance;
+  hasObjectSystemPayload;
+  displayText;
+  hasHookContext;
+  prefixPreview = "";
+  lastPartPreviewValues = [];
+  lastPartIsHookContext = false;
+  partCount = 0;
+  hasRawEligibleContent = false;
+  constructor(record) {
+    this.uuid = record.uuid;
+    this.parsedGoalContext = parseGoalContext(record.goalContext);
+    const claimed = isRecord(record.goalContext) ? record.goalContext : void 0;
+    this.claimedGoalId = typeof claimed?.["goalId"] === "string" ? claimed["goalId"] : void 0;
+    this.claimedRevision = typeof claimed?.["revision"] === "number" ? claimed["revision"] : void 0;
+    this.provenance = this.parsedGoalContext ? coherentEvidenceProvenance(record) : void 0;
+    const systemPayload = isRecord(record.systemPayload) ? record.systemPayload : void 0;
+    this.hasObjectSystemPayload = systemPayload !== void 0;
+    this.displayText = typeof systemPayload?.["displayText"] === "string" ? systemPayload["displayText"].slice(0, CATALOG_PREVIEW_LIMIT) : void 0;
+    this.hasHookContext = typeof systemPayload?.["hookContext"] === "string";
+    this.addFragment(record);
+  }
+  addFragment(record) {
+    if (!this.provenance) return;
+    for (const part of record.message?.parts ?? []) {
+      this.finishPreviousPart();
+      const previewValues = [];
+      if (part.thought !== true && typeof part.text === "string") {
+        previewValues.push(part.text.slice(0, CATALOG_PREVIEW_LIMIT));
+        if (part.text.trim()) this.hasRawEligibleContent = true;
+      }
+      if (this.provenance === "tool_result" && part.functionResponse) {
+        previewValues.push(renderToolResponsePreview(part.functionResponse));
+        if (part.functionResponse.response !== void 0) {
+          this.hasRawEligibleContent = true;
+        }
+      }
+      this.lastPartPreviewValues = previewValues;
+      this.lastPartIsHookContext = typeof part.text === "string" && isUserPromptSubmitContextPartText(part.text);
+      this.partCount++;
+    }
+  }
+  finish() {
+    let preview;
+    const hasFinalHookContextPart = this.partCount > 1 && this.lastPartIsHookContext;
+    if (this.provenance === "real_user" && (this.hasHookContext || hasFinalHookContextPart) && this.displayText !== void 0) {
+      preview = this.displayText.slice(0, CATALOG_PREVIEW_LIMIT).trim();
+    } else if (this.provenance === "real_user" && !this.hasObjectSystemPayload && hasFinalHookContextPart) {
+      preview = this.prefixPreview.trim();
+    } else {
+      preview = appendPreviewValues(
+        this.prefixPreview,
+        this.lastPartPreviewValues
+      ).trim();
+    }
+    const catalogEntry = this.provenance && this.parsedGoalContext && preview ? {
+      uuid: this.uuid,
+      provenance: this.provenance,
+      turnId: this.parsedGoalContext.turnId,
+      preview,
+      proofKind: proofKindOf(this.provenance)
+    } : void 0;
+    return {
+      uuid: this.uuid,
+      ...this.parsedGoalContext ? { parsedGoalContext: this.parsedGoalContext } : {},
+      ...this.claimedGoalId !== void 0 ? { claimedGoalId: this.claimedGoalId } : {},
+      ...this.claimedRevision !== void 0 ? { claimedRevision: this.claimedRevision } : {},
+      ...this.provenance ? { provenance: this.provenance } : {},
+      hasCatalogEligibleContent: catalogEntry !== void 0,
+      hasRawEligibleContent: this.hasRawEligibleContent,
+      ...catalogEntry ? {
+        catalogEntryBytes: Buffer.byteLength(
+          JSON.stringify(catalogEntry),
+          "utf8"
+        )
+      } : {}
+    };
+  }
+  finishPreviousPart() {
+    if (this.partCount === 0) return;
+    this.prefixPreview = appendPreviewValues(
+      this.prefixPreview,
+      this.lastPartPreviewValues
+    );
+  }
+};
+function appendPreviewValues(current, values) {
+  let preview = current;
+  for (const value of values) {
+    if (!value || preview.length >= CATALOG_PREVIEW_LIMIT) continue;
+    const separator = preview ? "\n" : "";
+    const remaining = CATALOG_PREVIEW_LIMIT - preview.length;
+    preview += `${separator}${value}`.slice(0, remaining);
+  }
+  return preview;
+}
+__name(appendPreviewValues, "appendPreviewValues");
+var GoalEvidenceCheckpointAccumulator = class {
+  constructor(hints, goal, permit) {
+    this.goal = goal;
+    if (permit.goalId !== goal.goalId || permit.revision !== goal.revision || !isNonEmptyString(permit.turnId)) {
+      throw new EvidenceSourceUnavailableError(
+        "permit_goal_mismatch",
+        "The current Goal permit does not match the Goal evidence revision."
+      );
+    }
+    const indexByUuid = /* @__PURE__ */ new Map();
+    for (let index = 0; index < hints.length; index++) {
+      const uuid = hints[index].uuid;
+      if (indexByUuid.has(uuid)) {
+        throw new EvidenceSourceUnavailableError(
+          "duplicate_record_uuid",
+          `The active transcript chain contains duplicate record UUID ${uuid}.`
+        );
+      }
+      indexByUuid.set(uuid, index);
+    }
+    const cursorId = goal.evidenceCursor.recordId;
+    if (cursorId === null) {
+      throw new EvidenceSourceUnavailableError(
+        "cursor_unset",
+        "The Goal evidence cursor is not available."
+      );
+    }
+    const cursorIndex = indexByUuid.get(cursorId);
+    if (cursorIndex === void 0) {
+      throw new EvidenceSourceUnavailableError(
+        "cursor_not_found",
+        `The Goal evidence cursor ${cursorId} is not in the active transcript chain.`
+      );
+    }
+    const lineageTurnIds = [];
+    const seenTurnIds = /* @__PURE__ */ new Set();
+    let currentTurnId;
+    for (let index = cursorIndex + 1; index < hints.length; index++) {
+      const hint = hints[index];
+      const context = hint.parsedGoalContext;
+      if (!context) {
+        if (hint.claimedGoalId === goal.goalId && hint.claimedRevision === goal.revision) {
+          throw new EvidenceSourceUnavailableError(
+            "malformed_turn_context",
+            `Goal-owned transcript record ${hint.uuid} has malformed turn context.`
+          );
+        }
+        continue;
+      }
+      if (context.goalId !== goal.goalId || context.revision !== goal.revision) {
+        continue;
+      }
+      if (context.turnId === currentTurnId) continue;
+      if (seenTurnIds.has(context.turnId)) {
+        throw new EvidenceSourceUnavailableError(
+          "turn_reentry",
+          `Goal turn ${context.turnId} re-enters the active transcript lineage.`
+        );
+      }
+      seenTurnIds.add(context.turnId);
+      lineageTurnIds.push(context.turnId);
+      currentTurnId = context.turnId;
+    }
+    if (lineageTurnIds.at(-1) !== permit.turnId) {
+      throw new EvidenceSourceUnavailableError(
+        "current_turn_not_tail",
+        "The current Goal permit is not the tail of the active transcript lineage."
+      );
+    }
+    this.checkpointEntries = checkpointCatalogEntries(goal);
+    const checkpointBytes = this.checkpointEntries.reduce(
+      (total, entry) => total + Buffer.byteLength(JSON.stringify(entry), "utf8"),
+      0
+    );
+    let truncated = this.checkpointEntries.length >= CATALOG_ENTRY_LIMIT || checkpointBytes > CATALOG_BYTE_LIMIT;
+    const rawEntryLimit = Math.max(
+      0,
+      CATALOG_ENTRY_LIMIT - this.checkpointEntries.length
+    );
+    let catalogBytes = checkpointBytes;
+    for (let index = hints.length - 1; !truncated && index > cursorIndex; index--) {
+      const hint = hints[index];
+      const context = hint.parsedGoalContext;
+      if (!hint.provenance || !context || context.goalId !== goal.goalId || context.revision !== goal.revision) {
+        continue;
+      }
+      if (this.candidateUuids.length >= rawEntryLimit) {
+        if (hint.hasRawEligibleContent) {
+          truncated = true;
+          break;
+        }
+        continue;
+      }
+      if (!hint.hasCatalogEligibleContent) continue;
+      const entryBytes = hint.catalogEntryBytes;
+      if (entryBytes === void 0 || catalogBytes + entryBytes > CATALOG_BYTE_LIMIT) {
+        truncated = true;
+        break;
+      }
+      this.candidateUuids.push(hint.uuid);
+      this.candidateUuidSet.add(hint.uuid);
+      catalogBytes += entryBytes;
+    }
+    this.truncated = truncated;
+    this.shouldCheckpoint = !truncated && this.candidateUuids.length > 0 && (this.checkpointEntries.length + this.candidateUuids.length >= CHECKPOINT_ENTRY_THRESHOLD || catalogBytes >= CHECKPOINT_BYTE_THRESHOLD);
+  }
+  static {
+    __name(this, "GoalEvidenceCheckpointAccumulator");
+  }
+  candidateUuids = [];
+  candidateUuidSet = /* @__PURE__ */ new Set();
+  captured = /* @__PURE__ */ new Map();
+  checkpointEntries;
+  truncated;
+  shouldCheckpoint;
+  getCandidateUuids() {
+    return this.shouldCheckpoint ? this.candidateUuids : [];
+  }
+  capture(record) {
+    if (!this.shouldCheckpoint || !this.candidateUuidSet.has(record.uuid)) {
+      return;
+    }
+    const provenance = coherentEvidenceProvenance(record);
+    if (!provenance) return;
+    const context = parseGoalContext(record.goalContext);
+    if (!context || context.goalId !== this.goal.goalId || context.revision !== this.goal.revision) {
+      return;
+    }
+    const preview = evidencePreview(record, provenance);
+    const content = evidenceContent(record, provenance);
+    if (!preview || !content) return;
+    this.captured.set(record.uuid, {
+      uuid: record.uuid,
+      provenance,
+      turnId: context.turnId,
+      preview,
+      proofKind: proofKindOf(provenance),
+      content: capCheckpointContent(content)
+    });
+  }
+  finish() {
+    const selected = this.shouldCheckpoint ? this.candidateUuids.map((uuid) => {
+      const entry = this.captured.get(uuid);
+      if (!entry) {
+        throw new InvalidGoalEvidenceReferenceError(
+          "ineligible_reference",
+          `Transcript record ${uuid} has no eligible evidence content.`,
+          uuid
+        );
+      }
+      return entry;
+    }) : [];
+    selected.reverse();
+    return {
+      previousClaims: structuredClone(
+        this.goal.evidenceCheckpoint?.claims ?? []
+      ),
+      evidence: selected,
+      truncated: this.truncated,
+      shouldCheckpoint: this.shouldCheckpoint
+    };
+  }
+};
+function getGoalEvidenceRecordIndexHint(record) {
+  return new GoalEvidenceRecordIndexAccumulator(record).finish();
+}
+__name(getGoalEvidenceRecordIndexHint, "getGoalEvidenceRecordIndexHint");
 function buildGoalEvidenceCatalog(input) {
   const analysis = analyzeEvidence(input);
   return {
@@ -487,32 +760,19 @@ function buildGoalEvidenceCatalog(input) {
 }
 __name(buildGoalEvidenceCatalog, "buildGoalEvidenceCatalog");
 function buildGoalEvidenceCheckpointWindow(input) {
-  const analysis = analyzeEvidence(input);
-  const rawEntries = analysis.catalog.filter(
-    (entry) => entry.provenance !== "goal_checkpoint"
+  const accumulator = new GoalEvidenceCheckpointAccumulator(
+    input.records.map(getGoalEvidenceRecordIndexHint),
+    input.goal,
+    input.permit
   );
-  const shouldCheckpoint = !analysis.catalogTruncated && rawEntries.length > 0 && (analysis.catalog.length >= CHECKPOINT_ENTRY_THRESHOLD || analysis.catalogBytes >= CHECKPOINT_BYTE_THRESHOLD);
-  const evidence = (shouldCheckpoint ? rawEntries : []).map((entry) => {
-    const recordIndex = analysis.indexByUuid.get(entry.uuid);
-    const record = recordIndex === void 0 ? void 0 : input.records[recordIndex];
-    const content = record ? evidenceContent(record, entry.provenance) : "";
-    if (!content) {
-      throw new InvalidGoalEvidenceReferenceError(
-        "ineligible_reference",
-        `Transcript record ${entry.uuid} has no eligible evidence content.`,
-        entry.uuid
-      );
-    }
-    return { ...entry, content: capCheckpointContent(content) };
-  });
-  return {
-    previousClaims: structuredClone(
-      input.goal.evidenceCheckpoint?.claims ?? []
-    ),
-    evidence,
-    truncated: analysis.catalogTruncated,
-    shouldCheckpoint
-  };
+  const recordsByUuid = new Map(
+    input.records.map((record) => [record.uuid, record])
+  );
+  for (const uuid of accumulator.getCandidateUuids()) {
+    const record = recordsByUuid.get(uuid);
+    if (record) accumulator.capture(record);
+  }
+  return accumulator.finish();
 }
 __name(buildGoalEvidenceCheckpointWindow, "buildGoalEvidenceCheckpointWindow");
 function validateGoalEvidenceReferences(input) {
@@ -1633,20 +1893,30 @@ var LEGACY_STOPPED_KINDS = /* @__PURE__ */ new Set([
   "paused"
 ]);
 function recoverGoalFromRecords(records) {
+  return selectGoalRecoveryFromRecords(records).recovery;
+}
+__name(recoverGoalFromRecords, "recoverGoalFromRecords");
+function selectGoalRecoveryFromRecords(records) {
   let unsupported;
+  let unsupportedSourceUuid;
   for (let index = records.length - 1; index >= 0; index -= 1) {
     const record = records[index];
     if (record?.subtype !== "goal_state") continue;
     const payload = record.type === "system" ? parseGoalStateRecordPayloadV2(record.systemPayload) : void 0;
-    if (payload) return { kind: "v2", payload };
-    unsupported ??= {
-      kind: "unsupported",
-      reason: `Goal lifecycle record ${record.uuid} is malformed or uses an unsupported version`
-    };
+    if (payload) {
+      return { recovery: { kind: "v2", payload }, sourceUuid: record.uuid };
+    }
+    if (!unsupported) {
+      unsupported = {
+        kind: "unsupported",
+        reason: `Goal lifecycle record ${record.uuid} is malformed or uses an unsupported version`
+      };
+      unsupportedSourceUuid = record.uuid;
+    }
   }
-  return unsupported ?? recoverLegacyGoal(records);
+  return unsupported ? { recovery: unsupported, sourceUuid: unsupportedSourceUuid } : recoverLegacyGoal(records);
 }
-__name(recoverGoalFromRecords, "recoverGoalFromRecords");
+__name(selectGoalRecoveryFromRecords, "selectGoalRecoveryFromRecords");
 function recoverLegacyGoal(records) {
   for (let recordIndex = records.length - 1; recordIndex >= 0; recordIndex -= 1) {
     const record = records[recordIndex];
@@ -1663,18 +1933,71 @@ function recoverLegacyGoal(records) {
       const kind = value["kind"];
       const condition = value["condition"];
       if (typeof kind !== "string" || typeof condition !== "string") {
-        return unsupportedLegacy(record.uuid);
+        return {
+          recovery: unsupportedLegacy(record.uuid),
+          sourceUuid: record.uuid
+        };
+      }
+      if (LEGACY_STOPPED_KINDS.has(kind)) {
+        return { recovery: { kind: "none" }, sourceUuid: record.uuid };
       }
-      if (LEGACY_STOPPED_KINDS.has(kind)) return { kind: "none" };
       if (!LEGACY_ACTIVE_KINDS.has(kind) || condition.trim().length === 0) {
-        return unsupportedLegacy(record.uuid);
+        return {
+          recovery: unsupportedLegacy(record.uuid),
+          sourceUuid: record.uuid
+        };
       }
-      return { kind: "legacy", objective: condition.trim() };
+      return {
+        recovery: { kind: "legacy", objective: condition.trim() },
+        sourceUuid: record.uuid
+      };
     }
   }
-  return { kind: "none" };
+  return { recovery: { kind: "none" } };
 }
 __name(recoverLegacyGoal, "recoverLegacyGoal");
+function normalizeGoalRecoveryRecord(record) {
+  if (record.subtype === "goal_state") {
+    return {
+      uuid: record.uuid,
+      type: record.type,
+      subtype: record.subtype,
+      systemPayload: record.type === "system" ? parseGoalStateRecordPayloadV2(record.systemPayload) ?? null : null
+    };
+  }
+  if (record.type !== "system" || record.subtype !== "slash_command") {
+    return void 0;
+  }
+  const payload = record.systemPayload;
+  if (payload?.phase !== "result" || !Array.isArray(payload.outputHistoryItems)) {
+    return void 0;
+  }
+  const goalStatusItems = payload.outputHistoryItems.filter(
+    (value) => isObjectRecord2(value) && value["type"] === "goal_status"
+  );
+  if (goalStatusItems.length === 0) return void 0;
+  return {
+    uuid: record.uuid,
+    type: record.type,
+    subtype: record.subtype,
+    systemPayload: {
+      phase: "result",
+      outputHistoryItems: goalStatusItems
+    }
+  };
+}
+__name(normalizeGoalRecoveryRecord, "normalizeGoalRecoveryRecord");
+function isGoalRecoveryCandidate(record) {
+  if (record.subtype === "goal_state") return true;
+  if (record.type !== "system" || record.subtype !== "slash_command") {
+    return false;
+  }
+  const payload = record.systemPayload;
+  return payload?.phase === "result" && Array.isArray(payload.outputHistoryItems) && payload.outputHistoryItems.some(
+    (value) => isObjectRecord2(value) && value["type"] === "goal_status"
+  );
+}
+__name(isGoalRecoveryCandidate, "isGoalRecoveryCandidate");
 function unsupportedLegacy(recordUuid) {
   return {
     kind: "unsupported",
@@ -1762,6 +2085,12 @@ function createGoalRuntime(options) {
   let nextVerifierFeedback;
   let currentTurnFeedback;
   let restored = false;
+  let restoreActivationPending = false;
+  let restorePreparation;
+  let restoreActivation;
+  let preparedRestoreCause;
+  let preparedRestoreHasSnapshot = false;
+  let preparedCheckpointWindow;
   let disposed = false;
   let recoveryError;
   let recoveryCause;
@@ -1861,7 +2190,7 @@ function createGoalRuntime(options) {
     void started.catch(handleStartFailure);
   }, "flushContinuation");
   const queueContinuation = /* @__PURE__ */ __name((cause) => {
-    if (snapshot.goal?.status !== "active" || currentPermit || pendingProposal || verificationAttempt || checkpointAttempt) {
+    if (restoreActivationPending || snapshot.goal?.status !== "active" || currentPermit || pendingProposal || verificationAttempt || checkpointAttempt) {
       return;
     }
     continuationQueued = true;
@@ -2214,10 +2543,10 @@ function createGoalRuntime(options) {
       }
     });
   }, "recordCheckpoint");
-  const runCheckpoint = /* @__PURE__ */ __name(async (attempt) => {
+  const runCheckpoint = /* @__PURE__ */ __name(async (attempt, preparedWindow) => {
     const evidenceSource = options.evidenceSource;
     const checkpointVerifier = options.checkpointVerifier;
-    if (!evidenceSource || !checkpointVerifier) {
+    if (!preparedWindow && !evidenceSource || !checkpointVerifier) {
       await recordCheckpointFailure(
         attempt,
         "Goal checkpoint recovery dependencies are unavailable"
@@ -2225,15 +2554,18 @@ function createGoalRuntime(options) {
       return;
     }
     try {
-      await evidenceSource.flush();
-      if (attempt.controller.signal.aborted) return;
-      const records = await evidenceSource.readActiveTranscriptChain();
-      if (attempt.controller.signal.aborted) return;
-      const window = buildGoalEvidenceCheckpointWindow({
-        records,
-        goal: attempt.goal,
-        permit: attempt.permit
-      });
+      let window = preparedWindow;
+      if (!window) {
+        await evidenceSource.flush();
+        if (attempt.controller.signal.aborted) return;
+        const records = await evidenceSource.readActiveTranscriptChain();
+        if (attempt.controller.signal.aborted) return;
+        window = buildGoalEvidenceCheckpointWindow({
+          records,
+          goal: attempt.goal,
+          permit: attempt.permit
+        });
+      }
       if (window.truncated) {
         await recordCheckpointFailure(
           attempt,
@@ -2300,8 +2632,11 @@ function createGoalRuntime(options) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
-    restore(records) {
-      const restoring = enqueue(
+    prepareRestore(records, checkpointWindow) {
+      if (restorePreparation) return restorePreparation.then(() => void 0);
+      restoreActivationPending = true;
+      preparedCheckpointWindow = checkpointWindow;
+      const preparation = enqueue(
         async () => {
           assertAvailable();
           if (restored) return;
@@ -2359,14 +2694,15 @@ function createGoalRuntime(options) {
               recoveredSnapshot = structuredClone(payload.snapshot);
               recoveredCause = payload.cause;
             }
+            assertAvailable();
             if (recoveredSnapshot) snapshot = recoveredSnapshot;
             recoveryError = void 0;
             restored = true;
             if (recoveredSnapshot) {
               recoveryCause = recoveredCause;
-              broadcast(recoveredCause);
             }
-            if (!checkpointAttempt) queueContinuation();
+            preparedRestoreHasSnapshot = recoveredSnapshot !== void 0;
+            preparedRestoreCause = recoveredCause;
             return checkpointAttempt;
           } catch (error) {
             if (!disposed) {
@@ -2376,14 +2712,66 @@ function createGoalRuntime(options) {
           }
         }
       );
-      return restoring.then(async (attempt) => {
-        if (!attempt) return;
+      restorePreparation = preparation;
+      return preparation.then(
+        () => void 0,
+        (error) => {
+          if (!restored && restorePreparation === preparation) {
+            restorePreparation = void 0;
+            restoreActivation = void 0;
+            restoreActivationPending = false;
+            preparedCheckpointWindow = void 0;
+          }
+          throw error;
+        }
+      );
+    },
+    getPreparedRestore() {
+      if (!restorePreparation) {
+        return Promise.reject(
+          new GoalPersistenceUnavailableError(
+            "Goal restore preparation has not started"
+          )
+        );
+      }
+      return restorePreparation.then(() => void 0);
+    },
+    activateRestoredWork() {
+      try {
+        assertAvailable();
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      if (!restorePreparation) {
+        return Promise.reject(
+          new GoalPersistenceUnavailableError(
+            "Goal restore preparation has not started"
+          )
+        );
+      }
+      if (restoreActivation) return restoreActivation;
+      restoreActivation = restorePreparation.then(async (attempt) => {
+        assertAvailable();
+        restoreActivationPending = false;
+        if (preparedRestoreHasSnapshot) broadcast(preparedRestoreCause);
+        if (!attempt) {
+          await enqueue(async () => {
+            assertAvailable();
+            queueContinuation();
+          });
+          return;
+        }
         try {
-          await runCheckpoint(attempt);
+          await runCheckpoint(attempt, preparedCheckpointWindow);
         } catch {
           await settleDanglingAttempt(attempt.permit);
         }
       });
+      return restoreActivation;
+    },
+    async restore(records) {
+      await this.prepareRestore(records);
+      await this.activateRestoredWork();
     },
     bindHost(nextHost) {
       assertOperational();
@@ -2753,11 +3141,18 @@ export {
   aggregateTranscriptRecordFragments,
   prepareTranscriptRecords,
   GOAL_EVIDENCE_REFERENCE_LIMIT,
+  EvidenceSourceUnavailableError,
+  InvalidGoalEvidenceReferenceError,
+  GoalEvidenceRecordIndexAccumulator,
+  GoalEvidenceCheckpointAccumulator,
   createGoalCheckpointVerifier,
   elapsedActiveTime,
   parseGoalStateRecordPayloadV2,
   parseGoalSnapshotV2,
   parseGoalStateCause,
+  selectGoalRecoveryFromRecords,
+  normalizeGoalRecoveryRecord,
+  isGoalRecoveryCandidate,
   GOAL_RUNTIME_DISPOSED_MESSAGE,
   STALE_GOAL_TURN_MESSAGE,
   GoalPersistenceUnavailableError,