@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{chunk-LDGWX737.js → chunk-XLLQJRAH.js}

@@ -1,8 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isUserPromptSubmitContextPartText,
+  projectUserTranscriptForDisplay
+} from "./chunk-7J6OTNGO.js";
 import {
   runSideQuery
-} from "./chunk-ZRYQMWEP.js";
+} from "./chunk-BWORX6FA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,8 +25,19 @@ var GOAL_CHECKPOINT_CLAIM_MAX_BYTES = 16e3;
 var GOAL_CHECKPOINT_SOURCE_REFERENCE_LIMIT = 32;
 var GOAL_EVIDENCE_CATALOG_EXHAUSTED_REASON = "The current Goal revision exceeded the bounded evidence catalog. Automatic retries cannot recover. Edit or replace the Goal before resuming it.";
 var GOAL_CHECKPOINT_REQUEST_TOO_LARGE_REASON = "The current Goal revision exceeded the checkpoint verifier request limit. Automatic retries cannot recover. Edit or replace the Goal before resuming it.";
+var GOAL_CHECKPOINT_STALL_LIMIT = 3;
+var GOAL_CHECKPOINT_STALLED_REASON = "The current Goal revision ran three consecutive evidence checkpoints without relief: the evidence window overflowed every time, and each check either came back with a full claim list or a result that could not be folded into claims at all, so every turn paid a checkpoint call and lost uncatalogued evidence. Automatic retries cannot recover. Edit or replace the Goal with a narrower objective before resuming it.";
+var GOAL_DEFAULT_TOKEN_BUDGET = 3e7;
+function goalTokenBudgetReason(tokenBudget) {
+  return `The Goal spent its autonomous token budget (${tokenBudget.toLocaleString("en-US")} tokens). Resume the Goal to authorize another budget window, or clear it.`;
+}
+__name(goalTokenBudgetReason, "goalTokenBudgetReason");
+function isGoalTokenBudgetSpent(goal) {
+  return goal.tokenBudget !== void 0 && goal.tokensUsed >= goal.tokenBudget;
+}
+__name(isGoalTokenBudgetSpent, "isGoalTokenBudgetSpent");
 function isGoalLimitKind(value) {
-  return value === "evidence_catalog" || value === "checkpoint_request";
+  return value === "evidence_catalog" || value === "checkpoint_request" || value === "token_budget";
 }
 __name(isGoalLimitKind, "isGoalLimitKind");
 function goalLimitKindForReason(reason) {
@@ -49,9 +64,10 @@ function goalRequiresExactPermit(snapshot) {
 }
 __name(goalRequiresExactPermit, "goalRequiresExactPermit");
 function isRepeatedBlockerProposal(proposal) {
-  return proposal.status === "blocked" && proposal.blockerKind !== "authority" && proposal.blockerKind !== "external";
+  return proposal.status === "blocked" && proposal.blockerKind !== "authority" && proposal.blockerKind !== "external" && proposal.blockerKind !== "infeasible";
 }
 __name(isRepeatedBlockerProposal, "isRepeatedBlockerProposal");
+var GOAL_INFEASIBLE_NEXT_STEP = "The objective cannot be satisfied as written; edit or replace the Goal with an objective the evidence allows before resuming it.";
 function validateGoalProposalReason(reason) {
   if (!reason.trim()) return "Goal proposal reason must not be empty";
   if ([...reason].length > GOAL_PROPOSAL_REASON_MAX_CHARACTERS) {
@@ -64,406 +80,10 @@ function validateGoalProposalReason(reason) {
 }
 __name(validateGoalProposalReason, "validateGoalProposalReason");
 
-// packages/core/src/utils/transcript-records.ts
-init_esbuild_shims();
-var USER_PROMPT_SUBMIT_CONTEXT_OPEN = "<qwen:user-prompt-submit-context>";
-var USER_PROMPT_SUBMIT_CONTEXT_CLOSE = "</qwen:user-prompt-submit-context>";
-var TranscriptRecordPreparationError = class extends TypeError {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "TranscriptRecordPreparationError";
-  }
-  static {
-    __name(this, "TranscriptRecordPreparationError");
-  }
-};
-var RECORD_TYPES = /* @__PURE__ */ new Set([
-  "user",
-  "assistant",
-  "tool_result",
-  "system"
-]);
-var ARTIFACT_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
-  "session_artifact_event",
-  "session_artifact_snapshot"
-]);
-var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
-  "chat_compression",
-  "slash_command",
-  "ui_telemetry",
-  "at_command",
-  "attribution_snapshot",
-  "notification",
-  "cron",
-  "mid_turn_user_message",
-  "realtime_message",
-  "custom_title",
-  "parent_session",
-  "rewind",
-  "agent_bootstrap",
-  "agent_launch_prompt",
-  "agent_retry",
-  "file_history_snapshot",
-  "session_source",
-  "branch_checkpoint",
-  "goal_state",
-  "goal_runtime",
-  "turn_result",
-  ...ARTIFACT_RECORD_SUBTYPES
-]);
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-__name(isObjectRecord, "isObjectRecord");
-function wrapUserPromptSubmitContext(context) {
-  return `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
-${context}
-${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
-}
-__name(wrapUserPromptSubmitContext, "wrapUserPromptSubmitContext");
-function isUserPromptSubmitContextPartText(text) {
-  const trimmed = text.trim();
-  const prefix = `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
-`;
-  const suffix = `
-${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
-  if (!trimmed.startsWith(prefix) || !trimmed.endsWith(suffix)) {
-    return false;
-  }
-  const body = trimmed.slice(prefix.length, -suffix.length);
-  return !body.includes(USER_PROMPT_SUBMIT_CONTEXT_OPEN) && !body.includes(USER_PROMPT_SUBMIT_CONTEXT_CLOSE);
-}
-__name(isUserPromptSubmitContextPartText, "isUserPromptSubmitContextPartText");
-function isUserPromptSubmitContextPart(part) {
-  return isObjectRecord(part) && typeof part["text"] === "string" && isUserPromptSubmitContextPartText(part["text"]);
-}
-__name(isUserPromptSubmitContextPart, "isUserPromptSubmitContextPart");
-function projectUserTranscriptForDisplay(record) {
-  const parts = record.message?.parts ?? [];
-  const hasFinalHookContextPart = parts.length > 1 && isUserPromptSubmitContextPart(parts[parts.length - 1]);
-  const payload = isObjectRecord(record.systemPayload) ? record.systemPayload : void 0;
-  const isUserPromptPayload = payload && (typeof payload["hookContext"] === "string" || hasFinalHookContextPart);
-  const displayText = isUserPromptPayload && typeof payload["displayText"] === "string" ? payload["displayText"] : void 0;
-  if (displayText !== void 0) {
-    const visibleParts = parts.filter(
-      (part) => !isObjectRecord(part) || typeof part["text"] !== "string"
-    );
-    return { displayText, parts: visibleParts };
-  }
-  if (payload === void 0 && hasFinalHookContextPart) {
-    return { displayText: void 0, parts: parts.slice(0, -1) };
-  }
-  return { displayText: void 0, parts };
-}
-__name(projectUserTranscriptForDisplay, "projectUserTranscriptForDisplay");
-function diagnostic(code, message, affectsCompleteness, fields = {}, severity = affectsCompleteness ? "warning" : "info") {
-  return {
-    code,
-    severity,
-    message,
-    affectsCompleteness,
-    ...fields
-  };
-}
-__name(diagnostic, "diagnostic");
-function isTranscriptConversationRecord(record) {
-  return !isTranscriptArtifactRecord(record);
-}
-__name(isTranscriptConversationRecord, "isTranscriptConversationRecord");
-function isTranscriptArtifactRecord(record) {
-  return record.type === "system" && typeof record.subtype === "string" && ARTIFACT_RECORD_SUBTYPES.has(record.subtype);
-}
-__name(isTranscriptArtifactRecord, "isTranscriptArtifactRecord");
-function validateTranscriptRecord(value, recordIndex) {
-  const diagnostics = [];
-  if (!isObjectRecord(value)) {
-    diagnostics.push(
-      diagnostic(
-        "invalid_record",
-        "Skipped a transcript record that is not an object.",
-        true,
-        { recordIndex }
-      )
-    );
-    return { diagnostics };
-  }
-  const uuid = value["uuid"];
-  const parentUuid = value["parentUuid"];
-  const sessionId = value["sessionId"];
-  const type = value["type"];
-  const recordId = typeof uuid === "string" ? uuid : void 0;
-  if (typeof uuid !== "string" || uuid.length === 0 || typeof parentUuid !== "string" && parentUuid !== null || typeof sessionId !== "string" || sessionId.length === 0) {
-    diagnostics.push(
-      diagnostic(
-        "invalid_record",
-        "Skipped a transcript record with invalid identity fields.",
-        true,
-        { recordIndex, recordId }
-      )
-    );
-    return { diagnostics };
-  }
-  if (typeof type !== "string" || !RECORD_TYPES.has(type)) {
-    diagnostics.push(
-      diagnostic(
-        "unknown_record_or_part",
-        "Skipped a transcript record with an unknown record type.",
-        true,
-        { recordIndex, recordId }
-      )
-    );
-    return { diagnostics };
-  }
-  const timestamp = value["timestamp"];
-  if (timestamp !== void 0 && (typeof timestamp !== "string" || !Number.isFinite(new Date(timestamp).getTime()))) {
-    diagnostics.push(
-      diagnostic(
-        "invalid_timestamp",
-        "Ignored an invalid transcript record timestamp.",
-        false,
-        { recordIndex, recordId, path: "timestamp" }
-      )
-    );
-  }
-  const subtype = value["subtype"];
-  if (subtype !== void 0 && (typeof subtype !== "string" || !KNOWN_RECORD_SUBTYPES.has(subtype))) {
-    diagnostics.push(
-      diagnostic(
-        "unknown_record_or_part",
-        "The transcript record has an unknown subtype.",
-        true,
-        { recordIndex, recordId, path: "subtype" }
-      )
-    );
-  }
-  let message;
-  if (value["message"] !== void 0) {
-    if (!isObjectRecord(value["message"])) {
-      diagnostics.push(
-        diagnostic(
-          "malformed_part",
-          "Ignored a malformed transcript message payload.",
-          true,
-          { recordIndex, recordId, path: "message" }
-        )
-      );
-    } else {
-      const parts = value["message"]["parts"];
-      if (parts !== void 0 && !Array.isArray(parts)) {
-        diagnostics.push(
-          diagnostic(
-            "malformed_part",
-            "Ignored malformed transcript message parts.",
-            true,
-            { recordIndex, recordId, path: "message.parts" }
-          )
-        );
-      }
-      message = {
-        ...typeof value["message"]["role"] === "string" ? { role: value["message"]["role"] } : {},
-        ...Array.isArray(parts) ? { parts } : {}
-      };
-    }
-  }
-  return {
-    record: {
-      ...value,
-      uuid,
-      parentUuid,
-      sessionId,
-      type,
-      ...typeof subtype === "string" ? { subtype } : { subtype: void 0 },
-      ...typeof timestamp === "string" && Number.isFinite(new Date(timestamp).getTime()) ? { timestamp } : { timestamp: void 0 },
-      ...message ? { message } : { message: void 0 }
-    },
-    diagnostics
-  };
-}
-__name(validateTranscriptRecord, "validateTranscriptRecord");
-function selectTranscriptLeaf(records, leafUuid) {
-  if (leafUuid !== void 0) {
-    return records.some(
-      (record) => record.uuid === leafUuid && isTranscriptConversationRecord(record)
-    ) ? leafUuid : void 0;
-  }
-  for (let index = records.length - 1; index >= 0; index -= 1) {
-    const record = records[index];
-    if (record && isTranscriptConversationRecord(record)) return record.uuid;
-  }
-  return void 0;
-}
-__name(selectTranscriptLeaf, "selectTranscriptLeaf");
-function walkTranscriptUuidChain(leafUuid, lookup) {
-  const uuids = [];
-  const gaps = [];
-  const visited = /* @__PURE__ */ new Set();
-  let currentUuid = leafUuid;
-  let cycleUuid;
-  while (currentUuid) {
-    if (visited.has(currentUuid)) {
-      cycleUuid = currentUuid;
-      break;
-    }
-    visited.add(currentUuid);
-    const record = lookup(currentUuid);
-    if (!record) break;
-    uuids.push(currentUuid);
-    if (!record.parentUuid) break;
-    if (!lookup(record.parentUuid)) {
-      gaps.push({
-        childUuid: currentUuid,
-        missingParentUuid: record.parentUuid
-      });
-      break;
-    }
-    currentUuid = record.parentUuid;
-  }
-  uuids.reverse();
-  return { uuids, gaps, ...cycleUuid ? { cycleUuid } : {} };
-}
-__name(walkTranscriptUuidChain, "walkTranscriptUuidChain");
-function aggregateTranscriptRecordFragments(records) {
-  const first = records[0];
-  if (!first) {
-    throw new Error("Cannot aggregate empty transcript record array");
-  }
-  const base = { ...first };
-  let message = first.message ? { ...first.message, parts: [...first.message.parts ?? []] } : void 0;
-  for (let index = 1; index < records.length; index += 1) {
-    const record = records[index];
-    if (record.message !== void 0) {
-      message = message ? {
-        role: message.role,
-        parts: [...message.parts ?? [], ...record.message.parts ?? []]
-      } : { ...record.message, parts: [...record.message.parts ?? []] };
-    }
-    if (record.usageMetadata) base["usageMetadata"] = record.usageMetadata;
-    if (record.toolCallResult && !base["toolCallResult"]) {
-      base["toolCallResult"] = record.toolCallResult;
-    }
-    if (record.model && !base["model"]) base["model"] = record.model;
-    if (record.timestamp && (!base["timestamp"] || record.timestamp > String(base["timestamp"]))) {
-      base["timestamp"] = record.timestamp;
-    }
-  }
-  base["message"] = message;
-  return base;
-}
-__name(aggregateTranscriptRecordFragments, "aggregateTranscriptRecordFragments");
-function prepareTranscriptRecords(values, options = {}) {
-  if (!Array.isArray(values)) {
-    throw new TranscriptRecordPreparationError(
-      "invalid_records",
-      "Transcript records must be an array."
-    );
-  }
-  const diagnostics = [];
-  const records = [];
-  const sourceIndexByRecord = /* @__PURE__ */ new Map();
-  for (let index = 0; index < values.length; index += 1) {
-    const validated = validateTranscriptRecord(values[index], index);
-    diagnostics.push(...validated.diagnostics);
-    if (validated.record) {
-      records.push(validated.record);
-      sourceIndexByRecord.set(validated.record, index);
-    }
-  }
-  const sessionIds = new Set(records.map((record) => record.sessionId));
-  if (sessionIds.size > 1) {
-    throw new TranscriptRecordPreparationError(
-      "mixed_session_ids",
-      "Transcript records contain multiple session ids."
-    );
-  }
-  const leafUuid = selectTranscriptLeaf(records, options.leafUuid);
-  if (options.leafUuid !== void 0 && leafUuid === void 0) {
-    throw new TranscriptRecordPreparationError(
-      "leaf_not_found",
-      "The requested transcript leaf was not found."
-    );
-  }
-  if (!leafUuid) {
-    if (records.length > 0) {
-      diagnostics.push(
-        diagnostic(
-          "artifact_only",
-          "The input contains no conversation records.",
-          false
-        )
-      );
-    }
-    return {
-      ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
-      records: [],
-      gaps: [],
-      diagnostics
-    };
-  }
-  const fragmentsByUuid = /* @__PURE__ */ new Map();
-  const firstByUuid = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    if (!isTranscriptConversationRecord(record)) continue;
-    const fragments = fragmentsByUuid.get(record.uuid);
-    if (fragments) {
-      if (fragments[0].parentUuid !== record.parentUuid) {
-        diagnostics.push(
-          diagnostic(
-            "conflicting_parent_uuid",
-            "Duplicate transcript record fragments disagree on parentUuid.",
-            true,
-            {
-              recordIndex: sourceIndexByRecord.get(record),
-              recordId: record.uuid,
-              path: "parentUuid"
-            }
-          )
-        );
-      }
-      fragments.push(record);
-    } else {
-      fragmentsByUuid.set(record.uuid, [record]);
-      firstByUuid.set(record.uuid, record);
-    }
-  }
-  const chain = walkTranscriptUuidChain(
-    leafUuid,
-    (uuid) => firstByUuid.get(uuid)
-  );
-  for (const gap of chain.gaps) {
-    diagnostics.push(
-      diagnostic(
-        "history_gap",
-        "The active transcript chain is missing a parent record.",
-        true,
-        { recordId: gap.childUuid }
-      )
-    );
-  }
-  if (chain.cycleUuid) {
-    diagnostics.push(
-      diagnostic(
-        "parent_cycle",
-        "The active transcript chain contains a parent cycle.",
-        true,
-        { recordId: chain.cycleUuid }
-      )
-    );
-  }
-  return {
-    ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
-    records: chain.uuids.map(
-      (uuid) => aggregateTranscriptRecordFragments(fragmentsByUuid.get(uuid) ?? [])
-    ),
-    gaps: chain.gaps,
-    diagnostics
-  };
-}
-__name(prepareTranscriptRecords, "prepareTranscriptRecords");
-
 // packages/core/src/goals/goal-evidence.ts
 init_esbuild_shims();
 var CATALOG_PREVIEW_LIMIT = 240;
+var CATALOG_PREVIEW_BYTE_LIMIT = 240;
 var CATALOG_ENTRY_LIMIT = 100;
 var CATALOG_BYTE_LIMIT = 24e3;
 var CATALOG_LINEAGE_LIMIT = 16;
@@ -557,6 +177,7 @@ var GoalEvidenceRecordIndexAccumulator = class {
         this.lastPartPreviewValues
       ).trim();
     }
+    preview = capPreviewBytes(preview, CATALOG_PREVIEW_BYTE_LIMIT);
     const catalogEntry = this.provenance && this.parsedGoalContext && preview ? {
       uuid: this.uuid,
       provenance: this.provenance,
@@ -703,7 +324,7 @@ var GoalEvidenceCheckpointAccumulator = class {
       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);
+    this.shouldCheckpoint = this.candidateUuids.length > 0 && (truncated || this.checkpointEntries.length + this.candidateUuids.length >= CHECKPOINT_ENTRY_THRESHOLD || catalogBytes >= CHECKPOINT_BYTE_THRESHOLD);
   }
   static {
     __name(this, "GoalEvidenceCheckpointAccumulator");
@@ -1051,7 +672,13 @@ function repeatedBlockerCoverageCatalogued(analysis) {
 __name(repeatedBlockerCoverageCatalogued, "repeatedBlockerCoverageCatalogued");
 function validateBlockerCoverage(proposal, citedRecords, analysis) {
   if (proposal.status !== "blocked") return;
-  if (proposal.blockerKind === "authority" || proposal.blockerKind === "external") {
+  if (proposal.blockerKind === "infeasible" && !citedRecords.some(({ proofKind }) => proofKind === "external_fact")) {
+    throw new InvalidGoalEvidenceReferenceError(
+      "infeasible_blocker_external_fact_required",
+      "An infeasible blocker requires cited external tool evidence of the fact that makes the objective unsatisfiable."
+    );
+  }
+  if (proposal.blockerKind === "authority" || proposal.blockerKind === "external" || proposal.blockerKind === "infeasible") {
     if (!citedRecords.some(
       ({ proofKind }) => proofKind === "user_input" || proofKind === "external_fact"
     )) {
@@ -1099,7 +726,10 @@ function checkpointCatalogEntries(goal) {
     uuid: claim.id,
     provenance: "goal_checkpoint",
     turnId: `checkpoint:${checkpoint.checkpointId}`,
-    preview: claim.claim.slice(0, CATALOG_PREVIEW_LIMIT),
+    preview: capPreviewBytes(
+      claim.claim.slice(0, CATALOG_PREVIEW_LIMIT),
+      CATALOG_PREVIEW_BYTE_LIMIT
+    ),
     proofKind: claim.proofKind
   }));
 }
@@ -1168,6 +798,21 @@ function legacySafeProvenance(record) {
   return void 0;
 }
 __name(legacySafeProvenance, "legacySafeProvenance");
+function capPreviewBytes(value, limit) {
+  if (Buffer.byteLength(value, "utf8") <= limit) {
+    return value;
+  }
+  let byteLength = 0;
+  let cutoff = 0;
+  for (const codePoint of value) {
+    const codePointBytes = Buffer.byteLength(codePoint, "utf8");
+    if (byteLength + codePointBytes > limit) break;
+    byteLength += codePointBytes;
+    cutoff += codePoint.length;
+  }
+  return value.slice(0, cutoff);
+}
+__name(capPreviewBytes, "capPreviewBytes");
 function capCheckpointContent(content) {
   if (Buffer.byteLength(content, "utf8") <= CHECKPOINT_CONTENT_BYTE_LIMIT) {
     return content;
@@ -1206,7 +851,10 @@ __name(evidenceContent, "evidenceContent");
 function evidencePreview(record, provenance) {
   const projection = provenance === "real_user" ? projectUserTranscriptForDisplay(record) : void 0;
   if (projection?.displayText !== void 0) {
-    return projection.displayText.slice(0, CATALOG_PREVIEW_LIMIT).trim();
+    return capPreviewBytes(
+      projection.displayText.slice(0, CATALOG_PREVIEW_LIMIT).trim(),
+      CATALOG_PREVIEW_BYTE_LIMIT
+    );
   }
   let preview = "";
   const append = /* @__PURE__ */ __name((value) => {
@@ -1225,7 +873,7 @@ function evidencePreview(record, provenance) {
     }
     if (preview.length >= CATALOG_PREVIEW_LIMIT) break;
   }
-  return preview.trim();
+  return capPreviewBytes(preview.trim(), CATALOG_PREVIEW_BYTE_LIMIT);
 }
 __name(evidencePreview, "evidencePreview");
 function renderToolResponse(functionResponse) {
@@ -1346,7 +994,8 @@ function reduceGoalControl(current, transition) {
       transition.nextGoalId,
       normalizeObjective(request.objective, snapshotOf(null)),
       transition.now,
-      transition.cursor
+      transition.cursor,
+      transition.tokenBudgetGrant
     );
   }
   assertExpectedVersion(
@@ -1360,7 +1009,8 @@ function reduceGoalControl(current, transition) {
       transition.nextGoalId,
       normalizeObjective(request.objective, snapshotOf(current)),
       transition.now,
-      transition.cursor
+      transition.cursor,
+      transition.tokenBudgetGrant
     );
   }
   if (request.action === "edit") {
@@ -1375,6 +1025,8 @@ function reduceGoalControl(current, transition) {
       objective: normalizeObjective(request.objective, snapshotOf(current)),
       evidenceCursor: copyCursor(transition.cursor),
       evidenceCheckpoint: void 0,
+      checkpointStalls: void 0,
+      ...rearmedTokenBudget(current, transition.tokenBudgetGrant),
       lastReason: void 0,
       limitKind: void 0
     });
@@ -1400,17 +1052,34 @@ function reduceGoalControl(current, transition) {
       snapshotOf(current)
     );
   }
-  if (current.status === "usage_limited" && isEvidenceLimited(current)) {
-    throw new GoalInvalidTransitionError(
-      "An evidence-limited Goal cannot be resumed; edit or replace the Goal first",
-      snapshotOf(current)
-    );
+  if (request.action === "resume" && current.status === "usage_limited" && current.limitKind === "token_budget") {
+    return transitionGoal(current, transition.now, {
+      status: "active",
+      ...rearmedTokenBudget(current, transition.tokenBudgetGrant),
+      lastReason: void 0,
+      limitKind: void 0
+    });
   }
   if (request.action !== "resume") {
     return assertNever(request, snapshotOf(current));
   }
+  if (current.status === "usage_limited" && isEvidenceLimited(current)) {
+    return transitionGoal(current, transition.now, {
+      status: "active",
+      evidenceCursor: copyCursor(transition.cursor),
+      evidenceCheckpoint: void 0,
+      // The streak counts checkpoints against one window; this resume starts
+      // a different one, so carrying it over would spend the new window's
+      // allowance on the old window's failures.
+      checkpointStalls: void 0,
+      ...rearmedTokenBudget(current, transition.tokenBudgetGrant),
+      lastReason: void 0,
+      limitKind: void 0
+    });
+  }
   return transitionGoal(current, transition.now, {
-    status: "active"
+    status: "active",
+    ...rearmedTokenBudget(current, transition.tokenBudgetGrant)
   });
 }
 __name(reduceGoalControl, "reduceGoalControl");
@@ -1423,7 +1092,9 @@ function reduceGoalTurnFinished(current, transition) {
   }
   return transitionGoal(current, transition.now, {
     turnCount: current.turnCount + 1,
-    ...transition.lastReason === void 0 ? {} : { lastReason: transition.lastReason }
+    tokensUsed: current.tokensUsed + Math.max(0, transition.tokensUsed ?? 0),
+    ...transition.lastReason === void 0 ? {} : { lastReason: transition.lastReason },
+    ...transition.windDownTurnId === void 0 ? {} : { windDownTurnId: transition.windDownTurnId }
   });
 }
 __name(reduceGoalTurnFinished, "reduceGoalTurnFinished");
@@ -1526,7 +1197,7 @@ function parseGoalStateCause(value) {
   return isGoalStateCause(value) ? value : void 0;
 }
 __name(parseGoalStateCause, "parseGoalStateCause");
-function createGoal(goalId, objective, now, cursor) {
+function createGoal(goalId, objective, now, cursor, tokenBudget) {
   return {
     goalId,
     revision: 1,
@@ -1535,6 +1206,10 @@ function createGoal(goalId, objective, now, cursor) {
     evidenceCursor: copyCursor(cursor),
     turnCount: 0,
     activeTimeMs: 0,
+    tokensUsed: 0,
+    // A non-finite grant (a host opting out) arms nothing: `Infinity` would
+    // not survive the JSON journal, so "unbounded" is spelled as no field.
+    ...tokenBudget !== void 0 && Number.isFinite(tokenBudget) ? { tokenBudget } : {},
     createdAt: now,
     updatedAt: now
   };
@@ -1558,16 +1233,30 @@ function normalizeObjective(objective, current) {
 }
 __name(normalizeObjective, "normalizeObjective");
 function isEvidenceLimited(goal) {
-  return goal.limitKind !== void 0 || goal.lastReason !== void 0 && goalLimitKindForReason(goal.lastReason) !== void 0;
+  return goal.limitKind === "evidence_catalog" || goal.limitKind === "checkpoint_request" || goal.lastReason !== void 0 && goalLimitKindForReason(goal.lastReason) !== void 0;
 }
 __name(isEvidenceLimited, "isEvidenceLimited");
+function rearmedTokenBudget(current, grant) {
+  if (grant === void 0 || !isGoalTokenBudgetSpent(current)) {
+    return {};
+  }
+  return Number.isFinite(grant) ? { tokenBudget: current.tokensUsed + grant, windDownTurnId: void 0 } : { tokenBudget: void 0, windDownTurnId: void 0 };
+}
+__name(rearmedTokenBudget, "rearmedTokenBudget");
 function transitionGoal(goal, now, changes) {
-  return {
+  const transitioned = {
     ...goal,
     ...changes,
     activeTimeMs: elapsedActiveTime(goal, now),
     updatedAt: now
   };
+  if ("tokenBudget" in changes && changes.tokenBudget === void 0) {
+    delete transitioned.tokenBudget;
+  }
+  if ("windDownTurnId" in changes && changes.windDownTurnId === void 0) {
+    delete transitioned.windDownTurnId;
+  }
+  return transitioned;
 }
 __name(transitionGoal, "transitionGoal");
 function snapshotOf(goal) {
@@ -1597,12 +1286,16 @@ function parseGoalRecord(value) {
     "evidenceCursor",
     "turnCount",
     "activeTimeMs",
+    "tokensUsed",
+    "tokenBudget",
+    "windDownTurnId",
     "createdAt",
     "updatedAt",
     "evidenceCheckpoint",
+    "checkpointStalls",
     "lastReason",
     "limitKind"
-  ]) || typeof value["goalId"] !== "string" || !value["goalId"] || !isNonNegativeInteger(value["revision"]) || value["revision"] === 0 || typeof value["objective"] !== "string" || !value["objective"].trim() || !isGoalStatus(value["status"]) || !isTranscriptCursor(value["evidenceCursor"]) || !isNonNegativeInteger(value["turnCount"]) || !isNonNegativeNumber(value["activeTimeMs"]) || !isFiniteNumber(value["createdAt"]) || !isFiniteNumber(value["updatedAt"]) || !isGoalEvidenceCheckpoint(value["evidenceCheckpoint"]) || value["lastReason"] !== void 0 && typeof value["lastReason"] !== "string" || value["limitKind"] !== void 0 && (!isGoalLimitKind(value["limitKind"]) || value["status"] !== "usage_limited")) {
+  ]) || typeof value["goalId"] !== "string" || !value["goalId"] || !isNonNegativeInteger(value["revision"]) || value["revision"] === 0 || typeof value["objective"] !== "string" || !value["objective"].trim() || !isGoalStatus(value["status"]) || !isTranscriptCursor(value["evidenceCursor"]) || !isNonNegativeInteger(value["turnCount"]) || !isNonNegativeNumber(value["activeTimeMs"]) || value["tokensUsed"] !== void 0 && !isNonNegativeNumber(value["tokensUsed"]) || value["tokenBudget"] !== void 0 && !isNonNegativeNumber(value["tokenBudget"]) || value["windDownTurnId"] !== void 0 && (typeof value["windDownTurnId"] !== "string" || !value["windDownTurnId"]) || !isFiniteNumber(value["createdAt"]) || !isFiniteNumber(value["updatedAt"]) || !isGoalEvidenceCheckpoint(value["evidenceCheckpoint"]) || value["checkpointStalls"] !== void 0 && !isNonNegativeInteger(value["checkpointStalls"]) || value["lastReason"] !== void 0 && typeof value["lastReason"] !== "string" || value["limitKind"] !== void 0 && (!isGoalLimitKind(value["limitKind"]) || value["status"] !== "usage_limited")) {
     return void 0;
   }
   if (value["evidenceCheckpoint"] && value["evidenceCursor"].recordId !== value["evidenceCheckpoint"].checkpointId) {
@@ -1616,11 +1309,18 @@ function parseGoalRecord(value) {
     evidenceCursor: copyCursor(value["evidenceCursor"]),
     turnCount: value["turnCount"],
     activeTimeMs: value["activeTimeMs"],
+    // Goals persisted before `tokensUsed` existed carry no spend to restore.
+    tokensUsed: value["tokensUsed"] ?? 0,
+    // And no budget: a Goal from before budgets existed stays unbounded.
+    ...value["tokenBudget"] === void 0 ? {} : { tokenBudget: value["tokenBudget"] },
+    ...value["windDownTurnId"] === void 0 ? {} : { windDownTurnId: value["windDownTurnId"] },
     createdAt: value["createdAt"],
     updatedAt: value["updatedAt"],
     ...value["evidenceCheckpoint"] === void 0 ? {} : {
       evidenceCheckpoint: structuredClone(value["evidenceCheckpoint"])
     },
+    // Zero is spelled as no field; a persisted 0 restores the same way.
+    ...value["checkpointStalls"] ? { checkpointStalls: value["checkpointStalls"] } : {},
     ...value["lastReason"] === void 0 ? {} : { lastReason: value["lastReason"] },
     ...value["limitKind"] === void 0 ? {} : { limitKind: value["limitKind"] }
   };
@@ -1712,6 +1412,10 @@ import { randomUUID } from "node:crypto";
 
 // packages/core/src/goals/goal-checkpoint.ts
 init_esbuild_shims();
+function isGoalCheckpointStalled(window, checkpoint) {
+  return window.truncated && checkpoint.claims.length >= GOAL_CHECKPOINT_CLAIM_LIMIT;
+}
+__name(isGoalCheckpointStalled, "isGoalCheckpointStalled");
 var InvalidGoalCheckpointError = class extends Error {
   static {
     __name(this, "InvalidGoalCheckpointError");
@@ -1894,10 +1598,14 @@ function parseGoalCheckpointVerifierText(text) {
   try {
     value = JSON.parse(text);
   } catch {
-    throw new Error("Goal checkpoint verifier returned invalid JSON");
+    throw new InvalidGoalCheckpointError(
+      "Goal checkpoint verifier returned invalid JSON"
+    );
   }
   if (!isRecord4(value) || !hasOnlyKeys4(value, ["claims"]) || !Array.isArray(value["claims"]) || value["claims"].length === 0 || value["claims"].length > GOAL_CHECKPOINT_CLAIM_LIMIT) {
-    throw new Error("Goal checkpoint verifier returned invalid claims");
+    throw new InvalidGoalCheckpointError(
+      "Goal checkpoint verifier returned invalid claims"
+    );
   }
   const claims = value["claims"].map(
     (claim, index) => parseClaim(claim, index)
@@ -1905,15 +1613,6 @@ function parseGoalCheckpointVerifierText(text) {
   return { claims };
 }
 __name(parseGoalCheckpointVerifierText, "parseGoalCheckpointVerifierText");
-function validateGoalCheckpointVerifierText(text) {
-  try {
-    parseGoalCheckpointVerifierText(text);
-    return null;
-  } catch (error) {
-    return error instanceof Error ? error.message : "Goal checkpoint verifier returned invalid output";
-  }
-}
-__name(validateGoalCheckpointVerifierText, "validateGoalCheckpointVerifierText");
 function createGoalCheckpointVerifier(config, options = {}) {
   const timeoutMs = options.timeoutMs ?? GOAL_CHECKPOINT_VERIFIER_TIMEOUT_MS;
   return async (input, attemptSignal) => {
@@ -1938,8 +1637,11 @@ function createGoalCheckpointVerifier(config, options = {}) {
           responseMimeType: "application/json",
           responseJsonSchema: GOAL_CHECKPOINT_VERIFIER_SCHEMA,
           thinkingConfig: { thinkingBudget: 0, includeThoughts: false }
-        },
-        validate: validateGoalCheckpointVerifierText
+        }
+        // Parsing stays out of a validate hook: runSideQuery re-wraps hook
+        // failures into plain Errors, dropping the InvalidGoalCheckpointError
+        // class the runtime's checkpoint stall breaker counts unusable
+        // results by.
       });
       return parseGoalCheckpointVerifierText(result.text);
     } finally {
@@ -1952,11 +1654,15 @@ function parseClaim(value, index) {
   if (!isRecord4(value) || !hasOnlyKeys4(value, ["proofKind", "claim", "sourceRefs"]) || !isGoalEvidenceProofKind(value["proofKind"]) || typeof value["claim"] !== "string" || !Array.isArray(value["sourceRefs"]) || value["sourceRefs"].length === 0 || value["sourceRefs"].length > GOAL_CHECKPOINT_SOURCE_REFERENCE_LIMIT || value["sourceRefs"].some(
     (reference) => typeof reference !== "string" || reference.length === 0
   ) || new Set(value["sourceRefs"]).size !== value["sourceRefs"].length) {
-    throw new Error(`Goal checkpoint verifier claim ${index + 1} is invalid`);
+    throw new InvalidGoalCheckpointError(
+      `Goal checkpoint verifier claim ${index + 1} is invalid`
+    );
   }
   const claim = value["claim"].trim();
   if (!claim || [...claim].length > GOAL_CHECKPOINT_CLAIM_MAX_CHARACTERS) {
-    throw new Error(`Goal checkpoint verifier claim ${index + 1} is invalid`);
+    throw new InvalidGoalCheckpointError(
+      `Goal checkpoint verifier claim ${index + 1} is invalid`
+    );
   }
   return {
     proofKind: value["proofKind"],
@@ -2021,7 +1727,7 @@ function recoverLegacyGoal(records) {
     }
     for (let itemIndex = payload.outputHistoryItems.length - 1; itemIndex >= 0; itemIndex -= 1) {
       const value = payload.outputHistoryItems[itemIndex];
-      if (!isObjectRecord2(value) || value["type"] !== "goal_status") continue;
+      if (!isObjectRecord(value) || value["type"] !== "goal_status") continue;
       const kind = value["kind"];
       const condition = value["condition"];
       if (typeof kind !== "string" || typeof condition !== "string") {
@@ -2065,7 +1771,7 @@ function normalizeGoalRecoveryRecord(record) {
     return void 0;
   }
   const goalStatusItems = payload.outputHistoryItems.filter(
-    (value) => isObjectRecord2(value) && value["type"] === "goal_status"
+    (value) => isObjectRecord(value) && value["type"] === "goal_status"
   );
   if (goalStatusItems.length === 0) return void 0;
   return {
@@ -2086,7 +1792,7 @@ function isGoalRecoveryCandidate(record) {
   }
   const payload = record.systemPayload;
   return payload?.phase === "result" && Array.isArray(payload.outputHistoryItems) && payload.outputHistoryItems.some(
-    (value) => isObjectRecord2(value) && value["type"] === "goal_status"
+    (value) => isObjectRecord(value) && value["type"] === "goal_status"
   );
 }
 __name(isGoalRecoveryCandidate, "isGoalRecoveryCandidate");
@@ -2097,10 +1803,10 @@ function unsupportedLegacy(recordUuid) {
   };
 }
 __name(unsupportedLegacy, "unsupportedLegacy");
-function isObjectRecord2(value) {
+function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isObjectRecord2, "isObjectRecord");
+__name(isObjectRecord, "isObjectRecord");
 function createMigratedGoalState(input) {
   const objective = input.objective.trim();
   if (!objective) {
@@ -2120,6 +1826,7 @@ function createMigratedGoalState(input) {
         evidenceCursor: { recordId: input.recordUuid },
         turnCount: 0,
         activeTimeMs: 0,
+        tokensUsed: 0,
         createdAt: input.now,
         updatedAt: input.now
       }
@@ -2169,6 +1876,9 @@ function createGoalRuntime(options) {
   let currentTurnKey;
   let queuedTurnKey;
   let continuationQueued = false;
+  let announcedObjective;
+  let currentTurnAnnouncement;
+  let currentTurnDelivered = false;
   let currentProposal;
   let pendingProposal;
   let verificationAttempt;
@@ -2178,6 +1888,7 @@ function createGoalRuntime(options) {
   let currentTurnFeedback;
   let restored = false;
   let restoreActivationPending = false;
+  let windDownTurnId;
   let restorePreparation;
   let restoreActivation;
   let preparedRestoreCause;
@@ -2192,6 +1903,73 @@ function createGoalRuntime(options) {
     recordUuid,
     controller: new AbortController()
   } : void 0, "createCheckpointAttempt");
+  const takeTurnTokens = /* @__PURE__ */ __name((turnId) => {
+    if (!options.tokenLedger) return 0;
+    try {
+      const tokens = options.tokenLedger.takeGoalTurnTokens(turnId);
+      return Number.isFinite(tokens) ? Math.max(0, tokens) : 0;
+    } catch {
+      return 0;
+    }
+  }, "takeTurnTokens");
+  const tokenBudgetGrant = options.tokenBudgetGrant ?? GOAL_DEFAULT_TOKEN_BUDGET;
+  const usageLimitedSnapshot = /* @__PURE__ */ __name((goal, reason, limitKind) => {
+    const now = Date.now();
+    return {
+      v: GOAL_STATE_VERSION,
+      goal: {
+        ...goal,
+        status: "usage_limited",
+        activeTimeMs: elapsedActiveTime(goal, now),
+        updatedAt: now,
+        lastReason: reason,
+        ...limitKind === void 0 ? {} : { limitKind }
+      },
+      activity: "idle"
+    };
+  }, "usageLimitedSnapshot");
+  const journalUsageLimitedSettle = /* @__PURE__ */ __name(async (goal, reason, limitKind) => {
+    const limitedSnapshot = usageLimitedSnapshot(goal, reason, limitKind);
+    await options.journal.recordGoalState(randomUUID(), {
+      v: GOAL_STATE_VERSION,
+      cause: "usage_limited",
+      snapshot: limitedSnapshot
+    });
+    return limitedSnapshot;
+  }, "journalUsageLimitedSettle");
+  const commitUsageLimitedSettle = /* @__PURE__ */ __name((limitedSnapshot) => {
+    continuationQueued = false;
+    currentTurnFeedback = void 0;
+    snapshot = structuredClone(limitedSnapshot);
+    broadcast("usage_limited");
+  }, "commitUsageLimitedSettle");
+  const stopForSpentBudget = /* @__PURE__ */ __name(() => {
+    void enqueue(async () => {
+      const goal = snapshot.goal;
+      if (!goal || goal.status !== "active" || !isGoalTokenBudgetSpent(goal) || currentPermit || pendingProposal || verificationAttempt || checkpointAttempt) {
+        return;
+      }
+      const reason = goalTokenBudgetReason(goal.tokenBudget);
+      let limitedSnapshot;
+      try {
+        limitedSnapshot = await journalUsageLimitedSettle(
+          goal,
+          reason,
+          "token_budget"
+        );
+      } catch {
+        limitedSnapshot = usageLimitedSnapshot(goal, reason, "token_budget");
+      }
+      if (snapshot.goal?.goalId !== goal.goalId || snapshot.goal.revision !== goal.revision || snapshot.goal.status !== "active" || currentPermit) {
+        return;
+      }
+      commitUsageLimitedSettle(limitedSnapshot);
+    }).catch(() => void 0);
+  }, "stopForSpentBudget");
+  const withCheckpointStalls = /* @__PURE__ */ __name((goal, checkpointStalls) => {
+    const { checkpointStalls: _previous, ...rest } = goal;
+    return checkpointStalls > 0 ? { ...rest, checkpointStalls } : rest;
+  }, "withCheckpointStalls");
   const assertAvailable = /* @__PURE__ */ __name(() => {
     if (disposed) throw new Error(GOAL_RUNTIME_DISPOSED_MESSAGE);
   }, "assertAvailable");
@@ -2214,7 +1992,14 @@ function createGoalRuntime(options) {
     } catch {
     }
   }, "preemptHost");
-  const flushContinuation = /* @__PURE__ */ __name((cause) => {
+  const settleCurrentTurnAnnouncement = /* @__PURE__ */ __name((delivered) => {
+    if (delivered && currentTurnAnnouncement !== void 0) {
+      announcedObjective = currentTurnAnnouncement;
+    }
+    currentTurnAnnouncement = void 0;
+    currentTurnDelivered = false;
+  }, "settleCurrentTurnAnnouncement");
+  const flushContinuation = /* @__PURE__ */ __name((cause, windDown = false) => {
     if (!continuationQueued || !host || currentPermit || pendingProposal || verificationAttempt || checkpointAttempt || snapshot.activity !== "idle" || snapshot.goal?.status !== "active") {
       return;
     }
@@ -2232,11 +2017,16 @@ function createGoalRuntime(options) {
     currentPermitHost = scheduledHost;
     currentTurnKey = `goal-runtime:${currentPermit.turnId}`;
     const startedPermit = structuredClone(currentPermit);
+    const objectiveUpdated = announcedObjective !== void 0 && announcedObjective !== continuationContext;
+    currentTurnAnnouncement = continuationContext;
+    currentTurnDelivered = false;
+    windDownTurnId = windDown ? startedPermit.turnId : void 0;
     snapshot = { ...snapshot, activity: "running" };
     broadcast(cause);
     const handleStartFailure = /* @__PURE__ */ __name(() => {
       void enqueue(async () => {
         if (isCurrentPermit(startedPermit)) {
+          settleCurrentTurnAnnouncement(false);
           const nextTurnKey = queuedTurnKey;
           currentPermit = void 0;
           currentPermitHost = void 0;
@@ -2273,6 +2063,8 @@ function createGoalRuntime(options) {
       started = scheduledHost.startGoalTurn({
         permit: startedPermit,
         continuationContext,
+        ...objectiveUpdated ? { objectiveUpdated } : {},
+        ...windDown ? { windDown } : {},
         ...verifierFeedback ? { verifierFeedback } : {}
       });
     } catch {
@@ -2285,6 +2077,15 @@ function createGoalRuntime(options) {
     if (restoreActivationPending || snapshot.goal?.status !== "active" || currentPermit || pendingProposal || verificationAttempt || checkpointAttempt) {
       return;
     }
+    if (isGoalTokenBudgetSpent(snapshot.goal)) {
+      if (snapshot.goal.windDownTurnId !== void 0) {
+        stopForSpentBudget();
+        return;
+      }
+      continuationQueued = true;
+      flushContinuation(cause, true);
+      return;
+    }
     continuationQueued = true;
     flushContinuation(cause);
   }, "queueContinuation");
@@ -2342,7 +2143,7 @@ function createGoalRuntime(options) {
     return {
       ...base,
       proposal: { ...attempt.proposal, status: "blocked" },
-      blockedPolicy: "A blocked Goal is resumable. It may be accepted immediately only when the evidence shows that new user authority or a material user choice is required, or that an external state change is required, and no meaningful in-scope work remains. An ordinary technical blocker requires evidence of the same cause from the current and two immediately preceding Goal turns. Difficulty, uncertainty, incomplete work, or a preference for clarification do not by themselves justify blocked."
+      blockedPolicy: "A blocked Goal is resumable. It may be accepted immediately only when the evidence shows that new user authority or a material user choice is required, or that an external state change is required, and no meaningful in-scope work remains. An infeasible blocker may also be accepted immediately, only when cited external_fact evidence shows the objective cannot be satisfied as written: it contradicts itself, it names a target that verifiably does not exist, or it requires an action outside what the tools can perform; reject it when the obstacle is difficulty, uncertainty, information the model could still obtain, or a preference to ask. An ordinary technical blocker requires evidence of the same cause from the current and two immediately preceding Goal turns. Difficulty, uncertainty, incomplete work, or a preference for clarification do not by themselves justify blocked."
     };
   }, "verifierInput");
   const promoteQueuedUserTurn = /* @__PURE__ */ __name(() => {
@@ -2379,7 +2180,7 @@ function createGoalRuntime(options) {
         ...snapshot.goal,
         activeTimeMs: elapsedActiveTime(snapshot.goal, now),
         updatedAt: now,
-        lastReason: outcome.result.reason
+        lastReason: attempt.proposal.blockerKind === "infeasible" ? `${outcome.result.reason} ${GOAL_INFEASIBLE_NEXT_STEP}` : outcome.result.reason
       };
       const acceptedSnapshot = {
         v: GOAL_STATE_VERSION,
@@ -2412,36 +2213,24 @@ function createGoalRuntime(options) {
       continuationQueued = false;
       nextVerifierFeedback = void 0;
       currentTurnFeedback = void 0;
+      if (attempt.proposal.status === "complete") {
+        announcedObjective = void 0;
+      }
       snapshot = structuredClone(terminalSnapshot);
       broadcast(attempt.proposal.status);
       return void 0;
     }
     if (outcome.kind === "usage_limited") {
-      const limitedSnapshot = {
-        v: GOAL_STATE_VERSION,
-        goal: {
-          ...snapshot.goal,
-          status: "usage_limited",
-          activeTimeMs: elapsedActiveTime(snapshot.goal, now),
-          updatedAt: now,
-          lastReason: outcome.reason,
-          ...outcome.limitKind === void 0 ? {} : { limitKind: outcome.limitKind }
-        },
-        activity: "idle"
-      };
-      await options.journal.recordGoalState(randomUUID(), {
-        v: GOAL_STATE_VERSION,
-        cause: "usage_limited",
-        snapshot: limitedSnapshot
-      });
+      const limitedSnapshot = await journalUsageLimitedSettle(
+        snapshot.goal,
+        outcome.reason,
+        outcome.limitKind
+      );
       if (!isCurrentVerificationAttempt(attempt) || !snapshot.goal) return;
       verificationAttempt = void 0;
       pendingProposal = void 0;
-      continuationQueued = false;
       nextVerifierFeedback = void 0;
-      currentTurnFeedback = void 0;
-      snapshot = structuredClone(limitedSnapshot);
-      broadcast("usage_limited");
+      commitUsageLimitedSettle(limitedSnapshot);
       return void 0;
     }
     const rejectedCheckpoint = isRepeatedBlockerProposal(attempt.proposal) ? void 0 : createCheckpointAttempt(attempt.permit, snapshot.goal);
@@ -2549,15 +2338,23 @@ function createGoalRuntime(options) {
       await settleDanglingAttempt(checkpoint.permit);
     }
   }, "runVerification");
-  const finishCheckpointCheck = /* @__PURE__ */ __name(async (attempt) => {
+  const finishCheckpointCheck = /* @__PURE__ */ __name(async (attempt, outcome = "inconclusive") => {
     await enqueue(async () => {
       if (!isCurrentCheckpointAttempt(attempt) || !snapshot.goal) return;
+      const checkpointStalls = outcome === "room" ? 0 : outcome === "stalled" ? (snapshot.goal.checkpointStalls ?? 0) + 1 : snapshot.goal.checkpointStalls ?? 0;
+      if (await settleIfCheckpointStalled(
+        attempt,
+        snapshot.goal,
+        checkpointStalls
+      )) {
+        return;
+      }
       const persistedCause = nextVerifierFeedback === void 0 ? "checkpoint" : "verifier_reject";
       const now = Date.now();
       const checkedSnapshot = {
         v: GOAL_STATE_VERSION,
         goal: {
-          ...snapshot.goal,
+          ...withCheckpointStalls(snapshot.goal, checkpointStalls),
           activeTimeMs: elapsedActiveTime(snapshot.goal, now),
           updatedAt: now
         },
@@ -2579,45 +2376,50 @@ function createGoalRuntime(options) {
       }
     });
   }, "finishCheckpointCheck");
+  const settleCheckpointFailure = /* @__PURE__ */ __name(async (attempt, goal, reason, limitKind) => {
+    const limitedSnapshot = await journalUsageLimitedSettle(
+      goal,
+      reason,
+      limitKind
+    );
+    if (!isCurrentCheckpointAttempt(attempt) || !snapshot.goal) return;
+    checkpointAttempt = void 0;
+    commitUsageLimitedSettle(limitedSnapshot);
+  }, "settleCheckpointFailure");
+  const settleIfCheckpointStalled = /* @__PURE__ */ __name(async (attempt, goal, checkpointStalls) => {
+    if (checkpointStalls < GOAL_CHECKPOINT_STALL_LIMIT) return false;
+    await settleCheckpointFailure(
+      attempt,
+      withCheckpointStalls(goal, checkpointStalls),
+      GOAL_CHECKPOINT_STALLED_REASON,
+      "evidence_catalog"
+    );
+    return true;
+  }, "settleIfCheckpointStalled");
   const recordCheckpointFailure = /* @__PURE__ */ __name(async (attempt, reason, limitKind) => {
     await enqueue(async () => {
       if (!isCurrentCheckpointAttempt(attempt) || !snapshot.goal) return;
-      const now = Date.now();
-      const limitedSnapshot = {
-        v: GOAL_STATE_VERSION,
-        goal: {
-          ...snapshot.goal,
-          status: "usage_limited",
-          activeTimeMs: elapsedActiveTime(snapshot.goal, now),
-          updatedAt: now,
-          lastReason: reason,
-          ...limitKind === void 0 ? {} : { limitKind }
-        },
-        activity: "idle"
-      };
-      await options.journal.recordGoalState(randomUUID(), {
-        v: GOAL_STATE_VERSION,
-        cause: "usage_limited",
-        snapshot: limitedSnapshot
-      });
-      if (!isCurrentCheckpointAttempt(attempt) || !snapshot.goal) return;
-      checkpointAttempt = void 0;
-      continuationQueued = false;
-      currentTurnFeedback = void 0;
-      snapshot = structuredClone(limitedSnapshot);
-      broadcast("usage_limited");
+      await settleCheckpointFailure(attempt, snapshot.goal, reason, limitKind);
     });
   }, "recordCheckpointFailure");
-  const recordCheckpoint = /* @__PURE__ */ __name(async (attempt, checkpoint) => {
+  const recordCheckpoint = /* @__PURE__ */ __name(async (attempt, checkpoint, stalled) => {
     if (!checkpoint) return;
     await enqueue(async () => {
       if (!isCurrentCheckpointAttempt(attempt) || !snapshot.goal) return;
+      const checkpointStalls = stalled ? (snapshot.goal.checkpointStalls ?? 0) + 1 : 0;
+      if (await settleIfCheckpointStalled(
+        attempt,
+        snapshot.goal,
+        checkpointStalls
+      )) {
+        return;
+      }
       const now = Date.now();
       const persistedCause = nextVerifierFeedback === void 0 ? "checkpoint" : "verifier_reject";
       const checkpointSnapshot = {
         v: GOAL_STATE_VERSION,
         goal: {
-          ...snapshot.goal,
+          ...withCheckpointStalls(snapshot.goal, checkpointStalls),
           evidenceCursor: { recordId: attempt.recordUuid },
           evidenceCheckpoint: checkpoint,
           activeTimeMs: elapsedActiveTime(snapshot.goal, now),
@@ -2664,7 +2466,7 @@ function createGoalRuntime(options) {
           permit: attempt.permit
         });
       }
-      if (window.truncated) {
+      if (window.truncated && !window.shouldCheckpoint) {
         await recordCheckpointFailure(
           attempt,
           GOAL_EVIDENCE_CATALOG_EXHAUSTED_REASON,
@@ -2673,7 +2475,7 @@ function createGoalRuntime(options) {
         return;
       }
       if (!window.shouldCheckpoint) {
-        await finishCheckpointCheck(attempt);
+        await finishCheckpointCheck(attempt, "room");
         return;
       }
       let checkpoint;
@@ -2708,10 +2510,18 @@ function createGoalRuntime(options) {
           );
           return;
         }
+        if (error instanceof InvalidGoalCheckpointError && window.truncated) {
+          await finishCheckpointCheck(attempt, "stalled");
+          return;
+        }
         await finishCheckpointCheck(attempt);
         return;
       }
-      await recordCheckpoint(attempt, checkpoint);
+      await recordCheckpoint(
+        attempt,
+        checkpoint,
+        isGoalCheckpointStalled(window, checkpoint)
+      );
     } catch (error) {
       if (attempt.controller.signal.aborted) return;
       if (error instanceof EvidenceSourceUnavailableError && error.code === "current_turn_not_tail") {
@@ -2921,6 +2731,7 @@ function createGoalRuntime(options) {
           if (currentTurnFeedback !== void 0) {
             nextVerifierFeedback ??= currentTurnFeedback;
           }
+          settleCurrentTurnAnnouncement(currentTurnDelivered);
           currentPermit = void 0;
           currentPermitHost = void 0;
           currentTurnKey = void 0;
@@ -2949,6 +2760,12 @@ function createGoalRuntime(options) {
         return released;
       });
     },
+    markTurnDelivered(turnKey) {
+      assertOperational();
+      if (currentPermit && currentTurnKey === turnKey) {
+        currentTurnDelivered = true;
+      }
+    },
     permitForTurn(turnKey) {
       assertOperational();
       return currentPermit && currentTurnKey === turnKey ? structuredClone(currentPermit) : void 0;
@@ -2967,10 +2784,15 @@ function createGoalRuntime(options) {
           if (!isCurrentPermit(permit) || !snapshot.goal) {
             throw new Error(STALE_GOAL_TURN_MESSAGE);
           }
+          settleCurrentTurnAnnouncement(currentTurnDelivered);
           const recordUuid = randomUUID();
+          const finishedWindDown = windDownTurnId === permit.turnId;
           const nextGoal = reduceGoalTurnFinished(snapshot.goal, {
-            now: Date.now()
+            now: Date.now(),
+            tokensUsed: takeTurnTokens(permit.turnId),
+            ...finishedWindDown ? { windDownTurnId: permit.turnId } : {}
           });
+          if (finishedWindDown) windDownTurnId = void 0;
           const persistedSnapshot = {
             v: GOAL_STATE_VERSION,
             goal: nextGoal,
@@ -3141,7 +2963,8 @@ ${proposal.reason}`;
           request,
           now: Date.now(),
           nextGoalId: randomUUID(),
-          cursor: request.action === "create" || request.action === "replace" || request.action === "edit" ? { recordId: recordUuid } : options.journal.getTranscriptCursor()
+          cursor: request.action === "create" || request.action === "replace" || request.action === "edit" ? { recordId: recordUuid } : options.journal.getTranscriptCursor(),
+          tokenBudgetGrant
         });
         const nextSnapshot = {
           v: GOAL_STATE_VERSION,
@@ -3174,6 +2997,7 @@ ${proposal.reason}`;
           invalidateAttempts(`Goal ${request.action}`);
         }
         if (invalidatesPermit) {
+          settleCurrentTurnAnnouncement(currentTurnDelivered);
           currentPermit = void 0;
           currentPermitHost = void 0;
           currentTurnKey = void 0;
@@ -3184,6 +3008,7 @@ ${proposal.reason}`;
           nextVerifierFeedback = void 0;
           currentTurnFeedback = void 0;
           continuationQueued = false;
+          if (request.action === "clear") announcedObjective = void 0;
         } else if (request.action === "resume") {
           blockedAudit = void 0;
         }
@@ -3218,6 +3043,8 @@ ${proposal.reason}`;
       blockedAudit = void 0;
       nextVerifierFeedback = void 0;
       currentTurnFeedback = void 0;
+      currentTurnAnnouncement = void 0;
+      currentTurnDelivered = false;
       preemptHost("Goal runtime disposed", invalidatedHost);
       host = void 0;
       listeners.clear();
@@ -3237,21 +3064,12 @@ export {
   emptyGoalSnapshot,
   goalRequiresExactPermit,
   validateGoalProposalReason,
-  wrapUserPromptSubmitContext,
-  isUserPromptSubmitContextPartText,
-  projectUserTranscriptForDisplay,
-  isTranscriptConversationRecord,
-  isTranscriptArtifactRecord,
-  validateTranscriptRecord,
-  selectTranscriptLeaf,
-  walkTranscriptUuidChain,
-  aggregateTranscriptRecordFragments,
-  prepareTranscriptRecords,
   GOAL_EVIDENCE_REFERENCE_LIMIT,
   EvidenceSourceUnavailableError,
   InvalidGoalEvidenceReferenceError,
   GoalEvidenceRecordIndexAccumulator,
   GoalEvidenceCheckpointAccumulator,
+  capPreviewBytes,
   createGoalCheckpointVerifier,
   GoalConflictError,
   GoalInvalidTransitionError,
@@ -3274,8 +3092,3 @@ export {
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */