@quantiya/codevibe-core 2.0.89 → 2.0.91

package/dist/companion-mode/codex-native-state.d.ts

@@ -0,0 +1,1544 @@
+import { z } from 'zod';
+import type { ConfirmDesktopSyncRetirementInput } from '../appsync/sync-session-retirement';
+declare const scopeSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodString;
+    expectedSessionKeyGen: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sessionId: string;
+    sessionGenerationId: string;
+    expectedSessionKeyGen: string;
+}, {
+    sessionId: string;
+    sessionGenerationId: string;
+    expectedSessionKeyGen: string;
+}>;
+declare const stableSchema: z.ZodObject<{
+    userId: z.ZodString;
+    environment: z.ZodEnum<["development", "production"]>;
+    deviceId: z.ZodString;
+    nativeThreadId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    deviceId: string;
+    environment: "production" | "development";
+    userId: string;
+    nativeThreadId: string;
+}, {
+    deviceId: string;
+    environment: "production" | "development";
+    userId: string;
+    nativeThreadId: string;
+}>;
+declare const ownerSchema: z.ZodObject<{
+    token: z.ZodString;
+    pid: z.ZodNumber;
+    host: z.ZodString;
+    scope: z.ZodObject<{
+        sessionId: z.ZodString;
+        sessionGenerationId: z.ZodString;
+        expectedSessionKeyGen: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    host: string;
+    pid: number;
+    token: string;
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+}, {
+    host: string;
+    pid: number;
+    token: string;
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+}>;
+declare const eventSchema: z.ZodObject<{
+    eventId: z.ZodEffects<z.ZodString, string, string>;
+    timestamp: z.ZodString;
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodNullable<z.ZodString>;
+    syncLifecycleVersion: z.ZodOptional<z.ZodLiteral<1>>;
+    source: z.ZodLiteral<"MOBILE">;
+    type: z.ZodEnum<["USER_PROMPT", "PROMPT_RESPONSE"]>;
+    payloadJson: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    source: "MOBILE";
+    eventId: string;
+    sessionId: string;
+    sessionGenerationId: string | null;
+    type: "USER_PROMPT" | "PROMPT_RESPONSE";
+    timestamp: string;
+    payloadJson: string;
+    syncLifecycleVersion?: 1 | undefined;
+}, {
+    source: "MOBILE";
+    eventId: string;
+    sessionId: string;
+    sessionGenerationId: string | null;
+    type: "USER_PROMPT" | "PROMPT_RESPONSE";
+    timestamp: string;
+    payloadJson: string;
+    syncLifecycleVersion?: 1 | undefined;
+}>;
+declare const approvalDecisionSchema: z.ZodUnion<[z.ZodEnum<["accept", "acceptForSession", "cancel", "decline"]>, z.ZodObject<{
+    acceptWithExecpolicyAmendment: z.ZodObject<{
+        execpolicy_amendment: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        execpolicy_amendment: string[];
+    }, {
+        execpolicy_amendment: string[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    acceptWithExecpolicyAmendment: {
+        execpolicy_amendment: string[];
+    };
+}, {
+    acceptWithExecpolicyAmendment: {
+        execpolicy_amendment: string[];
+    };
+}>]>;
+declare const controlSchema: z.ZodObject<{
+    key: z.ZodString;
+    scope: z.ZodObject<{
+        sessionId: z.ZodString;
+        sessionGenerationId: z.ZodString;
+        expectedSessionKeyGen: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }>;
+    nativeInstanceId: z.ZodString;
+    threadId: z.ZodString;
+    turnId: z.ZodString;
+    itemId: z.ZodString;
+    kind: z.ZodEnum<["async", "command", "file"]>;
+    detailsJson: z.ZodString;
+    raiseJson: z.ZodString;
+    state: z.ZodEnum<["OPEN", "PAUSED", "UNCERTAIN", "RESOLVED", "SESSION_ENDED", "REHOMED"]>;
+    cloudResolved: z.ZodBoolean;
+    nativeResolutionSha256: z.ZodNullable<z.ZodString>;
+    nativeResolutionJson: z.ZodNullable<z.ZodString>;
+    answerEventId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+}, "strict", z.ZodTypeAny, {
+    kind: "file" | "command" | "async";
+    key: string;
+    state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+    turnId: string;
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+    nativeInstanceId: string;
+    threadId: string;
+    itemId: string;
+    detailsJson: string;
+    raiseJson: string;
+    cloudResolved: boolean;
+    nativeResolutionSha256: string | null;
+    nativeResolutionJson: string | null;
+    answerEventId: string | null;
+}, {
+    kind: "file" | "command" | "async";
+    key: string;
+    state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+    turnId: string;
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+    nativeInstanceId: string;
+    threadId: string;
+    itemId: string;
+    detailsJson: string;
+    raiseJson: string;
+    cloudResolved: boolean;
+    nativeResolutionSha256: string | null;
+    nativeResolutionJson: string | null;
+    answerEventId: string | null;
+}>;
+declare const rejectionSchema: z.ZodObject<{
+    event: z.ZodObject<Omit<{
+        eventId: z.ZodEffects<z.ZodString, string, string>;
+        timestamp: z.ZodString;
+        sessionId: z.ZodString;
+        sessionGenerationId: z.ZodNullable<z.ZodString>;
+        syncLifecycleVersion: z.ZodOptional<z.ZodLiteral<1>>;
+        source: z.ZodLiteral<"MOBILE">;
+        type: z.ZodEnum<["USER_PROMPT", "PROMPT_RESPONSE"]>;
+        payloadJson: z.ZodString;
+    }, "payloadJson">, "strict", z.ZodTypeAny, {
+        source: "MOBILE";
+        eventId: string;
+        sessionId: string;
+        sessionGenerationId: string | null;
+        type: "USER_PROMPT" | "PROMPT_RESPONSE";
+        timestamp: string;
+        syncLifecycleVersion?: 1 | undefined;
+    }, {
+        source: "MOBILE";
+        eventId: string;
+        sessionId: string;
+        sessionGenerationId: string | null;
+        type: "USER_PROMPT" | "PROMPT_RESPONSE";
+        timestamp: string;
+        syncLifecycleVersion?: 1 | undefined;
+    }>;
+    eventSha256: z.ZodString;
+    scope: z.ZodObject<{
+        sessionId: z.ZodString;
+        sessionGenerationId: z.ZodString;
+        expectedSessionKeyGen: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }, {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    }>;
+    controlKey: z.ZodNullable<z.ZodString>;
+    winningEventId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    reason: z.ZodEnum<["ALREADY_ANSWERED", "NOT_APPLIED"]>;
+    raiseJson: z.ZodString;
+    noticeOutcome: z.ZodEnum<["MISSING", "ACCEPTED", "OMITTED"]>;
+    noticeResolved: z.ZodBoolean;
+    cloudDelivered: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+    event: {
+        source: "MOBILE";
+        eventId: string;
+        sessionId: string;
+        sessionGenerationId: string | null;
+        type: "USER_PROMPT" | "PROMPT_RESPONSE";
+        timestamp: string;
+        syncLifecycleVersion?: 1 | undefined;
+    };
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+    eventSha256: string;
+    controlKey: string | null;
+    raiseJson: string;
+    winningEventId: string | null;
+    noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+    noticeResolved: boolean;
+    cloudDelivered: boolean;
+}, {
+    reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+    event: {
+        source: "MOBILE";
+        eventId: string;
+        sessionId: string;
+        sessionGenerationId: string | null;
+        type: "USER_PROMPT" | "PROMPT_RESPONSE";
+        timestamp: string;
+        syncLifecycleVersion?: 1 | undefined;
+    };
+    scope: {
+        sessionId: string;
+        sessionGenerationId: string;
+        expectedSessionKeyGen: string;
+    };
+    eventSha256: string;
+    controlKey: string | null;
+    raiseJson: string;
+    winningEventId: string | null;
+    noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+    noticeResolved: boolean;
+    cloudDelivered: boolean;
+}>;
+declare const recordSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stable: z.ZodObject<{
+        userId: z.ZodString;
+        environment: z.ZodEnum<["development", "production"]>;
+        deviceId: z.ZodString;
+        nativeThreadId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        deviceId: string;
+        environment: "production" | "development";
+        userId: string;
+        nativeThreadId: string;
+    }, {
+        deviceId: string;
+        environment: "production" | "development";
+        userId: string;
+        nativeThreadId: string;
+    }>;
+    revision: z.ZodNumber;
+    owner: z.ZodObject<{
+        token: z.ZodString;
+        pid: z.ZodNumber;
+        host: z.ZodString;
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        host: string;
+        pid: number;
+        token: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+    }, {
+        host: string;
+        pid: number;
+        token: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+    }>;
+    handoffTo: z.ZodNullable<z.ZodString>;
+    scopes: z.ZodArray<z.ZodObject<{
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+        state: z.ZodEnum<["OPEN", "CLOSED"]>;
+        closureReason: z.ZodOptional<z.ZodEnum<["TERMINAL", "BACKEND_REPLACED"]>>;
+    }, "strict", z.ZodTypeAny, {
+        state: "CLOSED" | "OPEN";
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        closureReason?: "TERMINAL" | "BACKEND_REPLACED" | undefined;
+    }, {
+        state: "CLOSED" | "OPEN";
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        closureReason?: "TERMINAL" | "BACKEND_REPLACED" | undefined;
+    }>, "many">;
+    entries: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"INPUT">;
+        phase: z.ZodEnum<["PREPARED", "ATTEMPTED", "UNCERTAIN", "RECEIPTED"]>;
+        bodyJson: z.ZodString;
+        event: z.ZodObject<{
+            eventId: z.ZodEffects<z.ZodString, string, string>;
+            timestamp: z.ZodString;
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodNullable<z.ZodString>;
+            syncLifecycleVersion: z.ZodOptional<z.ZodLiteral<1>>;
+            source: z.ZodLiteral<"MOBILE">;
+            type: z.ZodEnum<["USER_PROMPT", "PROMPT_RESPONSE"]>;
+            payloadJson: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }>;
+        eventSha256: z.ZodString;
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+        binding: z.ZodObject<{
+            kind: z.ZodEnum<["user", "async", "approval"]>;
+            threadId: z.ZodString;
+            nativeId: z.ZodString;
+            turnId: z.ZodNullable<z.ZodString>;
+            intentSha256: z.ZodString;
+            receiptMatchSha256: z.ZodString;
+            approval: z.ZodNullable<z.ZodObject<{
+                nativeInstanceId: z.ZodString;
+                requestId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+                method: z.ZodEnum<["command", "file"]>;
+                decision: z.ZodUnion<[z.ZodEnum<["accept", "acceptForSession", "cancel", "decline"]>, z.ZodObject<{
+                    acceptWithExecpolicyAmendment: z.ZodObject<{
+                        execpolicy_amendment: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+                    }, "strict", z.ZodTypeAny, {
+                        execpolicy_amendment: string[];
+                    }, {
+                        execpolicy_amendment: string[];
+                    }>;
+                }, "strict", z.ZodTypeAny, {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                }, {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                }>]>;
+                detailsSha256: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            }, {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        }, {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        }>;
+        controlKey: z.ZodNullable<z.ZodString>;
+        cloudAck: z.ZodEnum<["MISSING", "EXECUTED"]>;
+        nativeReceiptSha256: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "INPUT";
+        phase: "ATTEMPTED" | "UNCERTAIN" | "PREPARED" | "RECEIPTED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        bodyJson: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    }, {
+        kind: "INPUT";
+        phase: "ATTEMPTED" | "UNCERTAIN" | "PREPARED" | "RECEIPTED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        bodyJson: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    }>, z.ZodObject<{
+        event: z.ZodObject<Omit<{
+            eventId: z.ZodEffects<z.ZodString, string, string>;
+            timestamp: z.ZodString;
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodNullable<z.ZodString>;
+            syncLifecycleVersion: z.ZodOptional<z.ZodLiteral<1>>;
+            source: z.ZodLiteral<"MOBILE">;
+            type: z.ZodEnum<["USER_PROMPT", "PROMPT_RESPONSE"]>;
+            payloadJson: z.ZodString;
+        }, "payloadJson">, "strict", z.ZodTypeAny, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }>;
+        kind: z.ZodLiteral<"RETIRED_EVIDENCE">;
+        outcome: z.ZodEnum<["NATIVE_CONFIRMED", "NOT_SENT", "UNKNOWN"]>;
+        eventSha256: z.ZodString;
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+        binding: z.ZodObject<{
+            kind: z.ZodEnum<["user", "async", "approval"]>;
+            threadId: z.ZodString;
+            nativeId: z.ZodString;
+            turnId: z.ZodNullable<z.ZodString>;
+            intentSha256: z.ZodString;
+            receiptMatchSha256: z.ZodString;
+            approval: z.ZodNullable<z.ZodObject<{
+                nativeInstanceId: z.ZodString;
+                requestId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+                method: z.ZodEnum<["command", "file"]>;
+                decision: z.ZodUnion<[z.ZodEnum<["accept", "acceptForSession", "cancel", "decline"]>, z.ZodObject<{
+                    acceptWithExecpolicyAmendment: z.ZodObject<{
+                        execpolicy_amendment: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+                    }, "strict", z.ZodTypeAny, {
+                        execpolicy_amendment: string[];
+                    }, {
+                        execpolicy_amendment: string[];
+                    }>;
+                }, "strict", z.ZodTypeAny, {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                }, {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                }>]>;
+                detailsSha256: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            }, {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        }, {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        }>;
+        controlKey: z.ZodNullable<z.ZodString>;
+        cloudAck: z.ZodEnum<["MISSING", "EXECUTED"]>;
+        nativeReceiptSha256: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "RETIRED_EVIDENCE";
+        outcome: "NATIVE_CONFIRMED" | "NOT_SENT" | "UNKNOWN";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    }, {
+        kind: "RETIRED_EVIDENCE";
+        outcome: "NATIVE_CONFIRMED" | "NOT_SENT" | "UNKNOWN";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    }>]>, "many">;
+    controls: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+        nativeInstanceId: z.ZodString;
+        threadId: z.ZodString;
+        turnId: z.ZodString;
+        itemId: z.ZodString;
+        kind: z.ZodEnum<["async", "command", "file"]>;
+        detailsJson: z.ZodString;
+        raiseJson: z.ZodString;
+        state: z.ZodEnum<["OPEN", "PAUSED", "UNCERTAIN", "RESOLVED", "SESSION_ENDED", "REHOMED"]>;
+        cloudResolved: z.ZodBoolean;
+        nativeResolutionSha256: z.ZodNullable<z.ZodString>;
+        nativeResolutionJson: z.ZodNullable<z.ZodString>;
+        answerEventId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "file" | "command" | "async";
+        key: string;
+        state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+        turnId: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        nativeInstanceId: string;
+        threadId: string;
+        itemId: string;
+        detailsJson: string;
+        raiseJson: string;
+        cloudResolved: boolean;
+        nativeResolutionSha256: string | null;
+        nativeResolutionJson: string | null;
+        answerEventId: string | null;
+    }, {
+        kind: "file" | "command" | "async";
+        key: string;
+        state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+        turnId: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        nativeInstanceId: string;
+        threadId: string;
+        itemId: string;
+        detailsJson: string;
+        raiseJson: string;
+        cloudResolved: boolean;
+        nativeResolutionSha256: string | null;
+        nativeResolutionJson: string | null;
+        answerEventId: string | null;
+    }>, "many">;
+    rejections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        event: z.ZodObject<Omit<{
+            eventId: z.ZodEffects<z.ZodString, string, string>;
+            timestamp: z.ZodString;
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodNullable<z.ZodString>;
+            syncLifecycleVersion: z.ZodOptional<z.ZodLiteral<1>>;
+            source: z.ZodLiteral<"MOBILE">;
+            type: z.ZodEnum<["USER_PROMPT", "PROMPT_RESPONSE"]>;
+            payloadJson: z.ZodString;
+        }, "payloadJson">, "strict", z.ZodTypeAny, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }, {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        }>;
+        eventSha256: z.ZodString;
+        scope: z.ZodObject<{
+            sessionId: z.ZodString;
+            sessionGenerationId: z.ZodString;
+            expectedSessionKeyGen: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }, {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        }>;
+        controlKey: z.ZodNullable<z.ZodString>;
+        winningEventId: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        reason: z.ZodEnum<["ALREADY_ANSWERED", "NOT_APPLIED"]>;
+        raiseJson: z.ZodString;
+        noticeOutcome: z.ZodEnum<["MISSING", "ACCEPTED", "OMITTED"]>;
+        noticeResolved: z.ZodBoolean;
+        cloudDelivered: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        controlKey: string | null;
+        raiseJson: string;
+        winningEventId: string | null;
+        noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+        noticeResolved: boolean;
+        cloudDelivered: boolean;
+    }, {
+        reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        controlKey: string | null;
+        raiseJson: string;
+        winningEventId: string | null;
+        noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+        noticeResolved: boolean;
+        cloudDelivered: boolean;
+    }>, "many">>;
+    diagnostic: z.ZodObject<{
+        nativeConfirmedCloudAckMissing: z.ZodNumber;
+        notSent: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        nativeConfirmedCloudAckMissing: number;
+        notSent: number;
+    }, {
+        nativeConfirmedCloudAckMissing: number;
+        notSent: number;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    owner: {
+        host: string;
+        pid: number;
+        token: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+    };
+    entries: ({
+        kind: "INPUT";
+        phase: "ATTEMPTED" | "UNCERTAIN" | "PREPARED" | "RECEIPTED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        bodyJson: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    } | {
+        kind: "RETIRED_EVIDENCE";
+        outcome: "NATIVE_CONFIRMED" | "NOT_SENT" | "UNKNOWN";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    })[];
+    version: 1;
+    revision: number;
+    stable: {
+        deviceId: string;
+        environment: "production" | "development";
+        userId: string;
+        nativeThreadId: string;
+    };
+    handoffTo: string | null;
+    scopes: {
+        state: "CLOSED" | "OPEN";
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        closureReason?: "TERMINAL" | "BACKEND_REPLACED" | undefined;
+    }[];
+    controls: {
+        kind: "file" | "command" | "async";
+        key: string;
+        state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+        turnId: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        nativeInstanceId: string;
+        threadId: string;
+        itemId: string;
+        detailsJson: string;
+        raiseJson: string;
+        cloudResolved: boolean;
+        nativeResolutionSha256: string | null;
+        nativeResolutionJson: string | null;
+        answerEventId: string | null;
+    }[];
+    rejections: {
+        reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        controlKey: string | null;
+        raiseJson: string;
+        winningEventId: string | null;
+        noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+        noticeResolved: boolean;
+        cloudDelivered: boolean;
+    }[];
+    diagnostic: {
+        nativeConfirmedCloudAckMissing: number;
+        notSent: number;
+    };
+}, {
+    owner: {
+        host: string;
+        pid: number;
+        token: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+    };
+    entries: ({
+        kind: "INPUT";
+        phase: "ATTEMPTED" | "UNCERTAIN" | "PREPARED" | "RECEIPTED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            payloadJson: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        bodyJson: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    } | {
+        kind: "RETIRED_EVIDENCE";
+        outcome: "NATIVE_CONFIRMED" | "NOT_SENT" | "UNKNOWN";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        binding: {
+            kind: "user" | "approval" | "async";
+            turnId: string | null;
+            approval: {
+                method: "file" | "command";
+                decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+                    acceptWithExecpolicyAmendment: {
+                        execpolicy_amendment: string[];
+                    };
+                };
+                nativeInstanceId: string;
+                requestId: string | number;
+                detailsSha256: string;
+            } | null;
+            threadId: string;
+            nativeId: string;
+            intentSha256: string;
+            receiptMatchSha256: string;
+        };
+        controlKey: string | null;
+        cloudAck: "EXECUTED" | "MISSING";
+        nativeReceiptSha256: string | null;
+    })[];
+    version: 1;
+    revision: number;
+    stable: {
+        deviceId: string;
+        environment: "production" | "development";
+        userId: string;
+        nativeThreadId: string;
+    };
+    handoffTo: string | null;
+    scopes: {
+        state: "CLOSED" | "OPEN";
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        closureReason?: "TERMINAL" | "BACKEND_REPLACED" | undefined;
+    }[];
+    controls: {
+        kind: "file" | "command" | "async";
+        key: string;
+        state: "PAUSED" | "RESOLVED" | "UNCERTAIN" | "OPEN" | "SESSION_ENDED" | "REHOMED";
+        turnId: string;
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        nativeInstanceId: string;
+        threadId: string;
+        itemId: string;
+        detailsJson: string;
+        raiseJson: string;
+        cloudResolved: boolean;
+        nativeResolutionSha256: string | null;
+        nativeResolutionJson: string | null;
+        answerEventId: string | null;
+    }[];
+    diagnostic: {
+        nativeConfirmedCloudAckMissing: number;
+        notSent: number;
+    };
+    rejections?: {
+        reason: "ALREADY_ANSWERED" | "NOT_APPLIED";
+        event: {
+            source: "MOBILE";
+            eventId: string;
+            sessionId: string;
+            sessionGenerationId: string | null;
+            type: "USER_PROMPT" | "PROMPT_RESPONSE";
+            timestamp: string;
+            syncLifecycleVersion?: 1 | undefined;
+        };
+        scope: {
+            sessionId: string;
+            sessionGenerationId: string;
+            expectedSessionKeyGen: string;
+        };
+        eventSha256: string;
+        controlKey: string | null;
+        raiseJson: string;
+        winningEventId: string | null;
+        noticeOutcome: "ACCEPTED" | "OMITTED" | "MISSING";
+        noticeResolved: boolean;
+        cloudDelivered: boolean;
+    }[] | undefined;
+}>;
+declare const intentSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"user">;
+    threadId: z.ZodString;
+    clientId: z.ZodEffects<z.ZodString, string, string>;
+    contentJson: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "user";
+    threadId: string;
+    clientId: string;
+    contentJson: string;
+}, {
+    kind: "user";
+    threadId: string;
+    clientId: string;
+    contentJson: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"async">;
+    threadId: z.ZodString;
+    questionItemId: z.ZodString;
+    output: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "async";
+    output: string;
+    threadId: string;
+    questionItemId: string;
+}, {
+    kind: "async";
+    output: string;
+    threadId: string;
+    questionItemId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"approval">;
+    threadId: z.ZodString;
+    turnId: z.ZodString;
+    itemId: z.ZodString;
+    nativeInstanceId: z.ZodString;
+    requestId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    method: z.ZodEnum<["command", "file"]>;
+    decision: z.ZodUnion<[z.ZodEnum<["accept", "acceptForSession", "cancel", "decline"]>, z.ZodObject<{
+        acceptWithExecpolicyAmendment: z.ZodObject<{
+            execpolicy_amendment: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            execpolicy_amendment: string[];
+        }, {
+            execpolicy_amendment: string[];
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        acceptWithExecpolicyAmendment: {
+            execpolicy_amendment: string[];
+        };
+    }, {
+        acceptWithExecpolicyAmendment: {
+            execpolicy_amendment: string[];
+        };
+    }>]>;
+    detailsSha256: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    method: "file" | "command";
+    kind: "approval";
+    decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+        acceptWithExecpolicyAmendment: {
+            execpolicy_amendment: string[];
+        };
+    };
+    turnId: string;
+    nativeInstanceId: string;
+    requestId: string | number;
+    detailsSha256: string;
+    threadId: string;
+    itemId: string;
+}, {
+    method: "file" | "command";
+    kind: "approval";
+    decision: "accept" | "acceptForSession" | "cancel" | "decline" | {
+        acceptWithExecpolicyAmendment: {
+            execpolicy_amendment: string[];
+        };
+    };
+    turnId: string;
+    nativeInstanceId: string;
+    requestId: string | number;
+    detailsSha256: string;
+    threadId: string;
+    itemId: string;
+}>]>;
+export type CodexNativeScope = z.infer<typeof scopeSchema>;
+export type CodexNativeStableIdentity = z.infer<typeof stableSchema>;
+export type CodexNativeOwner = z.infer<typeof ownerSchema>;
+export type CodexNativeEvent = z.infer<typeof eventSchema>;
+export type CodexNativeControl = z.infer<typeof controlSchema>;
+export type CodexNativeIntent = z.infer<typeof intentSchema>;
+export type CodexNativeState = z.infer<typeof recordSchema>;
+export type CodexNativeEntry = CodexNativeState['entries'][number];
+export type CodexNativeRejection = z.infer<typeof rejectionSchema>;
+export type CodexNativeApprovalDecision = z.infer<typeof approvalDecisionSchema>;
+export interface CodexNativeStateOptions {
+    identity: CodexNativeStableIdentity;
+    /** Stable installed data path. Private tests may supply their recorded root. */
+    root?: string;
+    readPrivateKey(): Promise<string | null>;
+    assertAccount(): void;
+    /** Caller must use the existing authenticated canonical Session read. */
+    assertActiveScope(scope: CodexNativeScope): Promise<void>;
+}
+export declare class CodexNativeStateError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** Exact JSON input, never a terminal-label catalogue. Mutable cloud delivery
+ * status is intentionally outside the immutable input identity. */
+export declare function snapshotCodexNativeEvent(value: {
+    eventId: string;
+    timestamp: string;
+    sessionId: string;
+    sessionGenerationId?: string | null;
+    syncLifecycleVersion?: number;
+    source: string;
+    type: string;
+    content?: string | null;
+    metadata?: unknown;
+    attachments?: unknown;
+    isEncrypted?: boolean | null;
+    promptId?: string;
+    encryptionVersion?: number;
+}): CodexNativeEvent;
+export declare class CodexNativeStateStore {
+    private readonly options;
+    readonly file: string;
+    private readonly stable;
+    private readonly root;
+    private readonly context;
+    private ingressClosed;
+    private claimedOwnerToken;
+    constructor(options: CodexNativeStateOptions);
+    private directory;
+    private locked;
+    private validate;
+    private read;
+    private write;
+    private owned;
+    private mutate;
+    private open;
+    private active;
+    /** First owner or exact successor. A live writer must explicitly close/join
+     * and authorize this token. ESRCH on the recorded same-host PID is required
+     * for crash takeover; age,heartbeat lag and unknown PID state never suffice. */
+    claim(value: CodexNativeOwner): Promise<void>;
+    snapshot(owner: CodexNativeOwner): Promise<CodexNativeState>;
+    close(owner: CodexNativeOwner, reason?: 'TERMINAL' | 'BACKEND_REPLACED'): Promise<void>;
+    private endControls;
+    authorizeHandoff(owner: CodexNativeOwner, nextToken: string, join: () => Promise<void>): Promise<void>;
+    putControl(owner: CodexNativeOwner, value: CodexNativeControl): Promise<void>;
+    /** Only a live backend-row replacement can re-home presentation. The old
+     * scope/input remains closed and unchanged;its exact E1 closure must already
+     * be acknowledged. A normal terminal resume is never re-home authority. */
+    rehomeControl(owner: CodexNativeOwner, previousKey: string, value: CodexNativeControl): Promise<void>;
+    pauseControl(owner: CodexNativeOwner, controlKey: string, paused: boolean): Promise<void>;
+    /** Approval preemption and answer reservation share one durable lock. An
+     * answer committed first is no longer pausable; it is not a handler error.
+     * Conversely a pause committed first still prevents prepare from sending. */
+    pauseOpenQuestions(owner: CodexNativeOwner): Promise<void>;
+    prepare(owner: CodexNativeOwner, value: CodexNativeEvent, intentValue: CodexNativeIntent, controlKey?: string | null): Promise<'COMMITTED' | 'DUPLICATE'>;
+    /** The same lock as answer reservation decides a losing explicit reply.
+     * Missing/paused controls and existing native attempts are never reclassified. */
+    rejectAnsweredControl(owner: CodexNativeOwner, value: CodexNativeEvent, promptId: string): Promise<CodexNativeRejection | null>;
+    /** A deterministic binding refusal before prepare/send is terminal for this
+     * exact event. The lock proves no native attempt exists; it never creates a
+     * control reservation, replay payload, or EXECUTED acknowledgement. */
+    rejectUnappliedInput(owner: CodexNativeOwner, value: CodexNativeEvent): Promise<CodexNativeRejection | null>;
+    acknowledgeRejectionNotice(owner: CodexNativeOwner, eventId: string, outcome: 'ACCEPTED' | 'OMITTED'): Promise<void>;
+    resolveRejectionNotice(owner: CodexNativeOwner, eventId: string): Promise<void>;
+    acknowledgeRejectedDelivery(owner: CodexNativeOwner, eventId: string, value: unknown): Promise<void>;
+    /** Shared eligibility for every saved input, including async questions and
+     * native approvals. A closed/paused control is normal retained work, not
+     * authority to send or an error that may monopolize the recovery queue. */
+    private preparedIntent;
+    /** Local read-only preflight before decode or cloud DELIVERED. Do not poll
+     * the backend for permanently retained closed controls on every tick.
+     * prepare/beginAttempt retain their independent canonical active-scope
+     * checks; this read cannot authorize a send. */
+    canAttempt(owner: CodexNativeOwner, eventId: string): Promise<boolean>;
+    /** The only initial-attempt gate. A successful return is an intent to send
+     * ONCE,not a native acknowledgement. The caller must not retry a failed RPC. */
+    beginAttempt(owner: CodexNativeOwner, eventId: string): Promise<CodexNativeIntent | null>;
+    markUncertain(owner: CodexNativeOwner, eventId: string): Promise<void>;
+    /** Only the current dispatcher may release its reservation BEFORE entering
+     * send. A crash or any call into native send must retain ATTEMPTED/UNCERTAIN;
+     * neither a failed RPC nor a missing receipt is proof that nothing was sent.
+     * Exact owner,scope and body prevent releasing another admission's attempt. */
+    deferUnsentAttempt(owner: CodexNativeOwner, eventId: string, intent: CodexNativeIntent): Promise<void>;
+    /** Persisted original native receipts can reconcile under a successor,even
+     * when the lost turn/start response never supplied a turn ID. No RPC retry. */
+    reconcile(owner: CodexNativeOwner, eventId: string, receipt: {
+        threadId: string;
+        turnId: string;
+        item: unknown;
+    }): Promise<void>;
+    acknowledgeControlClosure(owner: CodexNativeOwner, controlKey: string, receipt: unknown): Promise<void>;
+    /** Invoke the existing public SDK lifecycle with the exact retained owner.
+     * Its true result means verified resolution,including publication recovery;
+     * it is not converted into a fabricated wire receipt or native execution. */
+    resolveControl(owner: CodexNativeOwner, controlKey: string, resolve: (input: {
+        sessionId: string;
+        promptId: string;
+        ownerToken: string;
+    }) => Promise<boolean>): Promise<boolean>;
+    /** Structured output can originate from another native client. It may close
+     * this exact question,but must not mark a mobile Event executed by inference. */
+    observeQuestionResolution(owner: CodexNativeOwner, controlKey: string, receipt: {
+        threadId: string;
+        turnId: string;
+        item: unknown;
+    }): Promise<void>;
+    /** An interrupted native turn withdraws its unanswered questions. This is
+     * presentation closure, never proof that a mobile answer executed. */
+    observeQuestionInterruption(owner: CodexNativeOwner, controlKey: string, receipt: {
+        nativeInstanceId: string;
+        message: unknown;
+    }): Promise<void>;
+    /** Only an exact signed status receipt can record cloud execution. Native
+     * proof is independently required;an RPC write or DELIVERED is not enough. */
+    acknowledgeInputExecution(owner: CodexNativeOwner, eventId: string, value: unknown): Promise<void>;
+    private approvalResolution;
+    /** A resolved native dialog closes its presentation,but is not by itself
+     * proof that this mobile decision won a competing desktop response. */
+    observeApprovalResolution(owner: CodexNativeOwner, controlKey: string, receipt: {
+        nativeInstanceId: string;
+        message: unknown;
+    }): Promise<void>;
+    /** An exact terminal native item can close presentation after a missed
+     * callback notification. It does NOT prove which mobile decision won,so
+     * this deliberately supplies no serverRequest/resolved proof to an input. */
+    observeApprovalTerminalItem(owner: CodexNativeOwner, controlKey: string, receipt: {
+        nativeInstanceId: string;
+        message: unknown;
+    }): Promise<void>;
+    /** The native resolved notice plus an exact matching typed outcome is
+     * required. An RPC/socket write,model prose,or opposite desktop outcome
+     * cannot manufacture execution. Cancel also requires native interruption. */
+    reconcileApproval(owner: CodexNativeOwner, eventId: string, receipt: {
+        nativeInstanceId: string;
+        resolved?: unknown;
+        completed: unknown;
+        turnCompleted?: unknown;
+    }): Promise<void>;
+    /** No cached proof. Snapshot comparison after the network await prevents a
+     * fresh authority result from authorizing a different cleanup target set. */
+    retirePayloads(owner: CodexNativeOwner, scope: CodexNativeScope, join: () => Promise<void>, confirm: (input: ConfirmDesktopSyncRetirementInput) => Promise<unknown>): Promise<number>;
+    private requireClosed;
+    pruneSettled(owner: CodexNativeOwner, scope: CodexNativeScope, confirm: (input: ConfirmDesktopSyncRetirementInput) => Promise<unknown>): Promise<number>;
+    /** Remove the last empty per-thread owner record only after every remaining
+     * closed scope has fresh retirement authority. Pending/native-control state
+     * makes this a refusal,not an eviction policy or a background cleanup task. */
+    removeSettled(owner: CodexNativeOwner, join: () => Promise<void>, confirm: (input: ConfirmDesktopSyncRetirementInput) => Promise<unknown>): Promise<void>;
+}
+export {};