@sema-agent/core 5.7.0 → 5.8.0

package/dist/core/session-policy-store.d.ts

@@ -26,6 +26,7 @@ export interface SessionPolicyStore {
     listBySession?(sessionId: string): Promise<SessionRulesRecord[]>;
     deleteBySession?(sessionId: string): Promise<void>;
 }
+declare function lexWithin(root: string, p: string): boolean;
 export declare function normalizeRules(rules: SessionPermissionRules): SessionPermissionRules;
 export declare function loosenReasons(prior: SessionPermissionRules, next: SessionPermissionRules): string[];
 export declare function stripRev(rules: SessionPermissionRules): SessionPermissionRules;
@@ -37,3 +38,7 @@ export declare class InMemorySessionPolicyStore implements SessionPolicyStore {
     listBySession(sessionId: string): Promise<SessionRulesRecord[]>;
     deleteBySession(sessionId: string): Promise<void>;
 }
+export declare const __testables: {
+    lexWithin: typeof lexWithin;
+};
+export {};

package/dist/core/session-policy-store.js

@@ -1,4 +1,5 @@
 import { posix } from "node:path";
+import { isWinFormPath } from "../tools/fs/safety.js";
 export class SessionPolicyError extends Error {
     code;
     constructor(code, message) {
@@ -9,7 +10,7 @@ export class SessionPolicyError extends Error {
 }
 function lexWithin(root, p) {
     const fold = (x) => {
-        let n = x.replace(/\\/g, "/");
+        let n = isWinFormPath(x) ? x.replace(/\\/g, "/") : x;
         if (/^[A-Za-z]:(\/|$)/.test(n))
             n = n[0].toLowerCase() + n.slice(1);
         return n;
@@ -116,3 +117,4 @@ export class InMemorySessionPolicyStore {
         }
     }
 }
+export const __testables = { lexWithin };

package/dist/core/store-contracts/checkpoint-store-contract.js

@@ -157,8 +157,8 @@ export async function checkpointListByScopeSummaries(store) {
         scope: "tenant-a",
         sessionId: "out-of-budget",
         createdAt: 1_700_000_000_001,
-        gate: { kind: "resource_limit", reason: "budget" },
-        pendingAction: { kind: "resource_limit", reason: "budget" },
+        gate: { kind: "resource_limit", reason: "budget_tokens" },
+        pendingAction: { kind: "resource_limit", reason: "budget_tokens" },
         resourceLedger: { totalBudgetMicroUsd: 10_000_000, spentMicroUsd: 4_200_000, spentTokens: 9, spentTurns: 3, sliceCount: 2 },
     });
     const resolved = createCheckpointFixture({ token: "tok-resolved", scope: "tenant-a", sessionId: "done" });

package/dist/core/task-registry-agent.d.ts

@@ -106,6 +106,8 @@ export declare function settleRevivedAgentLane(core: DurableAgentCore, id: strin
     retryable?: boolean;
     errorKind?: string;
 }): "completed" | "failed" | "killed" | undefined;
+export declare function noteBackgroundAgentActivityLane(core: DurableAgentCore, id: string, now?: number): void;
+export declare function reapStaleSessionBackgroundAgentsLane(core: DurableAgentCore, staleMs: number, now?: number, onTerminal?: (note: () => void) => void): number;
 export declare function unmarkRetainedContinuationLane(core: DurableAgentCore, id: string): void;
 export declare function attachAgentNotifyLane(core: DurableAgentCore, id: string, notify: NonNullable<BackgroundAgentTaskHandle["notify"]>, cycle?: number): void;
 export declare function deliverToRunningAgentLane(core: DurableAgentCore, id: string, access: TaskAccess, notification: import("./task-notification.js").TaskNotificationPayload, opts?: {

package/dist/core/task-registry-agent.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { uuidv7 } from "../internal/harness.js";
-import { canAccessAgentRecord, BackgroundAgentStoreError, REVIVED_ROW_CLEARED_FIELDS, } from "./background-agent-store.js";
+import { canAccessAgentRecord, BackgroundAgentStoreError, REVIVED_ROW_CLEARED_FIELDS, STALE_RUNNING_REAP_ATTRIBUTION, } from "./background-agent-store.js";
 import { shutdownDebug } from "./shutdown-debug.js";
 import { delimitUntrusted } from "./untrusted-text.js";
 import { boundedRedactedSummary } from "./untrusted-egress.js";
@@ -870,6 +870,38 @@ export function reviveBackgroundAgentLane(core, id, access, abort) {
 export function settleRevivedAgentLane(core, id, cycle, outcome) {
     return settleBackgroundAgentLane(core, id, { ...outcome, cycle });
 }
+export function noteBackgroundAgentActivityLane(core, id, now = Date.now()) {
+    const handle = core.handles.get(id);
+    if (!handle || handle.type !== "background_agent" || handle.status !== "running")
+        return;
+    handle.updatedAt = now;
+}
+export function reapStaleSessionBackgroundAgentsLane(core, staleMs, now = Date.now(), onTerminal) {
+    if (!Number.isFinite(staleMs) || staleMs <= 0) {
+        throw new Error(`reapStaleSessionBackgroundAgents: staleMs must be a positive finite number of milliseconds (got ${String(staleMs)})`);
+    }
+    let reaped = 0;
+    for (const handle of core.handles.values()) {
+        if (handle.type !== "background_agent" || handle.status !== "running" || handle.sessionScoped !== true)
+            continue;
+        if (now - handle.updatedAt <= staleMs)
+            continue;
+        core.markStopSource(handle.id, "system");
+        const reapTerminalNote = handle.onReapTerminal;
+        handle.abort.abort();
+        settleBackgroundAgentLane(core, handle.id, {
+            status: "killed",
+            error: STALE_RUNNING_REAP_ATTRIBUTION,
+            cycle: handle.reviveCycle ?? 0,
+        });
+        if (reapTerminalNote !== undefined && handle.terminalNotified !== true) {
+            handle.terminalNotified = true;
+            onTerminal?.(reapTerminalNote);
+        }
+        reaped++;
+    }
+    return reaped;
+}
 export function unmarkRetainedContinuationLane(core, id) {
     const handle = core.handles.get(id);
     if (handle && handle.type === "background_agent")

package/dist/core/task-registry.d.ts

@@ -145,6 +145,8 @@ export declare class TaskRegistry {
         seq?: number;
         cycle?: number;
     }): "completed" | "failed" | "killed" | undefined;
+    noteBackgroundAgentActivity(id: string, now?: number): void;
+    reapStaleSessionBackgroundAgents(staleMs: number, now?: number): number;
     abortBackgroundAgentsForOwner(access: TaskAccess, opts?: {
         skipSessionScoped?: boolean;
         sessionScopedOnly?: boolean;

package/dist/core/task-registry.js

@@ -10,7 +10,7 @@ import { registerWorkflowLane, pollWorkflowLane, stopWorkflowLane } from "./task
 import { mintCompletionId, canAccessWorkflowRun, formatWorkflowRun, clipTaskOutput, assertOwnership, sleepPollStep, statusFromBackground, rollSpoolText, accountDroppedBytes, renderSpoolBody, spoolDropNote, droppedGapNote, alreadyTerminalStopNote, terminalTaskSummary, TASK_OUTPUT_MAX_CHARS, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccess, DURABLE_AGENT_HANDLE_RE, } from "./task-registry-shared.js";
 export { normalizeAgentName, DURABLE_AGENT_HEARTBEAT_MS, DURABLE_AGENT_HANDLE_RE, BG_AGENT_REAP_STOP_ERROR } from "./task-registry-shared.js";
 import { TASK_OUTPUT_TOOL_NAME, TASK_STOP_TOOL_NAME, TASK_OUTPUT_CONTRACT, TASK_STOP_CONTRACT, TASK_OUTPUT_MISSING_ID_MESSAGE, TASK_STOP_MISSING_ID_MESSAGE, TASK_STOP_PARAMS, resolveTaskIdArg, REGISTRY_TASK_TOOL_CAPS, composeTaskOutputDescription, composeTaskOutputParams, composeTaskStopDescription, } from "./task-tool-shape.js";
-import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
+import { durableAgentArmedLane, durableAgentRowProbeLane, beginDurableClaimLane, endDurableClaimLane, reapDurableAgentsLane, noteBackgroundAgentActivityLane, reapStaleSessionBackgroundAgentsLane, releaseDurableTranscriptAnchorLane, bindBackgroundAgentSessionLane, registerBackgroundAgentLane, parkBackgroundAgentLane, reconcileParkedAgentsLane, claimParkedAgentLane, rollbackParkedClaimLane, consumeParkedFlipLane, finalizeParkedResumeLane, settleBackgroundAgentLane, abortBackgroundAgentsForOwnerLane, serveDurableAgentRowLane, resolveBackgroundAgentByNameLane, markRetainedContinuationLane, reviveBackgroundAgentLane, settleRevivedAgentLane, unmarkRetainedContinuationLane, attachAgentNotifyLane, deliverToRunningAgentLane, runningBackgroundAgentLabelsLane, runningAgentFooterLane, notFoundRunningAgentsTail, pollBackgroundAgentLane, stopBackgroundAgentLane, } from "./task-registry-agent.js";
 export { canAccessWorkflowRun, clipTaskOutput, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE };
 const BLOCK_DEFAULT_TIMEOUT_MS = 30_000;
 const BLOCK_MAX_TIMEOUT_MS = 600_000;
@@ -167,6 +167,14 @@ export class TaskRegistry {
     settleBackgroundAgent(id, outcome) {
         return settleBackgroundAgentLane(this.core, id, outcome);
     }
+    noteBackgroundAgentActivity(id, now) {
+        return noteBackgroundAgentActivityLane(this.core, id, now);
+    }
+    reapStaleSessionBackgroundAgents(staleMs, now) {
+        return reapStaleSessionBackgroundAgentsLane(this.core, staleMs, now, (note) => {
+            this.notifier.notify(() => note(), "taskRegistry.reapTerminalNote");
+        });
+    }
     abortBackgroundAgentsForOwner(access, opts) {
         return abortBackgroundAgentsForOwnerLane(this.core, access, opts);
     }

package/dist/core/tool-errors.js

@@ -65,9 +65,14 @@ const BRAIN_FLAT_CODES = new Set([
     "refusal",
     "length_empty",
 ]);
+const EXACT_CODE_CLASS = new Map([
+    ["limits.max_tokens_exceeded", "budget"],
+    ["limits.max_cost_exceeded", "budget"],
+    ["limits.max_turns_exceeded", "limit"],
+    ["limits.max_walltime_exceeded", "limit"],
+]);
 const DOTTED_PREFIX_CLASS = [
-    ["budget.", "budget"],
-    ["limit.", "limit"],
+    ["limits.", "limit"],
     ["output.", "output"],
     ["suspend.", "suspend"],
     ["review.", "review"],
@@ -79,6 +84,9 @@ const DOTTED_PREFIX_CLASS = [
 export function errorClassOf(errorCode) {
     if (!errorCode)
         return "unknown";
+    const exact = EXACT_CODE_CLASS.get(errorCode);
+    if (exact !== undefined)
+        return exact;
     for (const [prefix, cls] of DOTTED_PREFIX_CLASS) {
         if (errorCode.startsWith(prefix))
             return cls;

package/dist/core/trace.d.ts

@@ -2,17 +2,10 @@ import type { TaskStatus, ToolEffect } from "./types.js";
 import type { ThinkingLevel } from "../internal/harness-types.js";
 import type { ToolManifestRow } from "../prompt-assembly/tool-catalog.js";
 export interface TraceMechanismsSummary {
-    finalizeInjected?: true;
-    nudgesSent?: number;
-    capShrinks?: number;
-    callCutoffs?: number;
-    toolClamps?: number;
-    toolCuts?: number;
-    toolCutKills?: number;
-    pendingCutTools?: number;
     finalVerifyInjected?: true;
     finalVerifyInjections?: number;
     attachmentsInjected?: number;
+    approachNoticesSent?: number;
     repetitionCuts?: number;
     repetitionSpared?: number;
 }

package/dist/core/types.d.ts

@@ -244,6 +244,22 @@ export type ImageInput = {
 } | {
     url: string;
 };
+export interface TaskLimits {
+    maxTokens?: number;
+    maxCostUsd?: number;
+    maxTurns?: number;
+    maxWalltimeMs?: number;
+    maxOutputTokens?: number;
+    approachNotice?: false | {
+        at?: [number, number];
+    };
+    budgetStreamCancel?: boolean;
+    degrade?: {
+        to: ModelRef;
+        atCostFraction: number;
+    };
+    brainCallGuardrailMs?: import("../brain/timeout.js").BrainCallGuardrailKnob;
+}
 export interface TaskSpec {
     taskId?: string;
     objective: string;
@@ -293,7 +309,7 @@ export interface TaskSpec {
     resourceSuspend?: {
         scope: string;
         totalBudgetUsd?: number;
-        totalWalltimeSec?: number;
+        totalTokens?: number;
         maxSlices?: number;
         ttlMs?: number;
     };
@@ -324,17 +340,7 @@ export interface TaskSpec {
             note?: string;
         };
     };
-    limits?: {
-        maxTurns?: number;
-        timeoutSec?: number;
-        maxOutputTokens?: number;
-        deadlineNudge?: false | {
-            at?: [number, number];
-        };
-        callCapByDeadline?: false;
-        gracefulFinalize?: false;
-        brainCallGuardrailMs?: import("../brain/timeout.js").BrainCallGuardrailKnob;
-    };
+    limits?: TaskLimits;
     configOverrides?: ReadonlyArray<import("../config/catalog.js").ConfigOverrideDeclaration>;
     forwardSubagentEvents?: boolean;
     retainSubagentSessions?: boolean | {
@@ -343,13 +349,6 @@ export interface TaskSpec {
     };
     retainBackgroundProcesses?: boolean;
     streamingToolExecution?: boolean;
-    maxCostUsd?: number;
-    maxTokens?: number;
-    budgetStreamCancel?: boolean;
-    degrade?: {
-        to: ModelRef;
-        atCostFraction: number;
-    };
     outputSchema?: TSchema;
     outputRetries?: number;
     tracer?: import("./trace.js").TracerHook;
@@ -389,7 +388,7 @@ export interface TaskSpec {
     } | undefined>;
     signal?: AbortSignal;
 }
-export type TaskStatus = "completed" | "blocked" | "failed" | "timeout" | "suspended" | "needs_review";
+export type TaskStatus = "completed" | "blocked" | "failed" | "suspended" | "needs_review";
 export interface RemoteEnvFailureNote {
     op: "suspendVM" | "resumeVM" | "postResumeInit";
     code: import("./remote-env.js").RemoteExecutionErrorCode;
@@ -446,17 +445,10 @@ export interface TaskResult {
             costMicroUsd: number;
         };
         mechanisms?: {
-            finalizeInjected?: true;
-            nudgesSent?: number;
-            capShrinks?: number;
-            callCutoffs?: number;
-            toolClamps?: number;
-            toolCuts?: number;
-            toolCutKills?: number;
-            pendingCutTools?: number;
             finalVerifyInjected?: true;
             finalVerifyInjections?: number;
             attachmentsInjected?: number;
+            approachNoticesSent?: number;
             repetitionCuts?: number;
             repetitionSpared?: number;
             repetitionEvents?: Array<{
@@ -568,7 +560,7 @@ export type TaskEvent = ({
     modelFallback?: true;
     fallbackReason?: "window";
     clampedRatio?: number;
-    clampReason?: "budget" | "walltime" | "tolerance";
+    clampReason?: "budget" | "tolerance";
     phaseDurations?: import("./auto-compaction.js").CompactionPhaseDurations;
 } & TaskEventIdentity) | ({
     type: "compaction_outcome";
@@ -577,7 +569,7 @@ export type TaskEvent = ({
     reason?: string;
 } & TaskEventIdentity) | ({
     type: "steering_injected";
-    source: "deadline_nudge" | "finalize" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
+    source: "limit_approach" | "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
     preview: string;
 } & TaskEventIdentity) | ({
     type: "diagnostics";
@@ -750,6 +742,8 @@ export interface RunnerDeps {
     workflowRunStore?: import("./workflow-run-store.js").WorkflowRunStore;
     backgroundAgentStore?: import("./background-agent-store.js").BackgroundAgentStore;
     mailboxStore?: import("./mailbox-store.js").MailboxStore;
+    usageWindows?: readonly import("./usage-window-store.js").UsageWindow[];
+    usageWindowStore?: import("./usage-window-store.js").UsageWindowStore;
     workflowJournalStore?: import("./workflow-journal-store.js").WorkflowJournalStore;
     workflowScriptStore?: import("../orchestration/workflow-script-store.js").WorkflowScriptStore;
     builtinWorkflows?: boolean;

package/dist/core/usage-window-store.d.ts

@@ -0,0 +1,39 @@
+export interface UsageWindow {
+    windowMs: number;
+    maxTokens: number;
+    anchor: "first-use" | "rolling";
+}
+export interface UsageSlot {
+    at: number;
+    tokens: number;
+}
+export interface UsageBucketRow {
+    windowMs: number;
+    openedAt: number;
+    tokens: number;
+}
+export interface UsageWindowRecord {
+    slots: readonly UsageSlot[];
+    buckets: readonly UsageBucketRow[];
+}
+export interface UsageWindowReading {
+    window: UsageWindow;
+    tokens: number;
+    exhausted: boolean;
+    retryAfterMs: number;
+}
+export interface UsageWindowStore {
+    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[]): Promise<void>;
+    read(key: string, windows: readonly UsageWindow[], now: number): Promise<readonly UsageWindowReading[]>;
+}
+export declare const GLOBAL_USAGE_KEY = "__usage_global__";
+export declare const EMPTY_USAGE_WINDOW_RECORD: UsageWindowRecord;
+export declare function resolveUsageWindows(windows: readonly UsageWindow[] | undefined): readonly UsageWindow[] | undefined;
+export declare function chargeUsageRecord(record: UsageWindowRecord, tokens: number, at: number, windows: readonly UsageWindow[]): UsageWindowRecord;
+export declare function readUsageRecord(record: UsageWindowRecord, windows: readonly UsageWindow[], now: number): UsageWindowReading[];
+export declare function usageRetryAfterMs(readings: readonly UsageWindowReading[]): number | undefined;
+export declare class InMemoryUsageWindowStore implements UsageWindowStore {
+    private readonly records;
+    charge(key: string, tokens: number, at: number, windows: readonly UsageWindow[]): Promise<void>;
+    read(key: string, windows: readonly UsageWindow[], now: number): Promise<readonly UsageWindowReading[]>;
+}

package/dist/core/usage-window-store.js

@@ -0,0 +1,115 @@
+export const GLOBAL_USAGE_KEY = "__usage_global__";
+export const EMPTY_USAGE_WINDOW_RECORD = Object.freeze({
+    slots: Object.freeze([]),
+    buckets: Object.freeze([]),
+});
+function usageConfigError(code, message) {
+    const e = new Error(message);
+    e.code = code;
+    return e;
+}
+export function resolveUsageWindows(windows) {
+    if (windows === undefined)
+        return undefined;
+    if (!Array.isArray(windows)) {
+        throw usageConfigError("config.usage_window_invalid", `RunnerDeps.usageWindows must be an array (got ${typeof windows})`);
+    }
+    for (const w of windows) {
+        if (w === null || typeof w !== "object") {
+            throw usageConfigError("config.usage_window_invalid", `RunnerDeps.usageWindows entries must be objects (got ${String(w)})`);
+        }
+        if (typeof w.windowMs !== "number" || !Number.isFinite(w.windowMs) || w.windowMs <= 0) {
+            throw usageConfigError("config.usage_window_invalid", `RunnerDeps.usageWindows[].windowMs must be a finite number of milliseconds > 0 (got ${String(w.windowMs)})`);
+        }
+        if (typeof w.maxTokens !== "number" || !Number.isFinite(w.maxTokens) || w.maxTokens < 0) {
+            throw usageConfigError("config.usage_window_invalid", `RunnerDeps.usageWindows[].maxTokens must be a finite, non-negative number (got ${String(w.maxTokens)})`);
+        }
+        if (w.anchor !== "first-use" && w.anchor !== "rolling") {
+            throw usageConfigError("config.usage_window_invalid", `RunnerDeps.usageWindows[].anchor must be "first-use" or "rolling" (got ${String(w.anchor)})`);
+        }
+    }
+    return windows;
+}
+function rollingHorizonMs(windows) {
+    let widest;
+    for (const w of windows) {
+        if (w.anchor !== "rolling")
+            continue;
+        if (widest === undefined || w.windowMs > widest)
+            widest = w.windowMs;
+    }
+    return widest;
+}
+export function chargeUsageRecord(record, tokens, at, windows) {
+    const horizon = rollingHorizonMs(windows);
+    const keptSlots = horizon === undefined ? [] : record.slots.filter((s) => s.at > at - horizon).map((s) => ({ at: s.at, tokens: s.tokens }));
+    if (horizon !== undefined && tokens > 0)
+        keptSlots.push({ at, tokens });
+    const buckets = [];
+    for (const w of windows) {
+        if (w.anchor !== "first-use")
+            continue;
+        if (buckets.some((b) => b.windowMs === w.windowMs))
+            continue;
+        const prior = record.buckets.find((b) => b.windowMs === w.windowMs);
+        const lapsed = prior === undefined || at >= prior.openedAt + w.windowMs;
+        if (lapsed) {
+            if (tokens > 0)
+                buckets.push({ windowMs: w.windowMs, openedAt: at, tokens });
+            continue;
+        }
+        buckets.push({ windowMs: w.windowMs, openedAt: prior.openedAt, tokens: prior.tokens + tokens });
+    }
+    return { slots: keptSlots, buckets };
+}
+export function readUsageRecord(record, windows, now) {
+    const readings = [];
+    for (const w of windows) {
+        let tokens = 0;
+        let freesAt;
+        if (w.anchor === "rolling") {
+            const floor = now - w.windowMs;
+            let oldest;
+            for (const s of record.slots) {
+                if (s.at <= floor)
+                    continue;
+                tokens += s.tokens;
+                if (oldest === undefined || s.at < oldest)
+                    oldest = s.at;
+            }
+            if (oldest !== undefined)
+                freesAt = oldest + w.windowMs;
+        }
+        else {
+            const row = record.buckets.find((b) => b.windowMs === w.windowMs);
+            if (row !== undefined && now < row.openedAt + w.windowMs) {
+                tokens = row.tokens;
+                freesAt = row.openedAt + w.windowMs;
+            }
+        }
+        const exhausted = tokens >= w.maxTokens;
+        const retryAfterMs = exhausted ? Math.max(1, freesAt === undefined ? w.windowMs : freesAt - now) : 0;
+        readings.push({ window: w, tokens, exhausted, retryAfterMs });
+    }
+    return readings;
+}
+export function usageRetryAfterMs(readings) {
+    let worst;
+    for (const r of readings) {
+        if (!r.exhausted)
+            continue;
+        if (worst === undefined || r.retryAfterMs > worst)
+            worst = r.retryAfterMs;
+    }
+    return worst;
+}
+export class InMemoryUsageWindowStore {
+    records = new Map();
+    async charge(key, tokens, at, windows) {
+        const prior = this.records.get(key) ?? EMPTY_USAGE_WINDOW_RECORD;
+        this.records.set(key, chargeUsageRecord(prior, tokens, at, windows));
+    }
+    async read(key, windows, now) {
+        return readUsageRecord(this.records.get(key) ?? EMPTY_USAGE_WINDOW_RECORD, windows, now);
+    }
+}

package/dist/engine/execution-env/node-execution-env.js

@@ -432,23 +432,6 @@ export class NodeExecutionEnv {
                 return;
             }
             closeSpoolFds();
-            if (options?.onSpawn && child.pid !== undefined) {
-                const spawnedPid = child.pid;
-                const spawnedChild = child;
-                try {
-                    options.onSpawn({
-                        pid: spawnedPid,
-                        kill: () => {
-                            abortKillInFlight = true;
-                            killProcessTree(spawnedPid, {
-                                stillRunning: () => spawnedChild.exitCode === null && spawnedChild.signalCode === null,
-                            });
-                        },
-                    });
-                }
-                catch {
-                }
-            }
             const timeoutMs = resolveExecTimeoutMs(options?.timeout);
             timeoutRef.current =
                 timeoutMs === undefined
@@ -580,11 +563,6 @@ export class NodeExecutionEnv {
                     return false;
                 if (spoolPumpRef.current)
                     clearInterval(spoolPumpRef.current);
-                try {
-                    options?.onDetachAdopted?.();
-                }
-                catch {
-                }
                 if (timeoutRef.current)
                     clearTimeout(timeoutRef.current);
                 const dso = stdoutTail.result();

package/dist/engine/harness/agent-harness.d.ts

@@ -17,11 +17,6 @@ export interface HarnessLoopRecovery {
         detect: (message: AssistantMessage) => boolean;
         maxContinues?: number;
     };
-    walltimeCutoff?: {
-        detect: (message: AssistantMessage) => boolean;
-        maxContinues?: number;
-        hasLiveWriteoutWindow?: () => boolean;
-    };
     promptTooLong?: {
         recover: (attempt: number) => Promise<boolean>;
         detect?: (message: AssistantMessage) => boolean;
@@ -54,9 +49,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private steeringQueueMode;
     private maxOutputTokens?;
     private maxOutputTokensPerCall?;
-    private callDeadlineMsPerCall?;
     private stallTimeoutsPerCall?;
-    private toolDeadline?;
     private loopTrace?;
     private resilience?;
     private maxToolConcurrency?;

package/dist/engine/harness/agent-harness.js

@@ -185,9 +185,7 @@ export class AgentHarness {
     steeringQueueMode;
     maxOutputTokens;
     maxOutputTokensPerCall;
-    callDeadlineMsPerCall;
     stallTimeoutsPerCall;
-    toolDeadline;
     loopTrace;
     resilience;
     maxToolConcurrency;
@@ -217,9 +215,7 @@ export class AgentHarness {
         this.steeringQueueMode = options.steeringMode ?? "one-at-a-time";
         this.maxOutputTokens = options.maxOutputTokens;
         this.maxOutputTokensPerCall = options.maxOutputTokensPerCall;
-        this.callDeadlineMsPerCall = options.callDeadlineMsPerCall;
         this.stallTimeoutsPerCall = options.stallTimeoutsPerCall;
-        this.toolDeadline = options.toolDeadline;
         this.loopTrace = options.loopTrace;
         this.resilience = options.resilience;
         this.maxToolConcurrency = options.maxToolConcurrency;
@@ -407,7 +403,6 @@ export class AgentHarness {
                 },
                 reasoning: streamOptions?.reasoning,
                 maxTokens: streamOptions?.maxTokens,
-                callDeadlineMs: streamOptions?.callDeadlineMs,
                 stallTimeouts: streamOptions?.stallTimeouts,
                 maxTokensDynamic: streamOptions?.maxTokensDynamic,
                 staticReasoningCutDowngrade: streamOptions?.staticReasoningCutDowngrade,
@@ -442,12 +437,9 @@ export class AgentHarness {
         return {
             model: turnState.model,
             reasoning: turnState.thinkingLevel,
-            liveThinkingLevel: () => self.thinkingLevel,
             ...(this.maxOutputTokens !== undefined ? { maxTokens: this.maxOutputTokens } : {}),
             ...(this.maxOutputTokensPerCall !== undefined ? { maxTokensPerCall: this.maxOutputTokensPerCall } : {}),
-            ...(this.callDeadlineMsPerCall !== undefined ? { callDeadlineMsPerCall: this.callDeadlineMsPerCall } : {}),
             ...(this.stallTimeoutsPerCall !== undefined ? { stallTimeoutsPerCall: this.stallTimeoutsPerCall } : {}),
-            ...(this.toolDeadline !== undefined ? { toolDeadline: this.toolDeadline } : {}),
             ...(this.resilience !== undefined ? { resilience: this.resilience } : {}),
             ...(this.maxToolConcurrency !== undefined ? { maxToolConcurrency: this.maxToolConcurrency } : {}),
             ...(this.streamingToolExecution === true && (this.getHandlers("tool_call")?.size ?? 0) === 0
@@ -511,9 +503,6 @@ export class AgentHarness {
                 get degenerateOutput() {
                     return self.loopRecovery?.degenerateOutput;
                 },
-                get walltimeCutoff() {
-                    return self.loopRecovery?.walltimeCutoff;
-                },
                 get promptTooLong() {
                     const ptl = self.loopRecovery?.promptTooLong;
                     if (!ptl)
@@ -681,7 +670,7 @@ export class AgentHarness {
             for (let i = newMessages.length - 1; i >= 0; i--) {
                 const message = newMessages[i];
                 if (message.role === "assistant") {
-                    return mergeTruncatedOutputChain(newMessages, i, this.loopRecovery?.walltimeCutoff?.detect);
+                    return mergeTruncatedOutputChain(newMessages, i);
                 }
             }
             throw new AgentHarnessError("invalid_state", "AgentHarness prompt completed without an assistant message");
@@ -931,54 +920,25 @@ function isEmptyFailureAssistant(message) {
         return false;
     return m.content.every((c) => c.type === "text" ? c.text.trim() === "" : c.type === "thinking" ? c.thinking.trim() === "" : false);
 }
-function mergeTruncatedOutputChain(messages, lastAssistantIndex, isWalltimeCutoff) {
+function mergeTruncatedOutputChain(messages, lastAssistantIndex) {
     const last = messages[lastAssistantIndex];
     const lastText = last.content.map((c) => (c.type === "text" ? c.text : "")).join("");
     const parts = [];
     let i = lastAssistantIndex;
     while (i - 2 >= 0) {
         const mid = messages[i - 1];
-        const downstreamText = parts.join("") + lastText;
-        const walltimeGate = last.stopReason === "error" || downstreamText.trim() === "";
-        let head;
-        let walltimeStep = false;
-        let nextI = i - 2;
-        if (mid.role === "custom") {
-            const h = messages[i - 2];
-            if (h.role !== "assistant")
-                break;
-            const assistant = h;
-            const step = (mid.customType === "loop:truncated-output-continue" && assistant.stopReason === "length") ||
-                (mid.customType === "loop:midstream-partial-continue" && assistant.stopReason === "stop") ||
-                (mid.customType === "loop:walltime-cutoff-recovery" && assistant.stopReason === "error" && walltimeGate);
-            if (!step)
-                break;
-            head = assistant;
-            walltimeStep = mid.customType === "loop:walltime-cutoff-recovery";
-        }
-        else if (mid.role === "user" && isWalltimeCutoff) {
-            let j = i - 1;
-            while (j >= 0 && messages[j].role === "user")
-                j--;
-            if (j < 0 || j >= i - 1)
-                break;
-            const h = messages[j];
-            if (h.role !== "assistant")
-                break;
-            const assistant = h;
-            if (!(assistant.stopReason === "error" && isWalltimeCutoff(assistant) && walltimeGate))
-                break;
-            head = assistant;
-            walltimeStep = true;
-            nextI = j;
-        }
-        else {
+        if (mid.role !== "custom")
             break;
-        }
-        const headText = head.content.map((c) => (c.type === "text" ? c.text : "")).join("");
-        const needsBreak = walltimeStep && downstreamText !== "" && headText !== "";
-        parts.unshift(needsBreak ? `${headText}\n\n` : headText);
-        i = nextI;
+        const h = messages[i - 2];
+        if (h.role !== "assistant")
+            break;
+        const head = h;
+        const step = (mid.customType === "loop:truncated-output-continue" && head.stopReason === "length") ||
+            (mid.customType === "loop:midstream-partial-continue" && head.stopReason === "stop");
+        if (!step)
+            break;
+        parts.unshift(head.content.map((c) => (c.type === "text" ? c.text : "")).join(""));
+        i = i - 2;
     }
     if (parts.length === 0) {
         return last;