@sema-agent/core 5.6.0 → 5.8.0

package/dist/brain/stream-engine.js

@@ -3,7 +3,6 @@ import { BrainError, classifyHttp, describeNetworkError } from "./errors.js";
 import { retryBackoffMs } from "./retry.js";
 import { emitBrainStatus, emitBrainTelemetry } from "./status-sink.js";
 import { createConnectController, resolveStallTimeoutMs } from "./timeout.js";
-import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
 const DEFAULT_MAX_RETRIES = 10;
 const MAX_RETRIES_ENV_CEILING = 15;
 const MAX_RETRIES_ENV = "SEMA_MAX_RETRIES";
@@ -43,9 +42,6 @@ function emptyAssistant(model) {
 function isAbortError(err) {
     return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
-function isWalltimeCutoff(err) {
-    return err instanceof Error && err.message === WALLTIME_CUTOFF_MESSAGE;
-}
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted)
@@ -78,7 +74,7 @@ async function sleepAnnouncingRetry(totalMs, signal, frame) {
     }
 }
 export function runStreamingBrain(args) {
-    const { model, doFetch, signal, config, httpLabel, buildRequest, makeParser, callDeadlineMs, stallTimeouts } = args;
+    const { model, doFetch, signal, config, httpLabel, buildRequest, makeParser, stallTimeouts } = args;
     const out = createAssistantMessageEventStream();
     let cleanup;
     let announcedRetry = false;
@@ -88,13 +84,10 @@ export function runStreamingBrain(args) {
         .catch((err) => {
         const aborted = signal?.aborted === true || isAbortError(err);
         terminalRetryPhase = "gave_up";
-        const walltimeCut = isWalltimeCutoff(err);
-        terminalRetryDetail = aborted ? "cancelled while retrying" : walltimeCut ? "wall-clock deadline reached while retrying" : "retries exhausted";
+        terminalRetryDetail = aborted ? "cancelled while retrying" : "retries exhausted";
         const errorMsg = emptyAssistant(model);
         errorMsg.stopReason = aborted ? "aborted" : "error";
         errorMsg.errorMessage = err instanceof Error ? err.message : String(err);
-        if (walltimeCut)
-            errorMsg.errorKind = "walltime_cutoff";
         errorMsg.usageMissing = true;
         out.push({ type: "error", reason: aborted ? "aborted" : "error", error: errorMsg });
     })
@@ -128,20 +121,13 @@ export function runStreamingBrain(args) {
                     e.name = "AbortError";
                     throw e;
                 }
-                if (callDeadlineMs !== undefined && Date.now() >= callDeadlineMs) {
-                    throw new Error(WALLTIME_CUTOFF_MESSAGE);
-                }
-                const cc = createConnectController(connectTimeoutMs, signal, callDeadlineMs);
+                const cc = createConnectController(connectTimeoutMs, signal);
                 let r;
                 let netErr;
                 try {
                     r = await doFetch(req.url, { method: "POST", headers: req.headers, body: req.body, signal: cc.signal });
                 }
                 catch (e) {
-                    if (cc.deadlineHit()) {
-                        cc.dispose();
-                        throw new Error(WALLTIME_CUTOFF_MESSAGE);
-                    }
                     if (cc.timedOut()) {
                         netErr = new Error(`connect timeout after ${connectTimeoutMs}ms`);
                     }
@@ -153,10 +139,6 @@ export function runStreamingBrain(args) {
                         netErr = e;
                     }
                 }
-                if (r && cc.deadlineHit()) {
-                    cc.dispose();
-                    throw new Error(WALLTIME_CUTOFF_MESSAGE);
-                }
                 if (r && r.ok && r.body) {
                     cc.clearTimer();
                     connect = cc;
@@ -168,13 +150,7 @@ export function runStreamingBrain(args) {
                 const retryable = netErr !== undefined ||
                     (r !== undefined && (r.status >= 500 || r.status === 429 || r.status === 408 || r.status === 409));
                 if (retryable && attempt < maxRetries) {
-                    if (callDeadlineMs !== undefined && Date.now() >= callDeadlineMs) {
-                        throw new Error(WALLTIME_CUTOFF_MESSAGE);
-                    }
                     const delayMs = retryBackoffMs(baseDelay, attempt, r);
-                    if (callDeadlineMs !== undefined && Date.now() + delayMs >= callDeadlineMs) {
-                        throw new Error(WALLTIME_CUTOFF_MESSAGE);
-                    }
                     const statusPhase = r?.status === 429 ? "rate_limited" : netErr !== undefined ? "reconnecting" : "retrying";
                     emitBrainTelemetry({ kind: "retry", attempt: attempt + 1, phase: "connect" });
                     announcedRetry = true;
@@ -228,8 +204,6 @@ export function runStreamingBrain(args) {
                     void reader.cancel().catch(() => undefined);
                 }, idleTimeoutMs);
             };
-            let dlTimer;
-            let deadlineCut = false;
             const sawContentToken = () => {
                 bumpIdle();
                 if (firstTokenSeen)
@@ -250,10 +224,6 @@ export function runStreamingBrain(args) {
                     clearTimeout(idleTimer);
                     idleTimer = undefined;
                 }
-                if (dlTimer) {
-                    clearTimeout(dlTimer);
-                    dlTimer = undefined;
-                }
                 connect?.dispose();
                 void reader.cancel().catch(() => undefined);
             };
@@ -273,14 +243,6 @@ export function runStreamingBrain(args) {
                 sawContentToken,
                 cancel: () => void reader.cancel().catch(() => undefined),
             });
-            if (callDeadlineMs !== undefined && parser.onDeadline) {
-                dlTimer = setTimeout(() => {
-                    dlTimer = undefined;
-                    deadlineCut = parser.onDeadline();
-                    void reader.cancel().catch(() => undefined);
-                }, Math.max(0, callDeadlineMs - Date.now()));
-                dlTimer.unref?.();
-            }
             const INBAND_OVERLOAD_WARNING = "API overloaded mid-response. The response above may be incomplete.";
             const onLineOverloadTierA = (line) => {
                 try {
@@ -334,14 +296,10 @@ export function runStreamingBrain(args) {
                 clearTimeout(idleTimer);
                 idleTimer = undefined;
             }
-            if (dlTimer) {
-                clearTimeout(dlTimer);
-                dlTimer = undefined;
-            }
-            if (!failure && firstTokenTimedOut && !deadlineCut) {
+            if (!failure && firstTokenTimedOut) {
                 failure = { kind: "stalled", err: new BrainError("network", `first-token timeout after ${firstTokenTimeoutMs}ms`) };
             }
-            if (!failure && idleTimedOut && !deadlineCut) {
+            if (!failure && idleTimedOut) {
                 failure = { kind: "stalled", err: new BrainError("network", `stream idle timeout after ${idleTimeoutMs}ms`) };
             }
             if (!failure) {

package/dist/brain/stream-shared.d.ts

@@ -6,13 +6,3 @@ export interface RepetitionPoll {
     readonly spared: RepetitionEvent[];
 }
 export declare function createRepetitionPoll(): RepetitionPoll;
-export interface WalltimeGate {
-    onDeadline(): boolean;
-    shouldDropLine(): boolean;
-    readonly cut: boolean;
-}
-export declare function createWalltimeGate(deps: {
-    callDeadlineMs: number | undefined;
-    isDegenerate: () => boolean;
-    cancel: () => void;
-}): WalltimeGate;

package/dist/brain/stream-shared.js

@@ -39,26 +39,3 @@ export function createRepetitionPoll() {
         },
     };
 }
-export function createWalltimeGate(deps) {
-    const { callDeadlineMs, isDegenerate, cancel } = deps;
-    let walltimeCut = false;
-    return {
-        get cut() {
-            return walltimeCut;
-        },
-        onDeadline() {
-            if (isDegenerate())
-                return false;
-            walltimeCut = true;
-            return true;
-        },
-        shouldDropLine() {
-            if (callDeadlineMs !== undefined && !walltimeCut && !isDegenerate() && Date.now() >= callDeadlineMs) {
-                walltimeCut = true;
-                cancel();
-                return true;
-            }
-            return walltimeCut;
-        },
-    };
-}

package/dist/brain/terminal-cause.d.ts

@@ -1,4 +1,3 @@
 import type { AssistantMessage } from "../internal/llm.js";
 export type TerminalCauseCarrier = Pick<AssistantMessage, "errorKind">;
 export declare function isDegenerateCutMessage(message: TerminalCauseCarrier): boolean;
-export declare function isWalltimeCutMessage(message: TerminalCauseCarrier): boolean;

package/dist/brain/terminal-cause.js

@@ -1,6 +1,3 @@
 export function isDegenerateCutMessage(message) {
     return message.errorKind === "degenerate";
 }
-export function isWalltimeCutMessage(message) {
-    return message.errorKind === "walltime_cutoff";
-}

package/dist/brain/timeout.d.ts

@@ -1,14 +1,16 @@
 import type { StreamFn } from "../internal/llm.js";
 export declare function resolveStallTimeoutMs(value: number | undefined, knob: string): number | undefined;
+export declare const STALL_CONNECT_MS = 30000;
+export declare const STALL_FIRST_TOKEN_MS = 120000;
+export declare const STALL_IDLE_MS = 90000;
 export interface BrainTimeoutConfig {
     connectTimeoutMs?: number;
     firstTokenTimeoutMs?: number;
     idleTimeoutMs?: number;
 }
-export declare function createConnectController(connectTimeoutMs: number | undefined, outerSignal: AbortSignal | undefined, deadlineAtMs?: number): {
+export declare function createConnectController(connectTimeoutMs: number | undefined, outerSignal: AbortSignal | undefined): {
     signal: AbortSignal;
     timedOut: () => boolean;
-    deadlineHit: () => boolean;
     clearTimer: () => void;
     dispose: () => void;
 };

package/dist/brain/timeout.js

@@ -8,10 +8,12 @@ export function resolveStallTimeoutMs(value, knob) {
     }
     return value;
 }
-export function createConnectController(connectTimeoutMs, outerSignal, deadlineAtMs) {
+export const STALL_CONNECT_MS = 30_000;
+export const STALL_FIRST_TOKEN_MS = 120_000;
+export const STALL_IDLE_MS = 90_000;
+export function createConnectController(connectTimeoutMs, outerSignal) {
     const ac = new AbortController();
     let timedOut = false;
-    let deadlineHit = false;
     const onAbort = () => ac.abort(outerSignal?.reason);
     if (outerSignal) {
         if (outerSignal.aborted)
@@ -26,26 +28,14 @@ export function createConnectController(connectTimeoutMs, outerSignal, deadlineA
             ac.abort();
         }, connectTimeoutMs);
     }
-    let deadlineTimer;
-    if (deadlineAtMs !== undefined) {
-        deadlineTimer = setTimeout(() => {
-            deadlineHit = true;
-            ac.abort();
-        }, Math.max(0, deadlineAtMs - Date.now()));
-        deadlineTimer.unref?.();
-    }
     const clearTimer = () => {
         if (timer)
             clearTimeout(timer);
         timer = undefined;
-        if (deadlineTimer)
-            clearTimeout(deadlineTimer);
-        deadlineTimer = undefined;
     };
     return {
         signal: ac.signal,
         timedOut: () => timedOut,
-        deadlineHit: () => deadlineHit,
         clearTimer,
         dispose: () => {
             clearTimer();

package/dist/config/catalog.d.ts

@@ -1,3 +1,4 @@
+import type { TaskLimits } from "../core/types.js";
 export declare const CONFIG_CATALOG_VERSION = "sema-config@1";
 export interface ConfigKnob {
     key: string;
@@ -24,18 +25,9 @@ export interface EffectiveConfigField {
 }
 export declare const MAX_OVERRIDE_DECLARATIONS = 32;
 export declare function resolveEffectiveConfig(spec: {
-    limits?: {
-        maxTurns?: number;
-        timeoutSec?: number;
-        maxOutputTokens?: number;
-        deadlineNudge?: false | object;
-        callCapByDeadline?: false;
-        gracefulFinalize?: false;
-    };
-    maxCostUsd?: number;
-    maxTokens?: number;
+    limits?: Pick<TaskLimits, "maxTurns" | "maxWalltimeMs" | "maxOutputTokens" | "maxCostUsd" | "maxTokens">;
     resourceSuspend?: {
-        totalWalltimeSec?: number;
+        totalTokens?: number;
         totalBudgetUsd?: number;
     };
     configOverrides?: readonly ConfigOverrideDeclaration[];

package/dist/config/catalog.js

@@ -1,22 +1,22 @@
-import { DEFAULT_MAX_TURNS, FORK_DEFAULT_MAX_TURNS, SESSION_BG_DEFAULT_TIMEOUT_SEC, RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX, SESSION_DEFAULT_TTL_DAYS } from "./defaults.js";
+import { RETAIN_DEFAULT_TTL_MS, RETAIN_DEFAULT_MAX, SESSION_DEFAULT_TTL_DAYS } from "./defaults.js";
 export const CONFIG_CATALOG_VERSION = "sema-config@1";
 export function describeConfigCatalog() {
     const knobs = [
         {
             key: "limits.maxTurns",
-            recommended: DEFAULT_MAX_TURNS,
+            recommended: null,
             unit: "turns",
-            kind: "safety-net",
-            summary: "Runaway net, NOT the long-run knob: catches a wedged tool-call loop before it burns budget. A genuinely long task sets its own explicit bound. 0 = unbounded.",
-            precedence: "spec.limits.maxTurns > engine default",
+            kind: "budget",
+            summary: "Per-slice turn ceiling. Unset = unbounded (design/164 retired the engine-side net): a task that needs a turn bound states one. 0 = the explicit unbounded sentinel.",
+            precedence: "spec.limits.maxTurns > unset",
         },
         {
-            key: "limits.timeoutSec",
+            key: "limits.maxWalltimeMs",
             recommended: null,
-            unit: "seconds",
+            unit: "ms",
             kind: "budget",
-            summary: "Hard wall-clock budget for the task. Unset = unbounded. Setting it arms the deadline family (nudges, call caps, graceful finalize) by default.",
-            precedence: "spec.limits.timeoutSec > unset",
+            summary: "Per-slice ACTIVE wall-clock window for the task (suspended time does not count; a resume opens a fresh window). Unset = unbounded, which is the recommendation — bound work by tokens, not by time.",
+            precedence: "spec.limits.maxWalltimeMs > unset",
         },
         {
             key: "limits.maxOutputTokens",
@@ -27,65 +27,35 @@ export function describeConfigCatalog() {
             precedence: "spec.limits.maxOutputTokens > model.maxTokens > provider default",
         },
         {
-            key: "limits.deadlineNudge",
-            recommended: true,
-            kind: "behavior",
-            summary: "Two one-shot convergence reminders (~80%/~95% of timeoutSec). Auto-ON when timeoutSec is set; no effect without it.",
-            precedence: "spec.limits.deadlineNudge > derived(timeoutSec set)",
-        },
-        {
-            key: "limits.callCapByDeadline",
-            recommended: true,
-            kind: "behavior",
-            summary: "Shrink each call's max_tokens to what remaining wall-clock can absorb (shrink-only). Auto-ON when timeoutSec is set.",
-            precedence: "spec.limits.callCapByDeadline > derived(timeoutSec set)",
-        },
-        {
-            key: "limits.gracefulFinalize",
-            recommended: true,
-            kind: "behavior",
-            summary: "One-shot finalize turn + write-out cushion + soft execution deadline when remaining time no longer fits a full cycle. Auto-ON when timeoutSec is set.",
-            precedence: "spec.limits.gracefulFinalize > derived(timeoutSec set)",
-        },
-        {
-            key: "budget.maxCostUsd",
+            key: "limits.maxCostUsd",
             recommended: null,
             unit: "usd",
             kind: "budget",
-            summary: "Cumulative spend cap for the task (hard-cancels the in-flight stream by default when crossed). Unset = unbounded.",
-            precedence: "spec.maxCostUsd > unset",
+            summary: "Per-slice spend ceiling (hard-cancels the in-flight stream by default when crossed). Unset = unbounded.",
+            precedence: "spec.limits.maxCostUsd > unset",
         },
         {
-            key: "budget.maxTokens",
+            key: "limits.maxTokens",
             recommended: null,
             unit: "tokens",
             kind: "budget",
-            summary: "Cumulative token budget for the task. Unset = unbounded.",
-            precedence: "spec.maxTokens > unset",
+            summary: "Per-slice token budget — the PRIMARY axis. Unset = unbounded.",
+            precedence: "spec.limits.maxTokens > unset",
         },
         {
-            key: "budget.totalWalltimeSec",
+            key: "limits.approachNotice",
             recommended: null,
-            unit: "seconds",
-            kind: "budget",
-            summary: "Cross-slice wall-clock allocation for resource-suspend tasks (RB-21). First slice only; later slices read the frozen ledger. Unset = per-slice budgets only.",
-            precedence: "spec.resources.totalWalltimeSec (first slice) > unset",
-        },
-        {
-            key: "delegation.forkMaxTurns",
-            recommended: FORK_DEFAULT_MAX_TURNS,
-            unit: "turns",
-            kind: "safety-net",
-            summary: "Default turn cap for the Agent fork arm (child inherits the parent's world; tighter net than the global default).",
-            precedence: "agent definition limits > fork default",
+            kind: "behavior",
+            summary: "Advisory limit-approach reminders (one at ~80% of the tightest armed axis, one at ~95%). Unset = ON whenever an axis is armed; false = off; { at } overrides the thresholds.",
+            precedence: "spec.limits.approachNotice > on-when-any-axis-armed",
         },
         {
-            key: "delegation.sessionBgTimeoutSec",
-            recommended: SESSION_BG_DEFAULT_TIMEOUT_SEC,
-            unit: "seconds",
-            kind: "safety-net",
-            summary: "Default wall-clock budget for a session-scoped background child.",
-            precedence: "spawn args > default",
+            key: "budget.totalTokens",
+            recommended: null,
+            unit: "tokens",
+            kind: "budget",
+            summary: "Cross-slice token allocation for resource-suspend tasks. First slice only; later slices read the frozen ledger. Unset = per-slice windows only.",
+            precedence: "spec.resourceSuspend.totalTokens (first slice) > unset",
         },
         {
             key: "delegation.retainTtlMs",
@@ -119,28 +89,19 @@ const MAX_DECLARATION_CHARS = 200;
 const sanitizeDeclarationText = (s) => s.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").slice(0, MAX_DECLARATION_CHARS);
 export function resolveEffectiveConfig(spec, ctx) {
     const l = spec.limits;
-    const hasDeadline = l?.timeoutSec !== undefined;
     const pick = (key, specVal, dflt) => specVal !== undefined ? { key, value: specVal, provenance: "spec" } : { key, value: dflt, provenance: "default" };
-    const deadlineSwitch = (key, v) => v === false
-        ? { key, value: false, provenance: "spec" }
-        : v !== undefined
-            ? { key, value: hasDeadline, provenance: "spec" }
-            : { key, value: hasDeadline, provenance: "derived" };
     const maxOutputTokens = l?.maxOutputTokens !== undefined
         ? { key: "limits.maxOutputTokens", value: l.maxOutputTokens, provenance: "spec" }
         : ctx?.modelMaxTokens !== undefined
             ? { key: "limits.maxOutputTokens", value: ctx.modelMaxTokens, provenance: "derived" }
             : { key: "limits.maxOutputTokens", value: null, provenance: "default" };
     const fields = [
-        pick("limits.maxTurns", l?.maxTurns, DEFAULT_MAX_TURNS),
-        pick("limits.timeoutSec", l?.timeoutSec, null),
+        pick("limits.maxTurns", l?.maxTurns, null),
+        pick("limits.maxWalltimeMs", l?.maxWalltimeMs, null),
         maxOutputTokens,
-        deadlineSwitch("limits.deadlineNudge", l?.deadlineNudge),
-        deadlineSwitch("limits.callCapByDeadline", l?.callCapByDeadline),
-        deadlineSwitch("limits.gracefulFinalize", l?.gracefulFinalize),
-        pick("budget.maxCostUsd", spec.maxCostUsd, null),
-        pick("budget.maxTokens", spec.maxTokens, null),
-        pick("budget.totalWalltimeSec", spec.resourceSuspend?.totalWalltimeSec, null),
+        pick("limits.maxCostUsd", l?.maxCostUsd, null),
+        pick("limits.maxTokens", l?.maxTokens, null),
+        pick("budget.totalTokens", spec.resourceSuspend?.totalTokens, null),
         pick("budget.totalBudgetUsd", spec.resourceSuspend?.totalBudgetUsd, null),
     ];
     for (const d of (spec.configOverrides ?? []).slice(0, MAX_OVERRIDE_DECLARATIONS)) {

package/dist/config/defaults.d.ts

@@ -1,6 +1,3 @@
-export declare const DEFAULT_MAX_TURNS = 1000;
-export declare const FORK_DEFAULT_MAX_TURNS = 200;
-export declare const SESSION_BG_DEFAULT_TIMEOUT_SEC: number;
 export declare const RETAIN_DEFAULT_TTL_MS: number;
 export declare const RETAIN_DEFAULT_MAX = 16;
 export declare const SESSION_DEFAULT_TTL_DAYS = 7;

package/dist/config/defaults.js

@@ -1,6 +1,3 @@
-export const DEFAULT_MAX_TURNS = 1000;
-export const FORK_DEFAULT_MAX_TURNS = 200;
-export const SESSION_BG_DEFAULT_TIMEOUT_SEC = 30 * 60;
 export const RETAIN_DEFAULT_TTL_MS = 30 * 60 * 1000;
 export const RETAIN_DEFAULT_MAX = 16;
 export const SESSION_DEFAULT_TTL_DAYS = 7;

package/dist/core/auto-compaction.d.ts

@@ -6,16 +6,14 @@ import type { Brain } from "./types.js";
 export declare const DEFAULT_COMPACTION_INSTRUCTIONS: string;
 export declare const COMPACTION_INSTRUCTIONS_MAX_CHARS = 2048;
 export declare function sanitizeCompactionInstructions(text: string): string;
-export declare const COMPACTION_THROUGHPUT_PRIOR_TOKENS_PER_MS = 3;
 export type CompactionPhaseDurations = Omit<Extract<TraceEvent, {
     kind: "compaction.phase_timings";
 }>, "kind" | "version" | "taskId" | "ts" | "durationMs">;
-export declare function isCompactionWalltimeAbort(err: unknown): boolean;
 export declare function isCompactionManualCancel(err: unknown): boolean;
 export interface CompactionWindowSafetyInfo {
     kind: "fallback" | "clamp_disclosure";
     truncationRatio: number;
-    reason?: "budget" | "walltime" | "tolerance";
+    reason?: "budget" | "tolerance";
     contentTokens: number;
     headroomTokens?: number;
     estCostMicroUsd?: number;
@@ -51,13 +49,6 @@ export interface MaybeCompactOptions {
         capMicroUsd: number;
         mainInputPer1M?: number;
     };
-    walltime?: {
-        deadlineMs: number;
-        cushionMs: () => number;
-        throughputRef: {
-            ewmaTokensPerMs?: number;
-        };
-    };
     onWindowSafety?: (info: CompactionWindowSafetyInfo) => void;
     minTokens?: number;
     force?: boolean;
@@ -131,7 +122,7 @@ export declare function maybeCompact(opts: MaybeCompactOptions): Promise<{
     modelFallback?: true;
     fallbackReason?: "window";
     clampedRatio?: number;
-    clampReason?: "budget" | "walltime" | "tolerance";
+    clampReason?: "budget" | "tolerance";
 }>;
 export declare function nextTrimForceBackoff(prev: boolean, comp: {
     compacted: boolean;

package/dist/core/auto-compaction.js

@@ -22,13 +22,7 @@ const WORKING_FILE_BREAKOUT_TAGS = ["working-file", "summary"];
 function escapeWorkingFilePathAttr(path) {
     return path.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/[\r\n]+/g, " ");
 }
-export const COMPACTION_THROUGHPUT_PRIOR_TOKENS_PER_MS = 3;
-const COMPACTION_THROUGHPUT_EWMA_ALPHA = 0.3;
-const COMPACTION_WALLTIME_ABORT_FLAG = "semaCompactionWalltimeAbort";
 const COMPACTION_MANUAL_CANCEL_FLAG = "semaCompactionManualCancel";
-export function isCompactionWalltimeAbort(err) {
-    return (typeof err === "object" && err !== null && err[COMPACTION_WALLTIME_ABORT_FLAG] === true);
-}
 export function isCompactionManualCancel(err) {
     return (typeof err === "object" && err !== null && err[COMPACTION_MANUAL_CANCEL_FLAG] === true);
 }
@@ -180,7 +174,7 @@ export async function maybeCompact(opts) {
         const wantsWindowSafety = opts.compactionModel !== undefined &&
             summarizationCharsCapacity(opts.compactionModel) < summarizationCharsCapacity(opts.model);
         let dry;
-        if (wantsWindowSafety || opts.walltime !== undefined) {
+        if (wantsWindowSafety) {
             dry = dryRunSummarizationClamp(prep.value, summaryModel, effectiveInstructions);
         }
         const contentTokens = dry !== undefined ? Math.ceil((dry.conversationChars + (prep.value.previousSummary?.length ?? 0)) / cpt) : 0;
@@ -201,13 +195,6 @@ export async function maybeCompact(opts) {
                         gate = "budget";
                     }
                 }
-                if (gate === undefined && opts.walltime !== undefined) {
-                    const remainingMs = opts.walltime.deadlineMs - opts.walltime.cushionMs() - Date.now();
-                    const throughput = opts.walltime.throughputRef.ewmaTokensPerMs ?? COMPACTION_THROUGHPUT_PRIOR_TOKENS_PER_MS;
-                    if (remainingMs < contentTokens / Math.max(throughput, 1e-6)) {
-                        gate = "walltime";
-                    }
-                }
                 if (gate === undefined) {
                     summaryModel = opts.model;
                     modelFallback = true;
@@ -245,35 +232,7 @@ export async function maybeCompact(opts) {
             }
         }
         const auth = await opts.getApiKeyAndHeaders?.(summaryModel);
-        let summarySignal = opts.signal;
-        let softTimer;
-        let softAbort;
-        let onOuterAbort;
-        let firstAbortCause;
-        const latchCallerCause = () => {
-            firstAbortCause ??= opts.manualCancelSignal?.aborted === true ? "manual" : "caller";
-        };
-        if (opts.walltime !== undefined) {
-            softAbort = new AbortController();
-            onOuterAbort = () => {
-                latchCallerCause();
-                softAbort?.abort();
-            };
-            if (opts.signal?.aborted) {
-                latchCallerCause();
-                softAbort.abort();
-            }
-            else if (opts.signal) {
-                opts.signal.addEventListener("abort", onOuterAbort, { once: true });
-            }
-            const softMs = opts.walltime.deadlineMs - opts.walltime.cushionMs() - Date.now();
-            softTimer = setTimeout(() => {
-                firstAbortCause ??= "walltime";
-                softAbort?.abort();
-            }, Math.max(0, softMs));
-            softTimer.unref?.();
-            summarySignal = softAbort.signal;
-        }
+        const summarySignal = opts.signal;
         const runtime = brainToRuntime(opts.brain);
         let res;
         summaryStartAt = Date.now();
@@ -284,23 +243,9 @@ export async function maybeCompact(opts) {
         }
         finally {
             summaryEndAt = Date.now();
-            if (softTimer !== undefined)
-                clearTimeout(softTimer);
-            if (onOuterAbort !== undefined)
-                opts.signal?.removeEventListener("abort", onOuterAbort);
         }
         if (!res.ok) {
-            const walltimeWon = softAbort !== undefined &&
-                softAbort.signal.aborted &&
-                (firstAbortCause !== undefined ? firstAbortCause === "walltime" : opts.signal?.aborted !== true);
-            if (walltimeWon) {
-                if (typeof res.error !== "object" || res.error === null) {
-                    throw Object.assign(new Error(String(res.error)), { [COMPACTION_WALLTIME_ABORT_FLAG]: true });
-                }
-                res.error[COMPACTION_WALLTIME_ABORT_FLAG] = true;
-            }
-            if (!walltimeWon &&
-                opts.manualCancelSignal?.aborted === true &&
+            if (opts.manualCancelSignal?.aborted === true &&
                 res.error instanceof CompactionError &&
                 res.error.code === "aborted") {
                 res.error[COMPACTION_MANUAL_CANCEL_FLAG] = true;
@@ -315,15 +260,6 @@ export async function maybeCompact(opts) {
             throw new Error(`compaction produced an oversized summary (≈${Math.ceil(summary.length / cpt)} tokens vs ` +
                 `${res.value.tokensBefore} before compaction; history left untouched)`);
         }
-        if (opts.walltime !== undefined && contentTokens > 0) {
-            const passMs = Math.max(1, Date.now() - compactStartAt);
-            const sample = contentTokens / passMs;
-            const prev = opts.walltime.throughputRef.ewmaTokensPerMs;
-            opts.walltime.throughputRef.ewmaTokensPerMs =
-                prev === undefined
-                    ? sample
-                    : COMPACTION_THROUGHPUT_EWMA_ALPHA * sample + (1 - COMPACTION_THROUGHPUT_EWMA_ALPHA) * prev;
-        }
         firstKeptEntryId = res.value.firstKeptEntryId;
         summaryTokensBefore = res.value.tokensBefore;
         details = res.value.details;