stitchkit 0.110.1 → 0.110.3

package/CHANGELOG.md

@@ -15,6 +15,22 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.110.3] - 2026-10-15
+
+### Added
+
+- `stitchkit/agent-runtime`: `AgentStoreTransitionRecordSchema` and its inferred `AgentStoreTransitionRecord` type inspect the persisted journal, including full transitions and compact hash-only streaming checkpoints. `AgentStoreTransitionSchema` continues to describe executable mutations. These two names belong to the runtime entrypoint (I3, I8, I15).
+
+### Fixed
+
+- `stitchkit/agent-runtime`: branch and restore accept complete SQLite streaming exports with companion projections, including schema v4 exports written by 0.109.4. Companion cache envelopes are validated and their values discarded; destination projections rebuild from the rekeyed ledger without importing source state or effects. Ordinary archive import also restores compacted history and admissions through the shared replay writer. Unknown journal payloads still refuse atomically; see ADR 0259.
+
+## [0.110.2] - 2026-10-15
+
+### Added
+
+- `stitchkit/agent-runtime`: atomic `store.branchConversation()` creates an independent conversation from an exact settled prefix or a validated archive. Typed identities and spill references are rekeyed; stable retries return a durable lineage receipt, while control observations remain inert and artifact access requires fresh destination policy. Six input/result/receipt type and schema exports belong to this entrypoint (I3, I8, I12, I15). Unknown opaque payloads fail before any destination write. Abandon transitions retain their exact terminal assistant for reconstruction after compaction; incomplete legacy recovery archives refuse.
+
 ## [0.110.1] - 2026-10-14
 
 ### Added

package/dist/agent-runtime/archive-projection.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** Derived companion cache, distinct from the authoritative runtime snapshot. */
+export declare const ArchiveProjectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodInt;
+    uptoSeq: z.ZodInt;
+    value: z.ZodJSONSchema;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+//# sourceMappingURL=archive-projection.d.ts.map

package/dist/agent-runtime/archive-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-projection.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/archive-projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,iFAAiF;AACjF,eAAO,MAAM,uBAAuB;;;;;;kBAQzB,CAAC"}

package/dist/agent-runtime/archive-spill.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const ArchiveSpillSchema: z.ZodObject<{
+    reference: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodString;
+    bytes: z.ZodInt;
+    sha256: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+    authorization: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<"read">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodString;
+        bytes: z.ZodInt;
+        overwrite: z.ZodBoolean;
+        createsDirectories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        mode: z.ZodEnum<{
+            content: "content";
+            path: "path";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"edit">;
+        path: z.ZodString;
+        baseSha256: z.ZodString;
+        resultSha256: z.ZodString;
+        resultBytes: z.ZodInt;
+        replacements: z.ZodInt;
+        dryRun: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"list">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"glob">;
+        pattern: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-read">;
+        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;
+        args: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+    }, z.core.$strict>], "operation">>;
+    base64: z.ZodString;
+}, z.core.$strict>;
+export type ArchiveSpill = z.infer<typeof ArchiveSpillSchema>;
+//# sourceMappingURL=archive-spill.d.ts.map

package/dist/agent-runtime/archive-spill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-spill.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/archive-spill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0B3B,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/agent-runtime/branch-contract.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+export declare const BranchAgentConversationInputSchema: z.ZodObject<{
+    requestKey: z.ZodString;
+    destinationConversationId: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"conversation">;
+        conversationId: z.ZodString;
+        throughRunId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"archive">;
+        bytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    }, z.core.$strict>], "kind">;
+    artifactAuthorization: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<"read">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodString;
+        bytes: z.ZodInt;
+        overwrite: z.ZodBoolean;
+        createsDirectories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        mode: z.ZodEnum<{
+            content: "content";
+            path: "path";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"edit">;
+        path: z.ZodString;
+        baseSha256: z.ZodString;
+        resultSha256: z.ZodString;
+        resultBytes: z.ZodInt;
+        replacements: z.ZodInt;
+        dryRun: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"list">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"glob">;
+        pattern: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-read">;
+        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;
+        args: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+    }, z.core.$strict>], "operation">>;
+}, z.core.$strict>;
+export type BranchAgentConversationInput = z.infer<typeof BranchAgentConversationInputSchema>;
+export declare const AgentConversationBranchReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestKey: z.ZodString;
+    fingerprint: z.ZodString;
+    conversationId: z.ZodString;
+    sourceConversationId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        archive: "archive";
+        conversation: "conversation";
+    }>;
+    throughRunId: z.ZodOptional<z.ZodString>;
+    sourceSeq: z.ZodInt;
+    sourceVersion: z.ZodInt;
+    sourceDigest: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AgentConversationBranchReceipt = z.infer<typeof AgentConversationBranchReceiptSchema>;
+export declare const AgentConversationBranchResultSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        created: "created";
+        duplicate: "duplicate";
+    }>;
+    receipt: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        requestKey: z.ZodString;
+        fingerprint: z.ZodString;
+        conversationId: z.ZodString;
+        sourceConversationId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            archive: "archive";
+            conversation: "conversation";
+        }>;
+        throughRunId: z.ZodOptional<z.ZodString>;
+        sourceSeq: z.ZodInt;
+        sourceVersion: z.ZodInt;
+        sourceDigest: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentConversationBranchResult = z.infer<typeof AgentConversationBranchResultSchema>;
+//# sourceMappingURL=branch-contract.d.ts.map

package/dist/agent-runtime/branch-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBpC,CAAC;AAEZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;kBActC,CAAC;AAEZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;kBAKrC,CAAC;AAEZ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC"}

package/dist/agent-runtime/branch-events.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { AgentStoreEventEnvelope } from '../durability/events.js';
+import type { BranchIdentities } from './branch-identities.js';
+import { BranchProvider } from './branch-provider.js';
+import type { AgentMessage } from './schemas.js';
+export declare function rekeyBranchEvents(ids: BranchIdentities, source: string, events: readonly AgentStoreEventEnvelope[], retainedMessages?: ReadonlyMap<string, AgentMessage>): {
+    schemaVersion: number;
+    eventId: string;
+    conversationId: string;
+    seq: number;
+    kind: string;
+    occurredAt: string;
+    payload: z.JSONType;
+    ignorable?: true | undefined;
+}[];
+export declare function collectBranchEvent(ids: BranchIdentities, event: AgentStoreEventEnvelope): void;
+export declare function rekeyBranchEvent(ids: BranchIdentities, source: string, event: AgentStoreEventEnvelope, provider: BranchProvider): AgentStoreEventEnvelope;
+//# sourceMappingURL=branch-events.d.ts.map

package/dist/agent-runtime/branch-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-events.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAK9C,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,uBAAuB,EAAE,EAC1C,gBAAgB,GAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAa;;;;;;;;;IAwBhE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,EAAE,KAAK,EAAE,uBAAuB,QAYvF;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,uBAAuB,EAC9B,QAAQ,EAAE,cAAc,GACvB,uBAAuB,CAiHzB"}

package/dist/agent-runtime/branch-identities.d.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage, AgentRun } from './schemas.js';
+import type { StoreOperation } from './store-reduce-shared.js';
+type IdentityKind = 'run' | 'message' | 'call' | 'approval' | 'operation' | 'spill' | 'event' | 'owner' | 'key' | 'schedule' | 'child';
+/** Definitions are collected before references are resolved; foreign references never mint IDs. */
+export declare class BranchIdentities {
+    readonly conversationId: string;
+    private readonly requestKey;
+    readonly sourceConversationId: string;
+    private readonly definitions;
+    private readonly references;
+    constructor(conversationId: string, requestKey: string, sourceConversationId: string);
+    define(kind: IdentityKind, source: string): string;
+    reference(kind: IdentityKind, source: string): string;
+    referenced(kind: IdentityKind): ReadonlySet<string>;
+    collectMessage(message: AgentMessage): void;
+    collectRun(run: AgentRun): void;
+    collectOperation(operation: StoreOperation): void;
+}
+export {};
+//# sourceMappingURL=branch-identities.d.ts.map

package/dist/agent-runtime/branch-identities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-identities.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-identities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,KAAK,YAAY,GACb,KAAK,GACL,SAAS,GACT,MAAM,GACN,UAAU,GACV,WAAW,GACX,OAAO,GACP,OAAO,GACP,OAAO,GACP,KAAK,GACL,UAAU,GACV,OAAO,CAAC;AAEZ,mGAAmG;AACnG,qBAAa,gBAAgB;IAIzB,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,oBAAoB,EAAE,MAAM;IALvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgD;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;IACnE,YACW,cAAc,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAC1B,oBAAoB,EAAE,MAAM,EACnC;IACJ,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUjD;IACD,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOpD;IACD,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAElD;IACD,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAM1C;IACD,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAI9B;IACD,gBAAgB,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAuBhD;CACF"}

package/dist/agent-runtime/branch-messages.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+import type { AgentMessage, AgentRun } from './schemas.js';
+/** Application JSON is data, never an undocumented runtime reference codec. */
+export declare function branchOpaqueJson(value: z.infer<ReturnType<typeof z.json>>): typeof value;
+export declare function branchToolJson(ids: BranchIdentities, name: string, value: z.infer<ReturnType<typeof z.json>>, output: boolean): string | number | boolean | z.JSONType[] | {
+    [key: string]: z.JSONType;
+} | {
+    matches: {
+        line: number;
+        text: string;
+    }[];
+    reference: string;
+} | {
+    executable: string;
+    exitCode: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+    artifact?: {
+        reference: string;
+        bytes: number;
+        truncated: boolean;
+        headBytes: number;
+        tailBytes: number;
+        omittedBytes: number;
+    } | undefined;
+} | null;
+export declare function branchMessage(ids: BranchIdentities, sourceConversationId: string, message: AgentMessage): AgentMessage;
+export declare function branchRun(ids: BranchIdentities, sourceConversationId: string, run: AgentRun, settled: boolean): AgentRun;
+//# sourceMappingURL=branch-messages.d.ts.map

package/dist/agent-runtime/branch-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-messages.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,YAAY,EAAoB,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1E,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,KAAK,CAoBxF;AAgCD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EACzC,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;SA4BhB;AA6CD,wBAAgB,aAAa,CAC3B,GAAG,EAAE,gBAAgB,EACrB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,EAAE,YAAY,GACpB,YAAY,CAad;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,gBAAgB,EACrB,oBAAoB,EAAE,MAAM,EAC5B,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,OAAO,GACf,QAAQ,CAsBV"}

package/dist/agent-runtime/branch-observations.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+/** Control observations are retained under an inert kind: no state/schedule/durability reader can replay them. */
+export declare function branchObservation(ids: BranchIdentities, kind: string, raw: z.infer<ReturnType<typeof z.json>>): {
+    result: {
+        grade: "full";
+        restrictions: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    } | {
+        grade: "partial";
+        restrictions: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+        gaps: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    } | {
+        grade: "unavailable";
+        reason: string;
+    };
+    required: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    missing: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+} | {
+    name: string;
+    version: number;
+    value: z.JSONType;
+    actor: "agent" | "human" | "system";
+} | {
+    attempt: number;
+    delayMs?: number | undefined;
+    reason?: string | undefined;
+} | {
+    effectName: string;
+    phase: "intent";
+    runId: string;
+    id?: string | undefined;
+} | {
+    effectName: string;
+    phase: "accepted";
+    encoded: string;
+    via: "reconcile" | "run";
+    runId: string;
+    id?: string | undefined;
+} | {
+    effectName: string;
+    phase: "uncertain";
+    runId: string;
+    id?: string | undefined;
+} | {
+    kind: "sleep";
+    name: string;
+    deadline: number;
+    runId: string;
+    id?: string | undefined;
+} | {
+    kind: "wait";
+    event: string;
+    id: string;
+    runId: string;
+} | {
+    stepName: string;
+    encoded: string;
+    runId: string;
+    id?: string | undefined;
+} | {
+    event: string;
+    id: string;
+    encoded: string;
+    runId: string;
+} | {
+    bytes: number;
+    sha256?: string | undefined;
+    reference: string;
+} | {
+    kind?: "after" | "at" | "every" | undefined;
+    nextAt?: string | null | undefined;
+    occurrence?: number | undefined;
+    lateByMs?: number | undefined;
+    state?: string | undefined;
+    message?: string | undefined;
+    attempts?: number | undefined;
+    retryAt?: string | null | undefined;
+    terminal?: boolean | undefined;
+    skipped?: boolean | undefined;
+    id: string;
+} | {
+    childConversationId?: string | undefined;
+    parentConversationId?: string | undefined;
+    seedUptoSeq?: number | undefined;
+    budget?: z.JSONType | undefined;
+    state?: string | undefined;
+    resultReference?: string | undefined;
+    reason?: string | undefined;
+    action?: "blocking-presented" | "blocking-resolved" | "message-sent" | undefined;
+    approvalId?: string | undefined;
+    childApprovalId?: string | undefined;
+    callId?: string | undefined;
+    toolName?: string | undefined;
+    input?: z.JSONType | undefined;
+    batchId?: string | undefined;
+    kind?: string | undefined;
+    presentedAt?: string | undefined;
+    approved?: boolean | undefined;
+};
+export declare const BranchObservationSchema: z.ZodObject<{
+    sourceKind: z.ZodString;
+    payload: z.ZodJSONSchema;
+}, z.core.$strict>;
+//# sourceMappingURL=branch-observations.d.ts.map

package/dist/agent-runtime/branch-observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-observations.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-observations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAiE5D,kHAAkH;AAClH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmFxC;AAED,eAAO,MAAM,uBAAuB;;;kBAEzB,CAAC"}

package/dist/agent-runtime/branch-provider.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+/** Provider IDs stay provider IDs; runtime call references and their content digests are rekeyed. */
+export declare class BranchProvider {
+    private readonly ids;
+    private readonly digests;
+    constructor(ids: BranchIdentities);
+    rekey(kind: string, raw: z.infer<ReturnType<typeof z.json>>): {
+        sha256: string;
+        message: {
+            role: "assistant" | "tool" | "user";
+            content: string | ({
+                type: "reasoning" | "text";
+                text: string;
+            } | {
+                type: "file";
+                data: string | {
+                    binary: true;
+                    sha256: string;
+                    bytes: number;
+                };
+                mediaType: string;
+                filename?: string | undefined;
+            } | {
+                type: "image";
+                image: string | {
+                    binary: true;
+                    sha256: string;
+                    bytes: number;
+                };
+                mediaType?: string | undefined;
+            } | {
+                type: "tool-call";
+                toolName: string;
+                toolCallId: string;
+                input: string | number | boolean | z.JSONType[] | {
+                    [key: string]: z.JSONType;
+                } | {
+                    matches: {
+                        line: number;
+                        text: string;
+                    }[];
+                    reference: string;
+                } | {
+                    executable: string;
+                    exitCode: number | null;
+                    signal: string | null;
+                    stdout: string;
+                    stderr: string;
+                    outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+                    artifact?: {
+                        reference: string;
+                        bytes: number;
+                        truncated: boolean;
+                        headBytes: number;
+                        tailBytes: number;
+                        omittedBytes: number;
+                    } | undefined;
+                } | null;
+                approvalId?: undefined;
+            } | {
+                type: "tool-result";
+                toolName: string;
+                toolCallId: string;
+                output: {
+                    type: "error-text" | "text";
+                    value: string;
+                } | {
+                    type: "error-json" | "json";
+                    value: string | number | boolean | z.JSONType[] | {
+                        [key: string]: z.JSONType;
+                    } | {
+                        matches: {
+                            line: number;
+                            text: string;
+                        }[];
+                        reference: string;
+                    } | {
+                        executable: string;
+                        exitCode: number | null;
+                        signal: string | null;
+                        stdout: string;
+                        stderr: string;
+                        outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+                        artifact?: {
+                            reference: string;
+                            bytes: number;
+                            truncated: boolean;
+                            headBytes: number;
+                            tailBytes: number;
+                            omittedBytes: number;
+                        } | undefined;
+                    } | null;
+                };
+                approvalId?: undefined;
+            } | {
+                type: "tool-approval-request";
+                approvalId: string;
+                toolCallId: string;
+            } | {
+                type: "tool-approval-response";
+                approved: boolean;
+                reason?: string | undefined;
+                toolCallId?: undefined;
+                approvalId: string;
+            })[];
+        };
+    } | {
+        attempt: number;
+        stepNumber: number;
+        modelId: string;
+        instructionsSha256: string;
+        sha256?: undefined;
+        message?: undefined;
+        runId: string;
+        messageShas: string[];
+        bodySha256: string;
+    } | {
+        attempt: number;
+        stepNumber: number;
+        response: {
+            id: string;
+            provider?: string | undefined;
+        };
+        sha256?: undefined;
+        message?: undefined;
+        runId: string;
+    };
+}
+//# sourceMappingURL=branch-provider.d.ts.map

package/dist/agent-runtime/branch-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-provider.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmH5D,qGAAqG;AACrG,qBAAa,cAAc;IAEb,OAAO,CAAC,QAAQ,CAAC,GAAG;IADhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,YAA6B,GAAG,EAAE,gBAAgB,EAAI;IACtD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF1D;CACF"}