stitchkit 0.110.1 → 0.110.2

package/CHANGELOG.md

@@ -15,6 +15,12 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [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-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"}