stitchkit 0.85.1 → 0.86.0

package/CHANGELOG.md

@@ -15,6 +15,184 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.86.0] — 2026-09-08
+
+### ⚠️ Breaking changes
+
+**Who must act:** applications that branch on `AgentTerminalReason` or show it
+to a person; applications implementing `AgentRuntimeStore` or an
+`AgentRuntimeStoreDriver` (Prisma, Postgres, anything not built in); operators
+of SQLite store files; subscribers that switch exhaustively over
+`AgentRuntimeEvent` (including browser reducers).
+
+- **A failure this runtime owns no longer reports `provider_failure`.** Three
+  values join the enum — `storage_conflict` (an owned mutation lost its
+  compare-and-set or the store refused it), `output_rejected` (the
+  application's own `protocol.acceptTerminal` refused the finished message) and
+  `runtime_failure` (this runtime, or a check the SDK runs on what this runtime
+  handed it, failed). Runs that ended `provider_failure` for these reasons now
+  end with the matching one, so a branch keyed on `provider_failure` stops
+  seeing them. `// before: reason === 'provider_failure'` → `// after:
+  reason === 'provider_failure' || reason === 'storage_conflict' ||
+  reason === 'output_rejected' || reason === 'runtime_failure'` for "did it
+  fail", and the specific value for what to tell a person. See the 0.86.0
+  migration in the upgrading guide.
+- **Direct stores add the canonical event-ledger methods, and drivers add the
+  table behind them.** `AgentRuntimeStore` gains `appendEvent`, bounded
+  `readEvents`, `exportConversation` and `importConversation`.
+  `AgentRuntimeStoreDriver` gains a **required** `events: { append, list }` —
+  a driver passed to `createAgentRuntimeStore` implements the ledger table
+  itself; the store composes the methods over it. The Prisma example shows the
+  table and both operations
+  (`examples/agent-store-prisma/schema.prisma`, `adapter.ts`). See the 0.86.0
+  migration in the upgrading guide for the driver section.
+- **The built-in SQLite stores migrate schema 1 → 2 on open, once, forward
+  only.** The first open of a version-1 file writes one `runtime/baseline`
+  event per conversation and sets the version to 2 in one transaction; a
+  0.85.x package then refuses the file (`Unsupported … schema version 2`).
+  Back the file up before upgrading. Version 2 requires SQLite built with FTS5
+  (`SELECT sqlite_compileoption_used('ENABLE_FTS5')`); a build without it is
+  refused at open with `requires FTS5 support`.
+- **Every run operation and every provider request now write to the ledger.**
+  Each store mutation appends a `runtime/transition`, and each model step
+  appends a `provider/request` before the provider is called. Bodies are
+  content-addressed: a message is written once per conversation as
+  `provider/message` (`{ sha256, message }`, binary parts as
+  `{ binary: true, sha256, bytes }` references) and a request names its instructions and messages by hash
+  (`{ runId, attempt, stepNumber, modelId, instructionsSha256, messageShas,
+  bodySha256 }`), so the ledger grows with new messages rather than with every
+  step's copy of the history. A checkpoint transition carries the draft's hash
+  and size, not the draft; the terminal commit carries the message. For an
+  external driver that is one more row per operation and per step, plus one
+  per new message, on the hot path; there is no opt-out, because the ledger is
+  the history.- **`AgentRuntimeEvent` gains the transient `attempt-reset` event.** Published
+  before a retried attempt's first delta, with `runtimeEpoch`, `sequence` and
+  `attempt`; `reduceAgentControlEvent` drops the run's transient text on it.
+  A reducer that switches exhaustively over `event.type` stops compiling until
+  it handles the case; a reducer that ignores unknown events keeps the failed
+  attempt's partial text on screen. `// before: switch (event.type) { … }` →
+  `// after: case 'attempt-reset': transient = { text: '', reasoning: '' }`.
+  Exported as `AgentAttemptResetEventSchema` from `stitchkit/agent-runtime` and
+  `stitchkit/agent-runtime/browser`.
+
+### Added
+
+- **Agent runtime history is reconstructable from one versioned event ledger.**
+  SQLite schema 2 migrates version 1 conversations through a baseline event,
+  keeps normalized operational tables, adds deterministic projection
+  checkpoints and FTS5 event search, and supports canonical byte-stable
+  conversation export/import. Unknown event versions are skippable only when
+  their envelope explicitly opts in. Direct `AgentRuntimeStore`
+  implementations add `appendEvent`, `readEvents`, `exportConversation` and
+  `importConversation`. → ADR 0175. A conversation export is one read transaction over events, companions and the snapshot. The store conformance suite appends twenty events concurrently and reads them back; the Prisma example passes it by re-running a transaction on a ledger key collision — under `SERIALIZABLE` a unique violation is a serialization conflict — and maps `ignorable` only when set.
+- **Projections fold events with a persisted checkpoint.**
+  `defineAgentProjection`, `createAgentProjectionRegistry` and
+  `createSqliteAgentProjectionStore` keep one row per conversation and
+  projection with the `uptoSeq` it was folded to — stale is possible, wrong is
+  not, and a reader always sees how far behind it is. Built-in:
+  `agentConversationCardProjection`, `agentSummaryProjection`,
+  `agentUsageProjection`, `agentOutlineProjection`, `agentStateSlotsProjection`,
+  `agentScheduleSummaryProjection`.
+- **Typed state slots survive compaction.** `defineStateSlot`,
+  `createAgentStateSlotStore` and `renderAgentStateSlots` keep goal, plan and
+  choices as `state/set` events and render them into every provider request
+  from the ledger, not from the history compaction rewrites; `agentGoalStateSlot`
+  and `agentTodoStateSlot` ship with `createAgentStateTools`.
+- **Events are searchable in the SQLite store.** `createSqliteAgentEventSearch`
+  over an FTS5 index answers with the exact `conversationId` and `seq`, denies
+  another conversation's events unless `authorizeConversation` says otherwise,
+  and `createAgentEventSearchTools` exposes `session_search`, `session_trace`
+  and `session_event`. Without an authorizer the query is bound to the requester's conversation in SQL; with one, foreign candidates are refused page by page until the requester's limit is met, so a louder neighbour cannot starve a match.
+- **Oversized tool output spills whole instead of being cut.**
+  `createSqliteAgentSpillStore` is an `AgentCodingArtifactStore`: a shell
+  result over `limits.maxShellOutputBytes` is kept in full as a conversation
+  artifact, the model receives head, tail, omitted byte count and an
+  `artifact.reference`, and `read_output`/`search_output` re-check the
+  originating authorization before returning any of it. Retention cleanup
+  writes `spill/deleted` with the size; export carries the bytes.
+- **A conversation can schedule its own input.** `createAgentScheduleService`
+  keeps `after`, `at` and `every` durably, delivers through the caller's
+  `dispatch` with `idempotencyKey: schedule:<id>:<occurrence>`, marks a firing missed across a
+  restart `late` with `lateByMs`, and requires an explicit IANA `timeZone` for
+  `every`; `schedule_*` tools for the agent. A row is claimed under compare-and-set before `dispatch`, one tick runs at a time, a `dispatch` that throws is recorded as `schedule/failed` with the row left due and the timer armed, and `every` fires once after an idle stretch. Delivery identity is `idempotencyKey: schedule:<id>:<occurrence>`.
+- **Child runs inherit a bounded seed and a budget.**
+  `createSqliteAgentChildManager` spawns a child from the parent's ledger up to
+  `seedUptoSeq`, stops it at the next step boundary when `usd`, `tokens` or
+  `milliseconds` run out (`child-budget` policy, overrun recorded), records
+  `spawned → running → finished | stopped | lost`, and — given to
+  `createAgentRuntime` as `children` — stops the parent's children after the
+  parent's terminal is durable. `createAgentChildTools` exposes `subagent`,
+  `subagent_fork`, `list_agents`. `agentChildBudgetStopPolicy` is the child
+  runtime's own stop policy — `recordStepUsage` at every step boundary,
+  `policy_stop` as `child-budget` when the budget is spent; `recordStepUsage`
+  reports `enforced: false` when the deciding process holds no handle. The cascade runs once, from the executor that committed the parent's terminal, on an explicit stop — interrupted, cancelled, timed out, shut down — and not on success, supersession or failure, where the conversation goes on and the children with it; a child this process holds no handle for is `lost`, not `stopped`; a late result never rewrites `stopped` or `lost`; a spawn that throws leaves no row; the host's stop and reachability calls are bounded.
+- **The shell tool reports its sandbox grade.** `probeAgentProcessSandbox`
+  probes once per process, `recordAgentSandboxProbe` writes `sandbox/probed`
+  with the grade and the required restrictions it lacks, and a missing required
+  restriction refuses `run_command` with `SANDBOX_UNAVAILABLE` — a different
+  code from a policy refusal — without running anything.
+- **Provider stream failures retry only at a durable step boundary.**
+  `loop.retry` (`AgentRetryPolicy`) retries a `stream-cut` or other retryable
+  provider failure before any tool call in that attempt, drops the attempt's
+  partial output, and records `retry/scheduled` then `retry/started`; a failure
+  after a tool has executed is never retried. Off unless configured. The runtime publishes `attempt-reset` before the next attempt's first delta, checkpoints the draft after the partial output is discarded, hands an input injected into the failed attempt back so the retry sees it and the terminal absorbs only what was answered, and keeps the failed attempt's `finish-step` usage in the run's spend.
+- **The tool catalog is inspectable and collision-checked.** `describeToolCatalog`
+  lists every tool with its origin, final name and schema size; two sources
+  producing one final name refuse at start naming both, and a schema-byte
+  budget is a warning unless made a refusal.
+- **The SQLite handle shares its connection and its transaction.**
+  `createBunSqliteAgentRuntimeStore` / `createNodeSqliteAgentRuntimeStore`
+  return `{ store, conversations, database, transaction, close }`. The SQLite
+  companions — `createSqliteAgentProjectionStore`, `createSqliteAgentSpillStore`,
+  `createSqliteAgentChildManager`, `createAgentScheduleService` — take
+  `{ sqlite }` and write their rows and events through `transaction`
+  (`SqliteStoreTransaction`), in the store's own serialization, so a row and its
+  event land together or not at all. A store call from inside a scope is refused
+  with an error rather than queued behind the transaction it is in.
+- **Provider failure fixtures have their own packed test entrypoint.**
+  `stitchkit/agent-runtime/testing` exposes a credential-free OpenAI-compatible
+  fault server, replay provider and deterministic race controls. Runtime
+  `loop.retry` records scheduled/started attempts and never automatically
+  repeats an attempt that already invoked a tool.
+
+### Fixed
+
+- **A subscriber can accumulate a run's text again.** The transient
+  `sequence` advanced on every stream part, published or not, so a run's first
+  delta reached subscribers as sequence 4 behind an unpublished `text-start`:
+  every cursor saw a gap on the first delta of every run, the control view
+  flagged a resync and never accumulated the text it exists for. The sequence
+  now counts published transient events only. Older than this release.
+- **A durable record no longer blames an upstream that was never contacted.**
+  `context_overflow` was carved out of `provider_failure` for exactly this
+  reason in an earlier release; the same misclassification remained at three
+  other sites. A store conflict — including the one 0.85.2 fixed, which ended
+  runs with zero provider calls — an acceptance refusal after a perfectly good
+  answer, and this runtime's own callback failing before any provider call all
+  said the provider failed. Provider origin is now marked where it is known,
+  at the `doStream` boundary, rather than assumed by elimination. The runtime
+  claims only failures it can identify as its own: an error part it cannot
+  identify is still the provider's, which is what an error part overwhelmingly
+  is.
+
+## [0.85.2] — 2026-09-08
+
+### Fixed
+
+- **An asynchronous store no longer fails a run before the provider is
+  called.** The assistant checkpoint and the model-request admission are two
+  owned mutations of one run, written by two independent schedules — the stream
+  consumer and the SDK's model middleware — and each named the revision it read
+  before its own `await`. Where the store answered on a later tick (a worker, a
+  socket, a real database) the second write named a spent revision, the losing
+  compare-and-set threw out of `wrapStream`, and the run ended
+  `provider_failure` with zero provider calls; frequent checkpoints
+  (`checkpointEveryEvents: 1`) made it reliable. Owned mutations of a run now
+  take their turn in one per-run queue and read the revision inside that turn.
+  Independent runs are unaffected — the queue is per run — and fencing,
+  cancellation and checkpoint durability are unchanged. Proven on the packed
+  tarball by a consumer-lane fixture, not only in-repo. → ADR 0174 (amended).
+
 ## [0.85.1] — 2026-09-07
 
 ### Fixed

package/README.md

@@ -109,6 +109,8 @@ continuations and reconnectable control compose there. Bounded direct file, sear
 shell and opaque-artifact tools live in the peer-free
 `stitchkit/agent-runtime/coding-tools` leaf. Neither surface owns process placement,
 restart, credentials, model catalogs or OS isolation.
+Credential-free replay, scripted provider failures and deterministic race
+controls live in `stitchkit/agent-runtime/testing` for Bun and Node tests.
 The separately installed `stitchkit-tui` package adds a maintained Bun/OpenTUI host over those
 headless contracts; its `stitchkit-tui/core` entrypoint exposes renderer-neutral terminal state
 without React, OpenTUI or agent-runtime imports. Neither enters the core dependency graph.
@@ -437,6 +439,7 @@ peer — an install pulls in only what the project actually uses.
 | `ai` | peer, optional | `stitchkit/tools` agent tools and the optional server-only `stitchkit/agent-runtime`. |
 | Headless harness | optional surface | `stitchkit/agent-runtime/harness`; uses the same optional `ai` peer and canonical runtime. |
 | Agent coding tools | optional surface | `stitchkit/agent-runtime/coding-tools`; peer-free, host-authorized direct file and shell tools. |
+| Agent runtime testing | optional test surface | `stitchkit/agent-runtime/testing`; peer-free local fault server, replay and race fixtures. |
 | `stitchkit-tui` | separate optional package | Renderer-neutral `./core` state plus a Bun/OpenTUI terminal controller, commands, model/session pickers and authenticated local attachment over a caller-composed harness. |
 | `@openrouter/ai-sdk-provider` | peer, optional | Only `stitchkit/agent-runtime/openrouter`; neutral runtime imports do not resolve it. |
 | SQLite | runtime built-in, optional | `bun:sqlite` through `stitchkit/agent-runtime/sqlite/bun`, or `node:sqlite` on Node ≥ 22.5 through the Node leaf. |

package/dist/agent-runtime/agent-tool.d.ts

@@ -0,0 +1,25 @@
+import type { ZodObject, ZodType, z } from 'zod';
+/** Peer-neutral tool definition for surfaces exposed only to an agent model. */
+export interface AgentToolDefinition<TInput extends ZodObject, TOutput extends ZodType> {
+    name: string;
+    description: string;
+    identity: {
+        serviceName: string;
+        action: string;
+        scope?: string;
+        method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+        meta?: Record<string, unknown>;
+    };
+    input: TInput;
+    output: TOutput;
+    transports: readonly ['AGENT'];
+    handler(context: unknown): unknown;
+}
+interface AgentToolSourceDefinition<TInput extends ZodObject, TOutput extends ZodType> extends Omit<AgentToolDefinition<TInput, TOutput>, 'handler'> {
+    handler(context: {
+        input: z.output<TInput>;
+    }): z.output<TOutput> | Promise<z.output<TOutput>>;
+}
+export declare function defineAgentTool<TInput extends ZodObject, TOutput extends ZodType>(definition: AgentToolSourceDefinition<TInput, TOutput>): AgentToolDefinition<TInput, TOutput>;
+export {};
+//# sourceMappingURL=agent-tool.d.ts.map

package/dist/agent-runtime/agent-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-tool.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/agent-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAEjD,gFAAgF;AAChF,MAAM,WAAW,mBAAmB,CAAC,MAAM,SAAS,SAAS,EAAE,OAAO,SAAS,OAAO;IACpF,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;QACpD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAChC,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;CACpC;AAED,UAAU,yBAAyB,CAAC,MAAM,SAAS,SAAS,EAAE,OAAO,SAAS,OAAO,CACnF,SAAQ,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC;IAC7D,OAAO,CAAC,OAAO,EAAE;QACf,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KACzB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;CACpD;AAED,wBAAgB,eAAe,CAAC,MAAM,SAAS,SAAS,EAAE,OAAO,SAAS,OAAO,EAC/E,UAAU,EAAE,yBAAyB,CAAC,MAAM,EAAE,OAAO,CAAC,GACrD,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAKtC"}

package/dist/agent-runtime/child-tools.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { type AgentChildManager } from './children.js';
+export declare function createAgentChildTools(manager: AgentChildManager): readonly [import("./agent-tool.js").AgentToolDefinition<z.ZodObject<{
+    parentConversationId: z.ZodString;
+    childInput: z.ZodJSONSchema;
+    budget: z.ZodObject<{
+        usd: z.ZodOptional<z.ZodNumber>;
+        tokens: z.ZodOptional<z.ZodInt>;
+        milliseconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    seedUptoSeq: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    childConversationId: z.ZodString;
+    state: z.ZodString;
+    resultReference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, import("./agent-tool.js").AgentToolDefinition<z.ZodObject<{
+    parentConversationId: z.ZodString;
+    childInput: z.ZodJSONSchema;
+    budget: z.ZodObject<{
+        usd: z.ZodOptional<z.ZodNumber>;
+        tokens: z.ZodOptional<z.ZodInt>;
+        milliseconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    seedUptoSeq: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    childConversationId: z.ZodString;
+    state: z.ZodString;
+    resultReference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, import("./agent-tool.js").AgentToolDefinition<z.ZodObject<{
+    parentConversationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    children: z.ZodArray<z.ZodObject<{
+        parentConversationId: z.ZodString;
+        childConversationId: z.ZodString;
+        seedUptoSeq: z.ZodInt;
+        state: z.ZodEnum<{
+            finished: "finished";
+            lost: "lost";
+            running: "running";
+            spawned: "spawned";
+            stopped: "stopped";
+        }>;
+        budget: z.ZodObject<{
+            usd: z.ZodOptional<z.ZodNumber>;
+            tokens: z.ZodOptional<z.ZodInt>;
+            milliseconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        usage: z.ZodObject<{
+            tokens: z.ZodInt;
+            usd: z.ZodNumber;
+            milliseconds: z.ZodInt;
+        }, z.core.$strict>;
+        resultReference: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>>, import("./agent-tool.js").AgentToolDefinition<z.ZodObject<{
+    parentConversationId: z.ZodString;
+    childConversationId: z.ZodString;
+    input: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    sent: z.ZodLiteral<true>;
+}, z.core.$strip>>, import("./agent-tool.js").AgentToolDefinition<z.ZodObject<{
+    parentConversationId: z.ZodString;
+    childConversationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    interrupted: z.ZodLiteral<true>;
+}, z.core.$strip>>];
+//# sourceMappingURL=child-tools.d.ts.map

package/dist/agent-runtime/child-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-tools.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/child-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,YAAY,CAAC;AAmDpB,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAuD/D"}

package/dist/agent-runtime/children.d.ts

@@ -0,0 +1,113 @@
+import type { LanguageModelUsage } from 'ai';
+import { z } from 'zod';
+import type { AgentRuntimeStopPolicy } from './runtime.js';
+import type { AgentUsage } from './schemas.js';
+import type { SqliteAgentRuntimeStore } from './sqlite.js';
+export declare const AgentChildBudgetSchema: z.ZodObject<{
+    usd: z.ZodOptional<z.ZodNumber>;
+    tokens: z.ZodOptional<z.ZodInt>;
+    milliseconds: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AgentChildBudget = z.infer<typeof AgentChildBudgetSchema>;
+export declare const AgentChildStateSchema: z.ZodEnum<{
+    finished: "finished";
+    lost: "lost";
+    running: "running";
+    spawned: "spawned";
+    stopped: "stopped";
+}>;
+export type AgentChildState = z.infer<typeof AgentChildStateSchema>;
+export declare const AgentChildRecordSchema: z.ZodObject<{
+    parentConversationId: z.ZodString;
+    childConversationId: z.ZodString;
+    seedUptoSeq: z.ZodInt;
+    state: z.ZodEnum<{
+        finished: "finished";
+        lost: "lost";
+        running: "running";
+        spawned: "spawned";
+        stopped: "stopped";
+    }>;
+    budget: z.ZodObject<{
+        usd: z.ZodOptional<z.ZodNumber>;
+        tokens: z.ZodOptional<z.ZodInt>;
+        milliseconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    usage: z.ZodObject<{
+        tokens: z.ZodInt;
+        usd: z.ZodNumber;
+        milliseconds: z.ZodInt;
+    }, z.core.$strict>;
+    resultReference: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type AgentChildRecord = z.infer<typeof AgentChildRecordSchema>;
+export interface AgentChildHandle {
+    result: Promise<{
+        resultReference?: string;
+    }>;
+    stopPolicy(name: string): void | Promise<void>;
+    sendMessage?(input: unknown): void | Promise<void>;
+    reachable?(): boolean | Promise<boolean>;
+}
+export interface AgentChildManager {
+    spawnChild(request: {
+        parentConversationId: string;
+        childConversationId?: string;
+        seedUptoSeq?: number;
+        childInput: unknown;
+        budget: AgentChildBudget;
+    }): Promise<AgentChildRecord>;
+    listChildren(parentConversationId: string): readonly AgentChildRecord[];
+    recordStepUsage(request: {
+        childConversationId: string;
+        usage: AgentUsage;
+        elapsedMs: number;
+    }): Promise<{
+        stop: boolean;
+        /** Whether a stop was delivered to the child's host from this process. */
+        enforced: boolean;
+        policyName?: string;
+        overrun: {
+            tokens: number;
+            usd: number;
+            milliseconds: number;
+        };
+    }>;
+    stopChildren(parentConversationId: string): Promise<void>;
+    sendMessage(parentConversationId: string, childConversationId: string, input: unknown): Promise<void>;
+    interruptChild(parentConversationId: string, childConversationId: string): Promise<void>;
+    waitChild(childConversationId: string): Promise<void>;
+}
+export declare function createSqliteAgentChildManager(input: {
+    sqlite: SqliteAgentRuntimeStore;
+    spawn(request: {
+        parentConversationId: string;
+        childConversationId: string;
+        seedArchive: Uint8Array;
+        childInput: unknown;
+        budget: AgentChildBudget;
+    }): AgentChildHandle | Promise<AgentChildHandle>;
+    remainingBudget?(parentConversationId: string): AgentChildBudget | Promise<AgentChildBudget>;
+    now?: () => Date;
+}): AgentChildManager;
+/**
+ * The child runtime's own budget policy.
+ *
+ * `recordStepUsage` measures and decides; something has to call it at every
+ * step boundary of the child's run, and that is the child's runtime. Given to
+ * `createAgentRuntime({ loop: { stopPolicies: [agentChildBudgetStopPolicy(…)] } })`
+ * in the host that runs the child, it records the last step's usage and stops
+ * the run as `policy_stop` (`child-budget`) when the budget is spent — the
+ * enforcement the guide promises, in the package rather than in every host.
+ */
+export declare function agentChildBudgetStopPolicy(input: {
+    manager: Pick<AgentChildManager, 'recordStepUsage'>;
+    childConversationId: string;
+    /** Cost of a step, when a USD budget is set; tokens come from the step itself. */
+    cost?: (step: {
+        usage: LanguageModelUsage;
+    }) => AgentUsage['cost'];
+}): AgentRuntimeStopPolicy;
+//# sourceMappingURL=children.d.ts.map

package/dist/agent-runtime/children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"children.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/children.ts"],"names":[],"mappings":"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"}

package/dist/agent-runtime/coding-tool-contract.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type { AgentProcessSandbox, AgentSandboxRestriction } from './sandbox.js';
 export declare const AgentCodingToolLimitsSchema: z.ZodObject<{
     maxPathBytes: z.ZodInt;
     maxReadBytes: z.ZodInt;
@@ -50,6 +51,11 @@ export declare const AgentCodingToolAuthorizationSchema: z.ZodDiscriminatedUnion
     reference: z.ZodString;
     offset: z.ZodInt;
     maxBytes: z.ZodInt;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"artifact-search">;
+    reference: z.ZodString;
+    query: z.ZodString;
+    maxMatches: z.ZodInt;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"shell">;
     executable: z.ZodString;
@@ -75,6 +81,10 @@ export interface AgentCodingToolConfig {
     executables?: Readonly<Record<string, string>>;
     environment?: Readonly<Record<string, string>>;
     artifacts?: AgentCodingArtifactStore;
+    sandbox?: {
+        adapter: AgentProcessSandbox;
+        required: readonly AgentSandboxRestriction[];
+    };
     search?: {
         /** Directory basenames omitted from workspace search at every depth. */
         excludeDirectories?: readonly string[];
@@ -82,9 +92,12 @@ export interface AgentCodingToolConfig {
     limits?: Partial<AgentCodingToolLimits>;
 }
 export interface AgentCodingArtifactStore {
+    /** Original admission checked before artifact bytes are read. */
+    authorization?(reference: string): AgentCodingToolAuthorization | undefined | Promise<AgentCodingToolAuthorization | undefined>;
     write(input: {
         mediaType: string;
         data: Uint8Array;
+        authorization?: AgentCodingToolAuthorization;
     }): {
         reference: string;
     } | Promise<{
@@ -97,10 +110,23 @@ export interface AgentCodingArtifactStore {
     }): {
         data: Uint8Array;
         totalBytes?: number;
+        authorization?: AgentCodingToolAuthorization;
     } | Promise<{
         data: Uint8Array;
         totalBytes?: number;
+        authorization?: AgentCodingToolAuthorization;
     }>;
+    search?(input: {
+        reference: string;
+        query: string;
+        maxMatches: number;
+    }): readonly {
+        line: number;
+        text: string;
+    }[] | Promise<readonly {
+        line: number;
+        text: string;
+    }[]>;
 }
 export interface AgentCodingToolDefinition {
     name: string;
@@ -171,6 +197,9 @@ export declare const ShellOutputSchema: z.ZodObject<{
         reference: z.ZodString;
         bytes: z.ZodInt;
         truncated: z.ZodBoolean;
+        headBytes: z.ZodInt;
+        tailBytes: z.ZodInt;
+        omittedBytes: z.ZodInt;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare function resolveCodingToolLimits(input: Partial<AgentCodingToolLimits> | undefined): AgentCodingToolLimits;

package/dist/agent-runtime/coding-tool-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-contract.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"coding-tool-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-contract.ts"],"names":[],"mappings":"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"}

package/dist/agent-runtime/coding-tool-refusals.d.ts

@@ -22,6 +22,8 @@ declare const REFUSAL_STATUS: {
     readonly FORBIDDEN: 403;
     readonly NOT_FOUND: 404;
     readonly CONFLICT: 409;
+    readonly SANDBOX_UNAVAILABLE: 503;
+    readonly SANDBOX_INSUFFICIENT: 503;
 };
 export type CodingRefusalCode = keyof typeof REFUSAL_STATUS;
 /**

package/dist/agent-runtime/coding-tool-refusals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-refusals.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-refusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,8EAA8E;AAC9E,QAAA,MAAM,cAAc;aAClB,WAAW,EAAE,GAAG;aAChB,SAAS,EAAE,GAAG;aACd,SAAS,EAAE,GAAG;aACd,QAAQ,EAAE,GAAG;CACL,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,cAAc,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAQP;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAKP;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAiC/E"}
+{"version":3,"file":"coding-tool-refusals.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-refusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,8EAA8E;AAC9E,QAAA,MAAM,cAAc;aAClB,WAAW,EAAE,GAAG;aAChB,SAAS,EAAE,GAAG;aACd,SAAS,EAAE,GAAG;aACd,QAAQ,EAAE,GAAG;aACb,mBAAmB,EAAE,GAAG;aACxB,oBAAoB,EAAE,GAAG;CACjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,cAAc,CAAC;AAE5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAQP;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,KAAK,CAKP;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAiC/E"}

package/dist/agent-runtime/coding-tool-shell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tool-shell.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-shell.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAG3B,MAAM,wBAAwB,CAAC;AAoKhC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,yBAAyB,CA4D3B"}
+{"version":3,"file":"coding-tool-shell.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tool-shell.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAG3B,MAAM,wBAAwB,CAAC;AAgNhC,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,yBAAyB,CAgH3B"}

package/dist/agent-runtime/coding-tools.d.ts

@@ -6,6 +6,7 @@ export declare const AGENT_CODING_TOOL_NAMES: {
     listDirectory: string;
     readFile: string;
     readOutput: string;
+    searchOutput: string;
     runCommand: string;
     searchFiles: string;
     writeFile: string;

package/dist/agent-runtime/coding-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coding-tools.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAE/B,MAAM,wBAAwB,CAAC;AAOhC,cAAc,wBAAwB,CAAC;AAEvC,eAAO,MAAM,uBAAuB;;;;;;;;;CASQ,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CA8EtC"}
+{"version":3,"file":"coding-tools.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/coding-tools.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAE/B,MAAM,wBAAwB,CAAC;AAOhC,cAAc,wBAAwB,CAAC;AAEvC,eAAO,MAAM,uBAAuB;;;;;;;;;;CAUQ,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,qBAAqB,GAC5B,SAAS,yBAAyB,EAAE,CA4HtC"}

package/dist/agent-runtime/control-schema.d.ts

@@ -240,10 +240,13 @@ export declare const AgentControlResponseSchema: z.ZodDiscriminatedUnion<[z.ZodO
                 cancelled: "cancelled";
                 context_overflow: "context_overflow";
                 interrupted: "interrupted";
+                output_rejected: "output_rejected";
                 policy_stop: "policy_stop";
                 provider_failure: "provider_failure";
                 provider_stop: "provider_stop";
+                runtime_failure: "runtime_failure";
                 shutdown: "shutdown";
+                storage_conflict: "storage_conflict";
                 success: "success";
                 superseded: "superseded";
                 timeout: "timeout";
@@ -469,10 +472,13 @@ export declare const AgentControlDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodO
                 cancelled: "cancelled";
                 context_overflow: "context_overflow";
                 interrupted: "interrupted";
+                output_rejected: "output_rejected";
                 policy_stop: "policy_stop";
                 provider_failure: "provider_failure";
                 provider_stop: "provider_stop";
+                runtime_failure: "runtime_failure";
                 shutdown: "shutdown";
+                storage_conflict: "storage_conflict";
                 success: "success";
                 superseded: "superseded";
                 timeout: "timeout";
@@ -701,6 +707,14 @@ export declare const AgentControlDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodO
             data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
         }, z.core.$strip>>;
         type: z.ZodLiteral<"reasoning-end">;
+    }, z.core.$strip>, z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        emittedAt: z.ZodISODateTime;
+        type: z.ZodLiteral<"attempt-reset">;
+        runtimeEpoch: z.ZodString;
+        sequence: z.ZodInt;
+        attempt: z.ZodInt;
     }, z.core.$strip>, z.ZodObject<{
         conversationId: z.ZodString;
         runId: z.ZodString;
@@ -933,10 +947,13 @@ export declare const AgentControlDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodO
             cancelled: "cancelled";
             context_overflow: "context_overflow";
             interrupted: "interrupted";
+            output_rejected: "output_rejected";
             policy_stop: "policy_stop";
             provider_failure: "provider_failure";
             provider_stop: "provider_stop";
+            runtime_failure: "runtime_failure";
             shutdown: "shutdown";
+            storage_conflict: "storage_conflict";
             success: "success";
             superseded: "superseded";
             timeout: "timeout";

package/dist/agent-runtime/control-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control-schema.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/control-schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"control-schema.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/control-schema.ts"],"names":[],"mappings":"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"}