@tangleai/context 0.21.1 → 0.24.1

package/src/schemas/ledger.d.ts

@@ -1,147 +1,177 @@
-export namespace GOAL_SCHEMA {
-    export let $id: string;
-    export let type: string;
-    export namespace properties {
-        export namespace objective {
-            let type_1: string;
-            export { type_1 as type };
-            export let minLength: number;
-        }
-        export { AT as createdAt };
-        export namespace status {
-            let _enum: string[];
-            export { _enum as enum };
-        }
-        export namespace progress {
-            let type_2: string;
-            export { type_2 as type };
-            export namespace items {
-                let type_3: string;
-                export { type_3 as type };
-                export namespace properties_1 {
-                    export { AT as at };
-                    export { ID as id };
-                    export namespace note {
-                        let type_4: string;
-                        export { type_4 as type };
-                        let minLength_1: number;
-                        export { minLength_1 as minLength };
-                    }
-                    export namespace evidence {
-                        let type_5: string;
-                        export { type_5 as type };
-                        let minLength_2: number;
-                        export { minLength_2 as minLength };
-                    }
-                }
-                export { properties_1 as properties };
-                export let required: string[];
-                export let additionalProperties: boolean;
-            }
-        }
-        export namespace checkpoint {
-            let type_6: string;
-            export { type_6 as type };
-            export namespace properties_2 {
-                namespace version {
-                    let _const: number;
-                    export { _const as const };
-                }
-                namespace records {
-                    let type_7: string;
-                    export { type_7 as type };
-                    export namespace items_1 {
-                        let type_8: string;
-                        export { type_8 as type };
-                        export namespace properties_3 {
-                            export { ID as note };
-                            export { ID as evidence };
-                        }
-                        export { properties_3 as properties };
-                        let required_1: string[];
-                        export { required_1 as required };
-                        let additionalProperties_1: boolean;
-                        export { additionalProperties_1 as additionalProperties };
-                    }
-                    export { items_1 as items };
-                }
-                namespace sources {
-                    let type_9: string;
-                    export { type_9 as type };
-                    export namespace items_2 {
-                        let type_10: string;
-                        export { type_10 as type };
-                        export namespace properties_4 {
-                            export { ID as id };
-                            export { AT as at };
-                            export namespace record {
-                                let type_11: string;
-                                export { type_11 as type };
-                                export let minimum: number;
-                            }
-                        }
-                        export { properties_4 as properties };
-                        let required_2: string[];
-                        export { required_2 as required };
-                        let additionalProperties_2: boolean;
-                        export { additionalProperties_2 as additionalProperties };
-                    }
-                    export { items_2 as items };
-                }
-            }
-            export { properties_2 as properties };
-            let required_3: string[];
-            export { required_3 as required };
-            let additionalProperties_3: boolean;
-            export { additionalProperties_3 as additionalProperties };
-        }
-        export namespace retention {
-            let type_12: string;
-            export { type_12 as type };
-            export namespace properties_5 {
-                export namespace version_1 {
-                    let _const_1: number;
-                    export { _const_1 as const };
-                }
-                export { version_1 as version };
-                export namespace reason {
-                    let _const_2: string;
-                    export { _const_2 as const };
-                }
-                export namespace retired {
-                    let type_13: string;
-                    export { type_13 as type };
-                    export { ID as items };
-                    export let uniqueItems: boolean;
-                }
-            }
-            export { properties_5 as properties };
-            let required_4: string[];
-            export { required_4 as required };
-            let additionalProperties_4: boolean;
-            export { additionalProperties_4 as additionalProperties };
-        }
-    }
-    let required_5: string[];
-    export { required_5 as required };
-    let additionalProperties_5: boolean;
-    export { additionalProperties_5 as additionalProperties };
-}
-export namespace MEMORY_SCHEMA {
-    let $id_1: string;
-    export { $id_1 as $id };
-    let type_14: string;
-    export { type_14 as type };
-    export namespace properties_6 {
-        export { ID as id };
-        export namespace text {
-            let type_15: string;
-            export { type_15 as type };
-            let minLength_3: number;
-            export { minLength_3 as minLength };
-        }
-        export namespace evidence_1 {
-            let anyOf: ({
+/**
+ * The ledger's four record schemas, as plain JSON Schema documents
+ * compiled by `JarenValidator` when a ledger is constructed. A malformed
+ * write is rejected at the boundary exactly the way a malformed tool call
+ * is — the suite validating its own durable state with its own validator.
+ *
+ * They live in one module rather than four files because they are small,
+ * they share a vocabulary (`at` is an RFC 3339 timestamp everywhere, ids
+ * are non-empty strings everywhere), and one file is where a reader looks
+ * for "what may a ledger hold".
+ *
+ * Why four kinds and not one bag: they differ in every dimension that
+ * matters. Lifetime — a goal is superseded, a memory accumulates, a slot
+ * is garbage. Retrieval — a goal is always in context, memories are
+ * recalled by relevance, slots are addressed by name. Write rule — a
+ * memory or skill may be proposed by a model (and must therefore carry
+ * evidence), a slot is written by the harness and never proposed.
+ */
+/**
+ * One active objective. Singular by construction: a second `setGoal`
+ * supersedes this one and archives it, so "what am I doing" has exactly
+ * one answer at any moment.
+ *
+ * `progress` is storage only in this order — an append-only record of
+ * what happened, with the evidence for it. Nothing here interprets a
+ * progress entry or decides when a goal is done.
+ */
+export declare const GOAL_SCHEMA: {
+    $id: string;
+    type: string;
+    properties: {
+        objective: {
+            type: string;
+            minLength: number;
+        };
+        createdAt: {
+            type: string;
+            format: string;
+            pattern: string;
+        };
+        status: {
+            enum: string[];
+        };
+        progress: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    at: {
+                        type: string;
+                        format: string;
+                        pattern: string;
+                    };
+                    id: {
+                        type: string;
+                        minLength: number;
+                    };
+                    note: {
+                        type: string;
+                        minLength: number;
+                    };
+                    evidence: {
+                        type: string;
+                        minLength: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        checkpoint: {
+            type: string;
+            properties: {
+                version: {
+                    const: number;
+                };
+                records: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            note: {
+                                type: string;
+                                minLength: number;
+                            };
+                            evidence: {
+                                type: string;
+                                minLength: number;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                sources: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                minLength: number;
+                            };
+                            at: {
+                                type: string;
+                                format: string;
+                                pattern: string;
+                            };
+                            record: {
+                                type: string;
+                                minimum: number;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        retention: {
+            type: string;
+            properties: {
+                version: {
+                    const: number;
+                };
+                reason: {
+                    const: string;
+                };
+                retired: {
+                    type: string;
+                    items: {
+                        type: string;
+                        minLength: number;
+                    };
+                    uniqueItems: boolean;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+/**
+ * A fact worth carrying past this context window.
+ *
+ * `evidence` is REQUIRED, and that is the load-bearing part: a memory
+ * without evidence is not a memory, it is a guess, and a ledger full of
+ * guesses is worse than an empty one. It is also what makes a
+ * model-proposed refinement auditable — the reviewer of a patch can ask
+ * "on what basis" and get an answer from the record itself.
+ *
+ * `embedding` + `embeddedBy` are optional and travel together: a memory
+ * that carries them can be recalled by meaning through the embedder
+ * seam; one that does not is recalled by tag and recency exactly as
+ * before, and ranked recall reports it as skipped rather than scoring it.
+ */
+export declare const MEMORY_SCHEMA: {
+    $id: string;
+    type: string;
+    properties: {
+        id: {
+            type: string;
+            minLength: number;
+        };
+        text: {
+            type: string;
+            minLength: number;
+        };
+        evidence: {
+            anyOf: ({
                 type: "object";
                 properties: Record<string, object>;
                 required: string[];
@@ -150,199 +180,566 @@ export namespace MEMORY_SCHEMA {
                 type: string;
                 minLength: number;
             })[];
-        }
-        export { evidence_1 as evidence };
-        export namespace tags {
-            let type_16: string;
-            export { type_16 as type };
-            export namespace items_3 {
-                let type_17: string;
-                export { type_17 as type };
-                let minLength_4: number;
-                export { minLength_4 as minLength };
-            }
-            export { items_3 as items };
-        }
-        export { AT as at };
-        export { EMBEDDING as embedding };
-        export { EMBEDDED_BY as embeddedBy };
-    }
-    export { properties_6 as properties };
-    let required_6: string[];
-    export { required_6 as required };
-    export { EMBEDDING_PAIR as dependencies };
-    let additionalProperties_6: boolean;
-    export { additionalProperties_6 as additionalProperties };
-}
-export namespace PROGRAM_SKILL_SCHEMA {
-    let type_18: string;
-    export { type_18 as type };
-    export namespace properties_7 {
-        export namespace version_2 {
-            let _const_3: number;
-            export { _const_3 as const };
-        }
-        export { version_2 as version };
-        export namespace question {
-            let type_19: string;
-            export { type_19 as type };
-            let minLength_5: number;
-            export { minLength_5 as minLength };
-        }
-        export namespace fingerprint {
-            let type_20: string;
-            export { type_20 as type };
-            export let pattern: string;
-        }
-        export namespace environmentId {
-            let type_21: string;
-            export { type_21 as type };
-            let minLength_6: number;
-            export { minLength_6 as minLength };
-        }
-        export namespace schemaVersion {
-            let type_22: string;
-            export { type_22 as type };
-            let minLength_7: number;
-            export { minLength_7 as minLength };
-        }
-        export namespace document {
-            let type_23: string;
-            export { type_23 as type };
-        }
-        export namespace evidence_2 {
-            let type_24: string;
-            export { type_24 as type };
-            let minLength_8: number;
-            export { minLength_8 as minLength };
-        }
-        export { evidence_2 as evidence };
-        export namespace checked {
-            let _const_4: boolean;
-            export { _const_4 as const };
-        }
-    }
-    export { properties_7 as properties };
-    let required_7: string[];
-    export { required_7 as required };
-    let additionalProperties_7: boolean;
-    export { additionalProperties_7 as additionalProperties };
-}
-export namespace SKILL_SCHEMA {
-    let $id_2: string;
-    export { $id_2 as $id };
-    let type_25: string;
-    export { type_25 as type };
-    export namespace properties_8 {
-        export { ID as id };
-        export namespace name {
-            let type_26: string;
-            export { type_26 as type };
-            let minLength_9: number;
-            export { minLength_9 as minLength };
-        }
-        export namespace when {
-            let type_27: string;
-            export { type_27 as type };
-            let minLength_10: number;
-            export { minLength_10 as minLength };
-        }
-        export namespace instructions {
-            let type_28: string;
-            export { type_28 as type };
-            let minLength_11: number;
-            export { minLength_11 as minLength };
-        }
-        export { PROGRAM_SKILL_SCHEMA as program };
-        export namespace tools {
-            let type_29: string;
-            export { type_29 as type };
-            export namespace items_4 {
-                let type_30: string;
-                export { type_30 as type };
-                let minLength_12: number;
-                export { minLength_12 as minLength };
-            }
-            export { items_4 as items };
-        }
-        export { AT as at };
-        export { EMBEDDING as embedding };
-        export { EMBEDDED_BY as embeddedBy };
-    }
-    export { properties_8 as properties };
-    let required_8: string[];
-    export { required_8 as required };
-    export { EMBEDDING_PAIR as dependencies };
-    let additionalProperties_8: boolean;
-    export { additionalProperties_8 as additionalProperties };
-}
-export namespace SLOT_SCHEMA {
-    let $id_3: string;
-    export { $id_3 as $id };
-    let type_31: string;
-    export { type_31 as type };
-    export namespace properties_9 {
-        export { ID as name };
-        export namespace kind {
-            let type_32: string;
-            export { type_32 as type };
-            let minLength_13: number;
-            export { minLength_13 as minLength };
-        }
-        export namespace size {
-            let type_33: string;
-            export { type_33 as type };
-            let minimum_1: number;
-            export { minimum_1 as minimum };
-        }
-        export namespace excerpt {
-            let type_34: string;
-            export { type_34 as type };
-        }
-        export { AT as at };
-        export namespace count {
-            let type_35: string;
-            export { type_35 as type };
-            let minimum_2: number;
-            export { minimum_2 as minimum };
-        }
-        export namespace pinned {
-            let type_36: string;
-            export { type_36 as type };
-        }
-    }
-    export { properties_9 as properties };
-    let required_9: string[];
-    export { required_9 as required };
-    let additionalProperties_9: boolean;
-    export { additionalProperties_9 as additionalProperties };
-}
-export namespace LEDGER_SCHEMAS {
-    export { GOAL_SCHEMA as goal };
-    export { MEMORY_SCHEMA as memory };
-    export { SKILL_SCHEMA as skill };
-    export { SLOT_SCHEMA as slot };
-}
+        };
+        tags: {
+            type: string;
+            items: {
+                type: string;
+                minLength: number;
+            };
+        };
+        at: {
+            type: string;
+            format: string;
+            pattern: string;
+        };
+        embedding: {
+            type: string;
+            items: {
+                type: string;
+            };
+            minItems: number;
+        };
+        embeddedBy: {
+            type: string;
+            properties: {
+                model: {
+                    type: string;
+                    minLength: number;
+                };
+                dims: {
+                    type: string;
+                    minimum: number;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+    required: string[];
+    dependencies: {
+        embedding: string[];
+        embeddedBy: string[];
+    };
+    additionalProperties: boolean;
+};
 /**
- * One evidenced progress entry on the active goal.
+ * A reusable recipe: when it applies, what to do, and which tools it
+ * needs. Retrieved like a memory and composed into a system prompt by
+ * whatever drives the agent — the ledger stores it and nothing more.
  */
+export declare const PROGRAM_SKILL_SCHEMA: {
+    type: string;
+    properties: {
+        version: {
+            const: number;
+        };
+        question: {
+            type: string;
+            minLength: number;
+        };
+        fingerprint: {
+            type: string;
+            pattern: string;
+        };
+        environmentId: {
+            type: string;
+            minLength: number;
+        };
+        schemaVersion: {
+            type: string;
+            minLength: number;
+        };
+        document: {
+            type: string;
+        };
+        evidence: {
+            type: string;
+            minLength: number;
+        };
+        checked: {
+            const: boolean;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const SKILL_SCHEMA: {
+    $id: string;
+    type: string;
+    properties: {
+        id: {
+            type: string;
+            minLength: number;
+        };
+        name: {
+            type: string;
+            minLength: number;
+        };
+        when: {
+            type: string;
+            minLength: number;
+        };
+        instructions: {
+            type: string;
+            minLength: number;
+        };
+        program: {
+            type: string;
+            properties: {
+                version: {
+                    const: number;
+                };
+                question: {
+                    type: string;
+                    minLength: number;
+                };
+                fingerprint: {
+                    type: string;
+                    pattern: string;
+                };
+                environmentId: {
+                    type: string;
+                    minLength: number;
+                };
+                schemaVersion: {
+                    type: string;
+                    minLength: number;
+                };
+                document: {
+                    type: string;
+                };
+                evidence: {
+                    type: string;
+                    minLength: number;
+                };
+                checked: {
+                    const: boolean;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        tools: {
+            type: string;
+            items: {
+                type: string;
+                minLength: number;
+            };
+        };
+        at: {
+            type: string;
+            format: string;
+            pattern: string;
+        };
+        embedding: {
+            type: string;
+            items: {
+                type: string;
+            };
+            minItems: number;
+        };
+        embeddedBy: {
+            type: string;
+            properties: {
+                model: {
+                    type: string;
+                    minLength: number;
+                };
+                dims: {
+                    type: string;
+                    minimum: number;
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+    };
+    required: string[];
+    dependencies: {
+        embedding: string[];
+        embeddedBy: string[];
+    };
+    additionalProperties: boolean;
+};
+/**
+ * An addressable blob's METADATA. The content lives under a separate
+ * storage key and never travels with the metadata — that separation is
+ * the whole point: a root request may carry `{ name, kind, size, excerpt }`
+ * for a hundred slots without carrying one slot's content.
+ */
+export declare const SLOT_SCHEMA: {
+    $id: string;
+    type: string;
+    properties: {
+        name: {
+            type: string;
+            minLength: number;
+        };
+        kind: {
+            type: string;
+            minLength: number;
+        };
+        size: {
+            type: string;
+            minimum: number;
+        };
+        excerpt: {
+            type: string;
+        };
+        at: {
+            type: string;
+            format: string;
+            pattern: string;
+        };
+        count: {
+            type: string;
+            minimum: number;
+        };
+        pinned: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+/** Every ledger schema by kind — what `createLedger` compiles at construction. */
+export declare const LEDGER_SCHEMAS: {
+    goal: {
+        $id: string;
+        type: string;
+        properties: {
+            objective: {
+                type: string;
+                minLength: number;
+            };
+            createdAt: {
+                type: string;
+                format: string;
+                pattern: string;
+            };
+            status: {
+                enum: string[];
+            };
+            progress: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        at: {
+                            type: string;
+                            format: string;
+                            pattern: string;
+                        };
+                        id: {
+                            type: string;
+                            minLength: number;
+                        };
+                        note: {
+                            type: string;
+                            minLength: number;
+                        };
+                        evidence: {
+                            type: string;
+                            minLength: number;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+            checkpoint: {
+                type: string;
+                properties: {
+                    version: {
+                        const: number;
+                    };
+                    records: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                note: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                                evidence: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    sources: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                id: {
+                                    type: string;
+                                    minLength: number;
+                                };
+                                at: {
+                                    type: string;
+                                    format: string;
+                                    pattern: string;
+                                };
+                                record: {
+                                    type: string;
+                                    minimum: number;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            retention: {
+                type: string;
+                properties: {
+                    version: {
+                        const: number;
+                    };
+                    reason: {
+                        const: string;
+                    };
+                    retired: {
+                        type: string;
+                        items: {
+                            type: string;
+                            minLength: number;
+                        };
+                        uniqueItems: boolean;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    memory: {
+        $id: string;
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                minLength: number;
+            };
+            text: {
+                type: string;
+                minLength: number;
+            };
+            evidence: {
+                anyOf: ({
+                    type: "object";
+                    properties: Record<string, object>;
+                    required: string[];
+                    additionalProperties: false;
+                } | {
+                    type: string;
+                    minLength: number;
+                })[];
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            at: {
+                type: string;
+                format: string;
+                pattern: string;
+            };
+            embedding: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                minItems: number;
+            };
+            embeddedBy: {
+                type: string;
+                properties: {
+                    model: {
+                        type: string;
+                        minLength: number;
+                    };
+                    dims: {
+                        type: string;
+                        minimum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: string[];
+        dependencies: {
+            embedding: string[];
+            embeddedBy: string[];
+        };
+        additionalProperties: boolean;
+    };
+    skill: {
+        $id: string;
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                minLength: number;
+            };
+            name: {
+                type: string;
+                minLength: number;
+            };
+            when: {
+                type: string;
+                minLength: number;
+            };
+            instructions: {
+                type: string;
+                minLength: number;
+            };
+            program: {
+                type: string;
+                properties: {
+                    version: {
+                        const: number;
+                    };
+                    question: {
+                        type: string;
+                        minLength: number;
+                    };
+                    fingerprint: {
+                        type: string;
+                        pattern: string;
+                    };
+                    environmentId: {
+                        type: string;
+                        minLength: number;
+                    };
+                    schemaVersion: {
+                        type: string;
+                        minLength: number;
+                    };
+                    document: {
+                        type: string;
+                    };
+                    evidence: {
+                        type: string;
+                        minLength: number;
+                    };
+                    checked: {
+                        const: boolean;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            tools: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            at: {
+                type: string;
+                format: string;
+                pattern: string;
+            };
+            embedding: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                minItems: number;
+            };
+            embeddedBy: {
+                type: string;
+                properties: {
+                    model: {
+                        type: string;
+                        minLength: number;
+                    };
+                    dims: {
+                        type: string;
+                        minimum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: string[];
+        dependencies: {
+            embedding: string[];
+            embeddedBy: string[];
+        };
+        additionalProperties: boolean;
+    };
+    slot: {
+        $id: string;
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                minLength: number;
+            };
+            kind: {
+                type: string;
+                minLength: number;
+            };
+            size: {
+                type: string;
+                minimum: number;
+            };
+            excerpt: {
+                type: string;
+            };
+            at: {
+                type: string;
+                format: string;
+                pattern: string;
+            };
+            count: {
+                type: string;
+                minimum: number;
+            };
+            pinned: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+/** One evidenced progress entry on the active goal. */
+/** The one rejection shape every schema-guarded write answers with —
+ * produced by `invalidInput` in `check.ts`, named here because this is
+ * where a consumer of the ledger's API goes looking for "what comes
+ * back when a write is refused". */
 export type LedgerProgressEntry = {
-    id?: string;
-    /**
-     * RFC 3339
-     */
+    id?: string; /**
+   * RFC 3339
+   */
     at: string;
     note: string;
     evidence: string;
 };
-/**
- * The active (or archived) objective — see {@link GOAL_SCHEMA}.
- */
 export type LedgerGoal = {
-    objective: string;
-    /**
-     * RFC 3339
-     */
+    objective: string; /**
+   * RFC 3339
+   */
     createdAt: string;
     status: "active" | "done" | "abandoned" | "superseded";
     progress: LedgerProgressEntry[];
@@ -364,24 +761,10 @@ export type LedgerGoal = {
         retired: string[];
     };
 };
-/**
- * A vector's identity — see {@link EMBEDDED_BY}. What `recall({ near })`
- * compares against the query embedder's `{ model, dims }` before any
- * arithmetic happens.
- */
 export type LedgerEmbeddedBy = {
     model: string;
     dims: number;
 };
-/**
- * The vector pair, both-or-neither — the schemas' `dependencies` rule
- * (see {@link EMBEDDING_PAIR}) stated in the type: a record either
- * carries `embedding` AND `embeddedBy`, or neither. `embedding` is the
- * vector `recall({ near })` ranks by — plain numbers, never a typed
- * array — and `embeddedBy` its identity. Narrow on either member and
- * the other follows: `if (record.embedding) record.embeddedBy.dims`.
- * An orphan vector does not type, just as the ledger refuses it.
- */
 export type LedgerEmbeddingPair = {
     embedding?: undefined;
     embeddedBy?: undefined;
@@ -389,37 +772,24 @@ export type LedgerEmbeddingPair = {
     embedding: number[];
     embeddedBy: LedgerEmbeddedBy;
 };
-/**
- * A stored memory's own members — see {@link MEMORY_SCHEMA}; the
- * record is these plus {@link LedgerEmbeddingPair}.
- */
 export type LedgerMemoryFields = {
     id: string;
     text: string;
-    evidence: string | import("./evidence.js").ClaimEvidenceEnvelope;
-    tags: string[];
-    /**
-     * RFC 3339
-     */
+    evidence: string | import('./evidence.ts').ClaimEvidenceEnvelope;
+    tags: string[]; /**
+   * RFC 3339
+   */
     at: string;
 };
-/**
- * A stored memory — see {@link MEMORY_SCHEMA}.
- */
 export type LedgerMemory = LedgerMemoryFields & LedgerEmbeddingPair;
-/**
- * A stored skill's own members — see {@link SKILL_SCHEMA}; the record
- * is these plus {@link LedgerEmbeddingPair}.
- */
 export type LedgerSkillFields = {
     id: string;
     name: string;
     when: string;
     instructions: string;
-    tools: string[];
-    /**
-     * RFC 3339
-     */
+    tools: string[]; /**
+   * RFC 3339
+   */
     at: string;
     program?: {
         version: 1;
@@ -432,84 +802,21 @@ export type LedgerSkillFields = {
         checked: true;
     };
 };
-/**
- * A stored skill — see {@link SKILL_SCHEMA}.
- */
 export type LedgerSkill = LedgerSkillFields & LedgerEmbeddingPair;
-/**
- * A slot's metadata — see {@link SLOT_SCHEMA}. Never the content.
- */
 export type LedgerSlot = {
     name: string;
     kind: string;
     size: number;
-    excerpt: string;
-    /**
-     * RFC 3339
-     */
+    excerpt: string; /**
+   * RFC 3339
+   */
     at: string;
     count?: number;
     pinned?: boolean;
 };
-/**
- * The one rejection shape every schema-guarded write answers with —
- * produced by `invalidInput` in `check.js`, named here because this is
- * where a consumer of the ledger's API goes looking for "what comes
- * back when a write is refused".
- */
 export type LedgerRejection = {
     error: string;
+    code?: string;
     errors: any[];
     inputSchema: any;
 };
-declare namespace AT {
-    let type_37: string;
-    export { type_37 as type };
-    export let format: string;
-    let pattern_1: string;
-    export { pattern_1 as pattern };
-}
-declare namespace ID {
-    let type_38: string;
-    export { type_38 as type };
-    let minLength_14: number;
-    export { minLength_14 as minLength };
-}
-declare namespace EMBEDDING {
-    let type_39: string;
-    export { type_39 as type };
-    export namespace items_5 {
-        let type_40: string;
-        export { type_40 as type };
-    }
-    export { items_5 as items };
-    export let minItems: number;
-}
-declare namespace EMBEDDED_BY {
-    let type_41: string;
-    export { type_41 as type };
-    export namespace properties_10 {
-        namespace model {
-            let type_42: string;
-            export { type_42 as type };
-            let minLength_15: number;
-            export { minLength_15 as minLength };
-        }
-        namespace dims {
-            let type_43: string;
-            export { type_43 as type };
-            let minimum_3: number;
-            export { minimum_3 as minimum };
-        }
-    }
-    export { properties_10 as properties };
-    let required_10: string[];
-    export { required_10 as required };
-    let additionalProperties_10: boolean;
-    export { additionalProperties_10 as additionalProperties };
-}
-declare namespace EMBEDDING_PAIR {
-    let embedding: string[];
-    let embeddedBy: string[];
-}
-export {};