@sema-agent/core 5.7.0 → 5.8.0

package/dist/engine/harness/types.d.ts

@@ -88,11 +88,6 @@ export interface ExecutionEnvExecOptions {
     onStdout?: (chunk: string) => void;
     onStderr?: (chunk: string) => void;
     detachSignal?: AbortSignal;
-    onSpawn?: (handle: {
-        pid: number;
-        kill: () => void;
-    }) => void;
-    onDetachAdopted?: () => void;
     autoBackgroundOnTimeout?: boolean;
 }
 export interface FileSystem {
@@ -144,6 +139,8 @@ export interface Shell {
     cleanup(): Promise<void>;
 }
 export interface ExecutionEnv extends FileSystem, Shell {
+    readonly lifetimeMs?: number;
+    readonly lifetimeStartedAt?: number;
 }
 export interface SessionTreeEntryBase {
     type: string;
@@ -544,17 +541,7 @@ export interface AgentHarnessOptions<TSkill extends Skill = Skill, TPromptTempla
     followUpMode?: QueueMode;
     maxOutputTokens?: number;
     maxOutputTokensPerCall?: () => number | undefined;
-    callDeadlineMsPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
-    toolDeadline?: {
-        deadlineMs: () => number | undefined;
-        onCut?: (info: {
-            toolCallId: string;
-            toolName: string;
-            elapsedMs: number;
-            settled: Promise<void>;
-        }) => void;
-    };
     loopTrace?: (step: import("../loop/agent-loop.js").LoopStep) => void;
     resilience?: import("../llm/types.js").ResilienceOptions;
     maxToolConcurrency?: number;

package/dist/engine/llm/types.d.ts

@@ -45,7 +45,6 @@ export interface StreamOptions {
     maxTokensDynamic?: boolean;
     staticReasoningCutDowngrade?: boolean;
     resilience?: ResilienceOptions;
-    callDeadlineMs?: number;
     stallTimeouts?: StallTimeouts;
     maxRetries?: number;
     maxRetryDelayMs?: number;
@@ -143,7 +142,7 @@ export interface AssistantMessage {
     usageMissing?: true;
     stopReason: StopReason;
     errorMessage?: string;
-    errorKind?: "length_empty" | "degenerate" | "walltime_cutoff";
+    errorKind?: "length_empty" | "degenerate";
     partialFinalized?: true;
     repetition?: {
         cut?: RepetitionEvent;

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

@@ -1,7 +1,7 @@
 import { type AgentCoreStreamRuntimeDeps } from "./runtime-deps.js";
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
-export type LoopContinueReason = "next_turn" | "steer_injected" | "follow_up_injected" | "reactive_compact_retry" | "max_output_tokens_recovery" | "malformed_tool_use_retry" | "thinking_only_retry" | "midstream_partial_recovery" | "degenerate_output_recovery" | "walltime_cutoff_recovery";
+export type LoopContinueReason = "next_turn" | "steer_injected" | "follow_up_injected" | "reactive_compact_retry" | "max_output_tokens_recovery" | "malformed_tool_use_retry" | "thinking_only_retry" | "midstream_partial_recovery" | "degenerate_output_recovery";
 export type LoopTerminalReason = "completed" | "aborted_before_stream" | "assistant_error" | "stop_requested" | "malformed_tool_use_exhausted" | "truncated_output_exhausted";
 export type LoopStep = {
     kind: "continue";

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

@@ -111,17 +111,6 @@ function createDegenerateRecoveryNudge() {
         timestamp: Date.now(),
     };
 }
-function createWalltimeCutoffRecoveryNudge() {
-    return {
-        role: "custom",
-        customType: "loop:walltime-cutoff-recovery",
-        provenance: "engine-note",
-        content: "Your previous response crossed the task's wall-clock deadline and was cut off (the partial text above is preserved). " +
-            "This is the FINAL turn: write your best current answer / deliverables NOW in one short response — no new work, no long commands.",
-        display: false,
-        timestamp: Date.now(),
-    };
-}
 function createReasoningCutContinueNudge() {
     return {
         role: "custom",
@@ -154,7 +143,6 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
         truncatedOutputContinues: 0,
         staticReasoningCutRecoveries: initialContext.messages.filter((m) => m.role === "assistant" && m.staticReasoningCut === true).length,
         degenerateContinues: 0,
-        walltimeCutoffContinues: 0,
         malformedToolUseRetries: 0,
         thinkingOnlyRetries: 0,
         midstreamPartialContinues: 0,
@@ -282,47 +270,8 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
         if (message.stopReason !== "error")
             state.degenerateContinues = 0;
     }
-    {
-        const wc = state.config.recovery?.walltimeCutoff;
-        if (wc &&
-            message.stopReason === "error" &&
-            !signal?.aborted &&
-            wc.detect(message) &&
-            (wc.hasLiveWriteoutWindow === undefined || wc.hasLiveWriteoutWindow()) &&
-            executor.admittedCount === 0 &&
-            message.content.every((b) => b.type !== "toolCall") &&
-            state.walltimeCutoffContinues < (wc.maxContinues ?? 1)) {
-            state.walltimeCutoffContinues++;
-            await emit({ type: "turn_end", message, toolResults: [] });
-            const drained = (await state.config.getSteeringMessages?.()) || [];
-            state.pendingMessages = drained.length > 0 ? drained : [createWalltimeCutoffRecoveryNudge()];
-            const liveLevel = state.config.liveThinkingLevel?.();
-            if (liveLevel !== undefined)
-                state.config = Object.assign({}, state.config, { reasoning: liveLevel });
-            return { kind: "ran", recovered: "walltime_cutoff_recovery" };
-        }
-    }
     if (message.stopReason === "error" || message.stopReason === "aborted") {
         const errorFinalResults = await harvestExecutorOnErrorFinal(executor, state, message, signal, emit);
-        if (state.config.recovery?.walltimeCutoff?.detect(message)) {
-            const covered = new Set(errorFinalResults.map((r) => r.toolCallId));
-            for (const tc of message.content.filter((c) => c.type === "toolCall")) {
-                if (covered.has(tc.id))
-                    continue;
-                const synthetic = {
-                    role: "toolResult",
-                    toolCallId: tc.id,
-                    toolName: tc.name,
-                    content: [{ type: "text", text: "[call aborted by walltime cutoff — never executed]" }],
-                    isError: true,
-                    timestamp: Date.now(),
-                };
-                await emitToolResultMessage(synthetic, emit);
-                state.context.messages.push(synthetic);
-                state.newMessages.push(synthetic);
-                errorFinalResults.push(synthetic);
-            }
-        }
         await emit({ type: "turn_end", message, toolResults: errorFinalResults });
         await emit({ type: "agent_end", messages: state.newMessages });
         return { kind: "terminal", reason: "assistant_error" };
@@ -440,12 +389,10 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn,
     const streamFunction = resolveAgentCoreStreamFn(runtime, streamFn);
     const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
     const perCallMaxTokens = config.maxTokensPerCall?.();
-    const perCallDeadlineMs = config.callDeadlineMsPerCall?.();
     const perCallStallTimeouts = config.stallTimeoutsPerCall?.();
     const response = await streamFunction(config.model, llmContext, {
         ...config,
         ...(perCallMaxTokens !== undefined ? { maxTokens: perCallMaxTokens, maxTokensDynamic: true } : {}),
-        ...(perCallDeadlineMs !== undefined ? { callDeadlineMs: perCallDeadlineMs } : {}),
         ...(perCallStallTimeouts !== undefined ? { stallTimeouts: perCallStallTimeouts } : {}),
         ...(staticReasoningCutDowngrade === true ? { staticReasoningCutDowngrade: true } : {}),
         apiKey: resolvedApiKey,
@@ -527,28 +474,6 @@ async function executeToolCalls(currentContext, assistantMessage, config, signal
     }
     return executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor);
 }
-const engineCutResults = new WeakSet();
-function isEngineCutResult(result) {
-    return engineCutResults.has(result);
-}
-function createEngineCutNotExecutedOutcome(toolCall) {
-    return {
-        toolCall,
-        result: {
-            content: [
-                {
-                    type: "text",
-                    text: `[not executed — engine stopped waiting at the write-out deadline] ${toolCall.name} was NOT executed: ` +
-                        `an earlier tool in this batch was cut at the task's write-out deadline, so the engine closed the batch ` +
-                        `immediately to reach the final write-out turn. This call ran no side effects and is safe to re-issue ` +
-                        `later if still needed — but do not start new long-running work now; write out your best current answer.`,
-                },
-            ],
-            details: { engineCut: "walltime_writeout", notExecuted: true },
-        },
-        isError: true,
-    };
-}
 async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];
     const messages = [];
@@ -562,7 +487,6 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         });
         const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
         let finalized;
-        let engineCutRaw = false;
         if (preparation.kind === "immediate") {
             finalized = {
                 toolCall,
@@ -571,8 +495,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
             };
         }
         else {
-            const executed = await executePreparedToolCall(preparation, config, signal, emit);
-            engineCutRaw = isEngineCutResult(executed.result);
+            const executed = await executePreparedToolCall(preparation, signal, emit);
             finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
         }
         await emitToolExecutionEnd(finalized, emit);
@@ -580,23 +503,6 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         await emitToolResultMessage(toolResultMessage, emit);
         finalizedCalls.push(finalized);
         messages.push(toolResultMessage);
-        if (engineCutRaw) {
-            for (const later of toolCalls.slice(i + 1)) {
-                await emit({
-                    type: "tool_execution_start",
-                    toolCallId: later.id,
-                    toolName: later.name,
-                    args: later.arguments,
-                });
-                const skipped = createEngineCutNotExecutedOutcome(later);
-                await emitToolExecutionEnd(skipped, emit);
-                const skippedMessage = createToolResultMessage(skipped);
-                await emitToolResultMessage(skippedMessage, emit);
-                finalizedCalls.push(skipped);
-                messages.push(skippedMessage);
-            }
-            break;
-        }
         if (signal?.aborted) {
             break;
         }
@@ -668,7 +574,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     const cap = resolveToolConcurrency(config.maxToolConcurrency);
     const allFinalized = [];
     const messages = [];
-    let engineCutSeen = false;
     const remainingCalls = [];
     for (const toolCall of toolCalls) {
         const held = executor?.take(toolCall.id);
@@ -676,8 +581,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
             remainingCalls.push(toolCall);
             continue;
         }
-        if (held.executed && isEngineCutResult(held.executed.result))
-            engineCutSeen = true;
         const finalized = await finalizeStreamEntry(currentContext, assistantMessage, held, config, signal);
         await emitToolExecutionEnd(finalized, emit);
         const toolResultMessage = createToolResultMessage(finalized);
@@ -695,23 +598,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     outer: for (const batch of batches) {
         if (signal?.aborted)
             break;
-        if (engineCutSeen) {
-            for (const toolCall of batch.calls) {
-                await emit({
-                    type: "tool_execution_start",
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    args: toolCall.arguments,
-                });
-                const skipped = createEngineCutNotExecutedOutcome(toolCall);
-                await emitToolExecutionEnd(skipped, emit);
-                const skippedMessage = createToolResultMessage(skipped);
-                await emitToolResultMessage(skippedMessage, emit);
-                allFinalized.push(skipped);
-                messages.push(skippedMessage);
-            }
-            continue;
-        }
         const entries = [];
         for (const toolCall of batch.calls) {
             await emit({
@@ -739,14 +625,7 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
     async function settleBatch(entries, concurrent) {
         const runOne = (entry) => async () => {
-            if (engineCutSeen) {
-                const skipped = createEngineCutNotExecutedOutcome(entry.toolCall);
-                await emitToolExecutionEnd(skipped, emit);
-                return skipped;
-            }
-            const executed = await executePreparedToolCall(entry.prepared, config, signal, emit);
-            if (isEngineCutResult(executed.result))
-                engineCutSeen = true;
+            const executed = await executePreparedToolCall(entry.prepared, signal, emit);
             const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, entry.prepared, executed, config, signal);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
@@ -828,10 +707,7 @@ class StreamToolExecutor {
                 return;
             }
             entry.prepared = preparation;
-            entry.executed = await executePreparedToolCall(preparation, this.config, this.signal, this.emit);
-            if (isEngineCutResult(entry.executed.result)) {
-                this.barrier = true;
-            }
+            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit);
         }
         catch (error) {
             entry.immediate = {
@@ -993,13 +869,12 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
 }
-async function executePreparedToolCall(prepared, config, signal, emit) {
+async function executePreparedToolCall(prepared, signal, emit) {
     const updateEvents = [];
     let acceptingUpdates = true;
     if (signal?.aborted) {
         return { result: createErrorToolResult("operation aborted before execution"), isError: true };
     }
-    const startedAt = Date.now();
     const work = (async () => {
         try {
             const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
@@ -1027,48 +902,7 @@ async function executePreparedToolCall(prepared, config, signal, emit) {
             };
         }
     })();
-    const cutDeadline = config.toolDeadline?.deadlineMs();
-    if (cutDeadline === undefined)
-        return work;
-    let cutTimer;
-    const cut = new Promise((resolve) => {
-        cutTimer = setTimeout(() => {
-            const elapsedMs = Date.now() - startedAt;
-            acceptingUpdates = false;
-            try {
-                config.toolDeadline?.onCut?.({
-                    toolCallId: prepared.toolCall.id,
-                    toolName: prepared.toolCall.name,
-                    elapsedMs,
-                    settled: work.then(() => undefined, () => undefined),
-                });
-            }
-            catch {
-            }
-            const cutResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `[tool cut short at the write-out deadline] ${prepared.toolCall.name} had been running for ${Math.round(elapsedMs / 1000)}s ` +
-                            `when the task's wall-clock write-out window opened — the ENGINE stopped waiting for it so the final answer can still be written out. ` +
-                            `The tool itself was NOT cancelled and did not fail: it may have completed or may still be running in the background, and its side effects ` +
-                            `may still land after this message — treat its outcome as UNKNOWN and do NOT blindly re-issue non-idempotent operations. ` +
-                            `Do not start new long-running work — write out your best current answer now.`,
-                    },
-                ],
-                details: { engineCut: "walltime_writeout", elapsedMs },
-            };
-            engineCutResults.add(cutResult);
-            resolve({ result: cutResult, isError: true });
-        }, Math.max(0, cutDeadline - Date.now()));
-        cutTimer.unref?.();
-    });
-    try {
-        return await Promise.race([work, cut]);
-    }
-    finally {
-        clearTimeout(cutTimer);
-    }
+    return work;
 }
 async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
     let result = executed.result;

package/dist/engine/loop/types.d.ts

@@ -68,29 +68,12 @@ export interface LoopRecoveryOptions {
         detect: (message: AssistantMessage) => boolean;
         maxContinues?: number;
     };
-    walltimeCutoff?: {
-        detect: (message: AssistantMessage) => boolean;
-        maxContinues?: number;
-        hasLiveWriteoutWindow?: () => boolean;
-    };
-}
-export interface ToolCutInfo {
-    toolCallId: string;
-    toolName: string;
-    elapsedMs: number;
-    settled: Promise<void>;
-}
-export interface LoopToolDeadline {
-    deadlineMs: () => number | undefined;
-    onCut?: (info: ToolCutInfo) => void;
 }
 export interface AgentLoopConfig extends SimpleStreamOptions {
     model: Model;
     recovery?: LoopRecoveryOptions;
     maxTokensPerCall?: () => number | undefined;
-    callDeadlineMsPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
-    toolDeadline?: LoopToolDeadline;
     maxToolConcurrency?: number;
     streamingToolExecution?: boolean;
     convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
@@ -98,7 +81,6 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
     getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
     shouldStopAfterTurn?: (context: ShouldStopAfterTurnContext) => boolean | Promise<boolean>;
     prepareNextTurn?: (context: PrepareNextTurnContext) => AgentLoopTurnUpdate | undefined | Promise<AgentLoopTurnUpdate | undefined>;
-    liveThinkingLevel?: () => ThinkingLevel;
     getSteeringMessages?: () => Promise<AgentMessage[]>;
     getFollowUpMessages?: () => Promise<AgentMessage[]>;
     toolExecution?: ToolExecutionMode;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export { Runner, runTask, DEFAULT_MAX_TURNS } from "./core/runner/runtask.js";
+export { Runner, runTask } from "./core/runner/runtask.js";
+export { resolveTaskLimits } from "./core/runner/prepare-task.js";
+export type { BudgetAxis } from "./core/runner/assemble-result.js";
 export { SESSION_LOG_DIGEST_SCHEME, sessionEntryDigest, sessionLogDigest, sessionLogDigestsComparable, } from "./engine/session/log-digest.js";
 export type { ResumeTaskConfig } from "./core/runner/runtask.js";
 export { defineTool } from "./core/tools.js";
@@ -75,7 +77,10 @@ export { HAND_TOOL_EFFECTS, bashReversibilityProbe, BASH_READONLY_DEFAULT_ALLOW,
 export { classifyCompoundReadonlyDetailed, formatOutOfRootReadApprovalOption, type BashReadonlyRootBoundary, type CompoundReadonlyVerdict, } from "./tools/fs/index.js";
 export { resolveBashTimeoutCaps } from "./tools/fs/index.js";
 export { InMemoryToolResultStore, OFFLOAD_TOOL_NAME, DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, assertSafeToolResultRef, type ToolResultStore, type ToolResultSlice, } from "./core/tool-result-store.js";
-export { InMemoryCheckpointStore, CheckpointError, mintCheckpointToken, checkpointVersionOf, CURRENT_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, WALLTIME_CHECKPOINT_VERSION, debitLedger, remainingBudgetMicroUsd, remainingWalltimeMs, winnerFromOutcome, validatePendingSteer, riskSeverity, buildRiskDescriptor, summarizeCheckpoint, type RiskDescriptor, type CheckpointStore, type CheckpointSummary, type Checkpoint, type CheckpointToken, type CheckpointGate, type CheckpointState, type SerializedCheckpointState, type CheckpointFaultMode, type PendingAction, type ResumeOutcome, type ResolvedOutcome, type ReopenReason, type ResolveExpectation, type SafetyAxis, type ResourceLedger, type ResourceLimitReason, } from "./core/checkpoint-store.js";
+export { InMemoryCheckpointStore, CheckpointError, mintCheckpointToken, checkpointVersionOf, CURRENT_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, TOKEN_CHECKPOINT_VERSION, debitLedger, remainingBudgetMicroUsd, remainingTokens, winnerFromOutcome, validatePendingSteer, riskSeverity, buildRiskDescriptor, summarizeCheckpoint, type RiskDescriptor, type CheckpointStore, type CheckpointSummary, type Checkpoint, type CheckpointToken, type CheckpointGate, type CheckpointState, type SerializedCheckpointState, type CheckpointFaultMode, type PendingAction, type ResumeOutcome, type ResolvedOutcome, type ReopenReason, type ResolveExpectation, type SafetyAxis, type ResourceLedger, type ResourceLimitReason, type PlatformLimitReason, } from "./core/checkpoint-store.js";
+export { InMemoryUsageWindowStore, GLOBAL_USAGE_KEY, EMPTY_USAGE_WINDOW_RECORD, chargeUsageRecord, readUsageRecord, usageRetryAfterMs, resolveUsageWindows, type UsageWindow, type UsageWindowStore, type UsageWindowReading, type UsageWindowRecord, type UsageSlot, type UsageBucketRow, } from "./core/usage-window-store.js";
+export { FileUsageWindowStore } from "./stores/file/usage-window-store.js";
+export { ENV_LIFETIME_SUSPEND_MARGIN_MS, USAGE_WINDOW_REAP_MARGIN_MS } from "./core/runner/prepare-task.js";
 export { InMemoryFileSnapshotStore, DEFAULT_SNAPSHOT_BOUNDS } from "./core/file-snapshot-store.js";
 export { captureManifest, applyManifest } from "./core/file-snapshot-store.js";
 export type { FileSnapshotStore, FileSnapshotResult, FileSnapshotError, FileSnapshotBounds } from "./core/file-snapshot-store.js";
@@ -86,7 +91,7 @@ export { brainToRuntime } from "./core/runtime.js";
 export { createSensitivePathPolicy, RECOMMENDED_SENSITIVE_PATTERNS } from "./core/sensitive-path-policy.js";
 export { createFsWriteGatePolicy, type FsWriteGatePolicyOptions } from "./core/fs-write-gate-policy.js";
 export { RETIRED_TOOL_NAMES } from "./core/tool-name-aliases.js";
-export { DEFAULT_SUBAGENT_TOOL_NAME, SESSION_BG_DEFAULT_TIMEOUT_SEC } from "./agents/subagent.js";
+export { DEFAULT_SUBAGENT_TOOL_NAME } from "./agents/subagent.js";
 export { renderTaskNotificationXml, taskNotificationDedupKey, SystemInjectionQueue, type TaskNotificationPayload, type TaskNotificationStatus, type ExternalNotificationInput, type SystemInjection, type SystemInjectionPriority, } from "./core/task-notification.js";
 export { TaskRegistry, defaultTaskRegistry, createTaskOutputTool, createTaskStopTool, type SemaTaskType, type SemaTaskStatus, type SemaTaskHandle, type ParkedClaimTicket, type TaskAccess, type UnifiedTaskOutput, type TaskRetrievalStatus, type StopSource, type RegisterMonitorInput, type MonitorTimers, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccessWorkflowRun, DURABLE_AGENT_HANDLE_RE, } from "./core/task-registry.js";
 export { InMemoryMailboxStore, type MailboxStore, type MailboxMessage, type MailboxLease } from "./core/mailbox-store.js";
@@ -179,7 +184,7 @@ export { MemoryRosterStore, FileRosterStore, type RosterStore, type RosterEntry,
 export { CONFIG_CATALOG_VERSION, describeConfigCatalog, resolveEffectiveConfig, type ConfigKnob, type ConfigOverrideDeclaration, type ConfigProvenance, type EffectiveConfigField, } from "./config/catalog.js";
 export { normalizeAgentName } from "./core/task-registry.js";
 export { COORDINATOR_ROLE_PROMPT, TEAMMATE_COMMUNICATION_ADDENDUM, TEAMMATE_TASK_LIST_ADDENDUM } from "./prompts/coordinator.js";
-export { createSubagentTool, FORK_SUBAGENT_TYPE, GENERAL_PURPOSE_SUBAGENT_TYPE, FORK_DEFAULT_MAX_TURNS, agentWhenToUseText, FORK_DIRECTIVE_FRAME, SUBAGENT_SYSTEM_NOTE, type SubagentToolOptions, type SubagentSpawnContext, type SubagentSteerHandle, type SubagentStep, type SubagentEditedFile, } from "./agents/subagent.js";
+export { createSubagentTool, FORK_SUBAGENT_TYPE, GENERAL_PURPOSE_SUBAGENT_TYPE, agentWhenToUseText, FORK_DIRECTIVE_FRAME, SUBAGENT_SYSTEM_NOTE, type SubagentToolOptions, type SubagentSpawnContext, type SubagentSteerHandle, type SubagentStep, type SubagentEditedFile, } from "./agents/subagent.js";
 export { getSessionRetainLedger, releaseSessionRetainLedger, } from "./agents/retain-ledger.js";
 export { createSendMessageTool, SEND_MESSAGE_TOOL_NAME, type SendMessageToolOptions } from "./agents/send-message-tool.js";
 export { createAgentTranscriptTool, AGENT_TRANSCRIPT_TOOL_NAME, type AgentTranscriptToolOptions, } from "./agents/agent-transcript-tool.js";
@@ -200,7 +205,7 @@ export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";
 export { createAssistantMessageEventStream } from "./internal/llm.js";
 export type { AssistantMessage, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
-export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, A2aServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
+export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, A2aServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskLimits, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
 export { Type } from "typebox";
 export type { TSchema, Static } from "typebox";
 export { explainPromptAssembly, describeDefaultPack, type DefaultPackDescription, type ExplainInput } from "./prompt-assembly/explain.js";

package/dist/index.js

@@ -1,4 +1,5 @@
-export { Runner, runTask, DEFAULT_MAX_TURNS } from "./core/runner/runtask.js";
+export { Runner, runTask } from "./core/runner/runtask.js";
+export { resolveTaskLimits } from "./core/runner/prepare-task.js";
 export { SESSION_LOG_DIGEST_SCHEME, sessionEntryDigest, sessionLogDigest, sessionLogDigestsComparable, } from "./engine/session/log-digest.js";
 export { defineTool } from "./core/tools.js";
 export { SKILL_TOOL_NAME } from "./core/runner/synthetic-tools.js";
@@ -64,7 +65,10 @@ export { HAND_TOOL_EFFECTS, bashReversibilityProbe, BASH_READONLY_DEFAULT_ALLOW,
 export { classifyCompoundReadonlyDetailed, formatOutOfRootReadApprovalOption, } from "./tools/fs/index.js";
 export { resolveBashTimeoutCaps } from "./tools/fs/index.js";
 export { InMemoryToolResultStore, OFFLOAD_TOOL_NAME, DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, assertSafeToolResultRef, } from "./core/tool-result-store.js";
-export { InMemoryCheckpointStore, CheckpointError, mintCheckpointToken, checkpointVersionOf, CURRENT_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, WALLTIME_CHECKPOINT_VERSION, debitLedger, remainingBudgetMicroUsd, remainingWalltimeMs, winnerFromOutcome, validatePendingSteer, riskSeverity, buildRiskDescriptor, summarizeCheckpoint, } from "./core/checkpoint-store.js";
+export { InMemoryCheckpointStore, CheckpointError, mintCheckpointToken, checkpointVersionOf, CURRENT_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, TOKEN_CHECKPOINT_VERSION, debitLedger, remainingBudgetMicroUsd, remainingTokens, winnerFromOutcome, validatePendingSteer, riskSeverity, buildRiskDescriptor, summarizeCheckpoint, } from "./core/checkpoint-store.js";
+export { InMemoryUsageWindowStore, GLOBAL_USAGE_KEY, EMPTY_USAGE_WINDOW_RECORD, chargeUsageRecord, readUsageRecord, usageRetryAfterMs, resolveUsageWindows, } from "./core/usage-window-store.js";
+export { FileUsageWindowStore } from "./stores/file/usage-window-store.js";
+export { ENV_LIFETIME_SUSPEND_MARGIN_MS, USAGE_WINDOW_REAP_MARGIN_MS } from "./core/runner/prepare-task.js";
 export { InMemoryFileSnapshotStore, DEFAULT_SNAPSHOT_BOUNDS } from "./core/file-snapshot-store.js";
 export { captureManifest, applyManifest } from "./core/file-snapshot-store.js";
 export { FileStorageBackend, FileSessionRepo, FileCheckpointStore, FileMemoryStore, FileToolResultStore, FileSessionPolicyStore, FileFileSnapshotStore, FileWorkflowJournalStore, MAX_JOURNAL_RESULT_BYTES, oversizeJournalResult, resolveDataRoot, sanitizeScope, sanitizePathComponent, createFileConsolidationLock, atomicWriteFile, writeThenLink, ensureDir, readJsonlRecords, AppendLog, } from "./stores/file/index.js";
@@ -74,7 +78,7 @@ export { brainToRuntime } from "./core/runtime.js";
 export { createSensitivePathPolicy, RECOMMENDED_SENSITIVE_PATTERNS } from "./core/sensitive-path-policy.js";
 export { createFsWriteGatePolicy } from "./core/fs-write-gate-policy.js";
 export { RETIRED_TOOL_NAMES } from "./core/tool-name-aliases.js";
-export { DEFAULT_SUBAGENT_TOOL_NAME, SESSION_BG_DEFAULT_TIMEOUT_SEC } from "./agents/subagent.js";
+export { DEFAULT_SUBAGENT_TOOL_NAME } from "./agents/subagent.js";
 export { renderTaskNotificationXml, taskNotificationDedupKey, SystemInjectionQueue, } from "./core/task-notification.js";
 export { TaskRegistry, defaultTaskRegistry, createTaskOutputTool, createTaskStopTool, MONITOR_BATCH_WINDOW_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_MAX_TIMEOUT_MS, MONITOR_MAX_BATCHES_PER_MINUTE, canAccessWorkflowRun, DURABLE_AGENT_HANDLE_RE, } from "./core/task-registry.js";
 export { InMemoryMailboxStore } from "./core/mailbox-store.js";
@@ -162,7 +166,7 @@ export { MemoryRosterStore, FileRosterStore } from "./agents/roster-store.js";
 export { CONFIG_CATALOG_VERSION, describeConfigCatalog, resolveEffectiveConfig, } from "./config/catalog.js";
 export { normalizeAgentName } from "./core/task-registry.js";
 export { COORDINATOR_ROLE_PROMPT, TEAMMATE_COMMUNICATION_ADDENDUM, TEAMMATE_TASK_LIST_ADDENDUM } from "./prompts/coordinator.js";
-export { createSubagentTool, FORK_SUBAGENT_TYPE, GENERAL_PURPOSE_SUBAGENT_TYPE, FORK_DEFAULT_MAX_TURNS, agentWhenToUseText, FORK_DIRECTIVE_FRAME, SUBAGENT_SYSTEM_NOTE, } from "./agents/subagent.js";
+export { createSubagentTool, FORK_SUBAGENT_TYPE, GENERAL_PURPOSE_SUBAGENT_TYPE, agentWhenToUseText, FORK_DIRECTIVE_FRAME, SUBAGENT_SYSTEM_NOTE, } from "./agents/subagent.js";
 export { getSessionRetainLedger, releaseSessionRetainLedger, } from "./agents/retain-ledger.js";
 export { createSendMessageTool, SEND_MESSAGE_TOOL_NAME } from "./agents/send-message-tool.js";
 export { createAgentTranscriptTool, AGENT_TRANSCRIPT_TOOL_NAME, } from "./agents/agent-transcript-tool.js";

package/dist/orchestration/goal.js

@@ -148,16 +148,12 @@ export async function runGoal(runner, spec) {
             if (result.status === "blocked")
                 return mk("blocked", iteration, { result });
             if (result.status === "failed") {
-                if (result.errorCode === "limit.max_turns") {
+                if (result.errorCode !== undefined && result.errorCode.startsWith("limits.max_")) {
                     lastFeedback = TIMEOUT_FEEDBACK;
                     continue;
                 }
                 return mk("failed", iteration, { result, errorCode: result.errorCode });
             }
-            if (result.status === "timeout") {
-                lastFeedback = TIMEOUT_FEEDBACK;
-                continue;
-            }
             const gate1 = hasOutputSchema ? result.structuredOutput !== undefined : doneRef.declared === true;
             if (!gate1) {
                 lastFeedback = NOT_DECLARED_FEEDBACK;

package/dist/orchestration/run-workflow-tool.d.ts

@@ -38,7 +38,7 @@ export interface WorkflowLimits {
     maxScriptChars?: number;
     maxAgents?: number;
     totalTimeoutMs?: number;
-    perAgentTimeoutSec?: number;
+    perAgentMaxWalltimeMs?: number;
     childMaxCostUsd?: number;
     childMaxTokens?: number;
     childMaxTurns?: number;

package/dist/orchestration/run-workflow-tool.js

@@ -17,7 +17,6 @@ const DEFAULTS = {
     maxScriptChars: 100_000,
     maxAgents: 50,
     totalTimeoutMs: 600_000,
-    perAgentTimeoutSec: 300,
     maxResultChars: 100_000,
     maxLogChars: 10_000,
 };
@@ -141,7 +140,7 @@ export async function createRunWorkflowTool(d) {
     const lim = d.limits ?? {};
     const maxScriptChars = lim.maxScriptChars ?? DEFAULTS.maxScriptChars;
     const childCaps = {
-        perAgentTimeoutSec: lim.perAgentTimeoutSec ?? DEFAULTS.perAgentTimeoutSec,
+        perAgentMaxWalltimeMs: lim.perAgentMaxWalltimeMs,
         childMaxCostUsd: lim.childMaxCostUsd,
         childMaxTokens: lim.childMaxTokens,
         childMaxTurns: lim.childMaxTurns,

package/dist/orchestration/workflow-governance.d.ts

@@ -13,20 +13,20 @@ export interface WorkflowAgentSpec {
     images?: ImageInput[];
     limits?: {
         maxTurns?: number;
-        timeoutSec?: number;
+        maxWalltimeMs?: number;
+        maxTokens?: number;
+        maxCostUsd?: number;
     };
-    maxCostUsd?: number;
-    maxTokens?: number;
 }
-export declare const WHITELIST_KEYS: readonly ["objective", "modelName", "thinking", "systemPrompt", "images", "limits", "maxCostUsd", "maxTokens"];
+export declare const WHITELIST_KEYS: readonly ["objective", "modelName", "thinking", "systemPrompt", "images", "limits"];
 export interface WorkflowChildCaps {
-    perAgentTimeoutSec?: number;
+    perAgentMaxWalltimeMs?: number;
     childMaxCostUsd?: number;
     childMaxTokens?: number;
     childMaxTurns?: number;
 }
 export interface ResourceClampNote {
-    field: "maxCostUsd" | "maxTokens" | "timeoutSec" | "maxTurns";
+    field: "maxCostUsd" | "maxTokens" | "maxWalltimeMs" | "maxTurns";
     requested: number | undefined;
     applied: number;
 }