@sema-agent/core 1.452.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

@@ -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" },

package/dist/core/tools.d.ts

@@ -1,10 +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

@@ -73,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>;
@@ -729,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: {
@@ -751,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;
@@ -797,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-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;

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

@@ -8,7 +8,7 @@ import { createInterface } from "node:readline";
 import { ExecutionError, err, FileError, ok, toError, } from "../harness/types.js";
 import { killProcessTree, shutdownDebug } from "./kill-tree.js";
 import { scrubSecretEnv } from "../../core/secret-env.js";
-import { RollingTailBuffer, markTruncated, newStreamCursorState, sliceStreamIncrement, } from "../../core/exec-output-tail.js";
+import { RollingTailBuffer, markLiveSpoolRotations, markTruncated, newStreamCursorState, sliceStreamIncrement, } from "../../core/exec-output-tail.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import { SchedulerError } from "../../core/scheduler.js";
 const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;
@@ -213,6 +213,23 @@ const EXEC_SPOOL_PUMP_MS = 200;
 const EXEC_SPOOL_ROTATE_BYTES = 8 * 1024 * 1024;
 const EXEC_SPOOL_FINAL_TAIL_BYTES = 8 * 1024 * 1024;
 const EXEC_SPOOL_HARD_CAP_BYTES = 16 * 1024 * 1024;
+export function decideSpoolReclaim(args) {
+    const rotate = args.rotateBytes ?? EXEC_SPOOL_ROTATE_BYTES;
+    const hardCap = args.hardCapBytes ?? EXEC_SPOOL_HARD_CAP_BYTES;
+    if (args.cursor < rotate)
+        return { reclaim: false };
+    if (args.size === args.cursor) {
+        if (!args.writerLive)
+            return { reclaim: true, live: false, skippedBytes: 0 };
+        if (args.size >= hardCap)
+            return { reclaim: true, live: true, skippedBytes: 0 };
+        return { reclaim: false };
+    }
+    if (args.size > args.cursor && args.size >= hardCap) {
+        return { reclaim: true, live: args.writerLive, skippedBytes: args.size - args.cursor };
+    }
+    return { reclaim: false };
+}
 const SIGNUM = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6, SIGKILL: 9, SIGSEGV: 11, SIGPIPE: 13, SIGTERM: 15 };
 export function openSpoolPair(base) {
     const outPath = `${base}.out.log`;
@@ -313,6 +330,9 @@ export class NodeExecutionEnv {
             const adoptOnTimeoutRef = {};
             const pumpSpoolRef = {};
             const drainSpoolRef = {};
+            const liveRotations = { out: 0, err: 0 };
+            const liveRotationsTotal = () => liveRotations.out + liveRotations.err;
+            const writerLive = () => !settled && child !== undefined && child.exitCode === null && child.signalCode === null;
             const armForceSettle = (result) => {
                 if (forceSettleRef.current || settled)
                     return;
@@ -331,7 +351,7 @@ export class NodeExecutionEnv {
                 drainSpoolRef.current?.();
                 const so = stdoutTail.result();
                 const se = stderrTail.result();
-                return { stdout: markTruncated(so.text, so.droppedBytes), stderr: markTruncated(se.text, se.droppedBytes) };
+                return { stdout: markTruncated(so.text, so.droppedBytes), stderr: markLiveSpoolRotations(markTruncated(se.text, se.droppedBytes), liveRotationsTotal()) };
             };
             const onAbort = () => {
                 abortKillInFlight = true;
@@ -520,16 +540,15 @@ export class NodeExecutionEnv {
                 if (spoolCursor[lane.cursor] < EXEC_SPOOL_ROTATE_BYTES)
                     return;
                 try {
-                    const size = statSync(lane.path).size;
-                    if (size === spoolCursor[lane.cursor]) {
-                        truncateSync(lane.path, 0);
-                        spoolCursor[lane.cursor] = 0;
-                    }
-                    else if (size >= EXEC_SPOOL_HARD_CAP_BYTES) {
-                        lane.tail.recordSkippedBytes(size - spoolCursor[lane.cursor]);
-                        truncateSync(lane.path, 0);
-                        spoolCursor[lane.cursor] = 0;
-                    }
+                    const d = decideSpoolReclaim({ size: statSync(lane.path).size, cursor: spoolCursor[lane.cursor], writerLive: writerLive() });
+                    if (!d.reclaim)
+                        return;
+                    if (d.skippedBytes > 0)
+                        lane.tail.recordSkippedBytes(d.skippedBytes);
+                    if (d.live)
+                        liveRotations[lane.cursor]++;
+                    truncateSync(lane.path, 0);
+                    spoolCursor[lane.cursor] = 0;
                 }
                 catch {
                 }
@@ -564,7 +583,9 @@ export class NodeExecutionEnv {
                 if (settled || !child)
                     return false;
                 pumpSpoolRef.current?.();
-                const shellId = this.adoptRunningChild(child, stdoutTail.result(), stderrTail.result(), execSpoolRef.current !== undefined ? { spool: execSpoolRef.current, cursors: { out: spoolCursor.out, err: spoolCursor.err } } : undefined);
+                const shellId = this.adoptRunningChild(child, stdoutTail.result(), stderrTail.result(), execSpoolRef.current !== undefined
+                    ? { spool: execSpoolRef.current, cursors: { out: spoolCursor.out, err: spoolCursor.err }, liveRotations: liveRotationsTotal() }
+                    : undefined);
                 if (shellId === undefined)
                     return false;
                 if (spoolPumpRef.current)
@@ -657,12 +678,12 @@ export class NodeExecutionEnv {
                     const signum = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6, SIGKILL: 9, SIGSEGV: 11, SIGPIPE: 13, SIGTERM: 15 };
                     settle(ok({
                         stdout: markTruncated(so.text, so.droppedBytes),
-                        stderr: `${markTruncated(se.text, se.droppedBytes)}${se.text.endsWith("\n") || se.text === "" ? "" : "\n"}[process terminated by ${signal}]`,
+                        stderr: markLiveSpoolRotations(`${markTruncated(se.text, se.droppedBytes)}${se.text.endsWith("\n") || se.text === "" ? "" : "\n"}[process terminated by ${signal}]`, liveRotationsTotal()),
                         exitCode: 128 + (signum[signal] ?? 9),
                     }));
                     return;
                 }
-                settle(ok({ stdout: markTruncated(so.text, so.droppedBytes), stderr: markTruncated(se.text, se.droppedBytes), exitCode: code ?? 0 }));
+                settle(ok({ stdout: markTruncated(so.text, so.droppedBytes), stderr: markLiveSpoolRotations(markTruncated(se.text, se.droppedBytes), liveRotationsTotal()), exitCode: code ?? 0 }));
             };
             child.on("close", (code, signal) => settleFromTermination(code, signal));
             child.on("exit", (code, signal) => {
@@ -1030,6 +1051,7 @@ export class NodeExecutionEnv {
             ...(handover !== undefined
                 ? { spool: { outPath: handover.spool.outPath, errPath: handover.spool.errPath, fileCursor: { ...handover.cursors }, ephemeral: true } }
                 : {}),
+            ...(handover !== undefined && (handover.liveRotations ?? 0) > 0 ? { liveRotations: handover.liveRotations } : {}),
         };
         const seedOut = Buffer.from(stdoutSoFar.text, "utf8");
         const seedErr = Buffer.from(stderrSoFar.text, "utf8");
@@ -1219,9 +1241,14 @@ export class NodeExecutionEnv {
         const out = sliceStreamIncrement(entry.stdout, terminal);
         const er = sliceStreamIncrement(entry.stderr, terminal);
         const droppedBeforeCursor = out.droppedBeforeCursor + er.droppedBeforeCursor;
+        let stderrInc = er.inc;
+        if (terminal && (entry.liveRotations ?? 0) > 0 && entry.liveRotationsDisclosed !== true) {
+            entry.liveRotationsDisclosed = true;
+            stderrInc = markLiveSpoolRotations(er.inc, entry.liveRotations ?? 0);
+        }
         return ok({
             stdout: out.inc,
-            stderr: er.inc,
+            stderr: stderrInc,
             status: entry.status,
             ...(entry.exitCode !== undefined ? { exitCode: entry.exitCode } : {}),
             ...(droppedBeforeCursor > 0 ? { truncated: true, bytesDroppedBeforeCursor: droppedBeforeCursor } : {}),
@@ -1283,15 +1310,18 @@ export class NodeExecutionEnv {
                     }
                 }
                 if (spool.ephemeral && spool.fileCursor[lane] >= EXEC_SPOOL_ROTATE_BYTES) {
-                    const size2 = statSync(path).size;
-                    if (size2 === spool.fileCursor[lane]) {
-                        truncateSync(path, 0);
-                        spool.fileCursor[lane] = 0;
-                    }
-                    else if (size2 >= EXEC_SPOOL_HARD_CAP_BYTES) {
-                        const skipped = size2 - spool.fileCursor[lane];
-                        stream.tail.recordSkippedBytes(skipped);
-                        stream.totalBytes += skipped;
+                    const d = decideSpoolReclaim({
+                        size: statSync(path).size,
+                        cursor: spool.fileCursor[lane],
+                        writerLive: entry.status === "running" || (entry.child.exitCode === null && entry.child.signalCode === null),
+                    });
+                    if (d.reclaim) {
+                        if (d.skippedBytes > 0) {
+                            stream.tail.recordSkippedBytes(d.skippedBytes);
+                            stream.totalBytes += d.skippedBytes;
+                        }
+                        if (d.live)
+                            entry.liveRotations = (entry.liveRotations ?? 0) + 1;
                         truncateSync(path, 0);
                         spool.fileCursor[lane] = 0;
                     }

package/dist/engine/lsp/frame-decoder.d.ts

@@ -1,2 +1,2 @@
 export declare function encodeFrame(json: string): Buffer;
-export declare function makeFrameDecoder(maxBytes?: number): (chunk: Buffer) => string[];
+export declare function createFrameDecoder(maxBytes?: number): (chunk: Buffer) => string[];

package/dist/engine/lsp/frame-decoder.js

@@ -2,7 +2,7 @@ export function encodeFrame(json) {
     const payload = Buffer.from(json, "utf8");
     return Buffer.concat([Buffer.from(`Content-Length: ${payload.length}\r\n\r\n`, "ascii"), payload]);
 }
-export function makeFrameDecoder(maxBytes = 50 * 1024 * 1024) {
+export function createFrameDecoder(maxBytes = 50 * 1024 * 1024) {
     const HEADER_SLACK = 128;
     let buf = Buffer.alloc(0);
     return function decode(chunk) {

package/dist/engine/lsp/node-lsp-manager.d.ts

@@ -1,7 +1,7 @@
 import { type SessionWarmup } from "../../core/lsp-session.js";
 import { type LspChildProcess } from "./stdio-lsp-transport.js";
 import { type LspServerManager, type LspSession, type LspReadText } from "../../core/lsp.js";
-import type { ExecutionEnv } from "../../internal/harness.js";
+import type { ExecutionEnv } from "../../internal/harness-types.js";
 export declare const DEFAULT_LSP_SERVERS: Readonly<Record<string, string>>;
 export type LspSpawn = (command: string, args: string[], cwd: string, signal?: AbortSignal) => Promise<LspChildProcess | undefined>;
 export interface NodeLspManagerOptions {

package/dist/engine/lsp/stdio-lsp-transport.js

@@ -1,4 +1,4 @@
-import { encodeFrame, makeFrameDecoder } from "./frame-decoder.js";
+import { encodeFrame, createFrameDecoder } from "./frame-decoder.js";
 import { killProcessTree } from "../execution-env/kill-tree.js";
 import { brandLspFailure } from "../../core/lsp.js";
 export class StdioLspTransport {
@@ -7,7 +7,7 @@ export class StdioLspTransport {
     nextId = 0;
     pending = new Map();
     isClosed = false;
-    decode = makeFrameDecoder();
+    decode = createFrameDecoder();
     notificationHandlers = new Set();
     constructor(child, requestTimeoutMs = 30_000) {
         this.child = child;