@sema-agent/core 3.0.0 → 4.0.0

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

@@ -21,22 +21,27 @@ export declare class WorkflowRunStoreError extends Error {
     readonly code: "workflow_run.already_exists";
     constructor(code: "workflow_run.already_exists", message: string);
 }
+export interface WorkflowRunListByScopeOptions {
+    status?: WorkflowRunStatus;
+    limit?: number;
+    session?: string;
+}
 export interface WorkflowRunStore {
     put(id: string, run: WorkflowRun): Promise<void>;
     get(id: string): Promise<WorkflowRun | null>;
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRunStatus;
-        limit?: number;
-        session?: string;
-    }): Promise<WorkflowRunSummary[]>;
+    listByScope(scope: string, opts?: WorkflowRunListByScopeOptions): Promise<WorkflowRunSummary[]>;
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
         keep?: number;
     }): Promise<number>;
 }
+export declare function nextWorkflowRunOnUpdate(cur: WorkflowRun | undefined, id: string, scope: string, run: WorkflowRun, expect?: {
+    rev: number;
+}): WorkflowRun | null;
+export declare function queryWorkflowRuns(runs: Iterable<WorkflowRun>, scope: string, opts?: WorkflowRunListByScopeOptions): WorkflowRunSummary[];
 export declare class InMemoryWorkflowRunStore implements WorkflowRunStore {
     private runs;
     put(id: string, run: WorkflowRun): Promise<void>;
@@ -44,11 +49,7 @@ export declare class InMemoryWorkflowRunStore implements WorkflowRunStore {
     update(id: string, scope: string, run: WorkflowRun, expect?: {
         rev: number;
     }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRunStatus;
-        limit?: number;
-        session?: string;
-    }): Promise<WorkflowRunSummary[]>;
+    listByScope(scope: string, opts?: WorkflowRunListByScopeOptions): Promise<WorkflowRunSummary[]>;
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
         keep?: number;

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

@@ -28,6 +28,25 @@ export class WorkflowRunStoreError extends Error {
         this.name = "WorkflowRunStoreError";
     }
 }
+export function nextWorkflowRunOnUpdate(cur, id, scope, run, expect) {
+    if (!cur || cur.scope !== scope)
+        return null;
+    if (expect !== undefined && (cur.rev ?? 0) !== expect.rev)
+        return null;
+    const next = structuredClone(run);
+    next.id = id;
+    next.scope = scope;
+    next.rev = (cur.rev ?? 0) + 1;
+    return next;
+}
+export function queryWorkflowRuns(runs, scope, opts) {
+    const rows = [...runs].filter((r) => r.scope === scope &&
+        (opts?.status === undefined || r.status === opts.status) &&
+        (opts?.session === undefined || r.originatingSessionId === opts.session));
+    rows.sort((a, b) => b.createdAt - a.createdAt);
+    const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
+    return limited.map(summarizeWorkflowRun);
+}
 export class InMemoryWorkflowRunStore {
     runs = new Map();
     async put(id, run) {
@@ -44,27 +63,14 @@ export class InMemoryWorkflowRunStore {
         return run ? structuredClone(run) : null;
     }
     async update(id, scope, run, expect) {
-        const cur = this.runs.get(id);
-        if (!cur || cur.scope !== scope) {
+        const next = nextWorkflowRunOnUpdate(this.runs.get(id), id, scope, run, expect);
+        if (!next)
             return false;
-        }
-        if (expect !== undefined && (cur.rev ?? 0) !== expect.rev) {
-            return false;
-        }
-        const next = structuredClone(run);
-        next.id = id;
-        next.scope = scope;
-        next.rev = (cur.rev ?? 0) + 1;
         this.runs.set(id, next);
         return true;
     }
     async listByScope(scope, opts) {
-        const rows = [...this.runs.values()].filter((r) => r.scope === scope &&
-            (opts?.status === undefined || r.status === opts.status) &&
-            (opts?.session === undefined || r.originatingSessionId === opts.session));
-        rows.sort((a, b) => b.createdAt - a.createdAt);
-        const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
-        return limited.map(summarizeWorkflowRun);
+        return queryWorkflowRuns(this.runs.values(), scope, opts);
     }
     async reap(scope, now, opts) {
         if (opts?.maxAgeMs === undefined && opts?.keep === undefined)

package/dist/engine/compaction/utils.js

@@ -1,4 +1,5 @@
 import { normalizeLlmMessageContent } from "../harness/messages.js";
+import { sliceHeadSafe } from "../../core/surrogate-safe-slice.js";
 import { cutEnginePrefix, cutEngineSegments, flattenableUserText } from "../../core/untrusted-text.js";
 import { fileArgPath } from "../../tools/fs/safety.js";
 export function createFileOps() {
@@ -287,11 +288,12 @@ function truncateForSummary(text, maxChars) {
     let keep = maxChars;
     let out = "";
     for (let i = 0; i < 4; i++) {
-        out = `${text.slice(0, keep)}\n\n[... ${text.length - keep} more characters truncated]`;
+        const kept = sliceHeadSafe(text, keep);
+        out = `${kept}\n\n[... ${text.length - kept.length} more characters truncated]`;
         if (out.length <= maxChars)
             break;
         if (keep === 0)
-            return maxChars >= 1 ? `${text.slice(0, maxChars - 1)}…` : "";
+            return maxChars >= 1 ? `${sliceHeadSafe(text, maxChars - 1)}…` : "";
         keep = Math.max(0, keep - (out.length - maxChars));
     }
     return out.length < text.length ? out : text;

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

@@ -1,4 +1,4 @@
-import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result } from "../harness/types.js";
+import { type ExecResult, type ExecutionEnv, ExecutionError, type ExecutionEnvExecOptions, FileError, type FileInfo, type Result } from "../harness/types.js";
 import type { BackgroundShellCapability, BackgroundShellId, BackgroundPoll, BackgroundSpawnOptions } from "../../core/background-shell.js";
 import { BackgroundShellError } from "../../core/background-shell.js";
 import type { SchedulerCapability, ScheduledIntent, SchedulerContext, ScheduledTaskId, ScheduledTaskSummary } from "../../core/scheduler.js";
@@ -54,29 +54,7 @@ export declare class NodeExecutionEnv implements ExecutionEnv, BackgroundShellCa
     list(ctx: SchedulerContext): Promise<Result<ScheduledTaskSummary[], SchedulerError>>;
     absolutePath(path: string): Promise<Result<string, FileError>>;
     joinPath(parts: string[]): Promise<Result<string, FileError>>;
-    exec(command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string>;
-        timeout?: number;
-        abortSignal?: AbortSignal;
-        onStdout?: (chunk: string) => void;
-        onStderr?: (chunk: string) => void;
-        detachSignal?: AbortSignal;
-        onSpawn?: (handle: {
-            pid: number;
-            kill: () => void;
-        }) => void;
-        onDetachAdopted?: () => void;
-        autoBackgroundOnTimeout?: boolean;
-    }): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        detached?: {
-            shellId: string;
-            cause?: "timeout";
-        };
-    }, ExecutionError>>;
+    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<ExecResult, ExecutionError>>;
     readTextFile(path: string, abortSignal?: AbortSignal): Promise<Result<string, FileError>>;
     readTextLines(path: string, options?: {
         maxLines?: number;

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

@@ -92,6 +92,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
         images?: ImageContent[];
     } & UserMessageProvenance): Promise<AssistantMessage>;
     private static emptyInjection;
+    private enqueueInjection;
     steer(text: string, options?: {
         images?: ImageContent[];
     } & UserMessageProvenance): Promise<void>;

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

@@ -478,14 +478,7 @@ export class AgentHarness {
                     details: result.details,
                     isError,
                 });
-                return patch
-                    ? {
-                        content: patch.content,
-                        details: patch.details,
-                        isError: patch.isError,
-                        terminate: patch.terminate,
-                    }
-                    : undefined;
+                return patch;
             },
             prepareNextTurn: async () => {
                 await this.flushPendingSessionWrites();
@@ -725,42 +718,29 @@ export class AgentHarness {
     static emptyInjection(text, options) {
         return text.trim().length === 0 && (options?.images === undefined || options.images.length === 0);
     }
+    async enqueueInjection(queue, text, options) {
+        if (AgentHarness.emptyInjection(text, options))
+            return;
+        const m = createUserMessage(text, options?.images, options);
+        if (options?.enginePayload !== undefined)
+            engineNotePayloads.set(m, options.enginePayload);
+        queue.push(m);
+        await this.emitQueueUpdate();
+    }
     async steer(text, options) {
         if (this.phase === "idle") {
             throw new AgentHarnessError("invalid_state", "Cannot steer while idle");
         }
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        {
-            const m = createUserMessage(text, options?.images, options);
-            if (options?.enginePayload !== undefined)
-                engineNotePayloads.set(m, options.enginePayload);
-            this.steerQueue.push(m);
-        }
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.steerQueue, text, options);
     }
     async followUp(text, options) {
         if (this.phase === "idle") {
             throw new AgentHarnessError("invalid_state", "Cannot follow up while idle");
         }
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        {
-            const m = createUserMessage(text, options?.images, options);
-            if (options?.enginePayload !== undefined)
-                engineNotePayloads.set(m, options.enginePayload);
-            this.followUpQueue.push(m);
-        }
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.followUpQueue, text, options);
     }
     async nextTurn(text, options) {
-        if (AgentHarness.emptyInjection(text, options))
-            return;
-        const m = createUserMessage(text, options?.images, options);
-        if (options?.enginePayload !== undefined)
-            engineNotePayloads.set(m, options.enginePayload);
-        this.nextTurnQueue.push(m);
-        await this.emitQueueUpdate();
+        await this.enqueueInjection(this.nextTurnQueue, text, options);
     }
     async appendMessage(message) {
         try {

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

@@ -1,5 +1,6 @@
+import type { PromptEpochDescriptor } from "../../prompt-assembly/epoch.js";
 import type { DocumentContent, ImageContent, Model, SimpleStreamOptions, TextContent, Transport } from "../llm/index.js";
-import type { AgentEvent, AgentMessage, AgentTool, QueueMode, ThinkingLevel } from "../loop/types.js";
+import type { AfterToolCallResult, AgentEvent, AgentMessage, AgentTool, BeforeToolCallResult, QueueMode, ThinkingLevel } from "../loop/types.js";
 import type { AgentCoreRuntimeDeps } from "../loop/runtime-deps.js";
 export type Result<TValue, TError> = {
     ok: true;
@@ -129,16 +130,17 @@ export interface FileSystem {
     }): Promise<Result<string, FileError>>;
     cleanup(): Promise<void>;
 }
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    detached?: {
+        shellId: string;
+        cause?: "timeout";
+    };
+}
 export interface Shell {
-    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        detached?: {
-            shellId: string;
-            cause?: "timeout";
-        };
-    }, ExecutionError>>;
+    exec(command: string, options?: ExecutionEnvExecOptions): Promise<Result<ExecResult, ExecutionError>>;
     cleanup(): Promise<void>;
 }
 export interface ExecutionEnv extends FileSystem, Shell {
@@ -195,15 +197,8 @@ export interface LeafEntry extends SessionTreeEntryBase {
     type: "leaf";
     targetId: string | null;
 }
-export interface PromptEpochEntry extends SessionTreeEntryBase {
+export interface PromptEpochEntry extends SessionTreeEntryBase, PromptEpochDescriptor {
     type: "prompt_epoch";
-    epoch: number;
-    artifactDigest: string;
-    packId: string;
-    assemblyApi: number;
-    activatedBy: "session_start" | "compaction" | "legacy_migration";
-    centerArtifactDigest?: string;
-    sourceRevision?: string;
 }
 export interface AnnouncedListingEntry extends SessionTreeEntryBase {
     type: "announced_listing";
@@ -211,28 +206,22 @@ export interface AnnouncedListingEntry extends SessionTreeEntryBase {
     skills?: string[];
     models?: string[];
 }
-export interface WorkspaceStateEntry extends SessionTreeEntryBase {
-    type: "workspace_state";
+export interface ActiveWorktreeSession {
+    worktreeDir: string;
+    originalCwd: string;
+    baseSha: string;
+    entered?: boolean;
+}
+export interface WorkspaceState {
     taskRoot: string;
     handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
+    activeWorktree?: ActiveWorktreeSession;
+}
+export interface WorkspaceStateEntry extends SessionTreeEntryBase, WorkspaceState {
+    type: "workspace_state";
 }
 export declare const WORKSPACE_STATE_MAX_PATH_CHARS = 4096;
-export declare function normalizeWorkspaceState(value: unknown): {
-    taskRoot: string;
-    handsCwd?: string;
-    activeWorktree?: {
-        worktreeDir: string;
-        originalCwd: string;
-        baseSha: string;
-        entered?: boolean;
-    };
-} | undefined;
+export declare function normalizeWorkspaceState(value: unknown): WorkspaceState | undefined;
 export declare const ANNOUNCED_LISTING_MAX_NAMES = 500;
 export declare const ANNOUNCED_LISTING_MAX_NAME_CHARS = 200;
 export declare function normalizeCompactionStateCarrier(v: unknown): {
@@ -331,26 +320,8 @@ export interface Session<TMetadata extends SessionMetadata = SessionMetadata> {
         skills?: string[];
         models?: string[];
     } | undefined>;
-    appendWorkspaceState(state: {
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    }): Promise<string>;
-    getWorkspaceState(): Promise<{
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    } | undefined>;
+    appendWorkspaceState(state: WorkspaceState): Promise<string>;
+    getWorkspaceState(): Promise<WorkspaceState | undefined>;
     getPromptEpoch?(): Promise<import("../../prompt-assembly/epoch.js").PromptEpochDescriptor | undefined>;
 }
 export interface SessionCreateOptions {
@@ -487,17 +458,8 @@ export interface BeforeProviderRequestResult {
 export interface BeforeProviderPayloadResult {
     payload: unknown;
 }
-export interface ToolCallResult {
-    block?: boolean;
-    reason?: string;
-    updatedInput?: unknown;
-}
-export interface ToolResultPatch {
-    content?: Array<TextContent | ImageContent | DocumentContent>;
-    details?: unknown;
-    isError?: boolean;
-    terminate?: boolean;
-}
+export type ToolCallResult = BeforeToolCallResult;
+export type ToolResultPatch = AfterToolCallResult;
 export interface SessionBeforeCompactResult {
     cancel?: boolean;
     compaction?: CompactResult;

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

@@ -143,7 +143,7 @@ export interface AssistantMessage {
     usageMissing?: true;
     stopReason: StopReason;
     errorMessage?: string;
-    errorKind?: "length_empty";
+    errorKind?: "length_empty" | "degenerate" | "walltime_cutoff";
     partialFinalized?: true;
     repetition?: {
         cut?: RepetitionEvent;

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

@@ -647,10 +647,16 @@ function partitionToolCalls(toolCalls, tools) {
     }
     return batches;
 }
+function resolveToolConcurrency(configured) {
+    if (configured === undefined)
+        return 10;
+    return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 1;
+}
 async function runCapped(thunks, limit) {
     const results = new Array(thunks.length);
     let next = 0;
-    const workers = Array.from({ length: Math.max(1, Math.min(limit, thunks.length)) }, async () => {
+    const width = Number.isFinite(limit) ? Math.max(1, Math.min(limit, thunks.length)) : 1;
+    const workers = Array.from({ length: width }, async () => {
         while (next < thunks.length) {
             const i = next++;
             results[i] = await thunks[i]();
@@ -660,7 +666,7 @@ async function runCapped(thunks, limit) {
     return results;
 }
 async function executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor) {
-    const cap = config.maxToolConcurrency ?? 10;
+    const cap = resolveToolConcurrency(config.maxToolConcurrency);
     const allFinalized = [];
     const messages = [];
     let engineCutSeen = false;
@@ -798,7 +804,7 @@ class StreamToolExecutor {
             this.signal?.aborted ||
             partialAssistant === null ||
             !isBatchSafeToolCall(findToolByName(this.context.tools, toolCall.name), toolCall) ||
-            this.inFlight >= (this.config.maxToolConcurrency ?? 10) ||
+            this.inFlight >= resolveToolConcurrency(this.config.maxToolConcurrency) ||
             this.entries.has(toolCall.id)) {
             this.barrier = true;
             return;
@@ -927,7 +933,8 @@ function prepareToolCallArguments(tool, toolCall) {
 async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
     const tool = findToolByName(currentContext.tools, toolCall.name);
     if (!tool) {
-        const tombstone = TOMBSTONED_TOOLS[toolCall.name];
+        const tombstoneEntry = Object.hasOwn(TOMBSTONED_TOOLS, toolCall.name) ? TOMBSTONED_TOOLS[toolCall.name] : undefined;
+        const tombstone = typeof tombstoneEntry === "string" ? tombstoneEntry : undefined;
         if (tombstone !== undefined) {
             return {
                 kind: "immediate",

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

@@ -74,21 +74,23 @@ export interface LoopRecoveryOptions {
         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?: {
-        deadlineMs: () => number | undefined;
-        onCut?: (info: {
-            toolCallId: string;
-            toolName: string;
-            elapsedMs: number;
-            settled: Promise<void>;
-        }) => void;
-    };
+    toolDeadline?: LoopToolDeadline;
     maxToolConcurrency?: number;
     streamingToolExecution?: boolean;
     convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;

package/dist/engine/session/memory-repo.d.ts

@@ -1,4 +1,4 @@
-import { type Session, type SessionMetadata, type SessionRepo, type SessionTreeEntry } from "../harness/types.js";
+import { type Session, type SessionForkOptions, type SessionMetadata, type SessionRepo, type SessionTreeEntry } from "../harness/types.js";
 export declare class InMemorySessionRepo implements SessionRepo<SessionMetadata, {
     id?: string;
 }> {
@@ -9,11 +9,7 @@ export declare class InMemorySessionRepo implements SessionRepo<SessionMetadata,
     open(metadata: SessionMetadata): Promise<Session>;
     list(): Promise<SessionMetadata[]>;
     delete(metadata: SessionMetadata): Promise<void>;
-    fork(sourceMetadata: SessionMetadata, options: {
-        entryId?: string;
-        position?: "before" | "at";
-        id?: string;
-    }): Promise<Session>;
+    fork(sourceMetadata: SessionMetadata, options: SessionForkOptions): Promise<Session>;
     exportEntries(sessionId: string): Promise<SessionTreeEntry[]>;
     importEntries(sessionId: string, owner: string | undefined, entries: SessionTreeEntry[]): Promise<void>;
 }

package/dist/engine/session/session.d.ts

@@ -1,7 +1,8 @@
 import type { ImageContent, TextContent } from "../llm/index.js";
 import type { AgentMessage } from "../loop/types.js";
-import type { Session, SessionContext, SessionMetadata, SessionStorage, SessionTreeEntry } from "../harness/types.js";
+import type { Session, SessionContext, SessionMetadata, SessionStorage, SessionTreeEntry, WorkspaceState } from "../harness/types.js";
 import type { BuildContextOptions } from "../harness/types.js";
+import type { PromptEpochDescriptor } from "../../prompt-assembly/epoch.js";
 export declare function buildSessionContext(pathEntries: SessionTreeEntry[], opts?: BuildContextOptions): SessionContext;
 export declare class StoredSession<TMetadata extends SessionMetadata = SessionMetadata> implements Session<TMetadata> {
     private storage;
@@ -19,40 +20,14 @@ export declare class StoredSession<TMetadata extends SessionMetadata = SessionMe
     appendMessage(message: AgentMessage): Promise<string>;
     appendThinkingLevelChange(thinkingLevel: string): Promise<string>;
     appendModelChange(provider: string, modelId: string): Promise<string>;
-    appendPromptEpoch(descriptor: {
-        epoch: number;
-        artifactDigest: string;
-        packId: string;
-        assemblyApi: number;
-        activatedBy: "session_start" | "compaction" | "legacy_migration";
-        centerArtifactDigest?: string;
-        sourceRevision?: string;
-    }): Promise<string>;
+    appendPromptEpoch(descriptor: PromptEpochDescriptor): Promise<string>;
     appendAnnouncedListing(snapshot: {
         agents?: readonly string[];
         skills?: readonly string[];
         models?: readonly string[];
     }): Promise<string>;
-    appendWorkspaceState(state: {
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    }): Promise<string>;
-    getWorkspaceState(): Promise<{
-        taskRoot: string;
-        handsCwd?: string;
-        activeWorktree?: {
-            worktreeDir: string;
-            originalCwd: string;
-            baseSha: string;
-            entered?: boolean;
-        };
-    } | undefined>;
+    appendWorkspaceState(state: WorkspaceState): Promise<string>;
+    getWorkspaceState(): Promise<WorkspaceState | undefined>;
     getAnnouncedListing(): Promise<{
         agents?: string[];
         skills?: string[];

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { assembleCodeTools, type CodeToolsConfig, CODE_ROLE } from "./scenarios/
 export { capAggregateToolResults, AGGREGATE_TOOL_RESULT_BUDGET_CHARS, DEFAULT_BUDGET_EXEMPT_TOOLS, type AggregateBudgetOptions, } from "./core/tool-result-budget.js";
 export { capAggregateMediaBytes, AGGREGATE_MEDIA_BUDGET_BYTES, type MediaStripInfo } from "./core/media-byte-cap.js";
 export { createAskUserQuestionTool, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, type OnQuestion, type AskQuestion, type AskQuestionOption, type AskQuestionRequest, type QuestionAnswer, type QuestionAnswerItem, } from "./core/ask-question.js";
-export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, type LspNoneReason, type LspOperation, type LspServerManager, type LspSession, type LspResult, type LspLocation, type LspSymbolInfo, type LspRequestParams, type LspToolOptions, type LspTransport, type LspReadText, } from "./core/lsp.js";
+export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, SharedAbortScope, settleOnAbort, type LspNoneReason, type LspOperation, type LspServerManager, type LspSession, type LspResult, type LspLocation, type LspSymbolInfo, type LspRequestParams, type LspToolOptions, type LspTransport, type LspReadText, } from "./core/lsp.js";
 export { buildRequest, parseResult, callHierarchyMethod, pathToUri } from "./core/lsp-protocol.js";
 export { TransportLspSession, type SessionWarmup } from "./core/lsp-session.js";
 export { LspDiagnosticsRegistry, formatDiagnosticsBlock, formatDiagnosticsSummary, type LspDiagnostic, type LspFileDiagnostics, } from "./core/lsp-diagnostics.js";
@@ -27,6 +27,7 @@ export { BrainError, classifyHttp, type BrainErrorCode } from "./brain/errors.js
 export { looksDegenerate, inspectDegenerate, trimDegenerateTail } from "./brain/repetition.js";
 export type { RepetitionEvent, RepetitionInspection } from "./brain/repetition.js";
 export { computeCostMicroUsd, modelCostToPricing, type ModelPricing, type TokenCounts, } from "./core/pricing.js";
+export { cacheFamilyOf, promptTokensOf, uncachedInputTokensOf, type CacheFamily } from "./core/runner/usage-accounting.js";
 export { emitTrace, type TraceEvent, type TracerHook } from "./core/trace.js";
 export { InMemoryStrategyStore, type StrategyStore, type StoredStrategy } from "./core/strategy-store.js";
 export { createSqlTool, validateReadOnlySql, type SqlToolOptions } from "./tools/sql.js";
@@ -56,6 +57,7 @@ export { getShellConfig, isWslBashLauncher } from "./engine/execution-env/node-e
 export { isSecretEnvKey, scrubSecretEnv } from "./core/secret-env.js";
 export { MAX_EXEC_OUTPUT_BYTES, RollingTailBuffer, markTruncated } from "./core/exec-output-tail.js";
 export type { ExecutionEnv, FileInfo, Result, FileErrorCode, ExecutionErrorCode } from "./internal/harness.js";
+export type { ExecResult } from "./internal/harness.js";
 export { RemoteExecutionError, hasDestroy, isRemoteExecutionEnv, isSuspendable, isIsolated, missingRestoreSurface, isRetryableRemoteErrorCode, RETRYABLE_REMOTE_ERROR_CODES, } from "./core/remote-env.js";
 export { withRetry } from "./core/with-retry.js";
 export type { RetryPolicy, RetryResult } from "./core/with-retry.js";

package/dist/index.js

@@ -12,7 +12,7 @@ export { assembleCodeTools, CODE_ROLE } from "./scenarios/full-body.js";
 export { capAggregateToolResults, AGGREGATE_TOOL_RESULT_BUDGET_CHARS, DEFAULT_BUDGET_EXEMPT_TOOLS, } from "./core/tool-result-budget.js";
 export { capAggregateMediaBytes, AGGREGATE_MEDIA_BUDGET_BYTES } from "./core/media-byte-cap.js";
 export { createAskUserQuestionTool, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, } from "./core/ask-question.js";
-export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, } from "./core/lsp.js";
+export { createLspTool, gitCheckIgnoreFilter, LSP_OPERATIONS, LSP_FAILURE_BRAND, brandLspFailure, lspFailureOf, SharedAbortScope, settleOnAbort, } from "./core/lsp.js";
 export { buildRequest, parseResult, callHierarchyMethod, pathToUri } from "./core/lsp-protocol.js";
 export { TransportLspSession } from "./core/lsp-session.js";
 export { LspDiagnosticsRegistry, formatDiagnosticsBlock, formatDiagnosticsSummary, } from "./core/lsp-diagnostics.js";
@@ -24,6 +24,7 @@ export { selectModel, selectModelOrThrow } from "./core/select-model.js";
 export { BrainError, classifyHttp } from "./brain/errors.js";
 export { looksDegenerate, inspectDegenerate, trimDegenerateTail } from "./brain/repetition.js";
 export { computeCostMicroUsd, modelCostToPricing, } from "./core/pricing.js";
+export { cacheFamilyOf, promptTokensOf, uncachedInputTokensOf } from "./core/runner/usage-accounting.js";
 export { emitTrace } from "./core/trace.js";
 export { InMemoryStrategyStore } from "./core/strategy-store.js";
 export { createSqlTool, validateReadOnlySql } from "./tools/sql.js";

package/dist/internal/harness-types.d.ts

@@ -3,5 +3,7 @@ export type { InvokedSkillRetention } from "../engine/compaction/utils.js";
 export type { AgentCoreRuntimeDeps } from "../engine/loop/runtime-deps.js";
 export type { AgentMessage, AgentTool, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel, ToolExecutionMode, } from "../engine/loop/types.js";
 export type { AgentHarnessEvent, CompactionSettings, ExecutionEnv, ExecutionErrorCode, FileErrorCode, FileInfo, Result, Session, SessionMetadata, SessionRepo, SessionStorage, SessionTreeEntry, Skill, } from "../engine/harness/types.js";
-export type { ExecutionEnvExecOptions } from "../engine/harness/types.js";
+export type { ExecutionEnvExecOptions, ExecResult } from "../engine/harness/types.js";
 export type { SessionWriteOptions, CompactionEntry } from "../engine/harness/types.js";
+export type { ActiveWorktreeSession, WorkspaceState } from "../engine/harness/types.js";
+export type { SessionForkOptions } from "../engine/harness/types.js";

package/dist/orchestration/run-spec.js

@@ -4,8 +4,10 @@ import { isAbsolute, resolve, sep } from "node:path";
 import { combinePolicies } from "../core/tool-policy.js";
 import { delimitUntrusted } from "../core/untrusted-text.js";
 import { isDurablePause } from "../agents/suspend-guard.js";
+import { isAbsolutePathForm, writeTargetPath } from "../tools/fs/safety.js";
+import { canonicalToolName } from "../core/tool-name-aliases.js";
 import { captureBaseline, resolveFrozenPaths, restoreFrozenPaths, runOracle, snapshotFrozenPaths, specError, } from "../core/spec-contract.js";
-const WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+const WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"].map(canonicalToolName));
 const CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
 const pathKey = (p) => {
     let n = p.replace(/\\/g, "/");
@@ -17,13 +19,14 @@ function frozenDenyPolicy(rootDir, frozenResolved) {
     const frozen = new Set(frozenResolved.map(pathKey));
     return {
         check(req) {
-            if (!WRITE_TOOLS.has(req.toolName))
+            const toolName = canonicalToolName(req.toolName);
+            if (!WRITE_TOOLS.has(toolName))
                 return { action: "allow" };
             const args = req.args;
-            const raw = args?.file_path ?? args?.path ?? args?.notebook_path;
+            const raw = writeTargetPath(toolName, args);
             if (typeof raw !== "string" || raw.length === 0)
                 return { action: "allow" };
-            const absForm = raw.startsWith("/") || /^[A-Za-z]:[\\/]/.test(raw);
+            const absForm = isAbsolutePathForm(raw);
             const abs = pathKey(absForm ? raw : resolve(rootDir, raw));
             if (frozen.has(abs)) {
                 return { action: "deny", reason: `${raw} is part of the frozen specification surface (read-only).` };