@heynixie/contract 0.0.0 → 0.55.0

package/dist/contract.d.ts

@@ -0,0 +1,2359 @@
+import { z } from 'zod';
+export declare const contract: {
+    conversation: {
+        read: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            beforeSequence: z.ZodOptional<z.ZodInt>;
+            limit: z.ZodOptional<z.ZodInt>;
+            thread: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            hasEarlier: z.ZodBoolean;
+            readAtSequence: z.ZodInt;
+            records: z.ZodArray<z.ZodObject<{
+                compaction: z.ZodOptional<z.ZodObject<{
+                    postTokens: z.ZodOptional<z.ZodInt>;
+                    preTokens: z.ZodInt;
+                    trigger: z.ZodEnum<{
+                        auto: "auto";
+                        manual: "manual";
+                    }>;
+                }, z.core.$strip>>;
+                compactionFailure: z.ZodOptional<z.ZodObject<{
+                    failures: z.ZodInt;
+                }, z.core.$strip>>;
+                forget: z.ZodOptional<z.ZodObject<{
+                    sequence: z.ZodInt;
+                }, z.core.$strip>>;
+                context: z.ZodOptional<z.ZodObject<{
+                    size: z.ZodInt;
+                    window: z.ZodInt;
+                }, z.core.$strip>>;
+                kind: z.ZodString;
+                message: z.ZodOptional<z.ZodObject<{
+                    clientMessageId: z.ZodOptional<z.ZodUUID>;
+                    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        mediaType: z.ZodEnum<{
+                            "image/gif": "image/gif";
+                            "image/jpeg": "image/jpeg";
+                            "image/png": "image/png";
+                            "image/webp": "image/webp";
+                        }>;
+                    }, z.core.$strip>>>;
+                    spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        end: z.ZodInt;
+                        source: z.ZodEnum<{
+                            dropped: "dropped";
+                            pasted: "pasted";
+                            typed: "typed";
+                            unknown: "unknown";
+                        }>;
+                        start: z.ZodInt;
+                    }, z.core.$strip>>>;
+                    text: z.ZodString;
+                }, z.core.$strip>>;
+                moment: z.ZodOptional<z.ZodObject<{
+                    momentID: z.ZodString;
+                    shortID: z.ZodString;
+                    title: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                rating: z.ZodOptional<z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        itemID: z.ZodString;
+                        version: z.ZodInt;
+                        hasNote: z.ZodBoolean;
+                        verdict: z.ZodEnum<{
+                            helpful: "helpful";
+                            misleading: "misleading";
+                            noise: "noise";
+                        }>;
+                    }, z.core.$strip>>;
+                    ratedBy: z.ZodOptional<z.ZodString>;
+                    recalledSequence: z.ZodInt;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        itemID: z.ZodString;
+                        version: z.ZodInt;
+                        score: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                recordedAt: z.ZodDate;
+                route: z.ZodOptional<z.ZodObject<{
+                    isMove: z.ZodBoolean;
+                    messages: z.ZodArray<z.ZodInt>;
+                    taskID: z.ZodString;
+                }, z.core.$strip>>;
+                sequence: z.ZodInt;
+                summary: z.ZodOptional<z.ZodObject<{
+                    contextSize: z.ZodOptional<z.ZodInt>;
+                    summaryTokens: z.ZodInt;
+                    text: z.ZodOptional<z.ZodString>;
+                    trigger: z.ZodEnum<{
+                        overflow: "overflow";
+                        threshold: "threshold";
+                    }>;
+                }, z.core.$strip>>;
+                thread: z.ZodString;
+                task: z.ZodOptional<z.ZodObject<{
+                    error: z.ZodOptional<z.ZodString>;
+                    errorLimit: z.ZodOptional<z.ZodInt>;
+                    errors: z.ZodOptional<z.ZodInt>;
+                    retryAt: z.ZodOptional<z.ZodDate>;
+                    stepKey: z.ZodOptional<z.ZodString>;
+                    taskID: z.ZodString;
+                }, z.core.$strip>>;
+                toolCall: z.ZodOptional<z.ZodObject<{
+                    callID: z.ZodString;
+                    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    outcome: z.ZodOptional<z.ZodString>;
+                    tool: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            lastStepEnd: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                compaction: z.ZodOptional<z.ZodObject<{
+                    postTokens: z.ZodOptional<z.ZodInt>;
+                    preTokens: z.ZodInt;
+                    trigger: z.ZodEnum<{
+                        auto: "auto";
+                        manual: "manual";
+                    }>;
+                }, z.core.$strip>>;
+                compactionFailure: z.ZodOptional<z.ZodObject<{
+                    failures: z.ZodInt;
+                }, z.core.$strip>>;
+                forget: z.ZodOptional<z.ZodObject<{
+                    sequence: z.ZodInt;
+                }, z.core.$strip>>;
+                context: z.ZodOptional<z.ZodObject<{
+                    size: z.ZodInt;
+                    window: z.ZodInt;
+                }, z.core.$strip>>;
+                kind: z.ZodString;
+                message: z.ZodOptional<z.ZodObject<{
+                    clientMessageId: z.ZodOptional<z.ZodUUID>;
+                    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        mediaType: z.ZodEnum<{
+                            "image/gif": "image/gif";
+                            "image/jpeg": "image/jpeg";
+                            "image/png": "image/png";
+                            "image/webp": "image/webp";
+                        }>;
+                    }, z.core.$strip>>>;
+                    spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        end: z.ZodInt;
+                        source: z.ZodEnum<{
+                            dropped: "dropped";
+                            pasted: "pasted";
+                            typed: "typed";
+                            unknown: "unknown";
+                        }>;
+                        start: z.ZodInt;
+                    }, z.core.$strip>>>;
+                    text: z.ZodString;
+                }, z.core.$strip>>;
+                moment: z.ZodOptional<z.ZodObject<{
+                    momentID: z.ZodString;
+                    shortID: z.ZodString;
+                    title: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                rating: z.ZodOptional<z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        itemID: z.ZodString;
+                        version: z.ZodInt;
+                        hasNote: z.ZodBoolean;
+                        verdict: z.ZodEnum<{
+                            helpful: "helpful";
+                            misleading: "misleading";
+                            noise: "noise";
+                        }>;
+                    }, z.core.$strip>>;
+                    ratedBy: z.ZodOptional<z.ZodString>;
+                    recalledSequence: z.ZodInt;
+                }, z.core.$strip>>;
+                recall: z.ZodOptional<z.ZodObject<{
+                    items: z.ZodArray<z.ZodObject<{
+                        itemID: z.ZodString;
+                        version: z.ZodInt;
+                        score: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                recordedAt: z.ZodDate;
+                route: z.ZodOptional<z.ZodObject<{
+                    isMove: z.ZodBoolean;
+                    messages: z.ZodArray<z.ZodInt>;
+                    taskID: z.ZodString;
+                }, z.core.$strip>>;
+                sequence: z.ZodInt;
+                summary: z.ZodOptional<z.ZodObject<{
+                    contextSize: z.ZodOptional<z.ZodInt>;
+                    summaryTokens: z.ZodInt;
+                    text: z.ZodOptional<z.ZodString>;
+                    trigger: z.ZodEnum<{
+                        overflow: "overflow";
+                        threshold: "threshold";
+                    }>;
+                }, z.core.$strip>>;
+                thread: z.ZodString;
+                task: z.ZodOptional<z.ZodObject<{
+                    error: z.ZodOptional<z.ZodString>;
+                    errorLimit: z.ZodOptional<z.ZodInt>;
+                    errors: z.ZodOptional<z.ZodInt>;
+                    retryAt: z.ZodOptional<z.ZodDate>;
+                    stepKey: z.ZodOptional<z.ZodString>;
+                    taskID: z.ZodString;
+                }, z.core.$strip>>;
+                toolCall: z.ZodOptional<z.ZodObject<{
+                    callID: z.ZodString;
+                    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    outcome: z.ZodOptional<z.ZodString>;
+                    tool: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            THREAD_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        send: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientMessageId: z.ZodUUID;
+            images: z.ZodOptional<z.ZodArray<z.ZodFile>>;
+            spans: z.ZodArray<z.ZodObject<{
+                end: z.ZodInt;
+                source: z.ZodEnum<{
+                    dropped: "dropped";
+                    pasted: "pasted";
+                    typed: "typed";
+                    unknown: "unknown";
+                }>;
+                start: z.ZodInt;
+            }, z.core.$strip>>;
+            text: z.ZodString;
+            thread: z.ZodString;
+            timeZone: z.ZodOptional<z.ZodString>;
+            writtenAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>, z.ZodObject<{
+            duplicate: z.ZodBoolean;
+            sequence: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            IMAGE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    position: z.ZodNullable<z.ZodInt>;
+                    reason: z.ZodEnum<{
+                        too_large: "too_large";
+                        too_many: "too_many";
+                        unsupported_type: "unsupported_type";
+                    }>;
+                }, z.core.$strip>;
+            };
+            THREAD_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readImage: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            position: z.ZodInt;
+            sequence: z.ZodInt;
+            thread: z.ZodString;
+        }, z.core.$strip>, z.ZodFile, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            IMAGE_NOT_FOUND: {
+                readonly message: 'No readable image of a message has this position';
+                readonly status: 404;
+            };
+        }>, Record<never, never>>;
+        forget: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            sequence: z.ZodInt;
+            thread: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            forgottenAt: z.ZodDate;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            RECORD_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        move: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            sequence: z.ZodInt;
+            thread: z.ZodString;
+            to: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"task">;
+                taskID: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"new">;
+                name: z.ZodString;
+                brief: z.ZodString;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>, z.ZodObject<{
+            movedAt: z.ZodDate;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            RECORD_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_TAKES_NO_MESSAGES: {
+                message: string;
+                status: number;
+            };
+            ALREADY_THERE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+    tasks: {
+        list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            tasks: z.ZodArray<z.ZodObject<{
+                brief: z.ZodString;
+                isTakingMessages: z.ZodBoolean;
+                lastActivityAt: z.ZodDate;
+                name: z.ZodString;
+                state: z.ZodEnum<{
+                    done: "done";
+                    failed: "failed";
+                    ready: "ready";
+                    running: "running";
+                    waiting: "waiting";
+                }>;
+                taskID: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+    memory: {
+        export: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+        }, z.core.$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+            chunk: string;
+        } | {
+            isComplete: true;
+        }, unknown, void>, import("@orpc/client").AsyncIteratorClass<{
+            chunk: string;
+        } | {
+            isComplete: true;
+        }, unknown, void>>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        keepMoment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            firstSequence: z.ZodInt;
+            lastSequence: z.ZodInt;
+            thread: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            momentID: z.ZodString;
+            shortID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            BAD_SPAN: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        listMoments: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            before: z.ZodOptional<z.ZodInt>;
+            includeRetired: z.ZodBoolean;
+            query: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            moments: z.ZodArray<z.ZodObject<{
+                editedAt: z.ZodNullable<z.ZodDate>;
+                keptAt: z.ZodDate;
+                keptBy: z.ZodEnum<{
+                    model: "model";
+                    owner: "owner";
+                }>;
+                momentID: z.ZodString;
+                shortID: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    retired: "retired";
+                }>;
+                title: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            next: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readMoment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            editedAt: z.ZodNullable<z.ZodDate>;
+            keptAt: z.ZodDate;
+            keptBy: z.ZodEnum<{
+                model: "model";
+                owner: "owner";
+            }>;
+            momentID: z.ZodString;
+            shortID: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                retired: "retired";
+            }>;
+            title: z.ZodNullable<z.ZodString>;
+            firstSequence: z.ZodInt;
+            lastSequence: z.ZodInt;
+            links: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                shortID: z.ZodString;
+                text: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            note: z.ZodNullable<z.ZodObject<{
+                text: z.ZodString;
+                writtenAt: z.ZodDate;
+            }, z.core.$strip>>;
+            reflections: z.ZodArray<z.ZodObject<{
+                model: z.ZodString;
+                text: z.ZodNullable<z.ZodString>;
+                writtenAt: z.ZodDate;
+                reflectionID: z.ZodString;
+            }, z.core.$strip>>;
+            thread: z.ZodString;
+            titleBy: z.ZodEnum<{
+                model: "model";
+                owner: "owner";
+            }>;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readMomentSpan: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+            after: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strip>, z.ZodObject<{
+            records: z.ZodArray<z.ZodObject<{
+                isGap: z.ZodBoolean;
+                kind: z.ZodString;
+                recordedAt: z.ZodDate;
+                sequence: z.ZodInt;
+                text: z.ZodNullable<z.ZodString>;
+                tool: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            next: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        editMoment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+            clientActionID: z.ZodUUID;
+            change: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"title">;
+                title: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"edges">;
+                firstSequence: z.ZodInt;
+                lastSequence: z.ZodInt;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"note">;
+                note: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"reflection_removed">;
+                reflectionID: z.ZodString;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>, z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            BAD_SPAN: {
+                message: string;
+                status: number;
+            };
+            REFLECTION_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        linkMoment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+            clientActionID: z.ZodUUID;
+            isLinked: z.ZodBoolean;
+            itemID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            ALREADY_LINKED: {
+                message: string;
+                status: number;
+            };
+            NOT_LINKED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        previewMomentDestroy: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            keptAt: z.ZodDate;
+            keptBy: z.ZodEnum<{
+                model: "model";
+                owner: "owner";
+            }>;
+            kept: z.ZodObject<{
+                records: z.ZodInt;
+            }, z.core.$strip>;
+            lost: z.ZodObject<{
+                links: z.ZodInt;
+                texts: z.ZodInt;
+            }, z.core.$strip>;
+            momentID: z.ZodString;
+            note: z.ZodNullable<z.ZodString>;
+            reflections: z.ZodArray<z.ZodObject<{
+                model: z.ZodString;
+                text: z.ZodNullable<z.ZodString>;
+                writtenAt: z.ZodDate;
+            }, z.core.$strip>>;
+            shortID: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                retired: "retired";
+            }>;
+            thread: z.ZodString;
+            title: z.ZodNullable<z.ZodString>;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        destroyMoment: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            momentID: z.ZodString;
+            version: z.ZodInt;
+            clientActionID: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            momentID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+            MOMENT_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        listItems: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            after: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                fact: "fact";
+                self: "self";
+            }>>;
+            limit: z.ZodOptional<z.ZodInt>;
+            state: z.ZodEnum<{
+                active: "active";
+                forgotten: "forgotten";
+                retired: "retired";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                changedAt: z.ZodDate;
+                createdAt: z.ZodDate;
+                forgottenAt: z.ZodNullable<z.ZodDate>;
+                isPinned: z.ZodBoolean;
+                isSensitive: z.ZodBoolean;
+                itemID: z.ZodString;
+                kind: z.ZodEnum<{
+                    fact: "fact";
+                    self: "self";
+                }>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                shortID: z.ZodString;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    forgetting: "forgetting";
+                    forgotten: "forgotten";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                subject: z.ZodEnum<{
+                    owner: "owner";
+                    self: "self";
+                    shared: "shared";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                until: z.ZodNullable<z.ZodDate>;
+                version: z.ZodInt;
+            }, z.core.$strip>>;
+            next: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            INVALID_CURSOR: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        findItems: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            query: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                changedAt: z.ZodDate;
+                createdAt: z.ZodDate;
+                forgottenAt: z.ZodNullable<z.ZodDate>;
+                isPinned: z.ZodBoolean;
+                isSensitive: z.ZodBoolean;
+                itemID: z.ZodString;
+                kind: z.ZodEnum<{
+                    fact: "fact";
+                    self: "self";
+                }>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                shortID: z.ZodString;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    forgetting: "forgetting";
+                    forgotten: "forgotten";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                subject: z.ZodEnum<{
+                    owner: "owner";
+                    self: "self";
+                    shared: "shared";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                until: z.ZodNullable<z.ZodDate>;
+                version: z.ZodInt;
+                score: z.ZodOptional<z.ZodNumber>;
+                similarity: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            searchMode: z.ZodEnum<{
+                hybrid: "hybrid";
+                keyword: "keyword";
+                "keyword-fallback": "keyword-fallback";
+            }>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readPinnedCore: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            budget: z.ZodInt;
+            items: z.ZodArray<z.ZodObject<{
+                changedAt: z.ZodDate;
+                createdAt: z.ZodDate;
+                forgottenAt: z.ZodNullable<z.ZodDate>;
+                isPinned: z.ZodBoolean;
+                isSensitive: z.ZodBoolean;
+                itemID: z.ZodString;
+                kind: z.ZodEnum<{
+                    fact: "fact";
+                    self: "self";
+                }>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                shortID: z.ZodString;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    forgetting: "forgetting";
+                    forgotten: "forgotten";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                subject: z.ZodEnum<{
+                    owner: "owner";
+                    self: "self";
+                    shared: "shared";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                until: z.ZodNullable<z.ZodDate>;
+                version: z.ZodInt;
+            }, z.core.$strip>>;
+            tokens: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readItem: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            itemID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            changedAt: z.ZodDate;
+            createdAt: z.ZodDate;
+            forgottenAt: z.ZodNullable<z.ZodDate>;
+            isPinned: z.ZodBoolean;
+            isSensitive: z.ZodBoolean;
+            itemID: z.ZodString;
+            kind: z.ZodEnum<{
+                fact: "fact";
+                self: "self";
+            }>;
+            origin: z.ZodEnum<{
+                conversation: "conversation";
+                lapse: "lapse";
+                memory_writer: "memory_writer";
+                owner: "owner";
+                task: "task";
+            }>;
+            shortID: z.ZodString;
+            source: z.ZodEnum<{
+                owner: "owner";
+                owner_data: "owner_data";
+                untrusted: "untrusted";
+            }>;
+            state: z.ZodEnum<{
+                active: "active";
+                forgetting: "forgetting";
+                forgotten: "forgotten";
+                retired: "retired";
+            }>;
+            status: z.ZodEnum<{
+                readable: "readable";
+                shredded: "shredded";
+                unreadable: "unreadable";
+            }>;
+            subject: z.ZodEnum<{
+                owner: "owner";
+                self: "self";
+                shared: "shared";
+            }>;
+            text: z.ZodOptional<z.ZodString>;
+            until: z.ZodNullable<z.ZodDate>;
+            version: z.ZodInt;
+            versions: z.ZodArray<z.ZodObject<{
+                change: z.ZodEnum<{
+                    created: "created";
+                    edited: "edited";
+                    restored: "restored";
+                    retired: "retired";
+                    undone: "undone";
+                }>;
+                checkerModel: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                evidence: z.ZodNullable<z.ZodObject<{
+                    end: z.ZodInt;
+                    message: z.ZodNullable<z.ZodObject<{
+                        status: z.ZodEnum<{
+                            missing: "missing";
+                            readable: "readable";
+                            shredded: "shredded";
+                            unreadable: "unreadable";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    sequence: z.ZodInt;
+                    start: z.ZodInt;
+                }, z.core.$strip>>;
+                evidenceQuote: z.ZodNullable<z.ZodString>;
+                image: z.ZodNullable<z.ZodObject<{
+                    position: z.ZodInt;
+                    sequence: z.ZodInt;
+                    thread: z.ZodString;
+                }, z.core.$strip>>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                proposalID: z.ZodNullable<z.ZodString>;
+                recordedAt: z.ZodDate;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                taskID: z.ZodNullable<z.ZodString>;
+                text: z.ZodOptional<z.ZodString>;
+                version: z.ZodInt;
+                writerModel: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        retire: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        restore: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        listNotices: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            thread: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            notices: z.ZodArray<z.ZodObject<{
+                entries: z.ZodArray<z.ZodObject<{
+                    change: z.ZodEnum<{
+                        created: "created";
+                        edited: "edited";
+                        proposed: "proposed";
+                        restored: "restored";
+                        retired: "retired";
+                        undone: "undone";
+                    }>;
+                    isKept: z.ZodBoolean;
+                    item: z.ZodNullable<z.ZodObject<{
+                        changedAt: z.ZodDate;
+                        createdAt: z.ZodDate;
+                        forgottenAt: z.ZodNullable<z.ZodDate>;
+                        isPinned: z.ZodBoolean;
+                        isSensitive: z.ZodBoolean;
+                        itemID: z.ZodString;
+                        kind: z.ZodEnum<{
+                            fact: "fact";
+                            self: "self";
+                        }>;
+                        origin: z.ZodEnum<{
+                            conversation: "conversation";
+                            lapse: "lapse";
+                            memory_writer: "memory_writer";
+                            owner: "owner";
+                            task: "task";
+                        }>;
+                        shortID: z.ZodString;
+                        source: z.ZodEnum<{
+                            owner: "owner";
+                            owner_data: "owner_data";
+                            untrusted: "untrusted";
+                        }>;
+                        state: z.ZodEnum<{
+                            active: "active";
+                            forgetting: "forgetting";
+                            forgotten: "forgotten";
+                            retired: "retired";
+                        }>;
+                        status: z.ZodEnum<{
+                            readable: "readable";
+                            shredded: "shredded";
+                            unreadable: "unreadable";
+                        }>;
+                        subject: z.ZodEnum<{
+                            owner: "owner";
+                            self: "self";
+                            shared: "shared";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                        until: z.ZodNullable<z.ZodDate>;
+                        version: z.ZodInt;
+                        change: z.ZodEnum<{
+                            created: "created";
+                            edited: "edited";
+                            restored: "restored";
+                            retired: "retired";
+                            undone: "undone";
+                        }>;
+                    }, z.core.$strip>>;
+                    itemID: z.ZodString;
+                    proposalID: z.ZodNullable<z.ZodString>;
+                    sequence: z.ZodInt;
+                    version: z.ZodNullable<z.ZodInt>;
+                }, z.core.$strip>>;
+                kind: z.ZodEnum<{
+                    batch: "batch";
+                    catch_up: "catch_up";
+                    run: "run";
+                    turn: "turn";
+                }>;
+                messageSequence: z.ZodNullable<z.ZodInt>;
+                noticeKey: z.ZodString;
+                proposed: z.ZodInt;
+                remembered: z.ZodInt;
+                retired: z.ZodInt;
+                sequence: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        undo: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            PINNED_CORE_FULL: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        keep: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        previewForget: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            changedAt: z.ZodDate;
+            createdAt: z.ZodDate;
+            forgottenAt: z.ZodNullable<z.ZodDate>;
+            isPinned: z.ZodBoolean;
+            isSensitive: z.ZodBoolean;
+            itemID: z.ZodString;
+            kind: z.ZodEnum<{
+                fact: "fact";
+                self: "self";
+            }>;
+            origin: z.ZodEnum<{
+                conversation: "conversation";
+                lapse: "lapse";
+                memory_writer: "memory_writer";
+                owner: "owner";
+                task: "task";
+            }>;
+            shortID: z.ZodString;
+            source: z.ZodEnum<{
+                owner: "owner";
+                owner_data: "owner_data";
+                untrusted: "untrusted";
+            }>;
+            state: z.ZodEnum<{
+                active: "active";
+                forgetting: "forgetting";
+                forgotten: "forgotten";
+                retired: "retired";
+            }>;
+            status: z.ZodEnum<{
+                readable: "readable";
+                shredded: "shredded";
+                unreadable: "unreadable";
+            }>;
+            subject: z.ZodEnum<{
+                owner: "owner";
+                self: "self";
+                shared: "shared";
+            }>;
+            text: z.ZodOptional<z.ZodString>;
+            until: z.ZodNullable<z.ZodDate>;
+            version: z.ZodInt;
+            versions: z.ZodArray<z.ZodObject<{
+                change: z.ZodEnum<{
+                    created: "created";
+                    edited: "edited";
+                    restored: "restored";
+                    retired: "retired";
+                    undone: "undone";
+                }>;
+                checkerModel: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                evidence: z.ZodNullable<z.ZodObject<{
+                    end: z.ZodInt;
+                    message: z.ZodNullable<z.ZodObject<{
+                        status: z.ZodEnum<{
+                            missing: "missing";
+                            readable: "readable";
+                            shredded: "shredded";
+                            unreadable: "unreadable";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    sequence: z.ZodInt;
+                    start: z.ZodInt;
+                }, z.core.$strip>>;
+                evidenceQuote: z.ZodNullable<z.ZodString>;
+                image: z.ZodNullable<z.ZodObject<{
+                    position: z.ZodInt;
+                    sequence: z.ZodInt;
+                    thread: z.ZodString;
+                }, z.core.$strip>>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                proposalID: z.ZodNullable<z.ZodString>;
+                recordedAt: z.ZodDate;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                taskID: z.ZodNullable<z.ZodString>;
+                text: z.ZodOptional<z.ZodString>;
+                version: z.ZodInt;
+                writerModel: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            lost: z.ZodObject<{
+                evidenceMessages: z.ZodInt;
+                proposals: z.ZodInt;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        forget: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+        }, z.core.$strip>, z.ZodObject<{
+            itemID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        previewForgetRetired: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            hasMore: z.ZodBoolean;
+            items: z.ZodArray<z.ZodObject<{
+                changedAt: z.ZodDate;
+                createdAt: z.ZodDate;
+                forgottenAt: z.ZodNullable<z.ZodDate>;
+                isPinned: z.ZodBoolean;
+                isSensitive: z.ZodBoolean;
+                itemID: z.ZodString;
+                kind: z.ZodEnum<{
+                    fact: "fact";
+                    self: "self";
+                }>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    lapse: "lapse";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                shortID: z.ZodString;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    forgetting: "forgetting";
+                    forgotten: "forgotten";
+                    retired: "retired";
+                }>;
+                status: z.ZodEnum<{
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                subject: z.ZodEnum<{
+                    owner: "owner";
+                    self: "self";
+                    shared: "shared";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                until: z.ZodNullable<z.ZodDate>;
+                version: z.ZodInt;
+                lost: z.ZodObject<{
+                    evidenceMessages: z.ZodInt;
+                    proposals: z.ZodInt;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        forgetRetired: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            targets: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                version: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodArray<z.ZodString>;
+            pending: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readForgetStatus: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            itemIDs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodArray<z.ZodString>;
+            pending: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        pin: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            itemID: z.ZodString;
+            version: z.ZodInt;
+            isPinned: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            isPinned: z.ZodBoolean;
+            itemID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            PINNED_CORE_FULL: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        markSensitive: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            isSensitive: z.ZodBoolean;
+            itemID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            isSensitive: z.ZodBoolean;
+            itemID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_ITEM_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            STALE_VERSION: {
+                message: string;
+                status: number;
+            };
+            WRONG_STATE: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        listProposals: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            proposals: z.ZodArray<z.ZodObject<{
+                actionHash: z.ZodString;
+                createdAt: z.ZodDate;
+                evidence: z.ZodNullable<z.ZodObject<{
+                    end: z.ZodInt;
+                    message: z.ZodNullable<z.ZodObject<{
+                        status: z.ZodEnum<{
+                            missing: "missing";
+                            readable: "readable";
+                            shredded: "shredded";
+                            unreadable: "unreadable";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    sequence: z.ZodInt;
+                    start: z.ZodInt;
+                }, z.core.$strip>>;
+                image: z.ZodNullable<z.ZodObject<{
+                    position: z.ZodInt;
+                    sequence: z.ZodInt;
+                    thread: z.ZodString;
+                }, z.core.$strip>>;
+                isPinned: z.ZodBoolean;
+                isSensitive: z.ZodBoolean;
+                itemID: z.ZodString;
+                kind: z.ZodEnum<{
+                    fact: "fact";
+                    self: "self";
+                }>;
+                lapseAt: z.ZodDate;
+                operation: z.ZodEnum<{
+                    pin: "pin";
+                    remember: "remember";
+                    retire: "retire";
+                }>;
+                origin: z.ZodEnum<{
+                    conversation: "conversation";
+                    memory_writer: "memory_writer";
+                    owner: "owner";
+                    task: "task";
+                }>;
+                proposalID: z.ZodString;
+                quote: z.ZodNullable<z.ZodString>;
+                reason: z.ZodEnum<{
+                    ambiguous_target: "ambiguous_target";
+                    checker_not_asserted: "checker_not_asserted";
+                    checker_unreachable: "checker_unreachable";
+                    checker_unsure: "checker_unsure";
+                    forgotten_evidence: "forgotten_evidence";
+                    from_photo: "from_photo";
+                    invisible_character: "invisible_character";
+                    no_quote: "no_quote";
+                    other: "other";
+                    pinned: "pinned";
+                    quote_in_quoted_block: "quote_in_quoted_block";
+                    quote_not_typed: "quote_not_typed";
+                    self_note: "self_note";
+                    sensitive: "sensitive";
+                    token_missing: "token_missing";
+                }>;
+                source: z.ZodEnum<{
+                    owner: "owner";
+                    owner_data: "owner_data";
+                    untrusted: "untrusted";
+                }>;
+                sources: z.ZodArray<z.ZodObject<{
+                    origin: z.ZodEnum<{
+                        conversation: "conversation";
+                        memory_writer: "memory_writer";
+                        owner: "owner";
+                        task: "task";
+                    }>;
+                    proposedAt: z.ZodDate;
+                    thread: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>>;
+                subject: z.ZodEnum<{
+                    owner: "owner";
+                    self: "self";
+                    shared: "shared";
+                }>;
+                targetVersion: z.ZodNullable<z.ZodInt>;
+                text: z.ZodString;
+                until: z.ZodNullable<z.ZodDate>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        approveProposals: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            answers: z.ZodArray<z.ZodObject<{
+                actionHash: z.ZodString;
+                clientActionID: z.ZodUUID;
+                proposalID: z.ZodString;
+                editedText: z.ZodOptional<z.ZodString>;
+                ignoreCloseMatch: z.ZodOptional<z.ZodBoolean>;
+                revisionOf: z.ZodOptional<z.ZodObject<{
+                    itemID: z.ZodString;
+                    version: z.ZodInt;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            outcomes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"applied">;
+            }, z.core.$strip>, z.ZodObject<{
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"rejected">;
+            }, z.core.$strip>, z.ZodObject<{
+                item: z.ZodObject<{
+                    itemID: z.ZodString;
+                    text: z.ZodString;
+                    version: z.ZodInt;
+                }, z.core.$strip>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"close_match">;
+            }, z.core.$strip>, z.ZodObject<{
+                cause: z.ZodEnum<{
+                    answered: "answered";
+                    changed: "changed";
+                    gone: "gone";
+                    lapsed: "lapsed";
+                    moved: "moved";
+                }>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"stale">;
+            }, z.core.$strip>, z.ZodObject<{
+                code: z.ZodEnum<{
+                    CLIENT_ACTION_ID_REUSED: "CLIENT_ACTION_ID_REUSED";
+                    PINNED_CORE_FULL: "PINNED_CORE_FULL";
+                    PIN_EDIT: "PIN_EDIT";
+                    RETIREMENT_EDIT: "RETIREMENT_EDIT";
+                    REVISION_TARGET: "REVISION_TARGET";
+                    WRONG_STATE: "WRONG_STATE";
+                }>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"refused">;
+            }, z.core.$strip>], "status">>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        rejectProposals: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            answers: z.ZodArray<z.ZodObject<{
+                actionHash: z.ZodString;
+                clientActionID: z.ZodUUID;
+                proposalID: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            outcomes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"applied">;
+            }, z.core.$strip>, z.ZodObject<{
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"rejected">;
+            }, z.core.$strip>, z.ZodObject<{
+                item: z.ZodObject<{
+                    itemID: z.ZodString;
+                    text: z.ZodString;
+                    version: z.ZodInt;
+                }, z.core.$strip>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"close_match">;
+            }, z.core.$strip>, z.ZodObject<{
+                cause: z.ZodEnum<{
+                    answered: "answered";
+                    changed: "changed";
+                    gone: "gone";
+                    lapsed: "lapsed";
+                    moved: "moved";
+                }>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"stale">;
+            }, z.core.$strip>, z.ZodObject<{
+                code: z.ZodEnum<{
+                    CLIENT_ACTION_ID_REUSED: "CLIENT_ACTION_ID_REUSED";
+                    PINNED_CORE_FULL: "PINNED_CORE_FULL";
+                    PIN_EDIT: "PIN_EDIT";
+                    RETIREMENT_EDIT: "RETIREMENT_EDIT";
+                    REVISION_TARGET: "REVISION_TARGET";
+                    WRONG_STATE: "WRONG_STATE";
+                }>;
+                proposalID: z.ZodString;
+                status: z.ZodLiteral<"refused">;
+            }, z.core.$strip>], "status">>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            MEMORY_NOT_STARTED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readVersions: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            versions: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                version: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            versions: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                version: z.ZodInt;
+                status: z.ZodEnum<{
+                    missing: "missing";
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        readRatingNotes: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            notes: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                sequence: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            notes: z.ZodArray<z.ZodObject<{
+                itemID: z.ZodString;
+                sequence: z.ZodInt;
+                status: z.ZodEnum<{
+                    missing: "missing";
+                    readable: "readable";
+                    shredded: "shredded";
+                    unreadable: "unreadable";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        writerStatus: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            isEnabled: z.ZodBoolean;
+            backlog: z.ZodInt;
+            batches: z.ZodInt;
+            cursor: z.ZodInt;
+            failures: z.ZodInt;
+            isCatchingUp: z.ZodBoolean;
+            lastError: z.ZodNullable<z.ZodObject<{
+                at: z.ZodDate;
+                code: z.ZodString;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            retryAt: z.ZodNullable<z.ZodDate>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        consolidatorStatus: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            isEnabled: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+    log: {
+        follow: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            afterSequence: z.ZodInt;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+            record: {
+                compaction?: {
+                    postTokens?: number | undefined;
+                    preTokens: number;
+                    trigger: "auto" | "manual";
+                } | undefined;
+                compactionFailure?: {
+                    failures: number;
+                } | undefined;
+                forget?: {
+                    sequence: number;
+                } | undefined;
+                context?: {
+                    size: number;
+                    window: number;
+                } | undefined;
+                kind: string;
+                message?: {
+                    clientMessageId?: string | undefined;
+                    images?: {
+                        mediaType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    }[] | undefined;
+                    spans?: {
+                        end: number;
+                        source: "dropped" | "pasted" | "typed" | "unknown";
+                        start: number;
+                    }[] | undefined;
+                    text: string;
+                } | undefined;
+                moment?: {
+                    momentID: string;
+                    shortID: string;
+                    title?: string | undefined;
+                } | undefined;
+                rating?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        hasNote: boolean;
+                        verdict: "helpful" | "misleading" | "noise";
+                    }[];
+                    ratedBy?: string | undefined;
+                    recalledSequence: number;
+                } | undefined;
+                recall?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        score?: number | undefined;
+                    }[];
+                } | undefined;
+                recordedAt: Date;
+                route?: {
+                    isMove: boolean;
+                    messages: number[];
+                    taskID: string;
+                } | undefined;
+                sequence: number;
+                summary?: {
+                    contextSize?: number | undefined;
+                    summaryTokens: number;
+                    text?: string | undefined;
+                    trigger: "overflow" | "threshold";
+                } | undefined;
+                thread: string;
+                task?: {
+                    error?: string | undefined;
+                    errorLimit?: number | undefined;
+                    errors?: number | undefined;
+                    retryAt?: Date | undefined;
+                    stepKey?: string | undefined;
+                    taskID: string;
+                } | undefined;
+                toolCall?: {
+                    callID: string;
+                    content?: Record<string, unknown> | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    outcome?: string | undefined;
+                    tool?: string | undefined;
+                } | undefined;
+            };
+        }, unknown, void>, import("@orpc/client").AsyncIteratorClass<{
+            record: {
+                compaction?: {
+                    postTokens?: number | undefined;
+                    preTokens: number;
+                    trigger: "auto" | "manual";
+                } | undefined;
+                compactionFailure?: {
+                    failures: number;
+                } | undefined;
+                forget?: {
+                    sequence: number;
+                } | undefined;
+                context?: {
+                    size: number;
+                    window: number;
+                } | undefined;
+                kind: string;
+                message?: {
+                    clientMessageId?: string | undefined;
+                    images?: {
+                        mediaType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    }[] | undefined;
+                    spans?: {
+                        end: number;
+                        source: "dropped" | "pasted" | "typed" | "unknown";
+                        start: number;
+                    }[] | undefined;
+                    text: string;
+                } | undefined;
+                moment?: {
+                    momentID: string;
+                    shortID: string;
+                    title?: string | undefined;
+                } | undefined;
+                rating?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        hasNote: boolean;
+                        verdict: "helpful" | "misleading" | "noise";
+                    }[];
+                    ratedBy?: string | undefined;
+                    recalledSequence: number;
+                } | undefined;
+                recall?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        score?: number | undefined;
+                    }[];
+                } | undefined;
+                recordedAt: Date;
+                route?: {
+                    isMove: boolean;
+                    messages: number[];
+                    taskID: string;
+                } | undefined;
+                sequence: number;
+                summary?: {
+                    contextSize?: number | undefined;
+                    summaryTokens: number;
+                    text?: string | undefined;
+                    trigger: "overflow" | "threshold";
+                } | undefined;
+                thread: string;
+                task?: {
+                    error?: string | undefined;
+                    errorLimit?: number | undefined;
+                    errors?: number | undefined;
+                    retryAt?: Date | undefined;
+                    stepKey?: string | undefined;
+                    taskID: string;
+                } | undefined;
+                toolCall?: {
+                    callID: string;
+                    content?: Record<string, unknown> | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    outcome?: string | undefined;
+                    tool?: string | undefined;
+                } | undefined;
+            };
+        }, unknown, void>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+    records: {
+        follow: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            afterSequence: z.ZodInt;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+            record: {
+                compaction?: {
+                    postTokens?: number | undefined;
+                    preTokens: number;
+                    trigger: "auto" | "manual";
+                } | undefined;
+                compactionFailure?: {
+                    failures: number;
+                } | undefined;
+                forget?: {
+                    sequence: number;
+                } | undefined;
+                context?: {
+                    size: number;
+                    window: number;
+                } | undefined;
+                kind: string;
+                message?: {
+                    clientMessageId?: string | undefined;
+                    images?: {
+                        mediaType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    }[] | undefined;
+                    spans?: {
+                        end: number;
+                        source: "dropped" | "pasted" | "typed" | "unknown";
+                        start: number;
+                    }[] | undefined;
+                    text: string;
+                } | undefined;
+                moment?: {
+                    momentID: string;
+                    shortID: string;
+                    title?: string | undefined;
+                } | undefined;
+                rating?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        hasNote: boolean;
+                        verdict: "helpful" | "misleading" | "noise";
+                    }[];
+                    ratedBy?: string | undefined;
+                    recalledSequence: number;
+                } | undefined;
+                recall?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        score?: number | undefined;
+                    }[];
+                } | undefined;
+                recordedAt: Date;
+                route?: {
+                    isMove: boolean;
+                    messages: number[];
+                    taskID: string;
+                } | undefined;
+                sequence: number;
+                summary?: {
+                    contextSize?: number | undefined;
+                    summaryTokens: number;
+                    text?: string | undefined;
+                    trigger: "overflow" | "threshold";
+                } | undefined;
+                thread: string;
+                task?: {
+                    error?: string | undefined;
+                    errorLimit?: number | undefined;
+                    errors?: number | undefined;
+                    retryAt?: Date | undefined;
+                    stepKey?: string | undefined;
+                    taskID: string;
+                } | undefined;
+                toolCall?: {
+                    callID: string;
+                    content?: Record<string, unknown> | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    outcome?: string | undefined;
+                    tool?: string | undefined;
+                } | undefined;
+            };
+        }, unknown, void>, import("@orpc/client").AsyncIteratorClass<{
+            record: {
+                compaction?: {
+                    postTokens?: number | undefined;
+                    preTokens: number;
+                    trigger: "auto" | "manual";
+                } | undefined;
+                compactionFailure?: {
+                    failures: number;
+                } | undefined;
+                forget?: {
+                    sequence: number;
+                } | undefined;
+                context?: {
+                    size: number;
+                    window: number;
+                } | undefined;
+                kind: string;
+                message?: {
+                    clientMessageId?: string | undefined;
+                    images?: {
+                        mediaType: "image/gif" | "image/jpeg" | "image/png" | "image/webp";
+                    }[] | undefined;
+                    spans?: {
+                        end: number;
+                        source: "dropped" | "pasted" | "typed" | "unknown";
+                        start: number;
+                    }[] | undefined;
+                    text: string;
+                } | undefined;
+                moment?: {
+                    momentID: string;
+                    shortID: string;
+                    title?: string | undefined;
+                } | undefined;
+                rating?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        hasNote: boolean;
+                        verdict: "helpful" | "misleading" | "noise";
+                    }[];
+                    ratedBy?: string | undefined;
+                    recalledSequence: number;
+                } | undefined;
+                recall?: {
+                    items: {
+                        itemID: string;
+                        version: number;
+                        score?: number | undefined;
+                    }[];
+                } | undefined;
+                recordedAt: Date;
+                route?: {
+                    isMove: boolean;
+                    messages: number[];
+                    taskID: string;
+                } | undefined;
+                sequence: number;
+                summary?: {
+                    contextSize?: number | undefined;
+                    summaryTokens: number;
+                    text?: string | undefined;
+                    trigger: "overflow" | "threshold";
+                } | undefined;
+                thread: string;
+                task?: {
+                    error?: string | undefined;
+                    errorLimit?: number | undefined;
+                    errors?: number | undefined;
+                    retryAt?: Date | undefined;
+                    stepKey?: string | undefined;
+                    taskID: string;
+                } | undefined;
+                toolCall?: {
+                    callID: string;
+                    content?: Record<string, unknown> | undefined;
+                    input?: Record<string, unknown> | undefined;
+                    outcome?: string | undefined;
+                    tool?: string | undefined;
+                } | undefined;
+            };
+        }, unknown, void>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+    sessions: {
+        enrol: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            code: z.ZodString;
+            deviceName: z.ZodString;
+            tokenDelivery: z.ZodEnum<{
+                bearer: "bearer";
+                cookie: "cookie";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionID: z.ZodUUID;
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            ENROLMENT_CODE_INVALID: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        issueCode: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            code: z.ZodString;
+            expiresAt: z.ZodDate;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+            sessions: z.ZodArray<z.ZodObject<{
+                createdAt: z.ZodDate;
+                current: z.ZodBoolean;
+                deviceName: z.ZodString;
+                lastUsedAt: z.ZodDate;
+                sessionID: z.ZodUUID;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        revoke: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            sessionID: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            revokedAt: z.ZodDate;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            SESSION_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
+};