@qwen-code/qwen-code 0.22.0 → 0.22.2-preview.0

package/chunks/{chunk-5XUTPXQU.js → chunk-EAV3TENS.js}

@@ -2,11 +2,14 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-45NQKMYB.js";
+} from "./chunk-7JPW6IYH.js";
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-QS4ENGVF.js";
+} from "./chunk-IKN3IUJP.js";
+import {
+  APPROVAL_MODES
+} from "./chunk-BVE5EMIG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -17,13 +20,7 @@ import {
 // packages/cli/src/commands/channel/config-utils.ts
 init_esbuild_shims();
 var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
-var CHANNEL_APPROVAL_MODES = /* @__PURE__ */ new Set([
-  "plan",
-  "default",
-  "auto-edit",
-  "auto",
-  "yolo"
-]);
+var CHANNEL_APPROVAL_MODES = new Set(APPROVAL_MODES);
 function resolveEnvVars(value, env = process.env) {
   if (value.startsWith("$$")) {
     return value.substring(1);

package/chunks/{chunk-LI4YHTQK.js → chunk-EB4VDXNI.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getErrorStatus
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-JOLJTKIG.js → chunk-EC5BONC3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-6NFAEG54.js";
+} from "./chunk-KOJ6MHD5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-W4CRPSC5.js → chunk-ELY4QVIB.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   Storage
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-AVCCKIZ6.js → chunk-EWBY3PFB.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-4CWDWDL6.js";
+} from "./chunk-RCDXSEJ5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-FBX2SDQ4.js

@@ -0,0 +1,48 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/web-shell-resolver.ts
+init_esbuild_shims();
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var BUNDLE_CHUNK_DIR = "chunks";
+function resolveBundleDirFastPath(importMetaUrl) {
+  const moduleDir = path.dirname(fileURLToPath(importMetaUrl));
+  return path.basename(moduleDir) === BUNDLE_CHUNK_DIR ? path.dirname(moduleDir) : moduleDir;
+}
+__name(resolveBundleDirFastPath, "resolveBundleDirFastPath");
+function resolveWebShellDir() {
+  const selfDir = path.dirname(fileURLToPath(import.meta.url));
+  const hasShell = /* @__PURE__ */ __name((dir2) => existsSync(path.join(dir2, "index.html")) && existsSync(path.join(dir2, "assets")), "hasShell");
+  const bundled = path.join(
+    resolveBundleDirFastPath(import.meta.url),
+    "web-shell"
+  );
+  if (hasShell(bundled)) return bundled;
+  let dir = selfDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = path.join(dir, "packages", "web-shell", "dist");
+    if (hasShell(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+__name(resolveWebShellDir, "resolveWebShellDir");
+
+export {
+  resolveWebShellDir
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-C72BXMJ5.js → chunk-FJWICLG7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

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

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runSideQuery
-} from "./chunk-ZRYQMWEP.js";
+} from "./chunk-IPQA4SR5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,6 +21,8 @@ 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.";
 function isGoalLimitKind(value) {
   return value === "evidence_catalog" || value === "checkpoint_request";
 }
@@ -106,6 +108,7 @@ var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
   "agent_retry",
   "file_history_snapshot",
   "session_source",
+  "session_model",
   "branch_checkpoint",
   "goal_state",
   "goal_runtime",
@@ -464,6 +467,7 @@ __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 +561,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 +708,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");
@@ -1099,7 +1104,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 +1176,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 +1229,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 +1251,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) {
@@ -1375,6 +1401,7 @@ function reduceGoalControl(current, transition) {
       objective: normalizeObjective(request.objective, snapshotOf(current)),
       evidenceCursor: copyCursor(transition.cursor),
       evidenceCheckpoint: void 0,
+      checkpointStalls: void 0,
       lastReason: void 0,
       limitKind: void 0
     });
@@ -1400,15 +1427,22 @@ 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") {
     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,
+      lastReason: void 0,
+      limitKind: void 0
+    });
+  }
   return transitionGoal(current, transition.now, {
     status: "active"
   });
@@ -1423,6 +1457,7 @@ function reduceGoalTurnFinished(current, transition) {
   }
   return transitionGoal(current, transition.now, {
     turnCount: current.turnCount + 1,
+    tokensUsed: current.tokensUsed + Math.max(0, transition.tokensUsed ?? 0),
     ...transition.lastReason === void 0 ? {} : { lastReason: transition.lastReason }
   });
 }
@@ -1535,6 +1570,7 @@ function createGoal(goalId, objective, now, cursor) {
     evidenceCursor: copyCursor(cursor),
     turnCount: 0,
     activeTimeMs: 0,
+    tokensUsed: 0,
     createdAt: now,
     updatedAt: now
   };
@@ -1597,12 +1633,14 @@ function parseGoalRecord(value) {
     "evidenceCursor",
     "turnCount",
     "activeTimeMs",
+    "tokensUsed",
     "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"]) || !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 +1654,15 @@ 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,
     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 +1754,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 +1940,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 +1955,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 +1979,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 +1996,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"],
@@ -2120,6 +2168,7 @@ function createMigratedGoalState(input) {
         evidenceCursor: { recordId: input.recordUuid },
         turnCount: 0,
         activeTimeMs: 0,
+        tokensUsed: 0,
         createdAt: input.now,
         updatedAt: input.now
       }
@@ -2192,6 +2241,19 @@ 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 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");
@@ -2549,15 +2611,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 +2649,66 @@ function createGoalRuntime(options) {
       }
     });
   }, "finishCheckpointCheck");
+  const settleCheckpointFailure = /* @__PURE__ */ __name(async (attempt, goal, reason, limitKind) => {
+    const now = Date.now();
+    const limitedSnapshot = {
+      v: GOAL_STATE_VERSION,
+      goal: {
+        ...goal,
+        status: "usage_limited",
+        activeTimeMs: elapsedActiveTime(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");
+  }, "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 +2755,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 +2764,7 @@ function createGoalRuntime(options) {
         return;
       }
       if (!window.shouldCheckpoint) {
-        await finishCheckpointCheck(attempt);
+        await finishCheckpointCheck(attempt, "room");
         return;
       }
       let checkpoint;
@@ -2708,10 +2799,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") {
@@ -2969,7 +3068,8 @@ function createGoalRuntime(options) {
           }
           const recordUuid = randomUUID();
           const nextGoal = reduceGoalTurnFinished(snapshot.goal, {
-            now: Date.now()
+            now: Date.now(),
+            tokensUsed: takeTurnTokens(permit.turnId)
           });
           const persistedSnapshot = {
             v: GOAL_STATE_VERSION,
@@ -3252,6 +3352,7 @@ export {
   InvalidGoalEvidenceReferenceError,
   GoalEvidenceRecordIndexAccumulator,
   GoalEvidenceCheckpointAccumulator,
+  capPreviewBytes,
   createGoalCheckpointVerifier,
   GoalConflictError,
   GoalInvalidTransitionError,

package/chunks/{chunk-3ZFJUBTP.js → chunk-FPH6TXD3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-S3G6YFQC.js";
+} from "./chunk-WEGXPP5E.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-WRT324N6.js → chunk-FVDQ5E67.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   delay
-} from "./chunk-YDJRMQU4.js";
+} from "./chunk-V3GINY6K.js";
 import {
   isTlsVerificationDisabled
-} from "./chunk-PZRUV52H.js";
+} from "./chunk-GTUKW3I6.js";
 import {
   getErrorMessage
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";