@sema-agent/core 3.0.0 → 5.0.0

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

@@ -29,6 +29,10 @@ export class InMemoryToolResultStore {
     totalChars = 0;
     constructor(opts) {
         this.opts = opts;
+        const cap = opts?.maxTotalChars;
+        if (cap !== undefined && Number.isNaN(cap)) {
+            throw new Error("InMemoryToolResultStore: maxTotalChars must be a number (got NaN) — omit it for an unbounded store");
+        }
     }
     put(ref, content) {
         assertSafeToolResultRef(ref);
@@ -37,7 +41,7 @@ export class InMemoryToolResultStore {
         this.map.set(ref, content);
         this.totalChars += content.length;
         const cap = this.opts?.maxTotalChars;
-        if (cap !== undefined && cap > 0) {
+        if (cap !== undefined && Number.isFinite(cap)) {
             for (const [oldRef, oldContent] of this.map) {
                 if (this.totalChars <= cap || oldRef === ref)
                     break;
@@ -93,6 +97,16 @@ export function isVolatileOffloadStore(store) {
     return store instanceof InMemoryToolResultStore;
 }
 export const OFFLOAD_TOOL_NAME = "ReadToolResult";
+export function createOffloadPersist(store, sessionId) {
+    return (toolCallId, fullText) => {
+        const ref = buildToolResultRef(sessionId, toolCallId);
+        void Promise.resolve(store.put(ref, fullText)).catch((err) => {
+            const cause = err instanceof Error ? err.message : String(err);
+            void Promise.resolve(store.put(ref, `[offload LOST at write time: ${cause} — the inline preview is all that survived]`)).catch(() => undefined);
+        });
+        return ref;
+    };
+}
 export function offloadPagebackHint(ref, form, reachableTools) {
     const activate = reachableTools !== undefined && !reachableTools.has(OFFLOAD_TOOL_NAME)
         ? `${OFFLOAD_TOOL_NAME} is not active yet — call ${TOOL_SEARCH_NAME} with {"query":"select:${OFFLOAD_TOOL_NAME}"} to activate it, then `
@@ -144,6 +158,8 @@ export function buildPreview(full, ref, sizes, reachableTools) {
         `</persisted-output>`);
 }
 export function withToolResultOffload(tool, store, thresholdChars, sessionId, reachableTools) {
+    if (!(Number.isFinite(thresholdChars) && thresholdChars > 0))
+        return tool;
     const wrappedExecute = async (toolCallId, params, signal, onUpdate) => {
         const res = await tool.execute(toolCallId, params, signal, onUpdate);
         if (totalTextChars(res.content) <= thresholdChars)

package/dist/core/trace.d.ts

@@ -1,5 +1,6 @@
 import type { TaskStatus, ToolEffect } from "./types.js";
 import type { ThinkingLevel } from "../internal/harness-types.js";
+import type { ToolManifestRow } from "../prompt-assembly/tool-catalog.js";
 export interface TraceMechanismsSummary {
     finalizeInjected?: true;
     nudgesSent?: number;
@@ -42,15 +43,7 @@ export type TraceEvent = {
         hash: string;
         contentHash?: string;
     }>;
-    tools?: Array<{
-        wireName: string;
-        aliases: string[];
-        contractId: string;
-        implementationRevision: string;
-        cardId: string;
-        shapeDigest: string;
-        wireSchemaDigest: string;
-    }>;
+    tools?: ToolManifestRow[];
     totalChars: number;
     snapshot?: {
         cacheIdentity: string;
@@ -183,6 +176,13 @@ export type TraceEvent = {
     reason: "breaker_open" | "rate_limit" | "budget" | "server_error" | "last_resort";
     atTurn: number;
     ts: number;
+} | {
+    kind: "observer.notify_failed";
+    version: 1;
+    taskId: string;
+    site: string;
+    message: string;
+    ts: number;
 } | {
     kind: "brain.failover";
     version: 1;

package/dist/core/types.d.ts

@@ -57,6 +57,19 @@ export type ToolReturn = string | {
     terminate?: boolean;
     isError?: boolean;
 };
+export interface NestedUsage {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd?: number;
+}
+export interface NestedUsageAccum {
+    tokens: number;
+    turns: number;
+    tasks: number;
+    costMicroUsd: number;
+    anyUnpriced: boolean;
+}
 export interface ToolExecuteContext {
     toolCallId: string;
     signal?: AbortSignal;
@@ -81,12 +94,7 @@ export interface ToolExecuteContext {
         release: () => Promise<void>;
     } | null>;
     parentCwd?: string;
-    reportUsage?: (usage: {
-        tokens: number;
-        turns: number;
-        tasks: number;
-        costMicroUsd?: number;
-    }) => void;
+    reportUsage?: (usage: NestedUsage) => void;
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
@@ -412,12 +420,7 @@ export interface TaskResult {
         outputTokens?: number;
         cacheWriteTokensLong?: number;
         costMicroUsd?: number;
-        nested?: {
-            tokens: number;
-            turns: number;
-            tasks: number;
-            costMicroUsd?: number;
-        };
+        nested?: NestedUsage;
         memory?: {
             tokens: number;
             costMicroUsd: number;

package/dist/core/untrusted-egress.d.ts

@@ -1,5 +1,7 @@
-export declare function redactSecrets(s: string): string;
-export declare function redactHostLeaks(s: string): string;
+import { type RedactionReport } from "./arg-summary.js";
+export type { RedactionFinding, RedactionReport, RedactionConfidence } from "./arg-summary.js";
+export declare function redactSecrets(s: string, report?: RedactionReport): string;
+export declare function redactHostLeaks(s: string, report?: RedactionReport): string;
 export declare function boundedRedactedSummary(value: unknown, max: number): string;
 export declare function untrustedEgressForHuman(value: unknown, opts: {
     label: string;

package/dist/core/untrusted-egress.js

@@ -1,5 +1,6 @@
 import { delimitUntrusted } from "./untrusted-text.js";
-import { scrubSecrets } from "./arg-summary.js";
+import { scrubSecrets, SECRET_PASSES, runRedactionPasses } from "./arg-summary.js";
+import { sliceHeadSafe } from "./surrogate-safe-slice.js";
 const URI_SCHEME = String.raw `[A-Za-z][A-Za-z0-9+.\-_]{0,63}`;
 const CREDENTIALS_IN_AUTHORITY = new RegExp(String.raw `(${URI_SCHEME}:\/\/)((?:[^/\s"'@]*@)+)`, "gi");
 const URL_OF_ANY_PROTOCOL = new RegExp(String.raw `${URI_SCHEME}:\/\/[^\s"'\`]+`, "gi");
@@ -14,15 +15,27 @@ function redactUserinfo(scheme, userinfoWithAt) {
     }
     return `${scheme}${userinfo.slice(0, colonIdx)}:[redacted-credentials]@`;
 }
-export function redactSecrets(s) {
-    return scrubSecrets(s)
-        .replace(CREDENTIALS_IN_AUTHORITY, (_m, scheme, userinfo) => redactUserinfo(scheme, userinfo))
-        .replace(/([?&#](?:sig|signature|sas|code)=)[^&\s"'#]+/gi, "$1[redacted]");
+const SECRET_TIER_PASSES = [
+    ...SECRET_PASSES,
+    {
+        kind: "url-credentials",
+        confidence: "medium",
+        marker: "[redacted-credentials]",
+        re: CREDENTIALS_IN_AUTHORITY,
+        replace: (_m, scheme, userinfo) => redactUserinfo(scheme, userinfo),
+    },
+    { kind: "signed-url-param", confidence: "high", marker: "[redacted]", re: /([?&#](?:sig|signature|sas|code)=)[^&\s"'#]+/gi, replace: "$1[redacted]" },
+];
+export function redactSecrets(s, report) {
+    return runRedactionPasses(s, SECRET_TIER_PASSES, report);
 }
-export function redactHostLeaks(s) {
-    return redactSecrets(s)
-        .replace(URL_OF_ANY_PROTOCOL, "[redacted-url]")
-        .replace(/(?:\/[A-Za-z0-9_.-]+){2,}/g, "[redacted-path]");
+const HOST_LEAK_PASSES = [
+    ...SECRET_TIER_PASSES,
+    { kind: "url", confidence: "medium", marker: "[redacted-url]", re: URL_OF_ANY_PROTOCOL, replace: "[redacted-url]" },
+    { kind: "fs-path", confidence: "low", marker: "[redacted-path]", re: /(?:\/[A-Za-z0-9_.-]+){2,}/g, replace: "[redacted-path]" },
+];
+export function redactHostLeaks(s, report) {
+    return runRedactionPasses(s, HOST_LEAK_PASSES, report);
 }
 const REDACTION_MARKER_RE = /\[redacted(?:-[a-z]+)?\]/g;
 function countRedactionMarkers(s) {
@@ -52,16 +65,17 @@ function boundedString(value, max, redact) {
     if (s.length <= max)
         return s;
     const totalMarkers = countRedactionMarkers(s);
-    const plainSuffix = (keepN) => `…[+${s.length - keepN} chars]`;
-    const enrichedSuffix = (keepN) => {
-        const lost = totalMarkers - countRedactionMarkers(s.slice(0, keepN));
-        return lost > 0 ? `…[+${s.length - keepN} chars, ${lost} redaction marker(s) among them]` : plainSuffix(keepN);
+    const plainSuffix = (kept) => `…[+${s.length - kept.length} chars]`;
+    const enrichedSuffix = (kept) => {
+        const lost = totalMarkers - countRedactionMarkers(kept);
+        return lost > 0 ? `…[+${s.length - kept.length} chars, ${lost} redaction marker(s) among them]` : plainSuffix(kept);
     };
     const converge = (suffixFor) => {
         let keep = max;
         let out = "";
         for (let i = 0; i < 4; i++) {
-            out = `${s.slice(0, keep)}${suffixFor(keep)}`;
+            const kept = sliceHeadSafe(s, keep);
+            out = `${kept}${suffixFor(kept)}`;
             if (out.length <= max)
                 return out;
             if (keep === 0)

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

@@ -3,23 +3,20 @@ export interface WorkflowJournalEntry {
     callKey: string;
     result: TaskResult;
 }
+export interface ResumeClaimArgs {
+    sourceRunId: string;
+    newRunId: string;
+    scope: string;
+}
 export interface WorkflowJournalStore {
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
     locator?(runId: string, scope: string): string | undefined;
-    resumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim?(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim?(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim?(input: ResumeClaimArgs): Promise<void>;
 }
 export declare const MAX_JOURNAL_RESULT_BYTES: number;
 export declare function oversizeJournalResult(serialized: string): boolean;
@@ -31,19 +28,11 @@ export declare class InMemoryWorkflowJournalStore implements WorkflowJournalStor
     private readonly runs;
     private readonly resumeClaims;
     private claimsForScope;
-    resumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<{
+    resumeClaim(input: ResumeClaimArgs): Promise<{
         granted: boolean;
         holder?: string;
     }>;
-    releaseResumeClaim(input: {
-        sourceRunId: string;
-        newRunId: string;
-        scope: string;
-    }): Promise<void>;
+    releaseResumeClaim(input: ResumeClaimArgs): Promise<void>;
     load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
     append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
 }

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/execution-env/node-execution-env.js

@@ -270,7 +270,7 @@ export class NodeExecutionEnv {
         this.backgroundCapabilities = {
             supported: true,
             maxConcurrent: 8,
-            defaultBgTimeoutSec: 30 * 60,
+            defaultBgTimeoutSec: 60 * 60,
             maxBgTimeoutSec: 2 * 60 * 60,
             supportsDetach: true,
             retainBackgroundProcesses: this.retainBackgroundProcesses,

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;