@lore-co/core 0.1.17 → 0.1.19

package/dist/snapshot-schemas.d.ts

@@ -0,0 +1,3503 @@
+import { z } from "zod";
+export declare const CONTEXT_SNAPSHOT_VERSION: "context-snapshot-v1";
+export declare const GUARD_POLICY_SNAPSHOT_VERSION: "guard-policy-snapshot-v1";
+export declare const CompactEd25519JwsSchema: z.ZodString;
+export type CompactEd25519Jws = z.infer<typeof CompactEd25519JwsSchema>;
+export declare const SnapshotJwsTypeSchema: z.ZodEnum<{
+    "lore-context-snapshot+jws": "lore-context-snapshot+jws";
+    "lore-guard-policy-snapshot+jws": "lore-guard-policy-snapshot+jws";
+}>;
+export type SnapshotJwsType = z.infer<typeof SnapshotJwsTypeSchema>;
+export declare const SnapshotJwsProtectedHeaderSchema: z.ZodObject<{
+    alg: z.ZodLiteral<"EdDSA">;
+    kid: z.ZodString;
+    typ: z.ZodEnum<{
+        "lore-context-snapshot+jws": "lore-context-snapshot+jws";
+        "lore-guard-policy-snapshot+jws": "lore-guard-policy-snapshot+jws";
+    }>;
+}, z.core.$strict>;
+export type SnapshotJwsProtectedHeader = z.infer<typeof SnapshotJwsProtectedHeaderSchema>;
+export declare const Ed25519PublicJwkSchema: z.ZodObject<{
+    kid: z.ZodString;
+    kty: z.ZodLiteral<"OKP">;
+    crv: z.ZodLiteral<"Ed25519">;
+    alg: z.ZodLiteral<"EdDSA">;
+    use: z.ZodLiteral<"sig">;
+    x: z.ZodString;
+}, z.core.$strict>;
+export type Ed25519PublicJwk = z.infer<typeof Ed25519PublicJwkSchema>;
+export declare const SnapshotPublicKeySchema: z.ZodObject<{
+    kid: z.ZodString;
+    kty: z.ZodLiteral<"OKP">;
+    crv: z.ZodLiteral<"Ed25519">;
+    alg: z.ZodLiteral<"EdDSA">;
+    use: z.ZodLiteral<"sig">;
+    x: z.ZodString;
+    notBefore: z.ZodISODateTime;
+    retiredAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type SnapshotPublicKey = z.infer<typeof SnapshotPublicKeySchema>;
+export declare const SnapshotPublicKeySetSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    workspaceId: z.ZodUUID;
+    algorithm: z.ZodLiteral<"Ed25519">;
+    currentKid: z.ZodString;
+    keys: z.ZodArray<z.ZodObject<{
+        kid: z.ZodString;
+        kty: z.ZodLiteral<"OKP">;
+        crv: z.ZodLiteral<"Ed25519">;
+        alg: z.ZodLiteral<"EdDSA">;
+        use: z.ZodLiteral<"sig">;
+        x: z.ZodString;
+        notBefore: z.ZodISODateTime;
+        retiredAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SnapshotPublicKeySet = z.infer<typeof SnapshotPublicKeySetSchema>;
+export declare const SignedContextPayloadSchema: z.ZodObject<{
+    policyVersion: z.ZodString;
+    requestId: z.ZodString;
+    requestHash: z.ZodString;
+    request: z.ZodObject<{
+        connector: z.ZodString;
+        eventId: z.ZodString;
+        sessionId: z.ZodString;
+        task: z.ZodObject<{
+            agent: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            task: z.ZodString;
+            diff: z.ZodOptional<z.ZodString>;
+            files: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+            components: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    eventId: z.ZodUUID;
+    receiptId: z.ZodUUID;
+    deliveredAt: z.ZodISODateTime;
+    context: z.ZodString;
+    memories: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        workspaceId: z.ZodOptional<z.ZodUUID>;
+        content: z.ZodString;
+        scope: z.ZodObject<{
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        category: z.ZodEnum<{
+            architecture: "architecture";
+            convention: "convention";
+            correction: "correction";
+            gotcha: "gotcha";
+            known_gotcha: "known_gotcha";
+            deprecated: "deprecated";
+            behavior: "behavior";
+            review_feedback: "review_feedback";
+            other: "other";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+            suppressed: "suppressed";
+            superseded: "superseded";
+            deleted: "deleted";
+        }>;
+        source: z.ZodObject<{
+            agent: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            eventId: z.ZodOptional<z.ZodUUID>;
+            userId: z.ZodOptional<z.ZodUUID>;
+            redacted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        confirmation: z.ZodOptional<z.ZodEnum<{
+            unconfirmed: "unconfirmed";
+            implicit: "implicit";
+            explicit: "explicit";
+        }>>;
+        enforcement: z.ZodOptional<z.ZodEnum<{
+            advisory: "advisory";
+            required: "required";
+        }>>;
+        reconciliationKey: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodString;
+        supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        deletedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    hits: z.ZodArray<z.ZodObject<{
+        memory: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        score: z.ZodNumber;
+        reasons: z.ZodArray<z.ZodEnum<{
+            symbol: "symbol";
+            path: "path";
+            lexical: "lexical";
+            semantic: "semantic";
+            component: "component";
+            repository: "repository";
+        }>>;
+        matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lexicalRank: z.ZodNullable<z.ZodNumber>;
+        semanticRank: z.ZodNullable<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            contractVersion: z.ZodLiteral<"explainability-v1">;
+            summary: z.ZodString;
+            reasons: z.ZodArray<z.ZodEnum<{
+                symbol: "symbol";
+                path: "path";
+                lexical: "lexical";
+                semantic: "semantic";
+                component: "component";
+                repository: "repository";
+            }>>;
+            matchedTerms: z.ZodArray<z.ZodString>;
+            provenance: z.ZodObject<{
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            freshness: z.ZodObject<{
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    packing: z.ZodObject<{
+        policyVersion: z.ZodLiteral<"context-pack-v1">;
+        estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+        limits: z.ZodObject<{
+            requestedItems: z.ZodNullable<z.ZodNumber>;
+            effectiveItems: z.ZodNumber;
+            maxCharacters: z.ZodNumber;
+            maxEstimatedTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        usage: z.ZodObject<{
+            retrievedItems: z.ZodNumber;
+            includedItems: z.ZodNumber;
+            omittedItems: z.ZodNumber;
+            characters: z.ZodNumber;
+            utf8Bytes: z.ZodNumber;
+            estimatedTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        includedMemoryIds: z.ZodArray<z.ZodUUID>;
+        omitted: z.ZodArray<z.ZodObject<{
+            memoryId: z.ZodUUID;
+            reason: z.ZodEnum<{
+                characters: "characters";
+                items: "items";
+                estimated_tokens: "estimated_tokens";
+            }>;
+        }, z.core.$strict>>;
+        contextSha256: z.ZodString;
+    }, z.core.$strict>;
+    issuedAt: z.ZodISODateTime;
+    asOf: z.ZodISODateTime;
+    validUntil: z.ZodISODateTime;
+    snapshotVersion: z.ZodLiteral<"context-snapshot-v1">;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    workspaceId: z.ZodUUID;
+    kind: z.ZodLiteral<"context">;
+}, z.core.$strict>;
+export type SignedContextPayload = z.infer<typeof SignedContextPayloadSchema>;
+export declare const GuardPolicyVersionSchema: z.ZodString;
+export type GuardPolicyVersion = z.infer<typeof GuardPolicyVersionSchema>;
+export declare const SnapshotRuleProvenanceSchema: z.ZodObject<{
+    agent: z.ZodString;
+    workspaceId: z.ZodUUID;
+    sessionId: z.ZodNullable<z.ZodString>;
+    messageId: z.ZodNullable<z.ZodString>;
+    eventId: z.ZodNullable<z.ZodUUID>;
+    userId: z.ZodNullable<z.ZodUUID>;
+    redacted: z.ZodBoolean;
+}, z.core.$strict>;
+export type SnapshotRuleProvenance = z.infer<typeof SnapshotRuleProvenanceSchema>;
+export declare const SnapshotRequiredRuleSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    fingerprint: z.ZodString;
+    content: z.ZodString;
+    category: z.ZodEnum<{
+        architecture: "architecture";
+        convention: "convention";
+        correction: "correction";
+        gotcha: "gotcha";
+        known_gotcha: "known_gotcha";
+        deprecated: "deprecated";
+        behavior: "behavior";
+        review_feedback: "review_feedback";
+        other: "other";
+    }>;
+    scope: z.ZodObject<{
+        organization: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+        component: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    status: z.ZodLiteral<"active">;
+    enforcement: z.ZodLiteral<"required">;
+    source: z.ZodObject<{
+        agent: z.ZodString;
+        workspaceId: z.ZodUUID;
+        sessionId: z.ZodNullable<z.ZodString>;
+        messageId: z.ZodNullable<z.ZodString>;
+        eventId: z.ZodNullable<z.ZodUUID>;
+        userId: z.ZodNullable<z.ZodUUID>;
+        redacted: z.ZodBoolean;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type SnapshotRequiredRule = z.infer<typeof SnapshotRequiredRuleSchema>;
+export declare const SignedGuardPolicyPayloadSchema: z.ZodObject<{
+    policyVersion: z.ZodString;
+    mode: z.ZodEnum<{
+        off: "off";
+        assist: "assist";
+        enforce: "enforce";
+    }>;
+    overrides: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    requiredRules: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        fingerprint: z.ZodString;
+        content: z.ZodString;
+        category: z.ZodEnum<{
+            architecture: "architecture";
+            convention: "convention";
+            correction: "correction";
+            gotcha: "gotcha";
+            known_gotcha: "known_gotcha";
+            deprecated: "deprecated";
+            behavior: "behavior";
+            review_feedback: "review_feedback";
+            other: "other";
+        }>;
+        scope: z.ZodObject<{
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        status: z.ZodLiteral<"active">;
+        enforcement: z.ZodLiteral<"required">;
+        source: z.ZodObject<{
+            agent: z.ZodString;
+            workspaceId: z.ZodUUID;
+            sessionId: z.ZodNullable<z.ZodString>;
+            messageId: z.ZodNullable<z.ZodString>;
+            eventId: z.ZodNullable<z.ZodUUID>;
+            userId: z.ZodNullable<z.ZodUUID>;
+            redacted: z.ZodBoolean;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+    asOf: z.ZodISODateTime;
+    validUntil: z.ZodISODateTime;
+    snapshotVersion: z.ZodLiteral<"guard-policy-snapshot-v1">;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    workspaceId: z.ZodUUID;
+    kind: z.ZodLiteral<"guard_policy">;
+}, z.core.$strict>;
+export type SignedGuardPolicyPayload = z.infer<typeof SignedGuardPolicyPayloadSchema>;
+export declare const SignedSnapshotPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    policyVersion: z.ZodString;
+    requestId: z.ZodString;
+    requestHash: z.ZodString;
+    request: z.ZodObject<{
+        connector: z.ZodString;
+        eventId: z.ZodString;
+        sessionId: z.ZodString;
+        task: z.ZodObject<{
+            agent: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            component: z.ZodOptional<z.ZodString>;
+            task: z.ZodString;
+            diff: z.ZodOptional<z.ZodString>;
+            files: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+            components: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    eventId: z.ZodUUID;
+    receiptId: z.ZodUUID;
+    deliveredAt: z.ZodISODateTime;
+    context: z.ZodString;
+    memories: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        workspaceId: z.ZodOptional<z.ZodUUID>;
+        content: z.ZodString;
+        scope: z.ZodObject<{
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        category: z.ZodEnum<{
+            architecture: "architecture";
+            convention: "convention";
+            correction: "correction";
+            gotcha: "gotcha";
+            known_gotcha: "known_gotcha";
+            deprecated: "deprecated";
+            behavior: "behavior";
+            review_feedback: "review_feedback";
+            other: "other";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+            suppressed: "suppressed";
+            superseded: "superseded";
+            deleted: "deleted";
+        }>;
+        source: z.ZodObject<{
+            agent: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            eventId: z.ZodOptional<z.ZodUUID>;
+            userId: z.ZodOptional<z.ZodUUID>;
+            redacted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        confirmation: z.ZodOptional<z.ZodEnum<{
+            unconfirmed: "unconfirmed";
+            implicit: "implicit";
+            explicit: "explicit";
+        }>>;
+        enforcement: z.ZodOptional<z.ZodEnum<{
+            advisory: "advisory";
+            required: "required";
+        }>>;
+        reconciliationKey: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodString;
+        supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        deletedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    hits: z.ZodArray<z.ZodObject<{
+        memory: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        score: z.ZodNumber;
+        reasons: z.ZodArray<z.ZodEnum<{
+            symbol: "symbol";
+            path: "path";
+            lexical: "lexical";
+            semantic: "semantic";
+            component: "component";
+            repository: "repository";
+        }>>;
+        matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lexicalRank: z.ZodNullable<z.ZodNumber>;
+        semanticRank: z.ZodNullable<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            contractVersion: z.ZodLiteral<"explainability-v1">;
+            summary: z.ZodString;
+            reasons: z.ZodArray<z.ZodEnum<{
+                symbol: "symbol";
+                path: "path";
+                lexical: "lexical";
+                semantic: "semantic";
+                component: "component";
+                repository: "repository";
+            }>>;
+            matchedTerms: z.ZodArray<z.ZodString>;
+            provenance: z.ZodObject<{
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            freshness: z.ZodObject<{
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    packing: z.ZodObject<{
+        policyVersion: z.ZodLiteral<"context-pack-v1">;
+        estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+        limits: z.ZodObject<{
+            requestedItems: z.ZodNullable<z.ZodNumber>;
+            effectiveItems: z.ZodNumber;
+            maxCharacters: z.ZodNumber;
+            maxEstimatedTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        usage: z.ZodObject<{
+            retrievedItems: z.ZodNumber;
+            includedItems: z.ZodNumber;
+            omittedItems: z.ZodNumber;
+            characters: z.ZodNumber;
+            utf8Bytes: z.ZodNumber;
+            estimatedTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        includedMemoryIds: z.ZodArray<z.ZodUUID>;
+        omitted: z.ZodArray<z.ZodObject<{
+            memoryId: z.ZodUUID;
+            reason: z.ZodEnum<{
+                characters: "characters";
+                items: "items";
+                estimated_tokens: "estimated_tokens";
+            }>;
+        }, z.core.$strict>>;
+        contextSha256: z.ZodString;
+    }, z.core.$strict>;
+    issuedAt: z.ZodISODateTime;
+    asOf: z.ZodISODateTime;
+    validUntil: z.ZodISODateTime;
+    snapshotVersion: z.ZodLiteral<"context-snapshot-v1">;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    workspaceId: z.ZodUUID;
+    kind: z.ZodLiteral<"context">;
+}, z.core.$strict>, z.ZodObject<{
+    policyVersion: z.ZodString;
+    mode: z.ZodEnum<{
+        off: "off";
+        assist: "assist";
+        enforce: "enforce";
+    }>;
+    overrides: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    requiredRules: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        fingerprint: z.ZodString;
+        content: z.ZodString;
+        category: z.ZodEnum<{
+            architecture: "architecture";
+            convention: "convention";
+            correction: "correction";
+            gotcha: "gotcha";
+            known_gotcha: "known_gotcha";
+            deprecated: "deprecated";
+            behavior: "behavior";
+            review_feedback: "review_feedback";
+            other: "other";
+        }>;
+        scope: z.ZodObject<{
+            organization: z.ZodOptional<z.ZodString>;
+            project: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+            component: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        status: z.ZodLiteral<"active">;
+        enforcement: z.ZodLiteral<"required">;
+        source: z.ZodObject<{
+            agent: z.ZodString;
+            workspaceId: z.ZodUUID;
+            sessionId: z.ZodNullable<z.ZodString>;
+            messageId: z.ZodNullable<z.ZodString>;
+            eventId: z.ZodNullable<z.ZodUUID>;
+            userId: z.ZodNullable<z.ZodUUID>;
+            redacted: z.ZodBoolean;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+    asOf: z.ZodISODateTime;
+    validUntil: z.ZodISODateTime;
+    snapshotVersion: z.ZodLiteral<"guard-policy-snapshot-v1">;
+    contractVersion: z.ZodLiteral<"reliability-v1">;
+    workspaceId: z.ZodUUID;
+    kind: z.ZodLiteral<"guard_policy">;
+}, z.core.$strict>], "kind">;
+export type SignedSnapshotPayload = z.infer<typeof SignedSnapshotPayloadSchema>;
+export declare const ReliableObservationResponseSchema: z.ZodObject<{
+    observation: z.ZodObject<{
+        memories: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        created: z.ZodNumber;
+        duplicates: z.ZodNumber;
+        reconciled: z.ZodNumber;
+        superseded: z.ZodNumber;
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+    }, z.core.$strict>;
+    capture: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        acknowledgement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"queued_local">;
+            durability: z.ZodLiteral<"local_machine">;
+            replayPending: z.ZodLiteral<true>;
+            replayed: z.ZodLiteral<false>;
+            processing: z.ZodLiteral<"pending_upload">;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"committed_server">;
+            durability: z.ZodLiteral<"workspace_database">;
+            replayPending: z.ZodLiteral<false>;
+            replayed: z.ZodBoolean;
+            processing: z.ZodEnum<{
+                pending_extraction: "pending_extraction";
+                completed: "completed";
+            }>;
+            eventId: z.ZodUUID;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>], "state">>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ReliableObservationResponse = z.infer<typeof ReliableObservationResponseSchema>;
+export declare const ReliableTurnResponseSchema: z.ZodObject<{
+    turn: z.ZodObject<{
+        requestId: z.ZodString;
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+        observation: z.ZodObject<{
+            memories: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+            created: z.ZodNumber;
+            duplicates: z.ZodNumber;
+            reconciled: z.ZodNumber;
+            superseded: z.ZodNumber;
+        }, z.core.$strict>;
+        context: z.ZodObject<{
+            memories: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memory: z.ZodObject<{
+                    id: z.ZodUUID;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    content: z.ZodString;
+                    scope: z.ZodObject<{
+                        organization: z.ZodOptional<z.ZodString>;
+                        project: z.ZodOptional<z.ZodString>;
+                        repo: z.ZodOptional<z.ZodString>;
+                        path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                        component: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    category: z.ZodEnum<{
+                        architecture: "architecture";
+                        convention: "convention";
+                        correction: "correction";
+                        gotcha: "gotcha";
+                        known_gotcha: "known_gotcha";
+                        deprecated: "deprecated";
+                        behavior: "behavior";
+                        review_feedback: "review_feedback";
+                        other: "other";
+                    }>;
+                    status: z.ZodEnum<{
+                        active: "active";
+                        proposed: "proposed";
+                        suppressed: "suppressed";
+                        superseded: "superseded";
+                        deleted: "deleted";
+                    }>;
+                    source: z.ZodObject<{
+                        agent: z.ZodString;
+                        sessionId: z.ZodOptional<z.ZodString>;
+                        messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        workspaceId: z.ZodOptional<z.ZodUUID>;
+                        eventId: z.ZodOptional<z.ZodUUID>;
+                        userId: z.ZodOptional<z.ZodUUID>;
+                        redacted: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                    confidence: z.ZodOptional<z.ZodNumber>;
+                    confirmation: z.ZodOptional<z.ZodEnum<{
+                        unconfirmed: "unconfirmed";
+                        implicit: "implicit";
+                        explicit: "explicit";
+                    }>>;
+                    enforcement: z.ZodOptional<z.ZodEnum<{
+                        advisory: "advisory";
+                        required: "required";
+                    }>>;
+                    reconciliationKey: z.ZodOptional<z.ZodString>;
+                    fingerprint: z.ZodString;
+                    supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                    suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                    deletedAt: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strict>;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                lexicalRank: z.ZodNullable<z.ZodNumber>;
+                semanticRank: z.ZodNullable<z.ZodNumber>;
+                explanation: z.ZodOptional<z.ZodObject<{
+                    contractVersion: z.ZodLiteral<"explainability-v1">;
+                    summary: z.ZodString;
+                    reasons: z.ZodArray<z.ZodEnum<{
+                        symbol: "symbol";
+                        path: "path";
+                        lexical: "lexical";
+                        semantic: "semantic";
+                        component: "component";
+                        repository: "repository";
+                    }>>;
+                    matchedTerms: z.ZodArray<z.ZodString>;
+                    provenance: z.ZodObject<{
+                        workspaceId: z.ZodOptional<z.ZodUUID>;
+                        agent: z.ZodString;
+                        sessionId: z.ZodOptional<z.ZodString>;
+                        messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        eventId: z.ZodOptional<z.ZodUUID>;
+                        userId: z.ZodOptional<z.ZodUUID>;
+                        redacted: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                    status: z.ZodEnum<{
+                        active: "active";
+                        proposed: "proposed";
+                        suppressed: "suppressed";
+                        superseded: "superseded";
+                        deleted: "deleted";
+                    }>;
+                    scope: z.ZodObject<{
+                        organization: z.ZodOptional<z.ZodString>;
+                        project: z.ZodOptional<z.ZodString>;
+                        repo: z.ZodOptional<z.ZodString>;
+                        path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                        component: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    freshness: z.ZodObject<{
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            text: z.ZodString;
+            packing: z.ZodOptional<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        receipt: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            eventId: z.ZodUUID;
+            requestId: z.ZodString;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            packing: z.ZodNullable<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+            querySha256: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retrievalPolicyVersion: z.ZodDefault<z.ZodString>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                fingerprint: z.ZodString;
+                content: z.ZodString;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            deliveredAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    capture: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        acknowledgement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"queued_local">;
+            durability: z.ZodLiteral<"local_machine">;
+            replayPending: z.ZodLiteral<true>;
+            replayed: z.ZodLiteral<false>;
+            processing: z.ZodLiteral<"pending_upload">;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"committed_server">;
+            durability: z.ZodLiteral<"workspace_database">;
+            replayPending: z.ZodLiteral<false>;
+            replayed: z.ZodBoolean;
+            processing: z.ZodEnum<{
+                pending_extraction: "pending_extraction";
+                completed: "completed";
+            }>;
+            eventId: z.ZodUUID;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>], "state">>;
+    }, z.core.$strict>;
+    retrieval: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    contextSnapshot: z.ZodString;
+}, z.core.$strict>;
+export type ReliableTurnResponse = z.infer<typeof ReliableTurnResponseSchema>;
+export declare const ReliableContextDeliveryResponseSchema: z.ZodObject<{
+    delivery: z.ZodObject<{
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        receipt: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            eventId: z.ZodUUID;
+            requestId: z.ZodString;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            packing: z.ZodNullable<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+            querySha256: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retrievalPolicyVersion: z.ZodDefault<z.ZodString>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                fingerprint: z.ZodString;
+                content: z.ZodString;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            deliveredAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+        memories: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            memory: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            score: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodEnum<{
+                symbol: "symbol";
+                path: "path";
+                lexical: "lexical";
+                semantic: "semantic";
+                component: "component";
+                repository: "repository";
+            }>>;
+            matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            lexicalRank: z.ZodNullable<z.ZodNumber>;
+            semanticRank: z.ZodNullable<z.ZodNumber>;
+            explanation: z.ZodOptional<z.ZodObject<{
+                contractVersion: z.ZodLiteral<"explainability-v1">;
+                summary: z.ZodString;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+                provenance: z.ZodObject<{
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                freshness: z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        context: z.ZodString;
+        packing: z.ZodObject<{
+            policyVersion: z.ZodLiteral<"context-pack-v1">;
+            estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+            limits: z.ZodObject<{
+                requestedItems: z.ZodNullable<z.ZodNumber>;
+                effectiveItems: z.ZodNumber;
+                maxCharacters: z.ZodNumber;
+                maxEstimatedTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            usage: z.ZodObject<{
+                retrievedItems: z.ZodNumber;
+                includedItems: z.ZodNumber;
+                omittedItems: z.ZodNumber;
+                characters: z.ZodNumber;
+                utf8Bytes: z.ZodNumber;
+                estimatedTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            includedMemoryIds: z.ZodArray<z.ZodUUID>;
+            omitted: z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                reason: z.ZodEnum<{
+                    characters: "characters";
+                    items: "items";
+                    estimated_tokens: "estimated_tokens";
+                }>;
+            }, z.core.$strict>>;
+            contextSha256: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    snapshot: z.ZodString;
+}, z.core.$strict>;
+export type ReliableContextDeliveryResponse = z.infer<typeof ReliableContextDeliveryResponseSchema>;
+export declare const ReliableGuardPolicyResponseSchema: z.ZodObject<{
+    policy: z.ZodObject<{
+        workspaceId: z.ZodUUID;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        overrides: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            mode: z.ZodEnum<{
+                off: "off";
+                assist: "assist";
+                enforce: "enforce";
+            }>;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    policyVersion: z.ZodString;
+    snapshot: z.ZodString;
+}, z.core.$strict>;
+export type ReliableGuardPolicyResponse = z.infer<typeof ReliableGuardPolicyResponseSchema>;
+export declare const ReliableGuardCheckResponseSchema: z.ZodObject<{
+    check: z.ZodObject<{
+        checkId: z.ZodUUID;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        modeSource: z.ZodEnum<{
+            workspace: "workspace";
+            repo_override: "repo_override";
+        }>;
+        relevant: z.ZodBoolean;
+        items: z.ZodArray<z.ZodObject<{
+            memoryId: z.ZodUUID;
+            content: z.ZodString;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            enforcement: z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodNullable<z.ZodString>;
+                userId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strict>;
+            reasons: z.ZodArray<z.ZodString>;
+            explanation: z.ZodOptional<z.ZodObject<{
+                contractVersion: z.ZodLiteral<"explainability-v1">;
+                summary: z.ZodString;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+                provenance: z.ZodObject<{
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                freshness: z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        conflicts: z.ZodArray<z.ZodObject<{
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            summary: z.ZodString;
+        }, z.core.$strict>>;
+        requiresConfirmation: z.ZodBoolean;
+        confirm: z.ZodOptional<z.ZodObject<{
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            command: z.ZodString;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    result: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            decision: z.ZodLiteral<"allow">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<false>;
+            matchedRuleIds: z.ZodArray<z.ZodUUID>;
+        }, z.core.$strict>, z.ZodObject<{
+            decision: z.ZodLiteral<"block">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<true>;
+            blockingRuleIds: z.ZodArray<z.ZodUUID>;
+            confirmation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"approval">;
+                command: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"break_glass">;
+                command: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            decision: z.ZodLiteral<"override">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<false>;
+            overriddenRuleIds: z.ZodArray<z.ZodUUID>;
+            override: z.ZodObject<{
+                id: z.ZodUUID;
+                reason: z.ZodString;
+                auditPending: z.ZodBoolean;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "decision">;
+    }, z.core.$strict>;
+    policyVersion: z.ZodString;
+    policySnapshot: z.ZodString;
+}, z.core.$strict>;
+export type ReliableGuardCheckResponse = z.infer<typeof ReliableGuardCheckResponseSchema>;
+export declare const ObservationReliabilityResponseSchema: z.ZodObject<{
+    observation: z.ZodObject<{
+        memories: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        created: z.ZodNumber;
+        duplicates: z.ZodNumber;
+        reconciled: z.ZodNumber;
+        superseded: z.ZodNumber;
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+    }, z.core.$strict>;
+    capture: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        acknowledgement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"queued_local">;
+            durability: z.ZodLiteral<"local_machine">;
+            replayPending: z.ZodLiteral<true>;
+            replayed: z.ZodLiteral<false>;
+            processing: z.ZodLiteral<"pending_upload">;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"committed_server">;
+            durability: z.ZodLiteral<"workspace_database">;
+            replayPending: z.ZodLiteral<false>;
+            replayed: z.ZodBoolean;
+            processing: z.ZodEnum<{
+                pending_extraction: "pending_extraction";
+                completed: "completed";
+            }>;
+            eventId: z.ZodUUID;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>], "state">>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const TurnReliabilityResponseSchema: z.ZodObject<{
+    turn: z.ZodObject<{
+        requestId: z.ZodString;
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+        observation: z.ZodObject<{
+            memories: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+            created: z.ZodNumber;
+            duplicates: z.ZodNumber;
+            reconciled: z.ZodNumber;
+            superseded: z.ZodNumber;
+        }, z.core.$strict>;
+        context: z.ZodObject<{
+            memories: z.ZodArray<z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memory: z.ZodObject<{
+                    id: z.ZodUUID;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    content: z.ZodString;
+                    scope: z.ZodObject<{
+                        organization: z.ZodOptional<z.ZodString>;
+                        project: z.ZodOptional<z.ZodString>;
+                        repo: z.ZodOptional<z.ZodString>;
+                        path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                        component: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    category: z.ZodEnum<{
+                        architecture: "architecture";
+                        convention: "convention";
+                        correction: "correction";
+                        gotcha: "gotcha";
+                        known_gotcha: "known_gotcha";
+                        deprecated: "deprecated";
+                        behavior: "behavior";
+                        review_feedback: "review_feedback";
+                        other: "other";
+                    }>;
+                    status: z.ZodEnum<{
+                        active: "active";
+                        proposed: "proposed";
+                        suppressed: "suppressed";
+                        superseded: "superseded";
+                        deleted: "deleted";
+                    }>;
+                    source: z.ZodObject<{
+                        agent: z.ZodString;
+                        sessionId: z.ZodOptional<z.ZodString>;
+                        messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        workspaceId: z.ZodOptional<z.ZodUUID>;
+                        eventId: z.ZodOptional<z.ZodUUID>;
+                        userId: z.ZodOptional<z.ZodUUID>;
+                        redacted: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                    confidence: z.ZodOptional<z.ZodNumber>;
+                    confirmation: z.ZodOptional<z.ZodEnum<{
+                        unconfirmed: "unconfirmed";
+                        implicit: "implicit";
+                        explicit: "explicit";
+                    }>>;
+                    enforcement: z.ZodOptional<z.ZodEnum<{
+                        advisory: "advisory";
+                        required: "required";
+                    }>>;
+                    reconciliationKey: z.ZodOptional<z.ZodString>;
+                    fingerprint: z.ZodString;
+                    supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                    suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                    deletedAt: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strict>;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                lexicalRank: z.ZodNullable<z.ZodNumber>;
+                semanticRank: z.ZodNullable<z.ZodNumber>;
+                explanation: z.ZodOptional<z.ZodObject<{
+                    contractVersion: z.ZodLiteral<"explainability-v1">;
+                    summary: z.ZodString;
+                    reasons: z.ZodArray<z.ZodEnum<{
+                        symbol: "symbol";
+                        path: "path";
+                        lexical: "lexical";
+                        semantic: "semantic";
+                        component: "component";
+                        repository: "repository";
+                    }>>;
+                    matchedTerms: z.ZodArray<z.ZodString>;
+                    provenance: z.ZodObject<{
+                        workspaceId: z.ZodOptional<z.ZodUUID>;
+                        agent: z.ZodString;
+                        sessionId: z.ZodOptional<z.ZodString>;
+                        messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        eventId: z.ZodOptional<z.ZodUUID>;
+                        userId: z.ZodOptional<z.ZodUUID>;
+                        redacted: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>;
+                    status: z.ZodEnum<{
+                        active: "active";
+                        proposed: "proposed";
+                        suppressed: "suppressed";
+                        superseded: "superseded";
+                        deleted: "deleted";
+                    }>;
+                    scope: z.ZodObject<{
+                        organization: z.ZodOptional<z.ZodString>;
+                        project: z.ZodOptional<z.ZodString>;
+                        repo: z.ZodOptional<z.ZodString>;
+                        path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                        component: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                    freshness: z.ZodObject<{
+                        createdAt: z.ZodISODateTime;
+                        updatedAt: z.ZodISODateTime;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            text: z.ZodString;
+            packing: z.ZodOptional<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        receipt: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            eventId: z.ZodUUID;
+            requestId: z.ZodString;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            packing: z.ZodNullable<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+            querySha256: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retrievalPolicyVersion: z.ZodDefault<z.ZodString>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                fingerprint: z.ZodString;
+                content: z.ZodString;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            deliveredAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    capture: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        acknowledgement: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"queued_local">;
+            durability: z.ZodLiteral<"local_machine">;
+            replayPending: z.ZodLiteral<true>;
+            replayed: z.ZodLiteral<false>;
+            processing: z.ZodLiteral<"pending_upload">;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"committed_server">;
+            durability: z.ZodLiteral<"workspace_database">;
+            replayPending: z.ZodLiteral<false>;
+            replayed: z.ZodBoolean;
+            processing: z.ZodEnum<{
+                pending_extraction: "pending_extraction";
+                completed: "completed";
+            }>;
+            eventId: z.ZodUUID;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            captureId: z.ZodUUID;
+            idempotencyKey: z.ZodString;
+            acknowledgedAt: z.ZodISODateTime;
+        }, z.core.$strict>], "state">>;
+    }, z.core.$strict>;
+    retrieval: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    contextSnapshot: z.ZodString;
+}, z.core.$strict>;
+export declare const ContextDeliveryReliabilityResponseSchema: z.ZodObject<{
+    delivery: z.ZodObject<{
+        event: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            connector: z.ZodString;
+            externalEventId: z.ZodString;
+            type: z.ZodEnum<{
+                observation: "observation";
+                paired_turn: "paired_turn";
+                context_delivery: "context_delivery";
+                guard_check: "guard_check";
+            }>;
+            agent: z.ZodString;
+            sessionId: z.ZodString;
+            conversationId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redacted: z.ZodBoolean;
+            requestId: z.ZodString;
+            occurredAt: z.ZodISODateTime;
+            receivedAt: z.ZodISODateTime;
+            actorUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        }, z.core.$strict>;
+        receipt: z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodUUID;
+            eventId: z.ZodUUID;
+            requestId: z.ZodString;
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            packing: z.ZodNullable<z.ZodObject<{
+                policyVersion: z.ZodLiteral<"context-pack-v1">;
+                estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+                limits: z.ZodObject<{
+                    requestedItems: z.ZodNullable<z.ZodNumber>;
+                    effectiveItems: z.ZodNumber;
+                    maxCharacters: z.ZodNumber;
+                    maxEstimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                usage: z.ZodObject<{
+                    retrievedItems: z.ZodNumber;
+                    includedItems: z.ZodNumber;
+                    omittedItems: z.ZodNumber;
+                    characters: z.ZodNumber;
+                    utf8Bytes: z.ZodNumber;
+                    estimatedTokens: z.ZodNumber;
+                }, z.core.$strict>;
+                includedMemoryIds: z.ZodArray<z.ZodUUID>;
+                omitted: z.ZodArray<z.ZodObject<{
+                    memoryId: z.ZodUUID;
+                    reason: z.ZodEnum<{
+                        characters: "characters";
+                        items: "items";
+                        estimated_tokens: "estimated_tokens";
+                    }>;
+                }, z.core.$strict>>;
+                contextSha256: z.ZodString;
+            }, z.core.$strict>>;
+            querySha256: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retrievalPolicyVersion: z.ZodDefault<z.ZodString>;
+            hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                fingerprint: z.ZodString;
+                content: z.ZodString;
+                score: z.ZodNumber;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            deliveredAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+        replayed: z.ZodBoolean;
+        memories: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            workspaceId: z.ZodOptional<z.ZodUUID>;
+            content: z.ZodString;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                proposed: "proposed";
+                suppressed: "suppressed";
+                superseded: "superseded";
+                deleted: "deleted";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                eventId: z.ZodOptional<z.ZodUUID>;
+                userId: z.ZodOptional<z.ZodUUID>;
+                redacted: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            confirmation: z.ZodOptional<z.ZodEnum<{
+                unconfirmed: "unconfirmed";
+                implicit: "implicit";
+                explicit: "explicit";
+            }>>;
+            enforcement: z.ZodOptional<z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>>;
+            reconciliationKey: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodString;
+            supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+            createdAt: z.ZodISODateTime;
+            updatedAt: z.ZodISODateTime;
+            suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+            deletedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        hits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            memory: z.ZodObject<{
+                id: z.ZodUUID;
+                workspaceId: z.ZodOptional<z.ZodUUID>;
+                content: z.ZodString;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                category: z.ZodEnum<{
+                    architecture: "architecture";
+                    convention: "convention";
+                    correction: "correction";
+                    gotcha: "gotcha";
+                    known_gotcha: "known_gotcha";
+                    deprecated: "deprecated";
+                    behavior: "behavior";
+                    review_feedback: "review_feedback";
+                    other: "other";
+                }>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                source: z.ZodObject<{
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+                confirmation: z.ZodOptional<z.ZodEnum<{
+                    unconfirmed: "unconfirmed";
+                    implicit: "implicit";
+                    explicit: "explicit";
+                }>>;
+                enforcement: z.ZodOptional<z.ZodEnum<{
+                    advisory: "advisory";
+                    required: "required";
+                }>>;
+                reconciliationKey: z.ZodOptional<z.ZodString>;
+                fingerprint: z.ZodString;
+                supersedesMemoryId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+                updatedAt: z.ZodISODateTime;
+                suppressedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+                deletedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            score: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodEnum<{
+                symbol: "symbol";
+                path: "path";
+                lexical: "lexical";
+                semantic: "semantic";
+                component: "component";
+                repository: "repository";
+            }>>;
+            matchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            lexicalRank: z.ZodNullable<z.ZodNumber>;
+            semanticRank: z.ZodNullable<z.ZodNumber>;
+            explanation: z.ZodOptional<z.ZodObject<{
+                contractVersion: z.ZodLiteral<"explainability-v1">;
+                summary: z.ZodString;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+                provenance: z.ZodObject<{
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                freshness: z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        context: z.ZodString;
+        packing: z.ZodObject<{
+            policyVersion: z.ZodLiteral<"context-pack-v1">;
+            estimator: z.ZodLiteral<"utf8-bytes-div-3-v1">;
+            limits: z.ZodObject<{
+                requestedItems: z.ZodNullable<z.ZodNumber>;
+                effectiveItems: z.ZodNumber;
+                maxCharacters: z.ZodNumber;
+                maxEstimatedTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            usage: z.ZodObject<{
+                retrievedItems: z.ZodNumber;
+                includedItems: z.ZodNumber;
+                omittedItems: z.ZodNumber;
+                characters: z.ZodNumber;
+                utf8Bytes: z.ZodNumber;
+                estimatedTokens: z.ZodNumber;
+            }, z.core.$strict>;
+            includedMemoryIds: z.ZodArray<z.ZodUUID>;
+            omitted: z.ZodArray<z.ZodObject<{
+                memoryId: z.ZodUUID;
+                reason: z.ZodEnum<{
+                    characters: "characters";
+                    items: "items";
+                    estimated_tokens: "estimated_tokens";
+                }>;
+            }, z.core.$strict>>;
+            contextSha256: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    snapshot: z.ZodString;
+}, z.core.$strict>;
+export declare const GuardPolicyReliabilityResponseSchema: z.ZodObject<{
+    policy: z.ZodObject<{
+        workspaceId: z.ZodUUID;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        overrides: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            mode: z.ZodEnum<{
+                off: "off";
+                assist: "assist";
+                enforce: "enforce";
+            }>;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    reliability: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"reliability-v1">;
+        operation: z.ZodEnum<{
+            capture: "capture";
+            retrieval: "retrieval";
+            guard: "guard";
+        }>;
+        status: z.ZodEnum<{
+            ok: "ok";
+            degraded: "degraded";
+            blocked: "blocked";
+            overridden: "overridden";
+            failed: "failed";
+        }>;
+        source: z.ZodEnum<{
+            live: "live";
+            cache: "cache";
+            local_queue: "local_queue";
+            none: "none";
+        }>;
+        freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"fresh">;
+        }, z.core.$strict>, z.ZodObject<{
+            asOf: z.ZodISODateTime;
+            ageMs: z.ZodNumber;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+            state: z.ZodLiteral<"stale">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            asOf: z.ZodNull;
+            ageMs: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "state">;
+        fallback: z.ZodEnum<{
+            local_queue: "local_queue";
+            none: "none";
+            live_lexical: "live_lexical";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            break_glass: "break_glass";
+        }>;
+        policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"live">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"cache">;
+            version: z.ZodString;
+            loadedAt: z.ZodISODateTime;
+            validUntil: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"none">;
+            version: z.ZodNull;
+            loadedAt: z.ZodNull;
+            validUntil: z.ZodNull;
+        }, z.core.$strict>], "source">;
+        reasons: z.ZodArray<z.ZodEnum<{
+            semantic_unavailable: "semantic_unavailable";
+            cached_context: "cached_context";
+            cached_policy: "cached_policy";
+            live_success: "live_success";
+            idempotent_replay: "idempotent_replay";
+            lexical_fallback: "lexical_fallback";
+            live_unavailable: "live_unavailable";
+            no_usable_cache: "no_usable_cache";
+            capture_queued: "capture_queued";
+            local_persistence_failed: "local_persistence_failed";
+            governed_rule: "governed_rule";
+            policy_unavailable: "policy_unavailable";
+            policy_expired: "policy_expired";
+            user_override: "user_override";
+            invalid_response: "invalid_response";
+            integration_unsupported: "integration_unsupported";
+        }>>;
+        requestId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    policyVersion: z.ZodString;
+    snapshot: z.ZodString;
+}, z.core.$strict>;
+export declare const GuardCheckReliabilityResponseSchema: z.ZodObject<{
+    check: z.ZodObject<{
+        checkId: z.ZodUUID;
+        mode: z.ZodEnum<{
+            off: "off";
+            assist: "assist";
+            enforce: "enforce";
+        }>;
+        modeSource: z.ZodEnum<{
+            workspace: "workspace";
+            repo_override: "repo_override";
+        }>;
+        relevant: z.ZodBoolean;
+        items: z.ZodArray<z.ZodObject<{
+            memoryId: z.ZodUUID;
+            content: z.ZodString;
+            category: z.ZodEnum<{
+                architecture: "architecture";
+                convention: "convention";
+                correction: "correction";
+                gotcha: "gotcha";
+                known_gotcha: "known_gotcha";
+                deprecated: "deprecated";
+                behavior: "behavior";
+                review_feedback: "review_feedback";
+                other: "other";
+            }>;
+            scope: z.ZodObject<{
+                organization: z.ZodOptional<z.ZodString>;
+                project: z.ZodOptional<z.ZodString>;
+                repo: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                component: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            enforcement: z.ZodEnum<{
+                advisory: "advisory";
+                required: "required";
+            }>;
+            source: z.ZodObject<{
+                agent: z.ZodString;
+                sessionId: z.ZodNullable<z.ZodString>;
+                userId: z.ZodNullable<z.ZodUUID>;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strict>;
+            reasons: z.ZodArray<z.ZodString>;
+            explanation: z.ZodOptional<z.ZodObject<{
+                contractVersion: z.ZodLiteral<"explainability-v1">;
+                summary: z.ZodString;
+                reasons: z.ZodArray<z.ZodEnum<{
+                    symbol: "symbol";
+                    path: "path";
+                    lexical: "lexical";
+                    semantic: "semantic";
+                    component: "component";
+                    repository: "repository";
+                }>>;
+                matchedTerms: z.ZodArray<z.ZodString>;
+                provenance: z.ZodObject<{
+                    workspaceId: z.ZodOptional<z.ZodUUID>;
+                    agent: z.ZodString;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    messageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    eventId: z.ZodOptional<z.ZodUUID>;
+                    userId: z.ZodOptional<z.ZodUUID>;
+                    redacted: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    proposed: "proposed";
+                    suppressed: "suppressed";
+                    superseded: "superseded";
+                    deleted: "deleted";
+                }>;
+                scope: z.ZodObject<{
+                    organization: z.ZodOptional<z.ZodString>;
+                    project: z.ZodOptional<z.ZodString>;
+                    repo: z.ZodOptional<z.ZodString>;
+                    path: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                    component: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                freshness: z.ZodObject<{
+                    createdAt: z.ZodISODateTime;
+                    updatedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        conflicts: z.ZodArray<z.ZodObject<{
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            summary: z.ZodString;
+        }, z.core.$strict>>;
+        requiresConfirmation: z.ZodBoolean;
+        confirm: z.ZodOptional<z.ZodObject<{
+            memoryIds: z.ZodArray<z.ZodUUID>;
+            command: z.ZodString;
+            expiresAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    result: z.ZodObject<{
+        reliability: z.ZodObject<{
+            contractVersion: z.ZodLiteral<"reliability-v1">;
+            operation: z.ZodEnum<{
+                capture: "capture";
+                retrieval: "retrieval";
+                guard: "guard";
+            }>;
+            status: z.ZodEnum<{
+                ok: "ok";
+                degraded: "degraded";
+                blocked: "blocked";
+                overridden: "overridden";
+                failed: "failed";
+            }>;
+            source: z.ZodEnum<{
+                live: "live";
+                cache: "cache";
+                local_queue: "local_queue";
+                none: "none";
+            }>;
+            freshness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"fresh">;
+            }, z.core.$strict>, z.ZodObject<{
+                asOf: z.ZodISODateTime;
+                ageMs: z.ZodNumber;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+                state: z.ZodLiteral<"stale">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                asOf: z.ZodNull;
+                ageMs: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "state">;
+            fallback: z.ZodEnum<{
+                local_queue: "local_queue";
+                none: "none";
+                live_lexical: "live_lexical";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                break_glass: "break_glass";
+            }>;
+            policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"live">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"cache">;
+                version: z.ZodString;
+                loadedAt: z.ZodISODateTime;
+                validUntil: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"none">;
+                version: z.ZodNull;
+                loadedAt: z.ZodNull;
+                validUntil: z.ZodNull;
+            }, z.core.$strict>], "source">;
+            reasons: z.ZodArray<z.ZodEnum<{
+                semantic_unavailable: "semantic_unavailable";
+                cached_context: "cached_context";
+                cached_policy: "cached_policy";
+                live_success: "live_success";
+                idempotent_replay: "idempotent_replay";
+                lexical_fallback: "lexical_fallback";
+                live_unavailable: "live_unavailable";
+                no_usable_cache: "no_usable_cache";
+                capture_queued: "capture_queued";
+                local_persistence_failed: "local_persistence_failed";
+                governed_rule: "governed_rule";
+                policy_unavailable: "policy_unavailable";
+                policy_expired: "policy_expired";
+                user_override: "user_override";
+                invalid_response: "invalid_response";
+                integration_unsupported: "integration_unsupported";
+            }>>;
+            requestId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        verdict: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            decision: z.ZodLiteral<"allow">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<false>;
+            matchedRuleIds: z.ZodArray<z.ZodUUID>;
+        }, z.core.$strict>, z.ZodObject<{
+            decision: z.ZodLiteral<"block">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<true>;
+            blockingRuleIds: z.ZodArray<z.ZodUUID>;
+            confirmation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"approval">;
+                command: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"break_glass">;
+                command: z.ZodString;
+                expiresAt: z.ZodISODateTime;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            decision: z.ZodLiteral<"override">;
+            checkId: z.ZodUUID;
+            requiresConfirmation: z.ZodLiteral<false>;
+            overriddenRuleIds: z.ZodArray<z.ZodUUID>;
+            override: z.ZodObject<{
+                id: z.ZodUUID;
+                reason: z.ZodString;
+                auditPending: z.ZodBoolean;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "decision">;
+    }, z.core.$strict>;
+    policyVersion: z.ZodString;
+    policySnapshot: z.ZodString;
+}, z.core.$strict>;
+//# sourceMappingURL=snapshot-schemas.d.ts.map