@vaur94/agz-memory 0.4.1 → 0.5.1

package/dist/types/admin/quarantine.d.ts

@@ -0,0 +1,15 @@
+import type { Database } from "bun:sqlite";
+/** Content-free input for a future V12 quarantine migration decision. */
+export declare function quarantinePrivacyReport(db: Database): {
+    quarantinedEvents: number;
+    keyedEvents: number;
+    unavailableKeyEvents: number;
+    legacyOrUnknownEvents: number;
+    keyIDs: string[];
+    digest: {
+        algorithm: "HMAC-SHA256";
+        input: "quarantine-source-identity-and-redacted-payload/2";
+        storage: "capture_events.payload_hash";
+        keyID: "capture_events.redaction_version quarantine-key suffix";
+    };
+};

package/dist/types/admin/reindex.d.ts

@@ -0,0 +1,41 @@
+export interface ProcessStartMarkerReaders {
+    readLinuxStat?: (pid: number) => string | null;
+    readMacOSPs?: (pid: number) => string | null;
+}
+export interface ReindexTestOptions {
+    /** Test-only fault point after a durable batch commit but before its cursor is saved. */
+    afterCommitBeforeStateWrite?: () => void;
+    /** Test-only fault point immediately before the batch's database identity verification. */
+    beforeBatchDatabaseIdentity?: () => void;
+    /** Test-only synchronization point after a stale lock is classified but before takeover. */
+    beforeStaleLockTakeover?: () => void;
+    /** Test-only synchronization point while the owner lock is held. */
+    afterOwnerLockAcquired?: () => void;
+}
+export interface ReindexOwnerMetadata {
+    ownerID: string;
+    pid: number;
+    processStart: string;
+    hostname: string;
+    createdAt: number;
+}
+export declare function classifyReindexOwner(owner: unknown, localHostname: string, processAlive: boolean, currentProcessStart: string | null): "live" | "stale" | "unverifiable";
+export declare function runResumableReindex(path: string, databaseID: string, backend: string, batchSize: number, maxBatches?: number, testOptions?: ReindexTestOptions): {
+    backend: string;
+    generation: number;
+    purges: number;
+    queued: number;
+    quarantined: number;
+    resumed: boolean;
+    incomplete?: undefined;
+} | {
+    backend: string;
+    generation: number;
+    purges: number;
+    queued: number;
+    quarantined: number;
+    incomplete: boolean;
+    resumed: boolean;
+};
+export declare function readReindexProcessStartMarker(pid: number, platform?: NodeJS.Platform, readers?: ProcessStartMarkerReaders): string | null;
+export declare function assertReindexOwnerLivenessSupported(platform?: NodeJS.Platform): void;

package/dist/types/capture/contract.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-export declare const CAPTURE_SCHEMA: "agz-memory.capture/1";
+export declare const CAPTURE_SCHEMA: "agz-memory.capture/2";
 export declare const SUPPORTED_OPENCODE_VERSION: "0.0.0-beta-18743";
 export declare const CAPTURE_EVENT_MAX_BYTES: number;
 export declare const CAPTURE_CONTENT_MAX_CHARACTERS = 4800;
@@ -34,7 +34,7 @@ declare const candidateSchema: z.ZodObject<{
     }>;
 }, z.core.$strict>;
 export declare const captureEventSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"agz-memory.capture/1">;
+    schema: z.ZodLiteral<"agz-memory.capture/2">;
     idempotencyKey: z.ZodString;
     projectID: z.ZodUUID;
     bindingKey: z.ZodString;
@@ -96,7 +96,9 @@ export declare const captureEventSchema: z.ZodObject<{
         truncated: z.ZodBoolean;
     }, z.core.$strict>;
 }, z.core.$strict>;
-export type MemoryCandidateV1 = z.infer<typeof candidateSchema>;
-export type CaptureEventV1 = z.infer<typeof captureEventSchema>;
-export declare function parseCaptureEvent(value: unknown): CaptureEventV1;
+export type MemoryCandidateV2 = z.infer<typeof candidateSchema>;
+export type CaptureEventV2 = z.infer<typeof captureEventSchema>;
+export type MemoryCandidateV1 = MemoryCandidateV2;
+export type CaptureEventV1 = CaptureEventV2;
+export declare function parseCaptureEvent(value: unknown): CaptureEventV2;
 export {};

package/dist/types/capture/redact.d.ts

@@ -9,4 +9,5 @@ export interface RedactionResult {
 export declare function redactText(value: string, options?: {
     maxCharacters?: number;
     denylist?: readonly string[];
+    sourceTruncated?: boolean;
 }): RedactionResult;

package/dist/types/config.d.ts

@@ -1,4 +1,5 @@
 export interface MemoryConfig {
     databasePath: string;
+    quarantineKeyringPath: string;
 }
 export declare function resolveConfig(environment?: NodeJS.ProcessEnv): MemoryConfig;

package/dist/types/context.d.ts

@@ -1 +1 @@
-export declare const MEMORY_GUIDANCE = "Use project-scoped memory for durable facts across sessions.\n- Start with project_list. Use the immutable projectID for stable references; projectName is a convenient unique lookup.\n- Create a project with project_create before storing its first note. Renaming a project never changes its ID.\n- Every memory_recall, memory_read, memory_update, memory_link, and memory_pin call must select exactly one project by projectID or projectName.\n- No notes are injected automatically; use memory_recall for relevant project history.\n- Read indexed note bodies and graph neighbors with memory_read.\n- Store only durable verified facts, decisions, procedures, research, preferences, or substantial completed work.\n- Use memory_pin to prioritize important matching notes inside their project. Pinning never moves notes between projects.\n- Never save transcripts, guesses, secrets, or routine progress.\n- project_delete permanently destroys the project and all of its memory. Call project_list first and provide the immutable ID, exact current name, and required confirmation phrase only when deletion is explicitly intended.";
+export declare const MEMORY_GUIDANCE = "Use project-scoped memory for durable facts across sessions.\n- Start with project_list. Reuse a project only when it intentionally represents the same durable workspace or product; create one only when no matching project exists. If the listed projects are ambiguous, ask rather than guessing from a directory or session name.\n- Prefer the immutable projectID for stable references. projectName is a convenient unique lookup, but names can change.\n- Every memory_recall, memory_read, memory_update, memory_link, and memory_pin call must select exactly one project by projectID or projectName.\n- The MCP server does not inject notes automatically. Recall relevant history before relying on prior decisions, and use memory_read for full indexed content and graph neighbors.\n- After substantial completed work, update an existing note or create a new one only for durable verified facts, decisions, procedures, research, preferences, tasks, or context.\n- Never save transcripts, guesses, secrets, credentials, hidden reasoning, or routine progress.\n- Use memory_pin only to prioritize important matching notes. Read directed links as sourceID PREDICATE targetID; links never cross projects.\n- Inspect every result from a batch because mutations are ordered and non-atomic: earlier items remain applied when a later item fails.\n- memory_update with delete:true permanently deletes one note. project_delete permanently deletes a project and all owned memory. Verify current IDs first and use destructive operations only when explicitly intended.";

package/dist/types/contracts/error.d.ts

@@ -0,0 +1,16 @@
+export type BusinessErrorCode = "invalid_request" | "not_found" | "conflict" | "limit_exceeded" | "invalid_cursor" | "cursor_scope_mismatch" | "stale_cursor" | "internal_error";
+export declare class MemoryBusinessError extends Error {
+    readonly code: BusinessErrorCode;
+    readonly correlationID: string;
+    readonly cause?: unknown;
+    constructor(code: BusinessErrorCode, message: string, correlationID?: string, cause?: unknown);
+}
+export declare function correlationID(): string;
+export declare function businessError(code: BusinessErrorCode, message: string, id?: string, cause?: unknown): MemoryBusinessError;
+export declare function toPublicError(error: MemoryBusinessError): {
+    code: BusinessErrorCode;
+    correlationID: string;
+    retryable: boolean;
+    message: string;
+};
+export declare function asBusinessError(error: unknown, id?: string): MemoryBusinessError;

package/dist/types/contracts/limits.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+/** Public payload limits, measured in UTF-8 bytes unless otherwise noted. */
+export declare const LIMITS: {
+    readonly title: 240;
+    readonly summary: 4096;
+    readonly content: 65536;
+    readonly query: 4096;
+    readonly noteID: 256;
+    readonly batch: 10;
+    readonly requestBytes: 1048576;
+    readonly responseBytes: 1048576;
+    readonly pageSize: 100;
+};
+export type TextLimit = "title" | "summary" | "content" | "query" | "noteID";
+export declare function utf8Bytes(value: string): number;
+export declare function assertTextLimit(field: TextLimit, value: string): void;
+export declare function boundedText(field: TextLimit, description: string): z.ZodString;
+export declare function assertRequestLimit(value: unknown): void;

package/dist/types/contracts/mutation.d.ts

@@ -0,0 +1,31 @@
+import { type Kind } from "../types";
+export interface CreateMutation {
+    operation: "create";
+    kind: Kind;
+    title: string;
+    summary: string;
+    content?: string;
+}
+export interface PatchMutation {
+    operation: "patch";
+    id: string;
+    changes: Partial<Pick<CreateMutation, "kind" | "title" | "summary" | "content">>;
+}
+export interface DeleteMutation {
+    operation: "delete";
+    id: string;
+    confirmation?: string;
+}
+export type MutationOperation = CreateMutation | PatchMutation | DeleteMutation;
+export interface LegacyMutation {
+    id?: string;
+    kind?: string;
+    title?: string;
+    summary?: string;
+    content?: string;
+    delete?: boolean;
+    confirmation?: string;
+}
+export declare function normalizeLegacyMutation(input: LegacyMutation): MutationOperation;
+export declare function isMutationOperation(value: unknown): value is MutationOperation;
+export declare function assertStrictMutationOperation(value: unknown): asserts value is MutationOperation;

package/dist/types/contracts/pagination.d.ts

@@ -0,0 +1,27 @@
+export interface CursorScope {
+    projectID: string;
+    query: string;
+    snapshot: string;
+}
+interface CursorPayload extends CursorScope {
+    v: 1;
+    offset: number;
+}
+export interface PageOptions extends CursorScope {
+    limit: number;
+    cursor?: string;
+    /** Snapshot returned by the client on a follow-up request. */
+    requestedSnapshot?: string;
+}
+export interface Page<T> {
+    items: T[];
+    snapshot: string;
+    etag: string;
+    nextCursor?: string;
+}
+export declare function encodeCursor(payload: Omit<CursorPayload, "v">): string;
+export declare function decodeCursor(cursor: string, scope: CursorScope): {
+    offset: number;
+};
+export declare function paginate<T>(items: readonly T[], options: PageOptions): Page<T>;
+export {};

package/dist/types/core.d.ts

@@ -1,4 +1,4 @@
-import type { RetrievalBackend } from "./retrieval/contract";
+import type { OutboxBackend, RetrievalBackend } from "./retrieval/contract";
 import { type OpenedDB } from "./db";
 import { CaptureStore } from "./store/capture";
 import { MemoryStore } from "./store";
@@ -7,7 +7,7 @@ import { RetrievalStore } from "./store/retrieval";
 export interface MemoryCoreOptions {
     indexBackends?: readonly string[];
     retrievalBackend?: RetrievalBackend;
-    outboxBackends?: ReadonlyMap<string, RetrievalBackend>;
+    outboxBackends?: ReadonlyMap<string, OutboxBackend>;
 }
 export declare class MemoryCore {
     private opened;
@@ -27,5 +27,9 @@ export * from "./capture/redact";
 export * from "./retrieval/contract";
 export * from "./retrieval/formatter";
 export * from "./store/capture";
+export * from "./contracts/limits";
+export * from "./contracts/mutation";
+export * from "./contracts/error";
+export * from "./contracts/pagination";
 export * from "./types";
 export * from "./version";

package/dist/types/db/backup.d.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { type MaintenanceGate } from "./maintenance";
 export declare const BACKUP_FORMAT: "agz-memory-backup/1";
 export interface BackupManifest {
     format: typeof BACKUP_FORMAT;
@@ -21,5 +22,5 @@ export interface VerifiedBackup {
 }
 export declare function createVerifiedBackup(db: Database, databasePath: string, sourceSchema: number, targetSchema: number, productVersion: string): VerifiedBackup;
 export declare function verifyBackupManifest(manifestPath: string): VerifiedBackup;
-export declare function restoreVerifiedBackup(manifestPath: string, targetPath: string, confirmation: string): string;
+export declare function restoreVerifiedBackup(manifestPath: string, targetPath: string, confirmation: string, existingGate?: MaintenanceGate, expectedSha256?: string): string;
 export declare function inspectBackupDatabase(path: string): import("./health").DatabaseHealth;

package/dist/types/db/health.d.ts

@@ -6,6 +6,10 @@ export interface DatabaseHealth {
     counts: Record<string, number>;
 }
 export declare function inspectDatabase(db: Database): DatabaseHealth;
-export declare function assertHealthyDatabase(db: Database): DatabaseHealth;
+export declare function assertHealthyDatabase(db: Database, options?: {
+    verifySchema?: boolean;
+}): DatabaseHealth;
+export declare function assertSchemaV11(db: Database): void;
+export declare function isSQLiteBusyError(error: unknown): boolean;
 export declare function hasTable(db: Database, table: string): boolean;
 export declare function hasColumn(db: Database, table: string, column: string): boolean;

package/dist/types/db/legacy-health.d.ts

@@ -0,0 +1,4 @@
+import type { Database } from "bun:sqlite";
+export declare function assertLegacySchemaIdentity(db: Database, version: number, options?: {
+    verifyHealth?: boolean;
+}): void;

package/dist/types/db/maintenance.d.ts

@@ -0,0 +1,21 @@
+export interface DatabaseLease {
+    databasePath: string;
+    release: () => void;
+}
+export interface MaintenanceGate {
+    databasePath: string;
+    release: () => void;
+    assertOwned: () => void;
+    retain: () => void;
+}
+export interface MaintenanceRecovery {
+    ownerID: string;
+    confirmation: "RECOVER_RETAINED_MAINTENANCE_GATE";
+}
+export declare function acquireDatabaseLease(databasePath: string): DatabaseLease;
+export declare function acquireMaintenanceGate(databasePath: string, recovery?: MaintenanceRecovery): MaintenanceGate;
+export declare function recoverStaleMaintenanceGate(databasePath: string, validate: () => void): boolean;
+export declare function assertMaintenanceGateFor(gate: MaintenanceGate, databasePath: string): void;
+export declare function canonicalDatabasePath(path: string): string;
+export declare function ensureDatabaseParent(path: string): void;
+export declare function assertNoSymbolicLinks(path: string, allowMissingLeaf?: boolean): void;

package/dist/types/db/migrations/v011.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "bun:sqlite";
+export declare function migrateV10ToV11(db: Database): void;
+export declare function assertV10SourceDatabase(db: Database): void;

package/dist/types/db/schema.d.ts

@@ -1,6 +1,15 @@
-import type { Database } from "bun:sqlite";
+import { Database } from "bun:sqlite";
+export declare const APPLICATION_ID = 1095195213;
+export declare const PRODUCT_ID: "agz-memory";
+export declare const HASH_POLICY: "hash-tuple/2";
 export declare const SCHEMA_TABLES: string;
 export declare const FTS_V9 = "\nCREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(\n  title, summary, content,\n  content='notes', content_rowid='rowid',\n  tokenize='unicode61'\n);\nCREATE TRIGGER IF NOT EXISTS notes_fts_ai AFTER INSERT ON notes BEGIN\n  INSERT INTO notes_fts(rowid, title, summary, content)\n  VALUES (new.rowid, new.title, new.summary, new.content);\nEND;\nCREATE TRIGGER IF NOT EXISTS notes_fts_ad AFTER DELETE ON notes BEGIN\n  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)\n  VALUES ('delete', old.rowid, old.title, old.summary, old.content);\nEND;\nCREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE OF title, summary, content ON notes BEGIN\n  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)\n  VALUES ('delete', old.rowid, old.title, old.summary, old.content);\n  INSERT INTO notes_fts(rowid, title, summary, content)\n  VALUES (new.rowid, new.title, new.summary, new.content);\nEND;\n";
+export declare const SCHEMA_V11_TABLES: string;
+export declare function captureEventsTableV11(table?: "capture_events" | "capture_events_v11"): string;
+export declare function schemaFingerprint(db: Database): string;
+export declare function expectedSchemaFingerprint(): string;
+export declare function createSchemaV11(db: Database): void;
+export declare function insertV11Identity(db: Database, databaseID?: `${string}-${string}-${string}-${string}-${string}`, createdAt?: number): void;
 export declare function createSchema(db: Database): void;
 export declare function rebuildFts(db: Database): void;
 export declare function captureEventsTable(table?: "capture_events" | "capture_events_v10"): string;

package/dist/types/db.d.ts

@@ -3,4 +3,15 @@ export interface OpenedDB {
     db: Database;
     close: () => void;
 }
-export declare function openMemoryDatabase(path: string): OpenedDB;
+export type MigrationStage = "source-validation" | "backup-checkpoint" | "v2-import" | "v8-to-v9" | "v9-to-v10" | "v10-to-v11" | "fingerprint" | "deep-health";
+export interface MigrationTiming {
+    phases: Array<{
+        stage: MigrationStage;
+        elapsedMs: number;
+    }>;
+}
+export declare function createMigrationTimingCollector(): MigrationTiming;
+export declare function openMemoryDatabase(path: string, options?: {
+    timing?: MigrationTiming;
+}): OpenedDB;
+export declare function openReadOnlyMemoryDatabase(path: string): OpenedDB;

package/dist/types/hash.d.ts

@@ -0,0 +1,4 @@
+export type HashTupleValue = null | string | boolean | number | Uint8Array;
+export declare function hashTuple(domain: string, version: number, fields: readonly HashTupleValue[]): string;
+export declare function noteContentHash(kind: string, title: string, summary: string, content: string): string;
+export declare const canonicalNoteHash: typeof noteContentHash;

package/dist/types/retrieval/contract.d.ts

@@ -32,11 +32,23 @@ export interface BackendHealth {
     version?: string;
     errorCode?: string;
 }
+export interface BackendOperationContext {
+    operationKey: string;
+    sequence: number;
+    fence: number;
+}
+export interface OutboxBackend extends RetrievalBackend {
+    readonly outboxProtocol: "agz-memory-outbox/1";
+    upsert(document: DerivedDocument, signal: AbortSignal, operation: BackendOperationContext): Promise<void>;
+    delete(ref: DerivedRef, signal: AbortSignal, operation: BackendOperationContext): Promise<void>;
+    purgeProject(projectID: string, signal: AbortSignal, operation: BackendOperationContext): Promise<void>;
+}
 export interface RetrievalBackend {
     id: string;
-    upsert(document: DerivedDocument, signal: AbortSignal): Promise<void>;
-    delete(ref: DerivedRef, signal: AbortSignal): Promise<void>;
-    purgeProject(projectID: string, signal: AbortSignal): Promise<void>;
+    upsert(document: DerivedDocument, signal: AbortSignal, operation?: BackendOperationContext): Promise<void>;
+    delete(ref: DerivedRef, signal: AbortSignal, operation?: BackendOperationContext): Promise<void>;
+    purgeProject(projectID: string, signal: AbortSignal, operation?: BackendOperationContext): Promise<void>;
     query(projectID: string, query: string, limit: number, signal: AbortSignal): Promise<RankedHit[]>;
     health(signal: AbortSignal): Promise<BackendHealth>;
 }
+export declare function validateBackendHits(value: unknown): value is RankedHit[];

package/dist/types/security/quarantine-key.d.ts

@@ -0,0 +1,47 @@
+export interface QuarantineSourceIdentity {
+    schema: string;
+    projectID: string;
+    bindingKey: string;
+    kind: string;
+    source: {
+        system: string;
+        opencodeVersion: string;
+        pluginVersion: string;
+        sessionID: string;
+        messageID?: string;
+        ordinal?: number;
+        toolCallID?: string;
+    };
+}
+export interface QuarantineDigest {
+    keyID: string;
+    digest: string;
+}
+export interface QuarantineKeyReference {
+    keyID: string;
+}
+/**
+ * Private local keyring for source-only quarantine digests. Windows is deliberately
+ * fail-closed until a current-user ACL verifier is available.
+ */
+export declare class QuarantineKeyring {
+    private readonly path;
+    constructor(path: string);
+    readActiveKey(): QuarantineKeyReference;
+    ensureActiveKey(): QuarantineKeyReference;
+    rotate(): QuarantineKeyReference;
+    digestSource(source: QuarantineSourceIdentity, payloadFingerprint: string): QuarantineDigest;
+    /** Use after lifecycle initialization; a later missing key must fail closed. */
+    digestExistingSource(source: QuarantineSourceIdentity, payloadFingerprint: string): QuarantineDigest;
+    verifySourceDigest(source: QuarantineSourceIdentity, payloadFingerprint: string, keyID: string, digest: string): boolean;
+    private activeKey;
+    private keyReference;
+    private createInitialKeyring;
+    private readDocument;
+    private writeAtomically;
+    private acquireLock;
+    private assertSafeParent;
+    private assertSupportedPlatform;
+    private assertPermissions;
+    private syncParent;
+}

package/dist/types/server.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import type { MemoryStore } from "./store";
 export declare const SERVER_NAME = "agz-memory";
-export declare const SERVER_VERSION: "0.4.1";
+export declare const SERVER_VERSION: "0.5.1";
 export declare function createMemoryServer(store: MemoryStore): McpServer;

package/dist/types/store/capture.d.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite";
+import { QuarantineKeyring } from "../security/quarantine-key";
 export interface ProjectBindingInput {
     memoryProjectID: string;
     opencodeProjectID: string;
@@ -6,6 +7,7 @@ export interface ProjectBindingInput {
     workspaceID?: string;
 }
 export type CaptureMode = "shadow" | "auto-write";
+type CheckpointState = "active" | "idle" | "unavailable" | "closed";
 export interface CaptureIngestResult {
     outcome: "shadowed" | "materialized" | "duplicate" | "ignored" | "review" | "rejected" | "quarantined";
     idempotencyKey: string;
@@ -15,17 +17,23 @@ export interface CaptureIngestResult {
 export declare class CaptureStore {
     private db;
     private indexBackends;
-    constructor(db: Database, indexBackends?: readonly string[]);
+    private readonly quarantineKeyring;
+    constructor(db: Database, indexBackends?: readonly string[], options?: {
+        quarantineKeyring?: QuarantineKeyring;
+    });
     bindProject(input: ProjectBindingInput): {
+        ok: true;
         bindingKey: string;
         projectID: string;
     };
-    checkpoint(sessionID: string, bindingKey: string, projectID: string, messageID?: string, state?: "active" | "idle" | "unavailable" | "closed"): void;
-    markReconciled(sessionID: string, state: "active" | "idle" | "unavailable" | "closed", lastMessageID?: string, failed?: boolean): void;
-    getCheckpoint(sessionID: string): {
+    checkpoint(sessionID: string, bindingKey: string, projectID: string, messageID?: string, state?: CheckpointState): void;
+    markReconciled(sessionID: string, state: CheckpointState, lastMessageID?: string, failed?: boolean, bindingKey?: string, projectID?: string): void;
+    markReconciled(sessionID: string, bindingKey: string, state: CheckpointState, lastMessageID?: string, failed?: boolean, projectID?: string): void;
+    markReconciled(sessionID: string, bindingKey: string, projectID: string, state: CheckpointState, lastMessageID?: string, failed?: boolean): void;
+    getCheckpoint(sessionID: string, bindingKey?: string, projectID?: string): {
         sessionID: string;
         lastMessageID?: string;
-        state: "active" | "idle" | "unavailable" | "closed";
+        state: CheckpointState;
     } | undefined;
     ingest(input: unknown, mode: CaptureMode, options?: {
         allowedKinds?: readonly string[];
@@ -48,4 +56,8 @@ export declare class CaptureStore {
     private enqueueOutbox;
     private finishEvent;
     private binding;
+    private hasBinding;
+    private checkpointRow;
+    private uniqueCheckpointForSession;
 }
+export {};

package/dist/types/store/outbox.d.ts

@@ -1,14 +1,26 @@
 import type { Database } from "bun:sqlite";
-import type { RetrievalBackend } from "../retrieval/contract";
-export type OutboxOutcome = "idle" | "succeeded" | "stale" | "quarantined" | "retry" | "dead";
+import type { OutboxBackend } from "../retrieval/contract";
+interface OutboxRetentionOptions {
+    terminalRetention?: number;
+    terminalPruneInterval?: number;
+}
+export type OutboxOutcome = "idle" | "succeeded" | "stale" | "quarantined" | "retry" | "dead" | "lost_lease";
 export declare class OutboxWorker {
     private db;
     private backends;
     private now;
     private random;
     private readonly workerID;
-    constructor(db: Database, backends: ReadonlyMap<string, RetrievalBackend>, now?: () => number, random?: () => number);
+    private readonly terminalRetention;
+    private readonly terminalPruneInterval;
+    private terminalTransitions;
+    constructor(db: Database, backends: ReadonlyMap<string, OutboxBackend>, now?: () => number, random?: () => number, retention?: OutboxRetentionOptions);
     processNext(): Promise<OutboxOutcome>;
+    private claim;
+    private runBackend;
+    private stale;
     private succeed;
     private fail;
+    private pruneTerminalOutbox;
 }
+export {};

package/dist/types/store/retrieval.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import type { RetrievalBackend, RetrievalRequest } from "../retrieval/contract";
+import { type RetrievalBackend, type RetrievalRequest } from "../retrieval/contract";
 import type { RecallCard } from "../types";
 export interface RetrievalResult {
     cards: RecallCard[];
@@ -14,5 +14,5 @@ export declare class RetrievalStore {
     private lexical;
     private graph;
     private graphPredicates;
-    private note;
+    private notes;
 }

package/dist/types/store.d.ts

@@ -1,17 +1,10 @@
 import type { Database } from "bun:sqlite";
+import { type MutationOperation } from "./contracts/mutation";
 import type { Edge, Note, Project, ProjectSummary, RecallCard } from "./types";
 export interface ProjectSelector {
     projectID?: string;
     projectName?: string;
 }
-export interface UpdateInput {
-    kind?: string;
-    title?: string;
-    summary?: string;
-    content?: string;
-    id?: string;
-    delete?: boolean;
-}
 export interface UpdateResult {
     ok: boolean;
     id?: string;
@@ -31,6 +24,7 @@ export declare class MemoryStore {
         reason?: string;
     };
     listProjects(): ProjectSummary[];
+    listProjectsPage(limit: number, cursor?: string, snapshot?: string): import("./core").Page<ProjectSummary>;
     createProject(nameValue: string): {
         ok: boolean;
         project?: Project;
@@ -53,13 +47,20 @@ export declare class MemoryStore {
         };
         reason?: string;
     };
-    update(projectID: string, input: UpdateInput): UpdateResult;
+    update(projectID: string, operation: MutationOperation): UpdateResult;
     pin(projectID: string, id: string, pinned: boolean): {
-        ok: boolean;
-        reason: string;
-        id?: undefined;
         projectID?: undefined;
         projectName?: undefined;
+        id?: undefined;
+        ok: boolean;
+        reason: string;
+        pinned?: undefined;
+    } | {
+        ok: boolean;
+        id: string;
+        projectID: string;
+        projectName: string;
+        reason: string;
         pinned?: undefined;
     } | {
         reason?: undefined;
@@ -73,8 +74,25 @@ export declare class MemoryStore {
     read(projectID: string, id: string): {
         note?: Note;
         edges?: Edge[];
+        snapshot?: string;
+        etag?: string;
+        nextCursor?: string;
         reason?: string;
     };
+    readPage(projectID: string, id: string, limit: number, cursor?: string, snapshot?: string): {
+        reason: string;
+    } | {
+        items: Edge[];
+        snapshot: string;
+        etag: string;
+        nextCursor?: string;
+        reason?: undefined;
+        note: Note;
+    };
+    listRevisionsPage(projectID: string, noteID: string, limit: number, cursor?: string, snapshot?: string): import("./core").Page<{
+        revision: number;
+        created_at: number;
+    }>;
     link(projectID: string, sourceID: string, targetID: string, predicate: string): {
         projectID?: undefined;
         projectName?: undefined;
@@ -87,9 +105,18 @@ export declare class MemoryStore {
         projectName: string;
     };
     recall(projectID: string, query: string, limit?: number): RecallCard[];
+    recallPage(projectID: string, query: string, limit?: number, cursor?: string, snapshot?: string): {
+        cards: RecallCard[];
+        snapshot: string;
+        etag: string;
+        nextCursor?: string | undefined;
+    };
     private getProjectRow;
+    private bumpProjectVersion;
+    private getProjectByNormalizedName;
     private projectNameExists;
     private getNoteRow;
     private recordCurrentRevision;
     private enqueueOutbox;
+    private immediateTransaction;
 }

package/dist/types/types.d.ts

@@ -1,4 +1,4 @@
-export declare const SCHEMA_VERSION = 10;
+export declare const SCHEMA_VERSION = 11;
 export declare const INLINE_LIMIT = 1200;
 export declare const KINDS: readonly ["decision", "fact", "procedure", "context", "research", "preference", "task"];
 export type Kind = (typeof KINDS)[number];

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const PRODUCT_VERSION: "0.4.1";
+export declare const PRODUCT_VERSION: "0.5.1";