stitchkit 0.93.0 → 0.94.1

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

@@ -1,7 +1,7 @@
+import type { AgentStoreEventEnvelope, AppendAgentStoreEvent } from '../durability/events.js';
 import type { SqliteDatabase } from '../internal/sqlite.js';
-import { type AgentConversationReader } from './conversations.js';
-import { createAgentRuntimeStore } from './store-driver.js';
-import { type AgentStoreEventEnvelope, type AppendAgentStoreEvent } from './store-events.js';
+import type { AgentConversationReader } from './conversations.js';
+import { createAgentRuntimeStore } from './store-create.js';
 export type { SqliteDatabase, SqliteStatement, SqliteValue } from '../internal/sqlite.js';
 export interface SqliteAgentRuntimeStoreConfig {
     database: SqliteDatabase;
@@ -40,9 +40,13 @@ export interface SqliteStoreTransaction {
     appendEvent(input: AppendAgentStoreEvent): Promise<AgentStoreEventEnvelope>;
 }
 /**
- * Create Stitchkit's schema without claiming an application's tables or SQLite user_version.
- * An orphaned partial Stitchkit schema is refused rather than destructively repaired.
+ * The SQLite store: the normalized driver over one owned connection, and the
+ * store built on it.
+ *
+ * Only the assembly lives here. The schema is in `sqlite-schema`, the
+ * serialized transactions in `sqlite-transactions`, the driver members in
+ * `sqlite-ledger`, `sqlite-history` and `sqlite-events`, the reads that open
+ * their own transaction in `sqlite-reads`, and the purge in `sqlite-purge`.
  */
-export declare function initializeAgentRuntimeSqlite(database: SqliteDatabase): void;
 export declare function createSqliteAgentRuntimeStore(config: SqliteAgentRuntimeStoreConfig): SqliteAgentRuntimeStore;
 //# sourceMappingURL=sqlite.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/sqlite.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,iBAAiB,CAAC;AAKzB,OAAO,EAOL,uBAAuB,EACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,KAAK,uBAAuB,EAG5B,KAAK,qBAAqB,EAG3B,MAAM,gBAAgB,CAAC;AAUxB,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEvF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,cAAc,CAAC;IACzB,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,cAAc,CAAC,CAAC,CAAC;IAClE,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB;;;;;;;;;OASG;IACH,WAAW,CAAC,MAAM,EAChB,IAAI,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,MAAM,CAAC,GACvD,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,oFAAoF;IACpF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,4DAA4D;AAC5D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC7E;AA8KD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CA6G3E;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,6BAA6B,GACpC,uBAAuB,CA8vBzB"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAkB/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEvF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,cAAc,CAAC;IACzB,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,cAAc,CAAC,CAAC,CAAC;IAClE,aAAa,EAAE,uBAAuB,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB;;;;;;;;;OASG;IACH,WAAW,CAAC,MAAM,EAChB,IAAI,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,MAAM,CAAC,GACvD,OAAO,CAAC,MAAM,CAAC,CAAC;IACnB,oFAAoF;IACpF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,4DAA4D;AAC5D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,6BAA6B,GACpC,uBAAuB,CAmCzB"}

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

@@ -0,0 +1,16 @@
+import { type AgentRuntimeStoreDriver } from './store-driver-contract.js';
+/**
+ * One read transaction for the whole archive.
+ *
+ * Events, the durable companions and the snapshot used to be three separate
+ * reads; a spill cleanup or a run transition landing between them produced
+ * an archive whose parts disagreed — a `spill/created` without its payload,
+ * a snapshot newer than its last transition — and an import of it restored a
+ * state no event had produced.
+ */
+export declare function exportConversation<TRANSACTION>(driver: AgentRuntimeStoreDriver<TRANSACTION>, conversationId: string): Promise<Uint8Array>;
+export declare function importConversation<TRANSACTION>(driver: AgentRuntimeStoreDriver<TRANSACTION>, bytes: Uint8Array): Promise<{
+    conversationId: string;
+    events: number;
+}>;
+//# sourceMappingURL=store-archive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-archive.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-archive.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,uBAAuB,EAE7B,MAAM,yBAAyB,CAAC;AAQjC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAC5C,MAAM,EAAE,uBAAuB,CAAC,WAAW,CAAC,EAC5C,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,UAAU,CAAC,CAsCrB;AAED,wBAAsB,kBAAkB,CAAC,WAAW,EAClD,MAAM,EAAE,uBAAuB,CAAC,WAAW,CAAC,EAC5C,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CA4FrD"}

package/dist/agent-runtime/store-conformance-lifecycle.d.ts

@@ -0,0 +1,434 @@
+/**
+ * The run-lifecycle scenario of the agent-store conformance kit, in the phases
+ * it walks one run through: admitted, acquired and fenced, read back, operated
+ * and interrupted, settled by a terminal race — and a second run abandoned.
+ * Each phase hands the next exactly what it needs.
+ */
+import { type AgentRun } from './schemas.js';
+import type { AgentRuntimeStore } from './store.js';
+/** Admission: idempotent, coalescing, refusing reserved identities, surviving compaction. */
+export declare function admissionPhase(store: AgentRuntimeStore, conversationId: string): Promise<{
+    schemaVersion: 1;
+    id: string;
+    conversationId: string;
+    inputMessageIds: string[];
+    assistantMessageId: string;
+    state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+    revision: number;
+    queuePriority?: "interrupt-next" | undefined;
+    executionSequence?: number | undefined;
+    ownerId?: string | undefined;
+    fencingToken?: number | undefined;
+    terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+    terminalPolicyName?: string | undefined;
+    absorbedIntoRunId?: string | undefined;
+    usage?: {
+        inputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        outputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        reasoningTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheReadTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheWriteTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cost?: {
+            value?: number | undefined;
+            currency?: string | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+    } | undefined;
+    lastOperation?: {
+        operationId: string;
+        kind: "compaction" | "model-request";
+        phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+        step?: number | undefined;
+        startedAt: string;
+        firstOutputAt?: string | undefined;
+        finishedAt?: string | undefined;
+    } | undefined;
+    createdAt: string;
+    updatedAt: string;
+}>;
+/** Acquisition and fencing: a stale revision, a stale token and another owner all conflict. */
+export declare function fencingPhase(store: AgentRuntimeStore, conversationId: string, assigned: AgentRun): Promise<{
+    running: {
+        schemaVersion: 1;
+        id: string;
+        conversationId: string;
+        inputMessageIds: string[];
+        assistantMessageId: string;
+        state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+        revision: number;
+        queuePriority?: "interrupt-next" | undefined;
+        executionSequence?: number | undefined;
+        ownerId?: string | undefined;
+        fencingToken?: number | undefined;
+        terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+        terminalPolicyName?: string | undefined;
+        absorbedIntoRunId?: string | undefined;
+        usage?: {
+            inputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            outputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            reasoningTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheReadTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheWriteTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cost?: {
+                value?: number | undefined;
+                currency?: string | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+        } | undefined;
+        lastOperation?: {
+            operationId: string;
+            kind: "compaction" | "model-request";
+            phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+            step?: number | undefined;
+            startedAt: string;
+            firstOutputAt?: string | undefined;
+            finishedAt?: string | undefined;
+        } | undefined;
+        createdAt: string;
+        updatedAt: string;
+    };
+    checkpoint: {
+        outcome: "applied";
+        snapshot: {
+            schemaVersion: 1;
+            conversationId: string;
+            version: number;
+            messages: {
+                schemaVersion: 1;
+                id: string;
+                conversationId: string;
+                runId?: string | undefined;
+                role: "assistant" | "summary" | "system" | "tool" | "user";
+                status: "committed" | "completed" | "failed" | "interrupted" | "streaming" | "superseded";
+                parts: ({
+                    type: "text";
+                    text: string;
+                } | {
+                    type: "reasoning";
+                    text: string;
+                    provider?: {
+                        schemaVersion: number;
+                        provider: string;
+                        data: Record<string, import("zod").JSONType>;
+                    } | undefined;
+                } | {
+                    type: "file";
+                    mediaType: string;
+                    reference: string;
+                    filename?: string | undefined;
+                } | {
+                    type: "source";
+                    sourceId: string;
+                    url?: string | undefined;
+                    title?: string | undefined;
+                } | {
+                    type: "tool-call";
+                    callId: string;
+                    toolName: string;
+                    input: import("zod").JSONType;
+                    provider?: {
+                        schemaVersion: number;
+                        provider: string;
+                        data: Record<string, import("zod").JSONType>;
+                    } | undefined;
+                } | {
+                    type: "tool-result";
+                    callId: string;
+                    toolName: string;
+                    outcome: "error" | "interrupted" | "success";
+                    output?: import("zod").JSONType | undefined;
+                } | {
+                    type: "tool-approval-request";
+                    approvalId: string;
+                    callId: string;
+                    isAutomatic?: boolean | undefined;
+                    signature?: string | undefined;
+                } | {
+                    type: "tool-approval-response";
+                    approvalId: string;
+                    approved: boolean;
+                    reason?: string | undefined;
+                } | {
+                    type: "provider";
+                    envelope: {
+                        schemaVersion: number;
+                        provider: string;
+                        data: Record<string, import("zod").JSONType>;
+                    };
+                } | {
+                    type: "control";
+                    reason: "run-interrupted" | "stale-run";
+                })[];
+                metadata?: Record<string, import("zod").JSONType> | undefined;
+                createdAt: string;
+                updatedAt: string;
+            }[];
+            runs: {
+                schemaVersion: 1;
+                id: string;
+                conversationId: string;
+                inputMessageIds: string[];
+                assistantMessageId: string;
+                state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+                revision: number;
+                queuePriority?: "interrupt-next" | undefined;
+                executionSequence?: number | undefined;
+                ownerId?: string | undefined;
+                fencingToken?: number | undefined;
+                terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+                terminalPolicyName?: string | undefined;
+                absorbedIntoRunId?: string | undefined;
+                usage?: {
+                    inputTokens: {
+                        value?: number | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    };
+                    outputTokens: {
+                        value?: number | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    };
+                    reasoningTokens?: {
+                        value?: number | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    } | undefined;
+                    cacheReadTokens?: {
+                        value?: number | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    } | undefined;
+                    cacheWriteTokens?: {
+                        value?: number | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    } | undefined;
+                    cost?: {
+                        value?: number | undefined;
+                        currency?: string | undefined;
+                        provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+                    } | undefined;
+                } | undefined;
+                lastOperation?: {
+                    operationId: string;
+                    kind: "compaction" | "model-request";
+                    phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+                    step?: number | undefined;
+                    startedAt: string;
+                    firstOutputAt?: string | undefined;
+                    finishedAt?: string | undefined;
+                } | undefined;
+                createdAt: string;
+                updatedAt: string;
+            }[];
+        };
+    };
+    checkpointedRun: {
+        schemaVersion: 1;
+        id: string;
+        conversationId: string;
+        inputMessageIds: string[];
+        assistantMessageId: string;
+        state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+        revision: number;
+        queuePriority?: "interrupt-next" | undefined;
+        executionSequence?: number | undefined;
+        ownerId?: string | undefined;
+        fencingToken?: number | undefined;
+        terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+        terminalPolicyName?: string | undefined;
+        absorbedIntoRunId?: string | undefined;
+        usage?: {
+            inputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            outputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            reasoningTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheReadTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheWriteTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cost?: {
+                value?: number | undefined;
+                currency?: string | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+        } | undefined;
+        lastOperation?: {
+            operationId: string;
+            kind: "compaction" | "model-request";
+            phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+            step?: number | undefined;
+            startedAt: string;
+            firstOutputAt?: string | undefined;
+            finishedAt?: string | undefined;
+        } | undefined;
+        createdAt: string;
+        updatedAt: string;
+    };
+    terminalAssistant: {
+        schemaVersion: 1;
+        id: string;
+        conversationId: string;
+        runId?: string | undefined;
+        role: "assistant" | "summary" | "system" | "tool" | "user";
+        status: "committed" | "completed" | "failed" | "interrupted" | "streaming" | "superseded";
+        parts: ({
+            type: "text";
+            text: string;
+        } | {
+            type: "reasoning";
+            text: string;
+            provider?: {
+                schemaVersion: number;
+                provider: string;
+                data: Record<string, import("zod").JSONType>;
+            } | undefined;
+        } | {
+            type: "file";
+            mediaType: string;
+            reference: string;
+            filename?: string | undefined;
+        } | {
+            type: "source";
+            sourceId: string;
+            url?: string | undefined;
+            title?: string | undefined;
+        } | {
+            type: "tool-call";
+            callId: string;
+            toolName: string;
+            input: import("zod").JSONType;
+            provider?: {
+                schemaVersion: number;
+                provider: string;
+                data: Record<string, import("zod").JSONType>;
+            } | undefined;
+        } | {
+            type: "tool-result";
+            callId: string;
+            toolName: string;
+            outcome: "error" | "interrupted" | "success";
+            output?: import("zod").JSONType | undefined;
+        } | {
+            type: "tool-approval-request";
+            approvalId: string;
+            callId: string;
+            isAutomatic?: boolean | undefined;
+            signature?: string | undefined;
+        } | {
+            type: "tool-approval-response";
+            approvalId: string;
+            approved: boolean;
+            reason?: string | undefined;
+        } | {
+            type: "provider";
+            envelope: {
+                schemaVersion: number;
+                provider: string;
+                data: Record<string, import("zod").JSONType>;
+            };
+        } | {
+            type: "control";
+            reason: "run-interrupted" | "stale-run";
+        })[];
+        metadata?: Record<string, import("zod").JSONType> | undefined;
+        createdAt: string;
+        updatedAt: string;
+    };
+}>;
+/** The two bounded reads answer what the snapshot answers, and nothing across conversations. */
+export declare function boundedReadsPhase(store: AgentRuntimeStore, conversationId: string, absentConversationId: string, checkpointed: Awaited<ReturnType<typeof fencingPhase>>): Promise<void>;
+/** A recoverable scan, a recorded operation and a durable interrupt of the live run. */
+export declare function interruptPhase(store: AgentRuntimeStore, conversationId: string, checkpointed: Awaited<ReturnType<typeof fencingPhase>>): Promise<{
+    schemaVersion: 1;
+    id: string;
+    conversationId: string;
+    inputMessageIds: string[];
+    assistantMessageId: string;
+    state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+    revision: number;
+    queuePriority?: "interrupt-next" | undefined;
+    executionSequence?: number | undefined;
+    ownerId?: string | undefined;
+    fencingToken?: number | undefined;
+    terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+    terminalPolicyName?: string | undefined;
+    absorbedIntoRunId?: string | undefined;
+    usage?: {
+        inputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        outputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        reasoningTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheReadTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheWriteTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cost?: {
+            value?: number | undefined;
+            currency?: string | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+    } | undefined;
+    lastOperation?: {
+        operationId: string;
+        kind: "compaction" | "model-request";
+        phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+        step?: number | undefined;
+        startedAt: string;
+        firstOutputAt?: string | undefined;
+        finishedAt?: string | undefined;
+    } | undefined;
+    createdAt: string;
+    updatedAt: string;
+}>;
+//# sourceMappingURL=store-conformance-lifecycle.d.ts.map

package/dist/agent-runtime/store-conformance-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-conformance-lifecycle.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,6FAA6F;AAC7F,wBAAsB,cAAc,CAAC,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GpF;AAED,+FAA+F;AAC/F,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4InB;AAED,gGAAgG;AAChG,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,EACtB,oBAAoB,EAAE,MAAM,EAC5B,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,GACrD,OAAO,CAAC,IAAI,CAAC,CAqDf;AAED,wFAAwF;AACxF,wBAAsB,cAAc,CAClC,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CvD"}

package/dist/agent-runtime/store-conformance-ordering.d.ts

@@ -0,0 +1,18 @@
+import type { AgentRuntimeStore } from './store.js';
+/** Urgent queued work survives storage and becomes the next acquired run. */
+export declare function assertInterruptPriorityOrder(store: AgentRuntimeStore, conversationId: string): Promise<void>;
+/** Active-run reads preserve admission order when identifiers point backwards. */
+export declare function assertActiveRunCausalOrder(store: AgentRuntimeStore, conversationId: string): Promise<void>;
+/** A later durable admission follows the predecessor answer in every snapshot. */
+export declare function assertCausalHistoryOrder(store: AgentRuntimeStore, conversationId: string): Promise<void>;
+/**
+ * One terminal commit, two run records — and they land together or not at all.
+ *
+ * A driver that saves the run it was asked about and drops the second is the
+ * failure this exists to catch: the absorbing run would claim to have answered
+ * an input whose own run is still queued, and that input would then be answered
+ * twice. The pair is written inside one transaction, so a driver that persists
+ * one record of it fails here.
+ */
+export declare function assertAbsorptionIsAtomic(store: AgentRuntimeStore, conversationId: string): Promise<void>;
+//# sourceMappingURL=store-conformance-ordering.d.ts.map

package/dist/agent-runtime/store-conformance-ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-conformance-ordering.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance-ordering.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,6EAA6E;AAC7E,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CA6Gf;AAED,kFAAkF;AAClF,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,kFAAkF;AAClF,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAuDf;AAED;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAuGf"}

package/dist/agent-runtime/store-conformance-support.d.ts

@@ -0,0 +1,130 @@
+export declare function userMessage(conversationId: string, id: string): {
+    schemaVersion: 1;
+    id: string;
+    conversationId: string;
+    runId?: string | undefined;
+    role: "assistant" | "summary" | "system" | "tool" | "user";
+    status: "committed" | "completed" | "failed" | "interrupted" | "streaming" | "superseded";
+    parts: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "reasoning";
+        text: string;
+        provider?: {
+            schemaVersion: number;
+            provider: string;
+            data: Record<string, import("zod").JSONType>;
+        } | undefined;
+    } | {
+        type: "file";
+        mediaType: string;
+        reference: string;
+        filename?: string | undefined;
+    } | {
+        type: "source";
+        sourceId: string;
+        url?: string | undefined;
+        title?: string | undefined;
+    } | {
+        type: "tool-call";
+        callId: string;
+        toolName: string;
+        input: import("zod").JSONType;
+        provider?: {
+            schemaVersion: number;
+            provider: string;
+            data: Record<string, import("zod").JSONType>;
+        } | undefined;
+    } | {
+        type: "tool-result";
+        callId: string;
+        toolName: string;
+        outcome: "error" | "interrupted" | "success";
+        output?: import("zod").JSONType | undefined;
+    } | {
+        type: "tool-approval-request";
+        approvalId: string;
+        callId: string;
+        isAutomatic?: boolean | undefined;
+        signature?: string | undefined;
+    } | {
+        type: "tool-approval-response";
+        approvalId: string;
+        approved: boolean;
+        reason?: string | undefined;
+    } | {
+        type: "provider";
+        envelope: {
+            schemaVersion: number;
+            provider: string;
+            data: Record<string, import("zod").JSONType>;
+        };
+    } | {
+        type: "control";
+        reason: "run-interrupted" | "stale-run";
+    })[];
+    metadata?: Record<string, import("zod").JSONType> | undefined;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function queuedRun(conversationId: string, inputMessageId: string, id: string): {
+    schemaVersion: 1;
+    id: string;
+    conversationId: string;
+    inputMessageIds: string[];
+    assistantMessageId: string;
+    state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+    revision: number;
+    queuePriority?: "interrupt-next" | undefined;
+    executionSequence?: number | undefined;
+    ownerId?: string | undefined;
+    fencingToken?: number | undefined;
+    terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+    terminalPolicyName?: string | undefined;
+    absorbedIntoRunId?: string | undefined;
+    usage?: {
+        inputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        outputTokens: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        };
+        reasoningTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheReadTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cacheWriteTokens?: {
+            value?: number | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+        cost?: {
+            value?: number | undefined;
+            currency?: string | undefined;
+            provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+        } | undefined;
+    } | undefined;
+    lastOperation?: {
+        operationId: string;
+        kind: "compaction" | "model-request";
+        phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+        step?: number | undefined;
+        startedAt: string;
+        firstOutputAt?: string | undefined;
+        finishedAt?: string | undefined;
+    } | undefined;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function requireOutcome<OUTCOME extends string>(actual: {
+    outcome: string;
+}, expected: OUTCOME): asserts actual is {
+    outcome: OUTCOME;
+};
+//# sourceMappingURL=store-conformance-support.d.ts.map

package/dist/agent-runtime/store-conformance-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-conformance-support.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance-support.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7D;AAED,wBAAgB,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnF;AAED,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,EACnD,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAC3B,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,MAAM,IAAI;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAMxC"}