@sema-agent/core 5.7.0 → 5.8.0

package/dist/core/runner/runtask.js

@@ -1,15 +1,14 @@
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, uuidv7 } from "../../internal/harness.js";
-import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, remainingWalltimeMs, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
-import { effectiveCushionMs, estimateCycleMs, hasRealContent, minLiveWriteoutWindowMs, recordCallSample, recordToolCycleSample, recordToolSample, recordTtftSample, softExecDeadlineMs, writeoutCushionMs } from "./call-cap.js";
+import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, remainingTokens, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
 import { engineVersion } from "../version.js";
 import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, isCompactionWalltimeAbort, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME, QUESTION_AWAITS_RESUME } from "../ask-question.js";
 import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { isDegenerateCutMessage, isWalltimeCutMessage } from "../../brain/terminal-cause.js";
+import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { primaryActivityArg } from "../arg-summary.js";
 import { resolveReasoning } from "../../brain/reasoning.js";
 import { readDegradation } from "../../brain/degrading.js";
@@ -41,17 +40,15 @@ import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, isDelegatedAgentTerminal, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
-import { DEFAULT_MAX_TURNS } from "../../config/defaults.js";
 import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
-export { DEFAULT_MAX_TURNS };
 function createRunState() {
     return {
         telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, pricingConfigured: true, unpricedSpend: false, tracer: undefined, taskId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
         degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
-        limits: { turnsExceeded: false, budgetHit: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
-        budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, overBudget: () => false, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => false },
+        limits: { turnsExceeded: false, budgetHit: undefined, budgetAxis: undefined, platformTerminal: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
+        budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, remainingTokens: undefined, maxTokensWindow: undefined, overBudget: () => undefined, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => undefined },
         turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
-        counters: { nudgesSent: 0, nudgeIdx: 0, finalizeInjected: false, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, callCutoffs: 0, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
+        counters: { approachNoticesSent: 0, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
         attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, sizeGuidelineState: undefined, attachmentsInjected: 0 },
     };
 }
@@ -96,14 +93,19 @@ const SUGGESTIONS_TIMEOUT_MS = 30_000;
 const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
 const SNAPSHOT_TIMEOUT_MS = 30_000;
 const SNAPSHOT_TOO_LARGE_TTL_MS = 30 * 60_000;
+const LIMIT_APPROACH_DEFAULT_THRESHOLDS = [0.8, 0.95];
+const DEFAULT_PRECALL_OUTPUT_TOKENS = 4096;
+function limitApproachFrames(index, axis, percent) {
+    return index === 0
+        ? `<system-reminder>[limit approach] This task has used about ${percent}% of its ${axis}. ` +
+            `Start converging: finish the step you are on, drop work that is not required for the deliverable, and ` +
+            `avoid starting anything you cannot complete within what is left.</system-reminder>`
+        : `<system-reminder>[limit approach] About ${percent}% of the ${axis} is gone. Deliver now: ` +
+            `stop exploring, write up what you have — including what is incomplete and what you would do next — ` +
+            `and end the task. Work that is not reported before the allowance runs out is lost.</system-reminder>`;
+}
 function resolveMaxTurns(limits) {
-    if (limits?.maxTurns !== undefined) {
-        return limits.maxTurns;
-    }
-    if (limits?.timeoutSec !== undefined && limits.timeoutSec > 0) {
-        return undefined;
-    }
-    return DEFAULT_MAX_TURNS;
+    return limits?.maxTurns;
 }
 function resumeDecisionWasNegative(resume) {
     const o = resume.outcome;
@@ -228,62 +230,85 @@ function resumeContinuation(resume) {
         `conversation above. Do NOT restart the task or re-run any tool you already ran; continue from this ` +
         `exact point, building on the existing results, and finish the remaining work.`);
 }
+function platformLimitTerminal(reason, retryAfterMs, moment = "turn_boundary") {
+    const message = moment === "entry"
+        ? `a deployment usage window is exhausted (RunnerDeps.usageWindows), so the task was refused before its first model call — nothing ran and nothing was spent. There is no checkpoint to suspend into at this point, so the caller re-submits after the window frees, in ${String(retryAfterMs ?? 0)}ms.`
+        : reason === "env_lifetime"
+            ? "the execution environment's declared lifetime is expiring and the run could not be suspended durably (not eligible, or the suspend was refused — see remoteEnvFailures / onError). It was stopped at a clean turn boundary instead of being killed mid-turn when the platform reclaims the environment."
+            : `a deployment usage window is exhausted (RunnerDeps.usageWindows) and the run could not be suspended durably, so it was stopped at a clean turn boundary. The window frees in ${String(retryAfterMs ?? 0)}ms.`;
+    const e = new Error(message);
+    e.code = reason === "env_lifetime" ? "env.lifetime_expired" : "usage.window_exhausted";
+    if (retryAfterMs !== undefined)
+        e.retryAfterMs = retryAfterMs;
+    return e;
+}
 function makeTurnBoundary(prepared, stats, rs, deps) {
-    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, turnToolSpan, walltimeDeadlineMs, walltimeMonotonicDeadline, nudgeSchedule, buildFinalizeText, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
+    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
     let finalVerifySeenAtLastBoundary = 0;
     const onTurnBoundary = async (event) => {
-        if (prepared.callCapRef && turnToolSpan.startMin !== undefined && turnToolSpan.endMax !== undefined) {
-            recordToolCycleSample(prepared.callCapRef.state, turnToolSpan.endMax - turnToolSpan.startMin);
-        }
-        turnToolSpan.startMin = undefined;
-        turnToolSpan.endMax = undefined;
         let boundarySteered = false;
-        if (prepared.suspendForResource === undefined) {
-            const nowMs = Date.now();
-            if (!rs.counters.finalizeInjected &&
-                spec.limits?.gracefulFinalize !== false &&
-                walltimeDeadlineMs !== undefined &&
-                prepared.callCapRef !== undefined) {
-                const remainingMs = walltimeDeadlineMs - nowMs;
-                if (remainingMs > 0 && remainingMs < estimateCycleMs(prepared.callCapRef.state) + (effectiveCushionMs(prepared.callCapRef) ?? 0)) {
-                    rs.counters.finalizeInjected = true;
-                    prepared.callCapRef.finalizeMode = true;
-                    void prepared.harness.setThinkingLevel("off").catch(() => { });
-                    prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
-                    rs.counters.nudgeIdx = nudgeSchedule.length;
-                    const finalizeText = buildFinalizeText();
-                    void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
-                    boundarySteered = true;
-                    queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
-                }
-            }
-            let due;
-            while (rs.counters.nudgeIdx < nudgeSchedule.length && nowMs >= nudgeSchedule[rs.counters.nudgeIdx].atMs) {
-                due = nudgeSchedule[rs.counters.nudgeIdx++];
-            }
-            if (due) {
-                void prepared.harness.steer(due.text, { engineMinted: true }).catch(() => { });
-                rs.counters.nudgesSent += 1;
-                boundarySteered = true;
-                queue.push({ type: "steering_injected", source: "deadline_nudge", preview: due.text.slice(0, 220), ...ident() });
-            }
-        }
         const walltimeHit = walltimeMonotonicDeadline !== undefined && performance.now() >= walltimeMonotonicDeadline;
         const preemptHit = spec.preemptSignal?.aborted === true;
         if (preemptHit && !prepared.suspendForResource && !rs.counters.preemptIgnoredReported) {
             rs.counters.preemptIgnoredReported = true;
             emitTrace(rs.telemetry.tracer, () => ({ kind: "preempt.ignored", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
         }
+        let platformCause;
+        let platformRetryAfterMs;
+        const preemptWillSuspend = preemptHit && prepared.suspendForResource !== undefined;
+        if (!preemptWillSuspend && prepared.suspendRef.token === undefined && !prepared.abortController.signal.aborted) {
+            if (prepared.envLifetimeSuspendAt !== undefined && Date.now() >= prepared.envLifetimeSuspendAt) {
+                platformCause = "env_lifetime";
+            }
+            else if (prepared.usageGovernance !== undefined) {
+                const governance = prepared.usageGovernance;
+                try {
+                    const at = Date.now();
+                    await governance.commit(stats.tokens, at);
+                    platformRetryAfterMs = await governance.check(at);
+                    if (platformRetryAfterMs !== undefined)
+                        platformCause = "usage_window";
+                }
+                catch (govErr) {
+                    rs.limits.platformTerminal = govErr instanceof Error ? govErr : new Error(String(govErr));
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                    return undefined;
+                }
+            }
+        }
+        if (platformCause !== undefined) {
+            const platformSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
+            const committed = prepared.suspendForPlatformLimit !== undefined &&
+                (await prepared.suspendForPlatformLimit(platformCause, platformSpend, platformRetryAfterMs !== undefined ? { resumeAfterMs: platformRetryAfterMs } : undefined));
+            if (committed) {
+                rs.limits.turnsExceeded = false;
+                rs.limits.budgetHit = undefined;
+                return undefined;
+            }
+            const terminal = platformLimitTerminal(platformCause, platformRetryAfterMs);
+            rs.limits.platformTerminal = terminal;
+            try {
+                runnerHooks.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+            }
+            catch {
+            }
+            void prepared.harness.abort();
+            prepared.abortController.abort();
+            return undefined;
+        }
         if (prepared.suspendForResource &&
             (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
             prepared.suspendRef.token === undefined) {
             const reason = preemptHit
                 ? "preempt"
                 : rs.limits.budgetHit !== undefined
-                    ? "budget"
-                    : walltimeHit
-                        ? "walltime"
-                        : "turns";
+                    ? rs.limits.budgetAxis === "tokens"
+                        ? "budget_tokens"
+                        : "budget_cost"
+                    : rs.limits.turnsExceeded
+                        ? "turns"
+                        : "walltime";
             const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
             if (await prepared.suspendForResource(reason, sliceSpend)) {
                 rs.limits.turnsExceeded = false;
@@ -308,6 +333,39 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             }
             return undefined;
         }
+        const approachCfg = spec.limits?.approachNotice;
+        if (approachCfg !== false &&
+            rs.counters.approachNoticesSent < LIMIT_APPROACH_DEFAULT_THRESHOLDS.length &&
+            prepared.suspendForResource === undefined &&
+            rs.turn.lastTurnHadToolCalls &&
+            !boundarySteered &&
+            !prepared.abortController.signal.aborted) {
+            const thresholds = approachCfg?.at ?? LIMIT_APPROACH_DEFAULT_THRESHOLDS;
+            const ratios = [];
+            if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow > 0) {
+                ratios.push({ axis: "token budget", ratio: stats.tokens / rs.budget.maxTokensWindow });
+            }
+            if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd > 0) {
+                ratios.push({ axis: "cost budget", ratio: stats.costMicroUsd / rs.budget.maxCostMicroUsd });
+            }
+            const declaredMaxTurns = spec.limits?.maxTurns;
+            if (declaredMaxTurns !== undefined && declaredMaxTurns > 0) {
+                ratios.push({ axis: "turn budget", ratio: (stats.turns + 1) / declaredMaxTurns });
+            }
+            let tightest;
+            for (const r of ratios)
+                if (tightest === undefined || r.ratio > tightest.ratio)
+                    tightest = r;
+            const index = rs.counters.approachNoticesSent;
+            if (tightest !== undefined && tightest.ratio >= thresholds[index]) {
+                rs.counters.approachNoticesSent += 1;
+                const percent = Math.min(100, Math.round(tightest.ratio * 100));
+                const body = limitApproachFrames(index === 0 ? 0 : 1, tightest.axis, percent);
+                void prepared.harness.steer(body, { engineMinted: true }).catch(() => undefined);
+                queue.push({ type: "steering_injected", source: "limit_approach", preview: body.slice(0, 220), ...ident() });
+                boundarySteered = true;
+            }
+        }
         if (prepared.reviewRequestRef.pending !== undefined) {
             const { reason } = prepared.reviewRequestRef.pending;
             prepared.reviewRequestRef.pending = undefined;
@@ -337,7 +395,6 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             rs.attach.sizeGuidelineState !== undefined ||
             rs.attach.attachState !== undefined) &&
             !boundarySteered &&
-            !rs.counters.finalizeInjected &&
             rs.counters.finalVerifyInjections === 0 &&
             !prepared.abortController.signal.aborted) {
             const due = [];
@@ -525,7 +582,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
             const batch = rs.turn.toolBatch;
             rs.turn.toolBatch = [];
             batchArgs?.clear();
-            const injectedThisTurn = finalVerifyInjectedThisTurn ? "final_verification" : rs.counters.finalizeInjected ? "finalize" : undefined;
+            const injectedThisTurn = finalVerifyInjectedThisTurn ? "final_verification" : undefined;
             if (!boundarySteered && !prepared.abortController.signal.aborted) {
                 try {
                     const r = await postToolBatchHook(batch, injectedThisTurn !== undefined ? { injectedThisTurn } : undefined);
@@ -555,7 +612,6 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         }
         const forceManual = manualCompactRef.requested;
         if ((!withinTaskCompaction && !forceManual) ||
-            (rs.counters.finalizeInjected && !forceManual) ||
             prepared.abortController.signal.aborted ||
             prepared.suspendRef.token !== undefined ||
             prepared.reviewRef.token !== undefined) {
@@ -617,9 +673,6 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         const trimPressure = trimPressureArmed && !rs.counters.trimForceBackoff;
         const passTrigger = trimPressure ? "forced" : forceManual ? "manual" : "auto";
         let manualOutcome = "failed";
-        if (rs.counters.finalizeInjected && forceManual) {
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.manual_in_finalize", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-        }
         const manualInstructions = claimedManual?.instructions;
         try {
             const comp = await maybeCompact({
@@ -744,16 +797,10 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                 manualOutcome = "mooted";
             }
             else if (!prepared.abortController.signal.aborted) {
-                const walltimeAbort = isCompactionWalltimeAbort(err);
-                if (!walltimeAbort)
-                    compactionBreaker.failures += 1;
+                compactionBreaker.failures += 1;
                 runnerHooks.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
                 const msg = String(err instanceof Error ? err.message : err);
-                const failReason = walltimeAbort
-                    ? "walltime soft-deadline abort (engine-initiated write-out protection; not counted toward the breaker)"
-                    : msg.length > 512
-                        ? `${msg.slice(0, 512)}…`
-                        : msg;
+                const failReason = msg.length > 512 ? `${msg.slice(0, 512)}…` : msg;
                 emitTrace(rs.telemetry.tracer, () => ({
                     kind: "compaction.failed",
                     version: 1,
@@ -776,7 +823,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
     return onTurnBoundary;
 }
 function makeHarnessHandlers(prepared, stats, rs, deps) {
-    const { spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
+    const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
     let lastWorkspaceCwd = prepared.cwdRef?.current;
     const announceWorkspaceMove = () => {
         const cwdNow = prepared.cwdRef?.current;
@@ -801,8 +848,10 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             rs.budget.callOutputChars += ev.delta.length;
             if (rs.budget.callOutputChars - rs.budget.lastStreamBudgetCheck >= 256) {
                 rs.budget.lastStreamBudgetCheck = rs.budget.callOutputChars;
-                if (rs.budget.projectedOverBudget()) {
+                const projectedAxis = rs.budget.projectedOverBudget();
+                if (projectedAxis !== undefined) {
                     rs.limits.budgetHit = "exceeded";
+                    rs.limits.budgetAxis = projectedAxis;
                     void prepared.harness.abort();
                     prepared.abortController.abort();
                 }
@@ -841,19 +890,8 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
             rs.turn.turnUsage.cacheWriteTokens += u.cacheWrite || 0;
             rs.turn.turnUsage.costMicroUsd += turnCostMicroUsd;
             const callEndAt = Date.now();
-            const callIssuedAt = prepared.callIssuedAtRef?.current;
-            if (prepared.callIssuedAtRef)
-                prepared.callIssuedAtRef.current = undefined;
-            const capLast = prepared.callCapRef?.state.last;
-            if (prepared.callCapRef) {
-                recordCallSample(prepared.callCapRef.state, u.output || 0, rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0, {
-                    contentValid: m.usageMissing === true && hasRealContent(m.content),
-                });
-                if (rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined) {
-                    recordTtftSample(prepared.callCapRef.state, rs.turn.firstTokenAt - rs.turn.callStartAt);
-                }
-                prepared.callCapRef.state.last = undefined;
-            }
+            const callIssuedAt = prepared.callIssuedAtRef.current;
+            prepared.callIssuedAtRef.current = undefined;
             emitTrace(rs.telemetry.tracer, () => ({
                 kind: "brain.call",
                 version: 1,
@@ -870,25 +908,11 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 firstTokenMs: rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined ? rs.turn.firstTokenAt - rs.turn.callStartAt : undefined,
                 ...(callIssuedAt !== undefined ? { callStartedAt: callIssuedAt } : {}),
                 ...(rs.telemetry.pricingConfigured ? { costMicroUsd: turnCostMicroUsd } : {}),
-                ...(capLast !== undefined ? { callCap: capLast.cap, capThinkingSkipped: capLast.thinkingSkipped } : {}),
                 ...(m.role === "assistant" && typeof m.stopReason === "string"
                     ? { stopReason: m.stopReason }
                     : {}),
                 ts: callEndAt,
             }));
-            if (prepared.callCapRef &&
-                prepared.callCapRef.reasoningObserved !== true &&
-                capLast !== undefined &&
-                m.role === "assistant" &&
-                m.stopReason === "length") {
-                const blocks = Array.isArray(m.content)
-                    ? (m.content)
-                    : [];
-                const productive = blocks.some((c) => c?.type === "toolCall") ||
-                    blocks.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim() !== "");
-                if (!productive)
-                    prepared.callCapRef.reasoningObserved = true;
-            }
             if (prepared.cacheBreakDetector && prepared.cacheFingerprint) {
                 const finding = prepared.cacheBreakDetector.observe({
                     turn: stats.turns + 1,
@@ -906,20 +930,6 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
         if (m.role === "assistant" && typeof m.stopReason === "string") {
             rs.turn.turnStopReason = m.stopReason;
         }
-        if (m.role === "assistant" && isWalltimeCutMessage(m)) {
-            rs.counters.callCutoffs += 1;
-            if (prepared.callCapRef)
-                prepared.callCapRef.finalizeMode = true;
-            if (!rs.counters.finalizeInjected) {
-                const finalizeText = buildFinalizeText();
-                void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
-                void prepared.harness.setThinkingLevel("off").catch(() => { });
-                prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
-                rs.counters.finalizeInjected = true;
-                rs.counters.nudgeIdx = nudgeSchedule.length;
-                queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
-            }
-        }
         if (m.role === "assistant") {
             const rep = m.repetition;
             if (rep !== undefined) {
@@ -950,13 +960,6 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 }
             }
         }
-        if (prepared.callCapRef &&
-            prepared.callCapRef.reasoningObserved !== true &&
-            m.role === "assistant" &&
-            Array.isArray(m.content) &&
-            m.content.some((c) => c?.type === "thinking")) {
-            prepared.callCapRef.reasoningObserved = true;
-        }
         if (m.role === "assistant") {
             const content = m.content;
             if (rs.attach.attachState !== undefined)
@@ -995,11 +998,6 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
         const toolStarted = toolStartAt.get(event.toolCallId);
         toolStartAt.delete(event.toolCallId);
         const toolNow = Date.now();
-        if (prepared.callCapRef && toolStarted !== undefined) {
-            recordToolSample(prepared.callCapRef.state, toolNow - toolStarted);
-            turnToolSpan.startMin = turnToolSpan.startMin === undefined ? toolStarted : Math.min(turnToolSpan.startMin, toolStarted);
-            turnToolSpan.endMax = turnToolSpan.endMax === undefined ? toolNow : Math.max(turnToolSpan.endMax, toolNow);
-        }
         if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
             rs.counters.wroteThisRun = true;
         }
@@ -1119,21 +1117,17 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
         }
         else {
             if (rs.degrade.degraded === undefined &&
-                spec.degrade &&
+                spec.limits?.degrade &&
                 rs.degrade.degradeToModel &&
                 rs.budget.maxCostMicroUsd !== undefined &&
-                stats.costMicroUsd >= spec.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
+                stats.costMicroUsd >= spec.limits.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
                 void prepared.harness.setModel(rs.degrade.degradeToModel);
                 rs.degrade.recordDegraded({ from: prepared.model.id, to: rs.degrade.degradeToModel.id, reason: "budget", atTurn: stats.turns }, rs.degrade.degradeToModel);
-                if (prepared.callCapRef &&
-                    spec.limits?.maxOutputTokens === undefined &&
-                    rs.degrade.degradeToModel.maxTokens !== undefined &&
-                    (prepared.callCapRef.staticCapTokens === undefined || rs.degrade.degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
-                    prepared.callCapRef.staticCapTokens = rs.degrade.degradeToModel.maxTokens;
-                }
             }
-            if (!rs.limits.budgetHit && rs.budget.overBudget()) {
+            const overAxis = rs.limits.budgetHit ? undefined : rs.budget.overBudget();
+            if (overAxis !== undefined) {
                 rs.limits.budgetHit = "exceeded";
+                rs.limits.budgetAxis = overAxis;
                 if (prepared.suspendForResource === undefined) {
                     void prepared.harness.abort();
                     prepared.abortController.abort();
@@ -1702,9 +1696,9 @@ export class Runner {
         rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
         rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
         rs.telemetry.pricingConfigured = this.deps.pricing?.[prepared.model.id] !== undefined || prepared.model.cost !== undefined;
-        if (spec.degrade) {
+        if (spec.limits?.degrade) {
             try {
-                rs.degrade.degradeToModel = resolveModel(spec.degrade.to, this.deps.models);
+                rs.degrade.degradeToModel = resolveModel(spec.limits.degrade.to, this.deps.models);
             }
             catch (e) {
                 this.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId });
@@ -1776,7 +1770,7 @@ export class Runner {
             catch {
             }
         };
-        const sliceWindowMicroUsd = spec.maxCostUsd !== undefined ? Math.round(spec.maxCostUsd * 1e6) : undefined;
+        const sliceWindowMicroUsd = spec.limits?.maxCostUsd !== undefined ? Math.round(spec.limits.maxCostUsd * 1e6) : undefined;
         rs.budget.remainingMicroUsd = prepared.resourceLedger
             ? remainingBudgetMicroUsd(prepared.resourceLedger)
             : spec.resourceSuspend?.totalBudgetUsd !== undefined
@@ -1786,24 +1780,36 @@ export class Runner {
             sliceWindowMicroUsd !== undefined && rs.budget.remainingMicroUsd !== undefined
                 ? Math.min(sliceWindowMicroUsd, rs.budget.remainingMicroUsd)
                 : (sliceWindowMicroUsd ?? rs.budget.remainingMicroUsd);
-        rs.budget.overBudget = () => (rs.budget.maxCostMicroUsd !== undefined && stats.costMicroUsd > rs.budget.maxCostMicroUsd) ||
-            (spec.maxTokens !== undefined && stats.tokens > spec.maxTokens);
+        rs.budget.remainingTokens = prepared.resourceLedger
+            ? remainingTokens(prepared.resourceLedger)
+            : spec.resourceSuspend?.totalTokens;
+        rs.budget.maxTokensWindow =
+            spec.limits?.maxTokens !== undefined && rs.budget.remainingTokens !== undefined
+                ? Math.min(spec.limits.maxTokens, rs.budget.remainingTokens)
+                : (spec.limits?.maxTokens ?? rs.budget.remainingTokens);
+        rs.budget.overBudget = () => {
+            if (rs.budget.maxTokensWindow !== undefined && stats.tokens > rs.budget.maxTokensWindow)
+                return "tokens";
+            if (rs.budget.maxCostMicroUsd !== undefined && stats.costMicroUsd > rs.budget.maxCostMicroUsd)
+                return "cost";
+            return undefined;
+        };
         rs.budget.streamCancel =
-            (spec.budgetStreamCancel ?? rs.budget.maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
+            (spec.limits?.budgetStreamCancel ?? rs.budget.maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
         rs.budget.callOutputChars = 0;
         rs.budget.lastStreamBudgetCheck = 0;
         rs.budget.projectedOverBudget = () => {
             const estOut = Math.ceil(rs.budget.callOutputChars / 4);
+            if (rs.budget.maxTokensWindow !== undefined && stats.tokens + estOut > rs.budget.maxTokensWindow)
+                return "tokens";
             if (rs.budget.maxCostMicroUsd !== undefined) {
                 const estOutMicro = computeCostMicroUsd({ totalInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: estOut }, rs.telemetry.pricing);
                 if (stats.costMicroUsd + estOutMicro > rs.budget.maxCostMicroUsd)
-                    return true;
+                    return "cost";
             }
-            return spec.maxTokens !== undefined && stats.tokens + estOut > spec.maxTokens;
+            return undefined;
         };
         rs.turn.turnUsageMissing = false;
-        rs.counters.nudgesSent = 0;
-        rs.counters.callCutoffs = 0;
         rs.counters.repetitionCuts = 0;
         rs.counters.repetitionSpared = 0;
         rs.counters.repetitionEvents = [];
@@ -1999,7 +2005,6 @@ export class Runner {
         }
         const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(name);
         const toolStartAt = new Map();
-        const turnToolSpan = {};
         const startedToolCallIds = new Set();
         emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
         emitTrace(rs.telemetry.tracer, () => ({
@@ -2054,61 +2059,9 @@ export class Runner {
                 };
             });
         }
-        const sliceWindowWalltimeMs = spec.limits?.timeoutSec ? spec.limits.timeoutSec * 1000 : undefined;
-        const remainingWalltimeBudgetMs = prepared.resourceLedger?.totalWalltimeSec !== undefined
-            ? remainingWalltimeMs(prepared.resourceLedger)
-            : spec.resourceSuspend?.totalWalltimeSec !== undefined
-                ? Math.max(0, spec.resourceSuspend.totalWalltimeSec * 1000 - (prepared.resourceLedger?.spentWalltimeMs ?? 0))
-                : undefined;
-        const effectiveTimeoutMs = sliceWindowWalltimeMs !== undefined && remainingWalltimeBudgetMs !== undefined
-            ? Math.min(sliceWindowWalltimeMs, remainingWalltimeBudgetMs)
-            : (sliceWindowWalltimeMs ?? remainingWalltimeBudgetMs);
-        const walltimeDeadlineMs = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStart + effectiveTimeoutMs : undefined;
+        const effectiveTimeoutMs = spec.limits?.maxWalltimeMs;
         const walltimeMonotonicDeadline = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStartMonotonic + effectiveTimeoutMs : undefined;
-        if (prepared.callCapRef && prepared.suspendForResource === undefined && walltimeDeadlineMs !== undefined) {
-            prepared.callCapRef.deadlineMs = walltimeDeadlineMs;
-            if (spec.limits?.gracefulFinalize !== false) {
-                prepared.callCapRef.cushionMs = writeoutCushionMs(effectiveTimeoutMs);
-                prepared.callCapRef.budgetMs = effectiveTimeoutMs;
-            }
-        }
-        rs.counters.finalizeInjected = false;
         rs.counters.walltimeSyncBackstopFired = false;
-        const nudgeSchedule = [];
-        {
-            const conf = spec.limits?.deadlineNudge;
-            const budgetSec = effectiveTimeoutMs !== undefined ? effectiveTimeoutMs / 1000 : undefined;
-            if (conf !== false && budgetSec && budgetSec > 0) {
-                const [a, b] = conf?.at ?? [0.8, 0.95];
-                if (a > 0 && a < 1) {
-                    const t1 = rs.telemetry.taskStart + a * budgetSec * 1000;
-                    const remainMin = Math.max(1, Math.round((budgetSec * 1000 * (1 - a)) / 60_000));
-                    const budgetMin = Math.max(1, Math.round(budgetSec / 60));
-                    nudgeSchedule.push({
-                        atMs: t1,
-                        text: `<system-reminder>[deadline] ~${remainMin} min of the ~${budgetMin}-min wall-clock budget remain. ` +
-                            `Start converging: persist finished work (write files / commit), prefer completing in-flight items over opening new ones.</system-reminder>`,
-                    });
-                    const t2 = rs.telemetry.taskStart + Math.max(Math.min(b * budgetSec * 1000, budgetSec * 1000 - 120_000), a * budgetSec * 1000 + 1);
-                    if (b > a && b < 1) {
-                        nudgeSchedule.push({
-                            atMs: t2,
-                            text: `<system-reminder>[deadline] the wall-clock budget is nearly exhausted. STOP new work — ` +
-                                `write out deliverables and give your final answer NOW; an unfinished answer beats a hard timeout.</system-reminder>`,
-                        });
-                    }
-                }
-            }
-        }
-        rs.counters.nudgeIdx = 0;
-        const buildFinalizeText = () => `<system-reminder>[deadline] the wall-clock budget is exhausted — this is the FINAL turn. ` +
-            `Write your best current work to the deliverable path NOW, even if incomplete — persist to disk FIRST; everything else comes after. ` +
-            `If a better version exists anywhere else (a draft, scratch or temp file), copy it to the deliverable path now. ` +
-            `Do NOT open new work, new investigations, or long commands; write out and stop.` +
-            (finalVerificationOn
-                ? ` After writing, if seconds permit, confirm the deliverable file actually EXISTS at the required path with your latest content.`
-                : "") +
-            `</system-reminder>`;
         const timeout = startTimeout(prepared.harness, prepared.abortController, walltimeMonotonicDeadline !== undefined ? walltimeMonotonicDeadline - performance.now() : undefined, prepared.suspendForResource !== undefined);
         const parentToolCallId = internals?.parentToolCallId;
         const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: rs.telemetry.taskId } : { eventId: uuidv7() };
@@ -2164,8 +2117,8 @@ export class Runner {
         const batchArgs = postToolBatchHook ? new Map() : undefined;
         rs.turn.toolBatch = [];
         const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = makeHarnessHandlers(prepared, stats, rs, {
-            spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName,
-            pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf,
+            spec, queue, internals, ident, parentToolCallId, subagentName,
+            pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
             toolLabels, postToolBatchHook, batchArgs,
             runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
         });
@@ -2206,7 +2159,6 @@ export class Runner {
         };
         const withinTaskCompaction = (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true);
         const compactionBreaker = { failures: 0 };
-        const compactionThroughputRef = {};
         const windowSafetyOptions = (mainModel) => ({
             ...(rs.budget.maxCostMicroUsd !== undefined
                 ? {
@@ -2217,15 +2169,6 @@ export class Runner {
                     },
                 }
                 : {}),
-            ...(walltimeDeadlineMs !== undefined && prepared.callCapRef !== undefined
-                ? {
-                    walltime: {
-                        deadlineMs: walltimeDeadlineMs,
-                        cushionMs: () => effectiveCushionMs(prepared.callCapRef) ?? 0,
-                        throughputRef: compactionThroughputRef,
-                    },
-                }
-                : {}),
             onWindowSafety: (info) => {
                 if (info.kind === "fallback") {
                     emitTrace(rs.telemetry.tracer, () => ({
@@ -2263,7 +2206,6 @@ export class Runner {
                     (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
                     rs.counters.wroteThisRun &&
                     prepared.outputRef.set !== true &&
-                    !rs.counters.finalizeInjected &&
                     !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1)) {
                     rs.counters.finalVerifyInjections += 1;
                     if (rs.counters.finalVerifyInjections === 2) {
@@ -2371,18 +2313,6 @@ export class Runner {
             malformedToolUse: {},
             thinkingOnly: {},
             degenerateOutput: { detect: (m) => isDegenerateCutMessage(m) },
-            walltimeCutoff: {
-                detect: (m) => isWalltimeCutMessage(m),
-                hasLiveWriteoutWindow: () => {
-                    const ref = prepared.callCapRef;
-                    if (ref === undefined)
-                        return true;
-                    const soft = softExecDeadlineMs(ref);
-                    if (soft === undefined)
-                        return true;
-                    return soft - Date.now() >= minLiveWriteoutWindowMs(ref.state);
-                },
-            },
             promptTooLong: {
                 recover: async () => {
                     if (!(spec.compaction?.enabled ?? true))
@@ -2456,8 +2386,7 @@ export class Runner {
                         return comp.compacted === true;
                     }
                     catch (err) {
-                        if (!isCompactionWalltimeAbort(err))
-                            compactionBreaker.failures += 1;
+                        compactionBreaker.failures += 1;
                         const msg = String(err instanceof Error ? err.message : err);
                         queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
                         return false;
@@ -2472,8 +2401,8 @@ export class Runner {
                 w.resolve(outcome);
         };
         const onTurnBoundary = makeTurnBoundary(prepared, stats, rs, {
-            spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, turnToolSpan,
-            walltimeDeadlineMs, walltimeMonotonicDeadline, nudgeSchedule, buildFinalizeText,
+            spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted,
+            walltimeMonotonicDeadline,
             timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
             compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
             runnerHooks: {
@@ -2541,8 +2470,13 @@ export class Runner {
                     void prepared.harness.abort();
                     prepared.abortController.abort();
                 }
+                else if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow <= 0) {
+                    rs.limits.budgetHit = "exceeded";
+                    rs.limits.budgetAxis = "tokens";
+                }
                 else if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd <= 0) {
                     rs.limits.budgetHit = "exceeded";
+                    rs.limits.budgetAxis = "cost";
                 }
                 else {
                     let continuation = resumeContinuation(resume);
@@ -2641,13 +2575,30 @@ export class Runner {
                         cacheReadTokens: 0,
                         cacheWriteTokens: 0,
                         cacheWriteTokensLong: 0,
-                        outputTokens: prepared.model.maxTokens ?? 4096,
+                        outputTokens: prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS,
                     }, rs.telemetry.pricing);
                 const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? rs.budget.remainingMicroUsd : rs.budget.maxCostMicroUsd;
+                const precallTokens = Math.ceil(effectiveObjective.length / 4) + (prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS);
+                const precallCeilingTokens = prepared.suspendForResource !== undefined ? rs.budget.remainingTokens : rs.budget.maxTokensWindow;
+                const entryUsageRetryAfterMs = prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
                 if (promptBlocked) {
                 }
+                else if (entryUsageRetryAfterMs !== undefined) {
+                    const terminal = platformLimitTerminal("usage_window", entryUsageRetryAfterMs, "entry");
+                    rs.limits.platformTerminal = terminal;
+                    try {
+                        this.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+                else if (precallCeilingTokens !== undefined && precallTokens > precallCeilingTokens) {
+                    rs.limits.budgetHit = "precall";
+                    rs.limits.budgetAxis = "tokens";
+                }
                 else if (precallCeilingMicroUsd !== undefined && precallMicroUsd > precallCeilingMicroUsd) {
                     rs.limits.budgetHit = "precall";
+                    rs.limits.budgetAxis = "cost";
                 }
                 else if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
                     timeout.fired = true;
@@ -2702,6 +2653,17 @@ export class Runner {
         if (threw === undefined && prepared.brainCallGuardrailRef.timedOut !== undefined) {
             threw = prepared.brainCallGuardrailRef.timedOut;
         }
+        if (rs.limits.platformTerminal !== undefined) {
+            threw = rs.limits.platformTerminal;
+        }
+        if (prepared.usageGovernance !== undefined) {
+            try {
+                await prepared.usageGovernance.commit(stats.tokens, Date.now());
+            }
+            catch (flushErr) {
+                this.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
+            }
+        }
         const suspended = prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined;
         const reviewPaused = prepared.reviewRef.token !== undefined && prepared.reviewRef.gate !== undefined;
         const durablyPaused = suspended || reviewPaused;
@@ -2800,24 +2762,12 @@ export class Runner {
                     gates: [...prepared.humanReviewRef.gates],
                 };
             }
-            const capShrinks = prepared.callCapRef?.shrinks ?? 0;
-            const toolClamps = prepared.callCapRef?.toolClamps ?? 0;
-            const toolCuts = prepared.callCapRef?.toolCuts ?? 0;
-            const pendingCutTools = prepared.callCapRef?.pendingCutTools ?? 0;
-            const toolCutKills = prepared.cutKills?.kills ?? 0;
-            if (rs.counters.finalizeInjected || rs.counters.nudgesSent > 0 || capShrinks > 0 || rs.counters.callCutoffs > 0 || toolClamps > 0 || toolCuts > 0 || toolCutKills > 0 || pendingCutTools > 0 || rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0) {
+            if (rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0 || rs.counters.approachNoticesSent > 0) {
                 stats.mechanisms = {
-                    ...(rs.counters.finalizeInjected ? { finalizeInjected: true } : {}),
-                    ...(rs.counters.nudgesSent > 0 ? { nudgesSent: rs.counters.nudgesSent } : {}),
-                    ...(capShrinks > 0 ? { capShrinks } : {}),
-                    ...(rs.counters.callCutoffs > 0 ? { callCutoffs: rs.counters.callCutoffs } : {}),
-                    ...(toolClamps > 0 ? { toolClamps } : {}),
-                    ...(toolCuts > 0 ? { toolCuts } : {}),
-                    ...(toolCutKills > 0 ? { toolCutKills } : {}),
-                    ...(pendingCutTools > 0 ? { pendingCutTools } : {}),
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjections: rs.counters.finalVerifyInjections } : {}),
                     ...(rs.attach.attachmentsInjected > 0 ? { attachmentsInjected: rs.attach.attachmentsInjected } : {}),
+                    ...(rs.counters.approachNoticesSent > 0 ? { approachNoticesSent: rs.counters.approachNoticesSent } : {}),
                     ...(rs.counters.repetitionCuts > 0 ? { repetitionCuts: rs.counters.repetitionCuts } : {}),
                     ...(rs.counters.repetitionSpared > 0 ? { repetitionSpared: rs.counters.repetitionSpared } : {}),
                     ...(rs.counters.repetitionEvents.length > 0 ? { repetitionEvents: rs.counters.repetitionEvents } : {}),
@@ -2833,6 +2783,7 @@ export class Runner {
                 abortedForTurns: rs.limits.turnsExceeded,
                 abortedLive,
                 budgetHit: rs.limits.budgetHit,
+                budgetAxis: rs.limits.budgetAxis,
                 blockedReason: prepared.blockedRef.reason,
                 conflict: prepared.conflictRef.hit,
                 outputInvalid: rs.degrade.outputInvalid,
@@ -2891,7 +2842,6 @@ export class Runner {
                 result.status === "failed" &&
                 final?.stopReason === "error" &&
                 !isDegenerateCutMessage(final) &&
-                !isWalltimeCutMessage(final) &&
                 threw === undefined &&
                 rs.limits.budgetHit === undefined &&
                 !rs.degrade.outputInvalid &&
@@ -2959,7 +2909,7 @@ export class Runner {
                 ts: Date.now(),
             }));
             setResult(result);
-            if (parentToolCallId !== undefined && (result.status === "completed" || result.status === "failed" || result.status === "timeout" || result.status === "blocked")) {
+            if (parentToolCallId !== undefined && (result.status === "completed" || result.status === "failed" || result.status === "blocked")) {
                 const terminalTick = {
                     type: "task_progress",
                     taskId: rs.telemetry.taskId,
@@ -3298,6 +3248,12 @@ export class Runner {
         if (checkpointVersionOf(cp) > MAX_SUPPORTED_CHECKPOINT_VERSION) {
             throw new CheckpointError("checkpoint.unsupported_version", `checkpoint version ${checkpointVersionOf(cp)} is newer than this worker supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION})`);
         }
+        const retiredWalltimeTotal = cp.resourceLedger?.totalWalltimeSec;
+        if (retiredWalltimeTotal !== undefined) {
+            throw new CheckpointError("checkpoint.walltime_axis_retired", "this checkpoint's ledger carries a cross-slice WALL-CLOCK allocation (resourceLedger.totalWalltimeSec), an axis this engine version retired — " +
+                "resuming here would run the leg with that ceiling unenforced. Rejected pre-CAS (the checkpoint stays pending): finish it on a worker of the " +
+                "previous release, or start a fresh task bounded by resourceSuspend.totalTokens / totalBudgetUsd.");
+        }
         if (taskConfig.signal?.aborted === true && cp.status === "pending") {
             throw new CheckpointError("checkpoint.resume_aborted", "the resume was handed an ALREADY-ABORTED signal — refusing to consume the approval on a leg that cannot run it (the checkpoint stays pending and is resumable with a live signal)");
         }