@sema-agent/core 1.451.0 → 2.0.0

package/dist/core/task-tool-shape.d.ts

@@ -0,0 +1,32 @@
+import { Type } from "typebox";
+export declare const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
+export declare const TASK_STOP_TOOL_NAME = "TaskStop";
+export declare const TASK_OUTPUT_ALIASES: readonly ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
+export declare const TASK_STOP_ALIASES: readonly ["KillShell", "KillBash"];
+export declare const TASK_OUTPUT_CONTRACT: {
+    readonly contractId: "core.task_output@1";
+    readonly implementationRevision: "1";
+};
+export declare const TASK_STOP_CONTRACT: {
+    readonly contractId: "core.task_stop@1";
+    readonly implementationRevision: "1";
+};
+export declare const TASK_OUTPUT_MISSING_ID_MESSAGE = "Error (TaskOutput): Missing required parameter: task_id";
+export declare const TASK_STOP_MISSING_ID_MESSAGE = "Missing required parameter: task_id";
+export declare const TASK_STOP_PARAMS: Type.TObject<{
+    task_id: Type.TOptional<Type.TString>;
+    shell_id: Type.TOptional<Type.TString>;
+}>;
+export declare function resolveTaskIdArg(...values: unknown[]): string | undefined;
+export interface TaskToolCapabilities {
+    lanes: boolean;
+    outputFile: boolean;
+    notification: boolean;
+    blockWait: boolean;
+    nameAddressing: boolean;
+}
+export declare const REGISTRY_TASK_TOOL_CAPS: TaskToolCapabilities;
+export declare const ENV_DIRECT_TASK_TOOL_CAPS: TaskToolCapabilities;
+export declare function composeTaskOutputDescription(caps: TaskToolCapabilities): string;
+export declare function composeTaskStopDescription(caps: TaskToolCapabilities): string;
+export declare function composeTaskOutputParams(caps: Pick<TaskToolCapabilities, "blockWait" | "lanes">): ReturnType<typeof Type.Object>;

package/dist/core/task-tool-shape.js

@@ -0,0 +1,83 @@
+import { Type } from "typebox";
+export const TASK_OUTPUT_TOOL_NAME = "TaskOutput";
+export const TASK_STOP_TOOL_NAME = "TaskStop";
+export const TASK_OUTPUT_ALIASES = ["BashOutput", "AgentOutputTool", "BashOutputTool", "AgentOutput", "WorkflowStatus"];
+export const TASK_STOP_ALIASES = ["KillShell", "KillBash"];
+export const TASK_OUTPUT_CONTRACT = { contractId: "core.task_output@1", implementationRevision: "1" };
+export const TASK_STOP_CONTRACT = { contractId: "core.task_stop@1", implementationRevision: "1" };
+export const TASK_OUTPUT_MISSING_ID_MESSAGE = "Error (TaskOutput): Missing required parameter: task_id";
+export const TASK_STOP_MISSING_ID_MESSAGE = "Missing required parameter: task_id";
+export const TASK_STOP_PARAMS = Type.Object({
+    task_id: Type.Optional(Type.String({ description: "The ID of the background task to stop" })),
+    shell_id: Type.Optional(Type.String({ description: "Deprecated: use task_id instead" })),
+});
+export function resolveTaskIdArg(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim() !== "")
+            return value.trim();
+    }
+    return undefined;
+}
+export const REGISTRY_TASK_TOOL_CAPS = {
+    lanes: true,
+    outputFile: true,
+    notification: true,
+    blockWait: true,
+    nameAddressing: true,
+};
+export const ENV_DIRECT_TASK_TOOL_CAPS = {
+    lanes: false,
+    outputFile: false,
+    notification: false,
+    blockWait: false,
+    nameAddressing: false,
+};
+export function composeTaskOutputDescription(caps) {
+    const parts = [];
+    if (caps.outputFile) {
+        parts.push("[Deprecated] — for background Bash tasks, prefer Read on the output file path; for agent tasks, use the Agent tool result directly. " +
+            "DEPRECATED: Background tasks return their output file path in the tool result" +
+            (caps.notification ? ", and you receive a <task-notification> with the same path when the task completes. " : ". "));
+    }
+    parts.push("Retrieve output or status for a background task by task_id. ");
+    parts.push(caps.lanes
+        ? "Supports background Bash tasks and workflow tasks returned by RunWorkflow. Returns only the caller's own task scope; unknown and out-of-scope ids are " +
+            "reported the same way. "
+        : "Reads a background shell started with Bash(run_in_background): returns the run status (running / exited(code) / killed / failed) plus NEW stdout/stderr since your last call. ");
+    if (!caps.notification) {
+        parts.push('When using a background command as a wait condition, call this repeatedly until status is no longer "running" — completion ' +
+            "is signalled by status/exitCode, not by any automatic notification; after you see a terminal status, one more " +
+            "poll captures any final output. ");
+    }
+    if (!caps.lanes)
+        parts.push("Optional `filter` is a regex keeping only matching lines. ");
+    parts.push("Legacy bash_id and runId arguments are accepted for compatibility.");
+    return parts.join("");
+}
+export function composeTaskStopDescription(caps) {
+    return [
+        "- Stops a running background task by its ID",
+        "- Takes a task_id parameter identifying the task to stop",
+        ...(caps.nameAddressing ? ["- To stop a background agent spawned with a name, pass that name as task_id"] : []),
+        "- Returns a success or failure status",
+        "- Use this tool when you need to terminate a long-running task",
+    ].join("\n");
+}
+export function composeTaskOutputParams(caps) {
+    return Type.Object({
+        task_id: Type.Optional(Type.String({
+            description: caps.lanes
+                ? "The task_id returned by Bash(run_in_background) or RunWorkflow."
+                : "The task_id returned by Bash(run_in_background).",
+        })),
+        ...(caps.blockWait
+            ? {
+                block: Type.Optional(Type.Boolean({
+                    description: "Whether to wait for completion (default true — the call waits until the task finishes or `timeout`, saving re-poll turns). Pass false for an instantaneous snapshot.",
+                })),
+                timeout: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds when block is true (default 30000, max 600000)." })),
+            }
+            : {}),
+        filter: Type.Optional(Type.String({ description: "Optional regex filter for background Bash output (sema extension)." })),
+    });
+}

package/dist/core/tool-policy.d.ts

@@ -29,10 +29,9 @@ export type PermissionResult = {
     reason?: string;
     decisionReason?: DecisionReason;
 };
-export type ToolDecision = PermissionResult;
 export declare function decisionText(d: PermissionResult): string | undefined;
 export interface ToolPolicy {
-    check(req: ToolCallRequest, signal?: AbortSignal): ToolDecision | Promise<ToolDecision>;
+    check(req: ToolCallRequest, signal?: AbortSignal): PermissionResult | Promise<PermissionResult>;
 }
 export interface ToolPolicyNameSets {
     readonly allow?: readonly string[];

package/dist/core/tool-result-budget.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from "../internal/harness.js";
+import type { AgentMessage } from "../internal/harness-types.js";
 import { type ToolResultStore } from "./tool-result-store.js";
 export declare const AGGREGATE_TOOL_RESULT_BUDGET_CHARS = 200000;
 export interface AggregateBudgetOptions {

package/dist/core/tool-result-store.d.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "../internal/harness.js";
+import type { AgentTool } from "../internal/harness-types.js";
 export interface ToolResultStore {
     put(ref: string, content: string): Promise<void> | void;
     get(ref: string, opts?: {
@@ -54,4 +54,4 @@ export declare function buildPreview(full: string, ref: string, sizes?: {
     tail: number;
 }): string;
 export declare function withToolResultOffload(tool: AgentTool, store: ToolResultStore, thresholdChars: number, sessionId: string): AgentTool;
-export declare function makeReadToolResultTool(store: ToolResultStore): AgentTool;
+export declare function createReadToolResultTool(store: ToolResultStore): AgentTool;

package/dist/core/tool-result-store.js

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { defineTool } from "./tools.js";
+import { defineTool, errorResult } from "./tools.js";
 export class InMemoryToolResultStore {
     opts;
     map = new Map();
@@ -128,7 +128,7 @@ export function withToolResultOffload(tool, store, thresholdChars, sessionId) {
     };
     return { ...tool, execute: wrappedExecute };
 }
-export function makeReadToolResultTool(store) {
+export function createReadToolResultTool(store) {
     return defineTool({
         name: OFFLOAD_TOOL_NAME,
         contract: { contractId: "core.read_tool_result@1", implementationRevision: "1" },
@@ -146,7 +146,7 @@ export function makeReadToolResultTool(store) {
             const lim = Math.min(READ_MAX_LIMIT, Math.max(1, intOr(limit, READ_DEFAULT_LIMIT)));
             const slice = await store.get(ref, { offset: off, limit: lim });
             if (!slice) {
-                return `No persisted output for ref "${ref}" — it may have expired, or this process has no durable tool-result store (the preview above is all that remains).`;
+                return errorResult(`No persisted output for ref "${ref}" — it may have expired, or this process has no durable tool-result store (the preview above is all that remains).`);
             }
             const end = slice.offset + slice.content.length;
             const more = end < slice.totalChars ? `\n…[${slice.totalChars - end} more chars — call again with offset=${end}.]` : "";

package/dist/core/tools.d.ts

@@ -1,5 +1,9 @@
 import type { TSchema } from "typebox";
-import type { AgentTool, Skill } from "../internal/harness.js";
-import type { SkillSpec, ToolSpec } from "./types.js";
+import type { AgentTool } from "../internal/harness.js";
+import type { ToolSpec } from "./types.js";
+export declare function errorResult(text: string, details?: unknown): {
+    content: string;
+    isError: true;
+    details?: unknown;
+};
 export declare function defineTool<TParams extends TSchema = TSchema>(spec: ToolSpec<TParams>): AgentTool<TParams>;
-export declare function toSkill(spec: SkillSpec): Skill;

package/dist/core/tools.js

@@ -22,6 +22,9 @@ function isEmptyToolContent(content) {
         return true;
     return content.every((b) => b.type === "text" && (typeof b.text !== "string" || b.text.trim() === ""));
 }
+export function errorResult(text, details) {
+    return details === undefined ? { content: text, isError: true } : { content: text, isError: true, details };
+}
 export function defineTool(spec) {
     const executionMode = spec.executionMode ?? (spec.effect === "read" ? "parallel" : "sequential");
     const tool = {
@@ -70,11 +73,3 @@ export function defineTool(spec) {
     }
     return tool;
 }
-export function toSkill(spec) {
-    return {
-        name: spec.name,
-        description: spec.description,
-        content: spec.content,
-        filePath: `memory://skills/${spec.name}`,
-    };
-}

package/dist/core/trace.d.ts

@@ -1,5 +1,5 @@
 import type { TaskStatus, ToolEffect } from "./types.js";
-import type { ThinkingLevel } from "../internal/harness.js";
+import type { ThinkingLevel } from "../internal/harness-types.js";
 export interface TraceMechanismsSummary {
     finalizeInjected?: true;
     nudgesSent?: number;
@@ -26,7 +26,7 @@ export type TraceEvent = {
     kind: "prompt.assembled";
     version: 1;
     taskId: string;
-    constitution: "core" | "replaced" | "provider-assembled" | "legacy";
+    constitution: "core" | "replaced" | "provider-assembled";
     blocks: Array<{
         id: string;
         chars: number;

package/dist/core/types.d.ts

@@ -87,7 +87,6 @@ export interface ToolExecuteContext {
         tokens: number;
         turns: number;
         tasks: number;
-        costUsd?: number;
         costMicroUsd?: number;
     }) => void;
     model?: Model;
@@ -247,7 +246,6 @@ export interface TaskSpec {
     appendSystemPrompt?: string;
     promptProvider?: import("../prompts/default.js").PromptProvider;
     memory?: import("./memory.js").MemorySpecInput;
-    memoryConsolidation?: MemoryConsolidationConfig;
     suggestNextPrompts?: boolean | {
         count?: number;
         role?: ModelRole;
@@ -398,12 +396,10 @@ export interface TaskResult {
         outputTokens?: number;
         cacheWriteTokensLong?: number;
         costMicroUsd?: number;
-        costUsd?: number;
         nested?: {
             tokens: number;
             turns: number;
             tasks: number;
-            costUsd?: number;
             costMicroUsd?: number;
         };
         memory?: {
@@ -596,7 +592,6 @@ export type TaskEvent = ({
 export type CompactOutcome = "compacted" | "failed" | "mooted" | "noop" | "blocked" | "disabled";
 export interface TaskStream extends AsyncIterable<TaskEvent> {
     result(): Promise<TaskResult>;
-    consolidation(): Promise<void>;
     suggestions(): Promise<string[]>;
     steer(text: string, options?: {
         trusted?: boolean;
@@ -612,17 +607,6 @@ export interface TaskStream extends AsyncIterable<TaskEvent> {
     interrupt(): Promise<void>;
     destroy(): Promise<void>;
 }
-export interface MemoryConsolidationConfig {
-    enabled: boolean;
-    role?: ModelRole;
-    band?: {
-        lo: number;
-        hi: number;
-    };
-    searchLimit?: number;
-    maxNotesPerTask?: number;
-    timeoutSec?: number;
-}
 export interface WorkflowGovernanceBaseline {
     base: Partial<TaskSpec>;
     worktreeBase?: Partial<TaskSpec>;
@@ -664,6 +648,7 @@ export interface BackgroundChildEvent {
     resumable?: boolean;
     status?: "completed" | "killed" | "failed";
     seq?: number;
+    completionId?: string;
     stoppedBy?: "user" | "parent" | "system" | (string & {});
     summary?: string;
     usage?: {
@@ -728,7 +713,6 @@ export interface RunnerDeps {
     onWorkflowAgentSpawn?: (handle: import("../orchestration/workflow.js").WorkflowAgentHandle) => void;
     maxSuspends?: number;
     now?: () => number;
-    memoryStore?: import("./memory.js").MemoryStore;
     memoryBackend?: import("./memory-engine/types.js").MemoryBackend;
     memoryEngineDir?: string;
     onMemoryHarvestReport?: (report: import("./memory-engine/types.js").HarvestReport, info: {
@@ -750,17 +734,6 @@ export interface RunnerDeps {
         path: string;
         contentHash: string | null;
     }> | null>;
-    utilityGate?: import("./memory.js").UtilityGate;
-    memoryConsolidation?: MemoryConsolidationConfig;
-    memoryRecall?: {
-        enabled?: boolean;
-        thresholdBytes?: number;
-        select?: import("./memory-recall.js").MemorySelector;
-        selectorModel?: ModelRef;
-        maxSelected?: number;
-        maxLinked?: number;
-        timeoutMs?: number;
-    };
     promptProvider?: import("../prompts/default.js").PromptProvider;
     onElicit?: OnElicit;
     mcpImageResizer?: import("./mcp.js").McpImageResizer;
@@ -796,6 +769,5 @@ export interface RunnerDeps {
     summaryProvider?: import("./auto-compaction.js").MaybeCompactOptions["summaryProvider"];
     onCompaction?: import("./auto-compaction.js").MaybeCompactOptions["onCompaction"];
     maxConsecutiveProviderReuse?: number;
-    dynamicRecall?: import("./dynamic-recall.js").DynamicRecallConfig;
 }
 export type { AgentTool, Model, StreamFn, ThinkingLevel };

package/dist/core/workflow-journal-store.d.ts

@@ -11,6 +11,8 @@ export interface WorkflowJournalStore {
 export declare const MAX_JOURNAL_RESULT_BYTES: number;
 export declare function oversizeJournalResult(serialized: string): boolean;
 export declare function callKeyOrdinal(callKey: string): number;
+export declare const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
+export declare function journalOversizeTombstone(result: TaskResult, bytes: number): TaskResult;
 export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStore {
     private readonly runs;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;

package/dist/core/workflow-journal-store.js

@@ -7,6 +7,20 @@ export function callKeyOrdinal(callKey) {
     const n = Number.parseInt(i >= 0 ? callKey.slice(0, i) : callKey, 10);
     return Number.isFinite(n) ? n : 0;
 }
+export const JOURNAL_OVERSIZE_ERROR_CODE = "workflow.journal_oversize";
+export function journalOversizeTombstone(result, bytes) {
+    const message = `[journal] result omitted: ${bytes} bytes exceeds the ${MAX_JOURNAL_RESULT_BYTES}-byte per-entry journal cap; ` +
+        `the agent's real terminal status was "${result.status}". A resume re-runs this agent (and everything after it) live.`;
+    return {
+        taskId: result.taskId,
+        sessionId: result.sessionId,
+        status: "failed",
+        result: message,
+        errorCode: JOURNAL_OVERSIZE_ERROR_CODE,
+        errorMessage: message,
+        stats: result.stats,
+    };
+}
 function snapshot(entry) {
     try {
         return structuredClone(entry);

package/dist/core/workflow-run-store-contract.d.ts

@@ -1,5 +1,5 @@
 import { type WorkflowRunStore } from "./workflow-run-store.js";
 import type { WorkflowRun, WorkflowRunStatus } from "../orchestration/workflow.js";
-export declare function makeWorkflowRun(over?: Partial<WorkflowRun>): WorkflowRun;
+export declare function createWorkflowRun(over?: Partial<WorkflowRun>): WorkflowRun;
 export declare function workflowRunStoreContract(make: () => WorkflowRunStore, runAssertion?: (name: string, fn: () => Promise<void>) => void): Promise<void>;
 export type { WorkflowRunStatus };

package/dist/core/workflow-run-store-contract.js

@@ -1,6 +1,6 @@
 import { strict as assert } from "node:assert";
 import { summarizeWorkflowRun } from "./workflow-run-store.js";
-export function makeWorkflowRun(over = {}) {
+export function createWorkflowRun(over = {}) {
     const createdAt = over.createdAt ?? 1_000;
     return {
         id: over.id ?? "run-1",
@@ -27,13 +27,13 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
     };
     run("put create-once → already_exists", async () => {
         const store = make();
-        const r = makeWorkflowRun();
+        const r = createWorkflowRun();
         await store.put(r.id, r);
         await assert.rejects(store.put(r.id, r), (e) => e.code === "workflow_run.already_exists");
     });
     run("get returns a deep copy (mutating the result must not corrupt the store)", async () => {
         const store = make();
-        const r = makeWorkflowRun();
+        const r = createWorkflowRun();
         await store.put(r.id, r);
         const got = await store.get(r.id);
         assert.ok(got);
@@ -44,7 +44,7 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
     });
     run("update CAS: bumps rev, scope-mismatch loses, stale-rev loses, current-rev wins", async () => {
         const store = make();
-        const r = makeWorkflowRun({ status: "running" });
+        const r = createWorkflowRun({ status: "running" });
         await store.put(r.id, r);
         assert.equal(await store.update(r.id, r.scope, { ...r, status: "running", stats: { ...r.stats, tokens: 200 } }), true);
         assert.equal((await store.get(r.id)).rev, 1);
@@ -54,11 +54,11 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
         assert.equal(await store.update(r.id, r.scope, { ...r, status: "completed" }, { rev: 1 }), true);
         assert.equal((await store.get(r.id)).rev, 2);
         assert.equal((await store.get(r.id)).status, "completed");
-        assert.equal(await store.update("ghost", r.scope, makeWorkflowRun({ id: "ghost" })), false);
+        assert.equal(await store.update("ghost", r.scope, createWorkflowRun({ id: "ghost" })), false);
     });
     run("the key id is authoritative — a payload with a mismatched id never poisons the projection (codex BUG4)", async () => {
         const store = make();
-        const r = makeWorkflowRun({ id: "real", status: "running" });
+        const r = createWorkflowRun({ id: "real", status: "running" });
         await store.put("real", { ...r, id: "spoofed" });
         assert.equal((await store.get("real")).id, "real");
         assert.equal(await store.get("spoofed"), null);
@@ -70,10 +70,10 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
     run("listByScope: history included (completed + failed + running), createdAt DESC, status filter + limit", async () => {
         const store = make();
         assert.deepEqual(await store.listByScope("tenant-a"), []);
-        const running = makeWorkflowRun({ id: "r-run", status: "running", createdAt: 3_000, endedAt: undefined });
-        const done = makeWorkflowRun({ id: "r-done", status: "completed", createdAt: 2_000 });
-        const failed = makeWorkflowRun({ id: "r-fail", status: "failed", createdAt: 1_000 });
-        const other = makeWorkflowRun({ id: "r-other", scope: "tenant-b", createdAt: 9_000 });
+        const running = createWorkflowRun({ id: "r-run", status: "running", createdAt: 3_000, endedAt: undefined });
+        const done = createWorkflowRun({ id: "r-done", status: "completed", createdAt: 2_000 });
+        const failed = createWorkflowRun({ id: "r-fail", status: "failed", createdAt: 1_000 });
+        const other = createWorkflowRun({ id: "r-other", scope: "tenant-b", createdAt: 9_000 });
         for (const r of [running, done, failed, other])
             await store.put(r.id, r);
         const all = await store.listByScope("tenant-a");
@@ -88,7 +88,7 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
         assert.equal(doneSummary.currentPhase, "build");
         assert.equal(doneSummary.name, undefined);
         assert.equal(doneSummary.description, undefined);
-        const named = makeWorkflowRun({
+        const named = createWorkflowRun({
             id: "r-named", name: "find-flaky", description: "find flaky tests", createdAt: 4_000,
             phases: [
                 { title: "scan", status: "completed", startedAt: 4_000, endedAt: 4_001 },
@@ -103,10 +103,10 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
     });
     run("reap: only terminal runs, NEVER running; maxAgeMs + keep retention; no policy → no-op", async () => {
         const store = make();
-        const running = makeWorkflowRun({ id: "k-run", status: "running", createdAt: 100, endedAt: undefined });
-        const oldDone = makeWorkflowRun({ id: "k-old", status: "completed", createdAt: 100, endedAt: 100 });
-        const newDone = makeWorkflowRun({ id: "k-new", status: "completed", createdAt: 9_000, endedAt: 9_000 });
-        const oldFail = makeWorkflowRun({ id: "k-fail", status: "failed", createdAt: 200, endedAt: 200 });
+        const running = createWorkflowRun({ id: "k-run", status: "running", createdAt: 100, endedAt: undefined });
+        const oldDone = createWorkflowRun({ id: "k-old", status: "completed", createdAt: 100, endedAt: 100 });
+        const newDone = createWorkflowRun({ id: "k-new", status: "completed", createdAt: 9_000, endedAt: 9_000 });
+        const oldFail = createWorkflowRun({ id: "k-fail", status: "failed", createdAt: 200, endedAt: 200 });
         for (const r of [running, oldDone, newDone, oldFail])
             await store.put(r.id, r);
         assert.equal(await store.reap("tenant-a", 1_000_000), 0);
@@ -120,10 +120,10 @@ export async function workflowRunStoreContract(make, runAssertion = defaultSeque
     });
     run("reap keep-newest-N: deletes all but the newest N terminal runs; running excluded from the count", async () => {
         const store = make();
-        const running = makeWorkflowRun({ id: "p-run", status: "running", createdAt: 50, endedAt: undefined });
-        const t1 = makeWorkflowRun({ id: "p-1", status: "completed", createdAt: 1_000 });
-        const t2 = makeWorkflowRun({ id: "p-2", status: "completed", createdAt: 2_000 });
-        const t3 = makeWorkflowRun({ id: "p-3", status: "failed", createdAt: 3_000 });
+        const running = createWorkflowRun({ id: "p-run", status: "running", createdAt: 50, endedAt: undefined });
+        const t1 = createWorkflowRun({ id: "p-1", status: "completed", createdAt: 1_000 });
+        const t2 = createWorkflowRun({ id: "p-2", status: "completed", createdAt: 2_000 });
+        const t3 = createWorkflowRun({ id: "p-3", status: "failed", createdAt: 3_000 });
         for (const r of [running, t1, t2, t3])
             await store.put(r.id, r);
         assert.equal(await store.reap("tenant-a", 99_999, { keep: 1 }), 2);

package/dist/engine/execution-env/node-execution-env.d.ts

@@ -9,6 +9,19 @@ export declare function getShellConfig(customShellPath?: string): Promise<Result
     shell: string;
     args: string[];
 }, ExecutionError>>;
+export declare function decideSpoolReclaim(args: {
+    size: number;
+    cursor: number;
+    writerLive: boolean;
+    rotateBytes?: number;
+    hardCapBytes?: number;
+}): {
+    reclaim: false;
+} | {
+    reclaim: true;
+    live: boolean;
+    skippedBytes: number;
+};
 export declare function openSpoolPair(base: string): {
     outPath: string;
     errPath: string;
@@ -71,6 +84,7 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
     }): Promise<Result<string[], FileError>>;
     readBinaryFile(path: string, abortSignal?: AbortSignal): Promise<Result<Uint8Array, FileError>>;
     writeFile(path: string, content: string | Uint8Array, abortSignal?: AbortSignal): Promise<Result<void, FileError>>;
+    private writeFileInPlace;
     writeFileExclusive(path: string, content: string | Uint8Array, abortSignal?: AbortSignal): Promise<Result<void, FileError>>;
     appendFile(path: string, content: string | Uint8Array): Promise<Result<void, FileError>>;
     fileInfo(path: string): Promise<Result<FileInfo, FileError>>;