@tangleai/context 0.21.1 → 0.25.0

package/src/evidence.d.ts

@@ -2,11 +2,10 @@
  * Validate structure and references, without interpreting prose or making requests.
  * Supplied artifacts are the host's allow-list; matching ids must retain their
  * admitted descriptor. Without an external list, the envelope is self-contained.
- * @param {any} envelope
- * @param {{ artifacts?: import('./schemas/evidence.js').ArtifactRecord[] }} [options]
+ * @param [options]
  */
-export function validateClaimEvidence(envelope: any, options?: {
-    artifacts?: import("./schemas/evidence.js").ArtifactRecord[];
+export declare function validateClaimEvidence(envelope: any, options?: {
+    artifacts?: import('./schemas/evidence.ts').ArtifactRecord[];
 }): {
     valid: boolean;
     errors: any[];
@@ -14,17 +13,13 @@ export function validateClaimEvidence(envelope: any, options?: {
 /**
  * A second guarded-document consumer: replace or patch a claim envelope using
  * host persistence and an explicit artifact admission list.
- * @param {{ read: () => Promise<any>, apply: (document: any, proposal: any) => any,
- *   validateProposal: (proposal: any) => any, commit: (document: any) => Promise<any>,
- *   artifacts: import('./schemas/evidence.js').ArtifactRecord[],
- *   snapshot?: () => Promise<any>, restore?: (token: any) => Promise<any> }} options
  */
-export function createClaimRefiner(options: {
+export declare function createClaimRefiner(options: {
     read: () => Promise<any>;
     apply: (document: any, proposal: any) => any;
     validateProposal: (proposal: any) => any;
     commit: (document: any) => Promise<any>;
-    artifacts: import("./schemas/evidence.js").ArtifactRecord[];
+    artifacts: import('./schemas/evidence.ts').ArtifactRecord[];
     snapshot?: () => Promise<any>;
     restore?: (token: any) => Promise<any>;
 }): {

package/src/evidence.js

@@ -1,71 +1,69 @@
-//@ts-check
 import { JarenValidator } from '@jarenjs/validate';
 import { checkOutcome } from '@jarenjs/core/check';
-import { CLAIM_EVIDENCE_SCHEMA } from './schemas/evidence.js';
+import { CLAIM_EVIDENCE_SCHEMA } from "./schemas/evidence.js";
 import { createGuardedRefiner } from '@jarenjs/core/guarded';
 const check = new JarenValidator({ collectErrors: true, skipErrors: false }).compile(CLAIM_EVIDENCE_SCHEMA);
-
 /**
  * Validate structure and references, without interpreting prose or making requests.
  * Supplied artifacts are the host's allow-list; matching ids must retain their
  * admitted descriptor. Without an external list, the envelope is self-contained.
- * @param {any} envelope
- * @param {{ artifacts?: import('./schemas/evidence.js').ArtifactRecord[] }} [options]
+ * @param [options]
  */
 export function validateClaimEvidence(envelope, options = {}) {
-  const shape = checkOutcome(check(envelope));
-  if (!shape.valid) return shape;
-  const errors = [];
-  const add = (code, docPath, message) => errors.push({ code, docPath, instancePath: docPath, message });
-  const sets = {};
-  for (const kind of ['artifacts', 'evidence', 'claims']) {
-    const ids = new Set();
-    envelope[kind].forEach((record, index) => {
-      if (ids.has(record.id)) add('EVIDENCE_DUPLICATE', `/${kind}/${index}/id`, `duplicate ${kind} id '${record.id}'`);
-      ids.add(record.id);
+    const shape = checkOutcome(check(envelope));
+    if (!shape.valid)
+        return shape;
+    const errors = [];
+    const add = (code, docPath, message) => errors.push({ code, docPath, instancePath: docPath, message });
+    const sets = {};
+    for (const kind of ['artifacts', 'evidence', 'claims']) {
+        const ids = new Set();
+        envelope[kind].forEach((record, index) => {
+            if (ids.has(record.id))
+                add('EVIDENCE_DUPLICATE', `/${kind}/${index}/id`, `duplicate ${kind} id '${record.id}'`);
+            ids.add(record.id);
+        });
+        sets[kind] = ids;
+    }
+    if (options.artifacts) {
+        const admitted = new Map(options.artifacts.map((artifact) => [artifact.id, artifact]));
+        envelope.artifacts.forEach((artifact, i) => {
+            const held = admitted.get(artifact.id);
+            if (!held || ['kind', 'locator', 'digest'].some((field) => artifact[field] !== held[field]))
+                add('EVIDENCE_UNADMITTED', `/artifacts/${i}`, `artifact '${artifact.id}' is not admitted with this descriptor`);
+        });
+    }
+    envelope.evidence.forEach((record, i) => {
+        if (!sets.artifacts.has(record.artifact))
+            add('EVIDENCE_ARTIFACT', `/evidence/${i}/artifact`, `unknown artifact '${record.artifact}'`);
     });
-    sets[kind] = ids;
-  }
-  if (options.artifacts) {
-    const admitted = new Map(options.artifacts.map((artifact) => [artifact.id, artifact]));
-    envelope.artifacts.forEach((artifact, i) => {
-      const held = admitted.get(artifact.id);
-      if (!held || ['kind', 'locator', 'digest'].some((field) => artifact[field] !== held[field]))
-        add('EVIDENCE_UNADMITTED', `/artifacts/${i}`, `artifact '${artifact.id}' is not admitted with this descriptor`);
+    const visible = new Set(envelope.visibleEvidence);
+    envelope.visibleEvidence.forEach((id, i) => {
+        if (!sets.evidence.has(id))
+            add('EVIDENCE_REFERENCE', `/visibleEvidence/${i}`, `unknown evidence '${id}'`);
     });
-  }
-  envelope.evidence.forEach((record, i) => {
-    if (!sets.artifacts.has(record.artifact))
-      add('EVIDENCE_ARTIFACT', `/evidence/${i}/artifact`, `unknown artifact '${record.artifact}'`);
-  });
-  const visible = new Set(envelope.visibleEvidence);
-  envelope.visibleEvidence.forEach((id, i) => {
-    if (!sets.evidence.has(id)) add('EVIDENCE_REFERENCE', `/visibleEvidence/${i}`, `unknown evidence '${id}'`);
-  });
-  envelope.claims.forEach((claim, i) => {
-    if (claim.critical && (claim.status === 'unresolved' || claim.evidence.length === 0))
-      add('EVIDENCE_CRITICAL', `/claims/${i}/status`, `critical claim '${claim.id}' is unresolved`);
-    claim.evidence.forEach((id, j) => {
-      if (!sets.evidence.has(id)) add('EVIDENCE_REFERENCE', `/claims/${i}/evidence/${j}`, `unknown evidence '${id}'`);
-      else if (!visible.has(id)) add('EVIDENCE_HIDDEN', `/claims/${i}/evidence/${j}`, `evidence '${id}' is outside the visible view`);
+    envelope.claims.forEach((claim, i) => {
+        if (claim.critical && (claim.status === 'unresolved' || claim.evidence.length === 0))
+            add('EVIDENCE_CRITICAL', `/claims/${i}/status`, `critical claim '${claim.id}' is unresolved`);
+        claim.evidence.forEach((id, j) => {
+            if (!sets.evidence.has(id))
+                add('EVIDENCE_REFERENCE', `/claims/${i}/evidence/${j}`, `unknown evidence '${id}'`);
+            else if (!visible.has(id))
+                add('EVIDENCE_HIDDEN', `/claims/${i}/evidence/${j}`, `evidence '${id}' is outside the visible view`);
+        });
     });
-  });
-  errors.sort((a, b) => a.docPath < b.docPath ? -1 : a.docPath > b.docPath ? 1 : a.code.localeCompare(b.code));
-  return { valid: errors.length === 0, errors };
+    errors.sort((a, b) => a.docPath < b.docPath ? -1 : a.docPath > b.docPath ? 1 : a.code.localeCompare(b.code));
+    return { valid: errors.length === 0, errors };
 }
-
 /**
  * A second guarded-document consumer: replace or patch a claim envelope using
  * host persistence and an explicit artifact admission list.
- * @param {{ read: () => Promise<any>, apply: (document: any, proposal: any) => any,
- *   validateProposal: (proposal: any) => any, commit: (document: any) => Promise<any>,
- *   artifacts: import('./schemas/evidence.js').ArtifactRecord[],
- *   snapshot?: () => Promise<any>, restore?: (token: any) => Promise<any> }} options
  */
 export function createClaimRefiner(options) {
-  const artifacts = JSON.parse(JSON.stringify(options.artifacts));
-  return createGuardedRefiner({ ...options,
-    validateCandidate: (next) => validateClaimEvidence(next, { artifacts }),
-    planCommit: (next) => next,
-  });
+    const artifacts = JSON.parse(JSON.stringify(options.artifacts));
+    return createGuardedRefiner({
+        ...options,
+        validateCandidate: (next) => validateClaimEvidence(next, { artifacts }),
+        planCommit: (next) => next,
+    });
 }

package/src/index.d.ts

@@ -1,9 +1,10 @@
-export { createMemoryStorage } from "./storage/memory.js";
-export { RECALL_TOOL_NAME, createRecallTool, roundSlotName, indexSlotName, slotRef, slotAddress, slotAddressesIn } from "./recall.js";
-export { createLedger, sameIdentity, describeIdentity } from "./ledger.js";
-export { createEnvironment, environmentTools, chunkSlotName, chunkFamily, CHUNK_KIND } from "./environment.js";
-export { LEDGER_SCHEMAS, GOAL_SCHEMA, MEMORY_SCHEMA, SKILL_SCHEMA, SLOT_SCHEMA } from "./schemas/ledger.js";
-export { REFINEMENT_PATCH_SCHEMA, refinementPatchSchema, REFINEMENT_PATH_PATTERN, DEFAULT_MAX_OPS, MEMORY_PROPOSAL_SCHEMA, SKILL_PROPOSAL_SCHEMA, PROGRESS_PROPOSAL_SCHEMA } from "./schemas/patch.js";
-export { validateClaimEvidence, createClaimRefiner } from "./evidence.js";
-export { CLAIM_EVIDENCE_SCHEMA, ARTIFACT_SCHEMA, EVIDENCE_SCHEMA, CLAIM_SCHEMA } from "./schemas/evidence.js";
-export { ledgerFootprint, checkpointProgress, validateCheckpoint, goalPrompt } from "./retention.js";
+/** context: public AI mechanisms over injected Jaren foundations. */
+export { RECALL_TOOL_NAME, createRecallTool, roundSlotName, indexSlotName, slotRef, slotAddress, slotAddressesIn } from './recall.ts';
+export { createLedger, sameIdentity, describeIdentity } from './ledger.ts';
+export { createEnvironment, environmentTools, chunkSlotName, chunkFamily, CHUNK_KIND } from './environment.ts';
+export { createMemoryStorage } from './storage/memory.ts';
+export { LEDGER_SCHEMAS, GOAL_SCHEMA, MEMORY_SCHEMA, SKILL_SCHEMA, SLOT_SCHEMA } from './schemas/ledger.ts';
+export { REFINEMENT_PATCH_SCHEMA, refinementPatchSchema, REFINEMENT_PATH_PATTERN, DEFAULT_MAX_OPS, MEMORY_PROPOSAL_SCHEMA, SKILL_PROPOSAL_SCHEMA, PROGRESS_PROPOSAL_SCHEMA } from './schemas/patch.ts';
+export { validateClaimEvidence, createClaimRefiner } from './evidence.ts';
+export { CLAIM_EVIDENCE_SCHEMA, ARTIFACT_SCHEMA, EVIDENCE_SCHEMA, CLAIM_SCHEMA } from './schemas/evidence.ts';
+export { ledgerFootprint, checkpointProgress, validateCheckpoint, goalPrompt } from './retention.ts';

package/src/index.js

@@ -1,11 +1,10 @@
-//@ts-check
 /** context: public AI mechanisms over injected Jaren foundations. */
-export { RECALL_TOOL_NAME, createRecallTool, roundSlotName, indexSlotName, slotRef, slotAddress, slotAddressesIn } from './recall.js';
-export { createLedger, sameIdentity, describeIdentity } from './ledger.js';
-export { createEnvironment, environmentTools, chunkSlotName, chunkFamily, CHUNK_KIND } from './environment.js';
-export { createMemoryStorage } from './storage/memory.js';
-export { LEDGER_SCHEMAS, GOAL_SCHEMA, MEMORY_SCHEMA, SKILL_SCHEMA, SLOT_SCHEMA } from './schemas/ledger.js';
-export { REFINEMENT_PATCH_SCHEMA, refinementPatchSchema, REFINEMENT_PATH_PATTERN, DEFAULT_MAX_OPS, MEMORY_PROPOSAL_SCHEMA, SKILL_PROPOSAL_SCHEMA, PROGRESS_PROPOSAL_SCHEMA } from './schemas/patch.js';
-export { validateClaimEvidence, createClaimRefiner } from './evidence.js';
-export { CLAIM_EVIDENCE_SCHEMA, ARTIFACT_SCHEMA, EVIDENCE_SCHEMA, CLAIM_SCHEMA } from './schemas/evidence.js';
-export { ledgerFootprint, checkpointProgress, validateCheckpoint, goalPrompt } from './retention.js';
+export { RECALL_TOOL_NAME, createRecallTool, roundSlotName, indexSlotName, slotRef, slotAddress, slotAddressesIn } from "./recall.js";
+export { createLedger, sameIdentity, describeIdentity } from "./ledger.js";
+export { createEnvironment, environmentTools, chunkSlotName, chunkFamily, CHUNK_KIND } from "./environment.js";
+export { createMemoryStorage } from "./storage/memory.js";
+export { LEDGER_SCHEMAS, GOAL_SCHEMA, MEMORY_SCHEMA, SKILL_SCHEMA, SLOT_SCHEMA } from "./schemas/ledger.js";
+export { REFINEMENT_PATCH_SCHEMA, refinementPatchSchema, REFINEMENT_PATH_PATTERN, DEFAULT_MAX_OPS, MEMORY_PROPOSAL_SCHEMA, SKILL_PROPOSAL_SCHEMA, PROGRESS_PROPOSAL_SCHEMA } from "./schemas/patch.js";
+export { validateClaimEvidence, createClaimRefiner } from "./evidence.js";
+export { CLAIM_EVIDENCE_SCHEMA, ARTIFACT_SCHEMA, EVIDENCE_SCHEMA, CLAIM_SCHEMA } from "./schemas/evidence.js";
+export { ledgerFootprint, checkpointProgress, validateCheckpoint, goalPrompt } from "./retention.js";

package/src/ledger.d.ts

@@ -1,3 +1,59 @@
+/**
+ * The ledger: schema-validated, durable, addressable state that outlives
+ * a context window.
+ *
+ * An agent today is bounded by one transcript — everything it learned is
+ * gone when the tab closes, and everything it gathered is gone when the
+ * history budget bites. The ledger is the other half: a goal it is
+ * working towards, memories it has earned, skills it can reuse, and
+ * slots holding content too big to carry. Four kinds, one small
+ * interface, over an injected storage adapter.
+ *
+ * Three decisions shape the whole file:
+ *
+ *  - **Storage is injected, never imported.** The adapter is four async
+ *    methods (`get`/`set`/`delete`/`keys`); a host backs it with
+ *    `@jarenjs/db` over OPFS, with `localStorage`, or with nothing. This
+ *    package keeps exactly two dependencies, so it still loads in a
+ *    static page — `createLedger()` with no arguments works, in memory.
+ *    Optional `mutate` atomically transforms a detached record map. Ledger
+ *    writes stage outside storage and publish with comparison against current
+ *    state. Four-method adapters retain the explicit single-writer contract.
+ *  - **Nothing enters without passing its schema**, compiled by
+ *    `JarenValidator` here at construction. A rejected write answers the
+ *    same `{ error, errors, inputSchema }` the toolbox answers with (one
+ *    implementation, in `check.ts`) and never throws: a model that wrote
+ *    a bad memory can read why and fix it.
+ *  - **Every mutation is reversible.** `snapshot()` before, `rollback()`
+ *    after — which is what will make model-proposed refinements safe to
+ *    accept later, because a bad one can be undone without a human
+ *    reading the diff.
+ *
+ * And one more, added when recall by meaning arrived:
+ *
+ *  - **Meaning is a seam, not a dependency.** A record may carry an
+ *    `embedding` with its identity (`embeddedBy: { model, dims }`);
+ *    `recall({ near })` ranks by cosine similarity through an injected
+ *    embedder — `createEmbeddingClient(...)`, `createHashEmbedder()`, or
+ *    any host `{ embed, model, dims }` — and without one it REFUSES,
+ *    naming the seam, exactly as a `where` predicate refuses without
+ *    `compileQuery`. It refuses a mixture of identities rather than
+ *    ranking the matching subset (a silent subset is a silent wrong
+ *    answer), it reports how many records it skipped for carrying no
+ *    vector rather than scoring them, and a write never acquires the
+ *    seam's network dependency unless `embedOnWrite` asks for it;
+ *    `embedMissing()` is the explicit sweep that closes the gap. Every
+ *    dot and cosine comes from `@jarenjs/core/vector`; none is computed
+ *    here. A storage adapter that can rank the records itself may say so
+ *    with an optional fifth method (`rank`, see
+ *    {@link createMemoryStorage}'s contract); the ledger then asks it
+ *    instead of sweeping, holds it to the same identity refusal and skip
+ *    report, and names which one ran in `via`.
+ *
+ * Its consumers today: the agent's compaction archive, the environment's
+ * slots, refinement's patchable state, and the website assistant's
+ * durable memory — all on this one implementation.
+ */
 /**
  * Whether two vector identities name the same space: the same model at
  * the same width. The rule the ledger applies before any arithmetic
@@ -18,15 +74,13 @@
  * produce vectors whose cosine is arithmetic without meaning, which is
  * why `dims` matching is necessary and never sufficient.
  *
- * @param {LedgerEmbeddedBy | undefined | null} a
- * @param {LedgerEmbeddedBy | undefined | null} b
- * @returns {boolean} whether both are identities naming one space
+ * @returns whether both are identities naming one space
  * @example
  * sameIdentity({ model: 'm', dims: 4 }, { model: 'm', dims: 4 });  // true
  * sameIdentity({ model: 'm', dims: 4 }, { model: 'm', dims: 8 });  // false — a re-embed, not a match
  * sameIdentity(undefined, undefined);                              // false — no space is not a shared space
  */
-export function sameIdentity(a: LedgerEmbeddedBy | undefined | null, b: LedgerEmbeddedBy | undefined | null): boolean;
+export declare function sameIdentity(a: LedgerEmbeddedBy | undefined | null, b: LedgerEmbeddedBy | undefined | null): boolean;
 /**
  * An identity as a refusal names it — `"text-embedding-3-small (1536
  * dims)"`. Exported for the same reason as {@link sameIdentity}: it is
@@ -35,31 +89,12 @@ export function sameIdentity(a: LedgerEmbeddedBy | undefined | null, b: LedgerEm
  * key for collecting the DISTINCT identities a `rank` adapter owes its
  * caller.
  *
- * @param {LedgerEmbeddedBy} identity
- * @returns {string}
  */
-export function describeIdentity(identity: LedgerEmbeddedBy): string;
+export declare function describeIdentity(identity: LedgerEmbeddedBy): string;
 /**
  * Create a ledger.
  *
- * @param {{ storage?: { get: (key: string) => Promise<any>,
- *     set: (key: string, value: any) => Promise<void>,
- *     delete: (key: string) => Promise<void>,
- *     keys: (prefix?: string) => Promise<string[]>,
- *     status?: () => any,
- *     mutate?: import('./storage/transaction.js').StorageMutation,
- *     rank?: (request: { prefix: string, vector: number[], model: string, dims: number,
- *       limit?: number, minScore?: number }) => Promise<{ hits: { key: string, score: number }[],
- *       skipped: number, identities: LedgerEmbeddedBy[], ranking?: LedgerRanking }> },
- *   compileQuery?: (document: any) => (data: any) => any,
- *   embedder?: Embedder,
- *   embedOnWrite?: boolean,
- *   validator?: any,
- *   now?: () => string,
- *   archiveLimits?: { maxItems?: number, maxBytes?: number },
- *   goalLimits?: { maxEntries?: number, maxBytes?: number, maxChars?: number },
- *   checkpointReducer?: (goal: any) => any,
- *   artifacts?: import('./schemas/evidence.js').ArtifactRecord[] }} [options]
+ * @param [options]
  *   - `storage` defaults to an in-memory adapter, so a ledger works with
  *     nothing wired. Anything durable is the host's to inject. Its four
  *     methods are the contract; an adapter that can rank vectors itself
@@ -84,14 +119,14 @@ export function describeIdentity(identity: LedgerEmbeddedBy): string;
  *   - `now` returns an RFC 3339 timestamp (injected for deterministic
  *     tests, exactly as the rest of the suite injects its environment).
  */
-export function createLedger(options?: {
+export declare function createLedger(options?: {
     storage?: {
         get: (key: string) => Promise<any>;
         set: (key: string, value: any) => Promise<void>;
         delete: (key: string) => Promise<void>;
         keys: (prefix?: string) => Promise<string[]>;
         status?: () => any;
-        mutate?: import("./storage/transaction.js").StorageMutation;
+        mutate?: import('./storage/transaction.ts').StorageMutation;
         rank?: (request: {
             prefix: string;
             vector: number[];
@@ -124,12 +159,13 @@ export function createLedger(options?: {
         maxChars?: number;
     };
     checkpointReducer?: (goal: any) => any;
-    artifacts?: import("./schemas/evidence.js").ArtifactRecord[];
+    artifacts?: import('./schemas/evidence.ts').ArtifactRecord[];
 }): {
     storageStatus: () => any;
     concurrency: string;
     validate: (kind: "goal" | "memory" | "skill" | "slot", record: any) => null | {
         error: string;
+        code?: string;
         errors: any[];
         inputSchema: any;
     };
@@ -147,12 +183,15 @@ export function createLedger(options?: {
         at?: string;
     }) => Promise<LedgerGoal | LedgerRejection | {
         error: string;
+        code?: string;
     }>;
     setGoalStatus: (status: "active" | "done" | "abandoned" | "superseded") => Promise<LedgerGoal | LedgerRejection | {
         error: string;
+        code?: string;
     }>;
     composeGoal: () => Promise<{
         error: string;
+        code?: string;
         errors: any[];
         inputSchema: any;
     } | {
@@ -190,12 +229,36 @@ export function createLedger(options?: {
     getSkill: (id: string) => Promise<LedgerSkill | null>;
     listSkills: () => Promise<LedgerSkill[]>;
     deleteSkill: (id: string) => Promise<boolean>;
-    recall: (query?: LedgerQuery) => Promise<LedgerMemory[] | LedgerRankedMemories | {
-        error: string;
-    }>;
-    recallSkills: (query?: LedgerQuery) => Promise<LedgerSkill[] | LedgerRankedSkills | {
-        error: string;
-    }>;
+    recall: {
+        (query: LedgerQuery & {
+            near: string;
+        }): Promise<LedgerRankedMemories | {
+            error: string;
+        }>;
+        (query?: LedgerQuery & {
+            near?: undefined;
+        }): Promise<LedgerMemory[] | {
+            error: string;
+        }>;
+        (query: LedgerQuery): Promise<LedgerMemory[] | LedgerRankedMemories | {
+            error: string;
+        }>;
+    };
+    recallSkills: {
+        (query: LedgerQuery & {
+            near: string;
+        }): Promise<LedgerRankedSkills | {
+            error: string;
+        }>;
+        (query?: LedgerQuery & {
+            near?: undefined;
+        }): Promise<LedgerSkill[] | {
+            error: string;
+        }>;
+        (query: LedgerQuery): Promise<LedgerSkill[] | LedgerRankedSkills | {
+            error: string;
+        }>;
+    };
     embedMissing: (options?: {
         limit?: number;
         batch?: number;
@@ -219,7 +282,7 @@ export function createLedger(options?: {
     }>;
     listSlots: () => Promise<LedgerSlot[]>;
     deleteSlot: (name: string) => Promise<boolean>;
-    putArchive: (entries: any, protection?: {}) => Promise<{
+    putArchive: (entries: any, protection?: Record<string, any>) => Promise<{
         error: string;
         code: string;
         retention?: undefined;
@@ -245,7 +308,7 @@ export function createLedger(options?: {
         report?: undefined;
         footprint?: undefined;
     } | {
-        next: any;
+        next: Record<string, any>;
         report: {
             version: number;
             policy: string;
@@ -261,10 +324,11 @@ export function createLedger(options?: {
         retention?: undefined;
     } | {
         error: string;
+        code?: string;
         errors: any[];
         inputSchema: any;
     } | {
-        ok: boolean;
+        ok: true;
         retention: {
             version: number;
             policy: string;
@@ -281,70 +345,46 @@ export function createLedger(options?: {
     snapshot: () => Promise<string>;
     rollback: (token: string) => Promise<true | {
         error: string;
+        code?: string;
     }>;
     transaction: (expected: any, work: (ledger: any) => Promise<any>) => Promise<any>;
 };
-export type LedgerGoal = import("./schemas/ledger.js").LedgerGoal;
-export type LedgerMemory = import("./schemas/ledger.js").LedgerMemory;
-export type LedgerSkill = import("./schemas/ledger.js").LedgerSkill;
-export type LedgerSlot = import("./schemas/ledger.js").LedgerSlot;
-export type LedgerRejection = import("./schemas/ledger.js").LedgerRejection;
-export type LedgerEmbeddingPair = import("./schemas/ledger.js").LedgerEmbeddingPair;
-export type LedgerEmbeddedBy = import("./schemas/ledger.js").LedgerEmbeddedBy;
-export type Embedder = import("@tangleai/models/embed").Embedder;
-/**
- * What `recall({ near })` answers: the memories that carry a comparable
- * vector, ranked by cosine similarity (descending; ties by recency, then
- * id), one score per memory in the same order, and the count of records
- * that passed the filter but carry no vector and were therefore skipped
- * — reported, never scored.
- */
+export type LedgerGoal = import('./schemas/ledger.ts').LedgerGoal;
+export type LedgerMemory = import('./schemas/ledger.ts').LedgerMemory;
+export type LedgerSkill = import('./schemas/ledger.ts').LedgerSkill;
+export type LedgerSlot = import('./schemas/ledger.ts').LedgerSlot;
+export type LedgerRejection = import('./schemas/ledger.ts').LedgerRejection;
+export type LedgerEmbeddingPair = import('./schemas/ledger.ts').LedgerEmbeddingPair;
+export type LedgerEmbeddedBy = import('./schemas/ledger.ts').LedgerEmbeddedBy;
+export type Embedder = import('@tangleai/models/embed').Embedder;
 export type LedgerRankedMemories = {
     memories: LedgerMemory[];
     scores: number[];
-    skipped: number;
-    /**
-     * - which path answered: the ledger's
-     * own read-and-rank, or the adapter's `rank` capability
-     */
-    via: "sweep" | "adapter";
-    /**
-     * - candidate selection provenance, not a quality guarantee
-     */
+    skipped: number; /**
+   * - which path answered: the ledger's
+   * own read-and-rank, or the adapter's `rank` capability
+   */
+    via: "sweep" | "adapter"; /**
+   * - candidate selection provenance, not a quality guarantee
+   */
     ranking: LedgerRanking;
 };
-/**
- * What `recallSkills({ near })` answers — see {@link LedgerRankedMemories}.
- */
 export type LedgerRankedSkills = {
     skills: LedgerSkill[];
     scores: number[];
-    skipped: number;
-    /**
-     * - see {@link LedgerRankedMemories}
-     */
-    via: "sweep" | "adapter";
-    /**
-     * - see {@link LedgerRankedMemories}
-     */
+    skipped: number; /**
+   * - see {@link LedgerRankedMemories}
+   */
+    via: "sweep" | "adapter"; /**
+   * - see {@link LedgerRankedMemories}
+   */
     ranking: LedgerRanking;
 };
-/**
- * Optional storage rank metadata. Legacy adapters normalize to exhaustive.
- * Exhaustive means exact candidate selection, not that every record is returned.
- * Candidate count is the number returned before ledger filtering and capping.
- */
 export type LedgerRanking = {
     algorithm: string;
     exhaustive: boolean;
     candidateCount: number;
 };
-/**
- * The query both recalls take. `near` is the string to rank by meaning
- * against, and needs the embedder seam; `minScore` filters the ranked
- * result (cosine, in [-1, 1]); `tags` and `where` narrow the candidates
- * first, exactly as they do without `near`.
- */
 export type LedgerQuery = {
     tags?: string[];
     where?: any;