@tangleai/context 0.21.1

package/src/schemas/ledger.d.ts

@@ -0,0 +1,515 @@
+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: ({
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: false;
+            } | {
+                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 };
+}
+/**
+ * One evidenced progress entry on the active goal.
+ */
+export type LedgerProgressEntry = {
+    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
+     */
+    createdAt: string;
+    status: "active" | "done" | "abandoned" | "superseded";
+    progress: LedgerProgressEntry[];
+    checkpoint?: {
+        version: 1;
+        records: {
+            note: string;
+            evidence: string;
+        }[];
+        sources: {
+            id: string;
+            at: string;
+            record: number;
+        }[];
+    };
+    retention?: {
+        version: 1;
+        reason: "goal-budget";
+        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;
+} | {
+    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
+     */
+    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
+     */
+    at: string;
+    program?: {
+        version: 1;
+        question: string;
+        fingerprint: string;
+        environmentId: string;
+        schemaVersion: string;
+        document: any;
+        evidence: string;
+        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
+     */
+    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;
+    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 {};