@sema-agent/core 5.7.0 → 5.9.0

package/dist/brain/openai.js

@@ -1,9 +1,8 @@
 import {} from "../internal/llm.js";
 import { repairTextToolCalls } from "./tool-call-repair.js";
 import { DEGENERATE_MESSAGE, trimDegenerateTail } from "./repetition.js";
-import { createRepetitionPoll, createWalltimeGate, parseStreamedToolArgs } from "./stream-shared.js";
+import { createRepetitionPoll, parseStreamedToolArgs } from "./stream-shared.js";
 import { mintFallbackToolCallId } from "./tool-call-id.js";
-import { WALLTIME_CUTOFF_MESSAGE } from "./walltime.js";
 import { emitBrainTelemetry } from "./status-sink.js";
 import { errorResultMediaNote, IMAGE_OMITTED_NO_VISION, imagesOmittedNoVisionNote, modelSupportsVision, sendableImages } from "./media-degrade.js";
 import { OPENAI_RESERVED, applyExtraBody, stripAuthHeaders } from "./request-params.js";
@@ -275,7 +274,6 @@ export function createOpenAIBrain(config = {}) {
             signal: options?.signal,
             config,
             httpLabel: "gateway",
-            callDeadlineMs: options?.callDeadlineMs,
             stallTimeouts: options?.stallTimeouts,
             buildRequest: () => {
                 const apiKey = options?.apiKey ?? config.apiKey;
@@ -330,7 +328,6 @@ export function createOpenAIBrain(config = {}) {
                 let degenerate = false;
                 let degenFace;
                 const rep = createRepetitionPoll();
-                const walltime = createWalltimeGate({ callDeadlineMs: options?.callDeadlineMs, isDegenerate: () => degenerate, cancel: () => ctrl.cancel() });
                 let lastDegenCheck = 0;
                 let lastDegenCheckReasoning = 0;
                 const detectRep = config.detectRepetition !== false;
@@ -410,10 +407,7 @@ export function createOpenAIBrain(config = {}) {
                     sealForRetry() {
                         closeThinking();
                     },
-                    onDeadline: () => walltime.onDeadline(),
                     onLine(rawLine) {
-                        if (walltime.shouldDropLine())
-                            return;
                         const line = rawLine.trim();
                         if (!line.startsWith("data:"))
                             return;
@@ -534,40 +528,35 @@ export function createOpenAIBrain(config = {}) {
                         const dynamicCut = truncatedEmpty && options?.maxTokensDynamic === true;
                         const safetyCut = finishReason === "content_filter";
                         const refused = accumRefusal.trim().length > 0;
-                        const emptyNoFinish = noUsableContent && finishReason == null && !degenerate && !walltime.cut;
+                        const emptyNoFinish = noUsableContent && finishReason == null && !degenerate;
                         const maxTokensNote = sentMaxTokens !== undefined
                             ? `effective max_tokens=${sentMaxTokens} (from ${sentMaxTokensLane === "options" ? "options.maxTokens" : "model.maxTokens"})`
                             : "max_tokens not set (neither options.maxTokens nor model.maxTokens — the provider's default cap applied)";
-                        const errorMessage = walltime.cut
-                            ? WALLTIME_CUTOFF_MESSAGE
-                            : degenerate
-                                ? DEGENERATE_MESSAGE
-                                : safetyCut
-                                    ? `[refusal] response cut by the provider content filter (finish_reason="content_filter") — the output was censored/truncated for policy and is unreliable`
-                                    : refused
-                                        ? `[refusal] response refused by the model for policy reasons: ${accumRefusal.trim()}`
-                                        : (toolError ??
-                                            (truncatedEmpty && !dynamicCut
-                                                ? accumReasoning.trim()
-                                                    ? `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
-                                                    : `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — raise max_tokens`
-                                                : emptyNoFinish
-                                                    ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
-                                                    : undefined));
-                        const errored = walltime.cut ||
-                            degenerate ||
+                        const errorMessage = degenerate
+                            ? DEGENERATE_MESSAGE
+                            : safetyCut
+                                ? `[refusal] response cut by the provider content filter (finish_reason="content_filter") — the output was censored/truncated for policy and is unreliable`
+                                : refused
+                                    ? `[refusal] response refused by the model for policy reasons: ${accumRefusal.trim()}`
+                                    : (toolError ??
+                                        (truncatedEmpty && !dynamicCut
+                                            ? accumReasoning.trim()
+                                                ? `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — the model spent the whole budget on reasoning (${accumReasoning.length} reasoning chars). Raise max_tokens, or disable thinking for this task.`
+                                                : `[length_empty] response truncated at max_tokens (finish_reason="length", ${maxTokensNote}) with no answer text — raise max_tokens`
+                                            : emptyNoFinish
+                                                ? `[stream_torn] model stream ended with no content and no finish_reason — the response was lost (a torn stream or an in-band provider error frame)${malformedFrames > 0 ? ` — ${malformedFrames} unparseable data frame(s) were dropped on this stream (first sample: ${JSON.stringify(malformedSample)})` : ""}`
+                                                : undefined));
+                        const errored = degenerate ||
                             safetyCut ||
                             refused ||
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut);
-                        const errorKind = walltime.cut
-                            ? "walltime_cutoff"
-                            : degenerate
-                                ? "degenerate"
-                                : !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
-                                    ? "length_empty"
-                                    : undefined;
+                        const errorKind = degenerate
+                            ? "degenerate"
+                            : !safetyCut && !refused && toolError === undefined && truncatedEmpty && !dynamicCut
+                                ? "length_empty"
+                                : undefined;
                         const finalMessage = {
                             ...partial,
                             content: finalContent.length > 0 ? finalContent : [{ type: "text", text: "" }],

package/dist/brain/request-params.d.ts

@@ -1,5 +1,6 @@
 export declare const OPENAI_RESERVED: ReadonlySet<string>;
 export declare const ANTHROPIC_RESERVED: ReadonlySet<string>;
+export declare const RESPONSES_RESERVED: ReadonlySet<string>;
 export declare function reservedFor(api: string): ReadonlySet<string>;
 export declare function applyExtraBody(body: Record<string, unknown>, extraBody: Record<string, unknown> | undefined, reserved: ReadonlySet<string>): Record<string, unknown>;
 export declare function stripAuthHeaders(headers: Record<string, string>): void;

package/dist/brain/request-params.js

@@ -25,7 +25,23 @@ export const ANTHROPIC_RESERVED = new Set([
     "output_config",
     "context_management",
 ]);
+export const RESPONSES_RESERVED = new Set([
+    "model",
+    "input",
+    "stream",
+    "instructions",
+    "tools",
+    "temperature",
+    "max_output_tokens",
+    "reasoning",
+    "store",
+    "previous_response_id",
+    "conversation",
+]);
+const RESPONSES_APIS = new Set(["openai-responses", "azure-openai-responses", "openai-chatgpt-responses"]);
 export function reservedFor(api) {
+    if (RESPONSES_APIS.has(api))
+        return RESPONSES_RESERVED;
     return api === "anthropic-messages" ? ANTHROPIC_RESERVED : OPENAI_RESERVED;
 }
 export function applyExtraBody(body, extraBody, reserved) {

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

@@ -18,7 +18,6 @@ export interface StreamControls {
 }
 export interface StreamParser {
     onLine(line: string): void;
-    onDeadline?(): boolean;
     finalize(): void;
     snapshot(): {
         hasSubstantiveText: boolean;
@@ -35,7 +34,6 @@ export declare function runStreamingBrain(args: {
     httpLabel: string;
     buildRequest: () => SSERequest;
     makeParser: (ctrl: StreamControls) => StreamParser;
-    callDeadlineMs?: number;
     stallTimeouts?: {
         connectMs?: number;
         firstTokenMs?: number;

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;