stitchkit 0.94.0 → 0.94.1

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"}

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

@@ -0,0 +1,12 @@
+/**
+ * How a run ends in the conformance kit: a terminal race that exactly one
+ * commit wins, and an abandoned run terminalized atomically.
+ */
+import { type AgentRun } from './schemas.js';
+import type { AgentRuntimeStore } from './store.js';
+import type { fencingPhase } from './store-conformance-lifecycle.js';
+/** Two terminal commits race and exactly one applies; the result survives compaction. */
+export declare function terminalPhase(store: AgentRuntimeStore, conversationId: string, checkpointed: Awaited<ReturnType<typeof fencingPhase>>, interruptedRun: AgentRun): Promise<void>;
+/** An abandoned run is terminalized atomically and leaves the recoverable index. */
+export declare function abandonPhase(store: AgentRuntimeStore, recoveryConversationId: string): Promise<void>;
+//# sourceMappingURL=store-conformance-terminal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-conformance-terminal.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance-terminal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAsB,KAAK,QAAQ,EAAmB,MAAM,WAAW,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGlE,yFAAyF;AACzF,wBAAsB,aAAa,CACjC,KAAK,EAAE,iBAAiB,EACxB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,EACtD,cAAc,EAAE,QAAQ,GACvB,OAAO,CAAC,IAAI,CAAC,CAsFf;AAED,oFAAoF;AACpF,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,EACxB,sBAAsB,EAAE,MAAM,GAC7B,OAAO,CAAC,IAAI,CAAC,CAmDf"}

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

@@ -1 +1 @@
-{"version":3,"file":"store-conformance.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAIjD;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAqCf"}
+{"version":3,"file":"store-conformance.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAkBjD;;;;;;;;;GASG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,WAAW,CACT,OAAO,EAAE,4BAA4B,GACpC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAClD;;;;;;;;OAQG;IACH,OAAO,CAAC,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvE;AAED,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAqCf"}

package/dist/application/admission-rate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The sliding windows behind admission's rate budgets: samples expire after
+ * their interval, and a refusal says how long until the oldest one does.
+ */
+import type { BoundedAdmissionPerKeyLimits, BoundedAdmissionPolicy, BoundedRateBudget } from './admission.js';
+export interface RateSample {
+    readonly at: number;
+}
+export interface KeyRecord {
+    active: number;
+    readonly rate: RateSample[];
+    /** Resolved once when this record was created; dropped with it on eviction. */
+    readonly limits: BoundedAdmissionPerKeyLimits | undefined;
+}
+/** Drop expired samples everywhere, and every key that holds nothing any more. */
+export declare function pruneExpired(policy: BoundedAdmissionPolicy, globalRate: RateSample[], keys: Map<string, KeyRecord>, at: number): void;
+/** Milliseconds until the oldest sample leaves its window — at least one. */
+export declare function retryAfter(samples: RateSample[], budget: BoundedRateBudget, at: number): number;
+/** Take back one reserved sample, if it is still in its window. */
+export declare function removeSample(samples: RateSample[], sample: RateSample | undefined): void;
+//# sourceMappingURL=admission-rate.d.ts.map

package/dist/application/admission-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission-rate.d.ts","sourceRoot":"","sources":["../../src/application/admission-rate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EACV,4BAA4B,EAC5B,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,4BAA4B,GAAG,SAAS,CAAC;CAC3D;AAUD,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,sBAAsB,EAC9B,UAAU,EAAE,UAAU,EAAE,EACxB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC5B,EAAE,EAAE,MAAM,GACT,IAAI,CAMN;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CACxB,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,EAAE,iBAAiB,EACzB,EAAE,EAAE,MAAM,GACT,MAAM,CAER;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,CAIxF"}

package/dist/application/admission-run.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An operation run under one admission lease, waited for within a deadline and
+ * a caller's signal. The lease is released when the WORK settles, not when the
+ * caller stops waiting: an abandoned wait never frees capacity the work holds.
+ */
+import { type BoundedAdmissionResult, type BoundedOperationRunContext, type BoundedOperationRunOptions } from './admission.js';
+export declare function runAdmitted<T>(acquire: (key?: string) => BoundedAdmissionResult, key: string | undefined, work: (context: BoundedOperationRunContext) => T | Promise<T>, options: BoundedOperationRunOptions): Promise<T>;
+//# sourceMappingURL=admission-run.d.ts.map

package/dist/application/admission-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission-run.d.ts","sourceRoot":"","sources":["../../src/application/admission-run.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAEhC,MAAM,aAAa,CAAC;AAErB,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,sBAAsB,EACjD,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC7D,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,CAAC,CAAC,CAgDZ"}