@sema-agent/core 5.6.0 → 5.8.0

package/dist/core/secret-env.d.ts

@@ -6,5 +6,7 @@ export interface SecretEnvFinding {
     confidence: RedactionConfidence;
     source: RedactionSource;
 }
+export type ExactEnvNameVerdict = "credential" | "exempt" | "unknown";
+export declare function classifyExactEnvName(key: string, credentialNames: ReadonlySet<string>, exemptNames: ReadonlySet<string>): ExactEnvNameVerdict;
 export declare function isSecretEnvKey(key: string): boolean;
 export declare function scrubSecretEnv(env: NodeJS.ProcessEnv, findings?: SecretEnvFinding[]): NodeJS.ProcessEnv;

package/dist/core/secret-env.js

@@ -4,16 +4,28 @@ const SECRET_ENV_EXACT_NAMES = new Set([
     "PGPASSWORD", "MYSQL_PWD", "SSHPASS", "GPG_PASSPHRASE", "GH_PAT", "GITHUB_PAT",
     "NPM_CONFIG__AUTH", "NPM_CONFIG__AUTHTOKEN",
 ]);
+const NON_SECRET_ENV_EXACT_NAMES = new Set([
+    "PARTITION_KEY", "SORT_KEY", "RANGE_KEY", "IDEMPOTENCY_KEY", "CACHE_KEY", "ROUTING_KEY",
+]);
 const SECRET_ENV_KIND_CONFIDENCE = {
     "exact-name": "high",
     "suffix-rule": "medium",
 };
+export function classifyExactEnvName(key, credentialNames, exemptNames) {
+    const upper = key.toUpperCase();
+    if (credentialNames.has(upper))
+        return "credential";
+    if (exemptNames.has(upper))
+        return "exempt";
+    return "unknown";
+}
 function classifySecretEnvKey(key) {
-    if (SECRET_ENV_RE.test(key))
-        return "suffix-rule";
-    if (SECRET_ENV_EXACT_NAMES.has(key.toUpperCase()))
+    const byExactName = classifyExactEnvName(key, SECRET_ENV_EXACT_NAMES, NON_SECRET_ENV_EXACT_NAMES);
+    if (byExactName === "credential")
         return "exact-name";
-    return undefined;
+    if (byExactName === "exempt")
+        return undefined;
+    return SECRET_ENV_RE.test(key) ? "suffix-rule" : undefined;
 }
 export function isSecretEnvKey(key) {
     return classifySecretEnvKey(key) !== undefined;

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-notification.d.ts

@@ -45,6 +45,7 @@ export declare function renderTaskNotificationXml(n: TaskNotificationPayload): s
 export declare const MAX_PENDING_EVENTS_PER_TASK = 50;
 export declare const MAX_PENDING_EVENTS_PER_SESSION = 200;
 export declare const MAX_PENDING_SESSIONS = 100;
+export declare function isDelegatedAgentTerminal(n: Pick<TaskNotificationPayload, "task_type" | "status">): boolean;
 export interface DrainedPendingNotifications {
     items: TaskNotificationPayload[];
     dropped: Map<string, {

package/dist/core/task-notification.js

@@ -83,6 +83,9 @@ export const MAX_PENDING_EVENTS_PER_SESSION = 200;
 export const MAX_PENDING_SESSIONS = 100;
 const MAX_TOMBSTONES = 5_000;
 const TERMINAL_STATUSES = new Set(["completed", "failed", "killed", "cancelled"]);
+export function isDelegatedAgentTerminal(n) {
+    return n.task_type === "background_agent" && TERMINAL_STATUSES.has(n.status);
+}
 export class PendingSessionNotifications {
     sessions = new Map();
     droppedSessions = 0;

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?;