@vaur94/agz-memory 0.4.0-beta.1

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

@@ -0,0 +1,10 @@
+import type { Database } from "bun:sqlite";
+import { inspectDatabase } from "../db/health";
+export interface DoctorReport {
+    ok: boolean;
+    health: ReturnType<typeof inspectDatabase>;
+    warnings: string[];
+    failures: string[];
+    invariants: Record<string, number>;
+}
+export declare function doctorDatabase(db: Database): DoctorReport;

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export declare function runAdmin(argv?: string[]): Promise<unknown>;

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

@@ -0,0 +1,102 @@
+import * as z from "zod/v4";
+export declare const CAPTURE_SCHEMA: "opencode2-memory.capture/1";
+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;
+export declare const CAPTURE_SUMMARY_MAX_CHARACTERS = 1200;
+export declare const CAPTURE_SUBJECT_MAX_CHARACTERS = 240;
+declare const candidateSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        context: "context";
+        decision: "decision";
+        fact: "fact";
+        preference: "preference";
+        procedure: "procedure";
+        research: "research";
+        task: "task";
+    }>;
+    title: z.ZodString;
+    summary: z.ZodString;
+    content: z.ZodString;
+    subjectKey: z.ZodOptional<z.ZodString>;
+    intent: z.ZodEnum<{
+        create: "create";
+        ignore: "ignore";
+        review: "review";
+        supersede: "supersede";
+    }>;
+    targetNoteID: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    evidence: z.ZodEnum<{
+        "explicit-user": "explicit-user";
+        "session-summary": "session-summary";
+        "verified-outcome": "verified-outcome";
+    }>;
+}, z.core.$strict>;
+export declare const captureEventSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"opencode2-memory.capture/1">;
+    idempotencyKey: z.ZodString;
+    projectID: z.ZodUUID;
+    bindingKey: z.ZodString;
+    kind: z.ZodEnum<{
+        "assistant-candidate": "assistant-candidate";
+        "session-summary": "session-summary";
+        "tool-signal": "tool-signal";
+        "user-candidate": "user-candidate";
+    }>;
+    source: z.ZodObject<{
+        system: z.ZodLiteral<"opencode-v2">;
+        opencodeVersion: z.ZodLiteral<"0.0.0-beta-18743">;
+        pluginVersion: z.ZodString;
+        sessionID: z.ZodString;
+        messageID: z.ZodOptional<z.ZodString>;
+        ordinal: z.ZodOptional<z.ZodNumber>;
+        toolCallID: z.ZodOptional<z.ZodString>;
+        observedAt: z.ZodNumber;
+    }, z.core.$strict>;
+    candidate: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            context: "context";
+            decision: "decision";
+            fact: "fact";
+            preference: "preference";
+            procedure: "procedure";
+            research: "research";
+            task: "task";
+        }>;
+        title: z.ZodString;
+        summary: z.ZodString;
+        content: z.ZodString;
+        subjectKey: z.ZodOptional<z.ZodString>;
+        intent: z.ZodEnum<{
+            create: "create";
+            ignore: "ignore";
+            review: "review";
+            supersede: "supersede";
+        }>;
+        targetNoteID: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodEnum<{
+            "explicit-user": "explicit-user";
+            "session-summary": "session-summary";
+            "verified-outcome": "verified-outcome";
+        }>;
+    }, z.core.$strict>>;
+    signal: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            error: "error";
+        }>;
+        errorType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    redaction: z.ZodObject<{
+        policyVersion: z.ZodString;
+        replacements: z.ZodNumber;
+        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 {};

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

@@ -0,0 +1,25 @@
+export type CaptureIdentityInput = {
+    kind: "user";
+    bindingKey: string;
+    sessionID: string;
+    messageID: string;
+} | {
+    kind: "assistant";
+    bindingKey: string;
+    sessionID: string;
+    assistantMessageID: string;
+    ordinal: number;
+} | {
+    kind: "tool";
+    bindingKey: string;
+    sessionID: string;
+    assistantMessageID: string;
+    toolCallID: string;
+    terminalStatus: "completed" | "error";
+} | {
+    kind: "summary";
+    bindingKey: string;
+    sessionID: string;
+    checkpointMessageID: string;
+};
+export declare function captureIdempotencyKey(input: CaptureIdentityInput): string;

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

@@ -0,0 +1,9 @@
+import type { MemoryCandidateV1 } from "./contract";
+export declare const CAPTURE_POLICY_VERSION = "capture-policy/1";
+export declare const EXTRACTOR_VERSION = "deterministic-extractor/1";
+export declare function extractExplicitUserCandidate(text: string): MemoryCandidateV1 | undefined;
+export declare function canAutoWrite(candidate: MemoryCandidateV1, redaction: {
+    truncated: boolean;
+    quarantined: boolean;
+}, allowedKinds?: readonly string[], minConfidence?: number): boolean;
+export declare function normalizeSubjectKey(value: string): string;

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

@@ -0,0 +1,17 @@
+export interface ProjectedText {
+    text: string;
+    truncated: boolean;
+}
+export declare function projectUserPrompt(prompt: {
+    text?: unknown;
+}, maxCharacters?: number): ProjectedText;
+export declare function projectAssistantParts(parts: readonly unknown[], maxCharacters?: number): ProjectedText;
+export declare function projectSessionSummary(messages: readonly {
+    role: string;
+    parts: readonly unknown[];
+}[], maxCharacters?: number): ProjectedText;
+export declare function projectToolSignal(tool: string, status: "completed" | "error", error?: unknown): {
+    tool: string;
+    status: "completed" | "error";
+    errorType?: string;
+};

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

@@ -0,0 +1,12 @@
+export declare const REDACTION_POLICY_VERSION = "redaction/1";
+export interface RedactionResult {
+    text: string;
+    replacements: number;
+    classes: Record<string, number>;
+    truncated: boolean;
+    quarantined: boolean;
+}
+export declare function redactText(value: string, options?: {
+    maxCharacters?: number;
+    denylist?: readonly string[];
+}): RedactionResult;

package/dist/types/config.d.ts

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

package/dist/types/context.d.ts

@@ -0,0 +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.";

package/dist/types/core.d.ts

@@ -0,0 +1,30 @@
+import type { RetrievalBackend } from "./retrieval/contract";
+import { type OpenedDB } from "./db";
+import { CaptureStore } from "./store/capture";
+import { MemoryStore } from "./store";
+import { OutboxWorker } from "./store/outbox";
+import { RetrievalStore } from "./store/retrieval";
+export interface MemoryCoreOptions {
+    indexBackends?: readonly string[];
+    retrievalBackend?: RetrievalBackend;
+    outboxBackends?: ReadonlyMap<string, RetrievalBackend>;
+}
+export declare class MemoryCore {
+    private opened;
+    readonly memory: MemoryStore;
+    readonly capture: CaptureStore;
+    readonly retrieval: RetrievalStore;
+    readonly outbox?: OutboxWorker;
+    constructor(opened: OpenedDB, options?: MemoryCoreOptions);
+    close(): void;
+}
+export declare function openMemoryCore(databasePath: string, options?: MemoryCoreOptions): MemoryCore;
+export * from "./capture/contract";
+export * from "./capture/identity";
+export * from "./capture/policy";
+export * from "./capture/projection";
+export * from "./capture/redact";
+export * from "./retrieval/contract";
+export * from "./retrieval/formatter";
+export * from "./store/capture";
+export * from "./types";

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

@@ -0,0 +1,25 @@
+import { Database } from "bun:sqlite";
+export declare const BACKUP_FORMAT: "opencode2-memory-backup/1";
+export interface BackupManifest {
+    format: typeof BACKUP_FORMAT;
+    productVersion: string;
+    sourceSchema: number;
+    targetSchema: number;
+    createdAt: string;
+    sqliteVersion: string;
+    databaseFile: string;
+    sha256: string;
+    size: number;
+    counts: Record<string, number>;
+    integrity: "ok";
+    foreignKeyViolations: 0;
+}
+export interface VerifiedBackup {
+    databasePath: string;
+    manifestPath: string;
+    manifest: BackupManifest;
+}
+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 inspectBackupDatabase(path: string): import("./health").DatabaseHealth;

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

@@ -0,0 +1,11 @@
+import type { Database } from "bun:sqlite";
+export interface DatabaseHealth {
+    integrity: string;
+    foreignKeyViolations: unknown[];
+    schemaVersion?: number;
+    counts: Record<string, number>;
+}
+export declare function inspectDatabase(db: Database): DatabaseHealth;
+export declare function assertHealthyDatabase(db: Database): DatabaseHealth;
+export declare function hasTable(db: Database, table: string): boolean;
+export declare function hasColumn(db: Database, table: string, column: string): boolean;

package/dist/types/db/migration-lock.d.ts

@@ -0,0 +1,17 @@
+export interface MigrationLockOwner {
+    ownerID: string;
+    pid: number;
+    processStartMarker: string;
+    hostname: string;
+    startedAt: number;
+    targetSchema: number;
+}
+export interface MigrationLock {
+    path: string;
+    owner: MigrationLockOwner;
+    release(): void;
+}
+export declare function migrationLockPath(databasePath: string): string;
+export declare function acquireMigrationLock(databasePath: string, targetSchema: number, timeoutMs?: number): MigrationLock;
+export declare function readMigrationLockOwner(path: string): MigrationLockOwner | undefined;
+export declare function breakMigrationLock(databasePath: string, ownerID: string, confirmation: string): void;

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

@@ -0,0 +1,3 @@
+import type { Database } from "bun:sqlite";
+export declare function migrateV8ToV9(db: Database): void;
+export declare function noteContentHash(kind: string, title: string, summary: string, content: string): string;

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

@@ -0,0 +1,5 @@
+import type { Database } from "bun:sqlite";
+export declare const SCHEMA_V9_TABLES = "\nCREATE TABLE IF NOT EXISTS projects (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  normalized_name TEXT NOT NULL UNIQUE,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\nCREATE TABLE IF NOT EXISTS notes (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL CHECK (kind IN ('decision','fact','procedure','context','research','preference','task')),\n  title TEXT NOT NULL,\n  summary TEXT NOT NULL,\n  content TEXT NOT NULL,\n  size_class TEXT NOT NULL CHECK (size_class IN ('inline','indexed')),\n  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0,1)),\n  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','superseded','archived')),\n  supersedes_id TEXT,\n  current_revision INTEGER NOT NULL DEFAULT 1 CHECK (current_revision >= 1),\n  subject_key TEXT,\n  content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL,\n  UNIQUE(project_id, id)\n);\nCREATE INDEX IF NOT EXISTS notes_project_idx ON notes(project_id, status);\nCREATE UNIQUE INDEX IF NOT EXISTS notes_active_subject_idx\n  ON notes(project_id, kind, subject_key)\n  WHERE status = 'active' AND subject_key IS NOT NULL;\nCREATE TABLE IF NOT EXISTS note_edges (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  source_id TEXT NOT NULL,\n  target_id TEXT NOT NULL,\n  predicate TEXT NOT NULL CHECK (predicate IN ('SUPPORTS','DERIVED_FROM','PART_OF','ABOUT','PRECEDES','SUPERSEDES')),\n  created_at INTEGER NOT NULL,\n  UNIQUE(project_id, source_id, target_id, predicate),\n  FOREIGN KEY (project_id, source_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,\n  FOREIGN KEY (project_id, target_id) REFERENCES notes(project_id, id) ON DELETE CASCADE\n);\nCREATE INDEX IF NOT EXISTS note_edges_source_idx ON note_edges(project_id, source_id);\nCREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, target_id);\nCREATE TABLE IF NOT EXISTS project_bindings (\n  binding_key TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  source TEXT NOT NULL CHECK (source = 'opencode-v2'),\n  source_project_id TEXT NOT NULL,\n  workspace_id TEXT NOT NULL,\n  canonical_path_hash TEXT NOT NULL CHECK (length(canonical_path_hash) = 64),\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL,\n  UNIQUE(source, source_project_id, workspace_id)\n);\nCREATE TABLE IF NOT EXISTS capture_checkpoints (\n  session_id TEXT PRIMARY KEY,\n  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  state TEXT NOT NULL CHECK (state IN ('active','idle','unavailable','closed')),\n  last_message_id TEXT,\n  last_reconciled_at INTEGER,\n  next_reconcile_at INTEGER NOT NULL,\n  failure_count INTEGER NOT NULL DEFAULT 0 CHECK (failure_count >= 0),\n  lease_owner TEXT,\n  lease_expires_at INTEGER,\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL\n);\nCREATE INDEX IF NOT EXISTS capture_checkpoints_due_idx\n  ON capture_checkpoints(state, next_reconcile_at);\nCREATE TABLE IF NOT EXISTS capture_events (\n  idempotency_key TEXT PRIMARY KEY,\n  contract TEXT NOT NULL CHECK (contract = 'opencode2-memory.capture/1'),\n  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,\n  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,\n  event_kind TEXT NOT NULL CHECK (event_kind IN ('user-candidate','assistant-candidate','session-summary','tool-signal')),\n  source_session_id TEXT NOT NULL,\n  source_message_id TEXT,\n  source_ordinal INTEGER CHECK (source_ordinal IS NULL OR source_ordinal >= 0),\n  source_tool_call_id TEXT,\n  payload_json TEXT CHECK (payload_json IS NULL OR json_valid(payload_json)),\n  payload_hash TEXT,\n  redaction_version TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('pending','shadowed','review','materialized','duplicate','ignored','rejected','quarantined','failed','dead')),\n  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),\n  note_id TEXT,\n  last_error_code TEXT,\n  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),\n  created_at INTEGER NOT NULL,\n  updated_at INTEGER NOT NULL,\n  processed_at INTEGER\n);\nCREATE INDEX IF NOT EXISTS capture_events_state_idx ON capture_events(state, updated_at);\nCREATE INDEX IF NOT EXISTS capture_events_session_idx ON capture_events(project_id, source_session_id);\nCREATE INDEX IF NOT EXISTS capture_events_note_idx ON capture_events(project_id, note_id);\nCREATE TABLE IF NOT EXISTS note_provenance (\n  id TEXT PRIMARY KEY,\n  project_id TEXT NOT NULL,\n  note_id TEXT NOT NULL,\n  source_type TEXT NOT NULL CHECK (source_type IN ('mcp-manual','opencode-capture','migration','legacy-import','admin')),\n  capture_event_id TEXT,\n  source_session_id TEXT,\n  source_message_id TEXT,\n  source_ordinal INTEGER,\n  source_tool_call_id TEXT,\n  redaction_version TEXT,\n  extractor_version TEXT,\n  confidence REAL CHECK (confidence IS NULL OR (confidence >= 0 AND confidence <= 1)),\n  created_at INTEGER NOT NULL,\n  UNIQUE(project_id, id),\n  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE\n);\nCREATE TABLE IF NOT EXISTS note_revisions (\n  project_id TEXT NOT NULL,\n  note_id TEXT NOT NULL,\n  revision INTEGER NOT NULL CHECK (revision >= 1),\n  kind TEXT NOT NULL,\n  title TEXT NOT NULL,\n  summary TEXT NOT NULL,\n  content TEXT NOT NULL,\n  size_class TEXT NOT NULL,\n  pinned INTEGER NOT NULL CHECK (pinned IN (0,1)),\n  status TEXT NOT NULL CHECK (status IN ('active','superseded','archived')),\n  supersedes_id TEXT,\n  subject_key TEXT,\n  content_hash TEXT NOT NULL,\n  provenance_id TEXT NOT NULL,\n  created_at INTEGER NOT NULL,\n  PRIMARY KEY(project_id, note_id, revision),\n  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,\n  FOREIGN KEY (project_id, provenance_id) REFERENCES note_provenance(project_id, id)\n);\nCREATE TABLE IF NOT EXISTS index_outbox (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  backend TEXT NOT NULL,\n  operation TEXT NOT NULL CHECK (operation IN ('upsert-note','delete-note','purge-project')),\n  project_id TEXT NOT NULL,\n  note_id TEXT,\n  revision INTEGER,\n  content_hash TEXT,\n  state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','leased','succeeded','dead')),\n  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),\n  available_at INTEGER NOT NULL,\n  lease_owner TEXT,\n  lease_expires_at INTEGER,\n  last_error_code TEXT,\n  created_at INTEGER NOT NULL,\n  completed_at INTEGER,\n  UNIQUE(backend, operation, project_id, note_id, revision)\n);\nCREATE INDEX IF NOT EXISTS index_outbox_due_idx\n  ON index_outbox(backend, project_id, state, available_at, id);\nCREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);\n";
+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 function createSchemaV9(db: Database): void;
+export declare function rebuildFts(db: Database): void;

package/dist/types/db.d.ts

@@ -0,0 +1,6 @@
+import { Database } from "bun:sqlite";
+export interface OpenedDB {
+    db: Database;
+    close: () => void;
+}
+export declare function openMemoryDatabase(path: string): OpenedDB;

package/dist/types/identity.d.ts

@@ -0,0 +1 @@
+export declare function hashRoot(directory: string): string;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/types/project.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_PROJECT_NAME_LENGTH = 120;
+export declare function cleanProjectName(value: string): string;
+export declare function normalizeProjectName(value: string): string;
+export declare function validateProjectName(value: string): string | undefined;

package/dist/types/retrieval/backends/none.d.ts

@@ -0,0 +1,9 @@
+import type { BackendHealth, DerivedDocument, DerivedRef, RankedHit, RetrievalBackend } from "../contract";
+export declare class NoneBackend implements RetrievalBackend {
+    readonly id = "none";
+    upsert(_document: DerivedDocument, _signal: AbortSignal): Promise<void>;
+    delete(_ref: DerivedRef, _signal: AbortSignal): Promise<void>;
+    purgeProject(_projectID: string, _signal: AbortSignal): Promise<void>;
+    query(_projectID: string, _query: string, _limit: number, _signal: AbortSignal): Promise<RankedHit[]>;
+    health(_signal: AbortSignal): Promise<BackendHealth>;
+}

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

@@ -0,0 +1,42 @@
+export interface RetrievalRequest {
+    projectID: string;
+    query: string;
+    limit: number;
+    deadlineAt: number;
+    semantic: "off" | "shadow" | "on";
+}
+export interface RankedHit {
+    noteID: string;
+    channel: "lexical" | "semantic" | "graph";
+    rank: number;
+    score?: number;
+    revision?: number;
+    contentHash?: string;
+}
+export interface DerivedDocument {
+    projectID: string;
+    noteID: string;
+    revision: number;
+    kind: string;
+    title: string;
+    summary: string;
+    content: string;
+    contentHash: string;
+}
+export interface DerivedRef {
+    projectID: string;
+    noteID: string;
+}
+export interface BackendHealth {
+    ok: boolean;
+    version?: string;
+    errorCode?: string;
+}
+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>;
+    query(projectID: string, query: string, limit: number, signal: AbortSignal): Promise<RankedHit[]>;
+    health(signal: AbortSignal): Promise<BackendHealth>;
+}

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

@@ -0,0 +1,11 @@
+import type { DerivedDocument } from "./contract";
+export interface CanonicalDocumentSource {
+    projectID: string;
+    noteID: string;
+    revision: number;
+    kind: string;
+    title: string;
+    summary: string;
+    content: string;
+}
+export declare function deriveDocument(source: CanonicalDocumentSource): DerivedDocument | undefined;

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

@@ -0,0 +1,5 @@
+import type { RecallCard } from "../types";
+export declare function formatUntrustedContext(projectID: string, cards: readonly RecallCard[], options?: {
+    maxCards?: number;
+    maxCharacters?: number;
+}): string | undefined;

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

@@ -0,0 +1,8 @@
+import type { RankedHit } from "./contract";
+export interface FusedHit {
+    noteID: string;
+    score: number;
+    matchedCandidate: boolean;
+    channels: Set<RankedHit["channel"]>;
+}
+export declare function weightedReciprocalRankFusion(channels: readonly RankedHit[]): FusedHit[];

package/dist/types/server.d.ts

@@ -0,0 +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.0-beta.1";
+export declare function createMemoryServer(store: MemoryStore): McpServer;

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

@@ -0,0 +1,46 @@
+import type { Database } from "bun:sqlite";
+export interface ProjectBindingInput {
+    memoryProjectID: string;
+    opencodeProjectID: string;
+    canonicalDirectory: string;
+    workspaceID?: string;
+}
+export type CaptureMode = "shadow" | "auto-write";
+export interface CaptureIngestResult {
+    outcome: "shadowed" | "materialized" | "duplicate" | "ignored" | "review" | "rejected" | "quarantined";
+    idempotencyKey: string;
+    noteID?: string;
+    existing?: boolean;
+}
+export declare class CaptureStore {
+    private db;
+    private indexBackends;
+    constructor(db: Database, indexBackends?: readonly string[]);
+    bindProject(input: ProjectBindingInput): {
+        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): {
+        sessionID: string;
+        lastMessageID?: string;
+        state: "active" | "idle" | "unavailable" | "closed";
+    } | undefined;
+    ingest(input: unknown, mode: CaptureMode, options?: {
+        allowedKinds?: readonly string[];
+        minConfidence?: number;
+        denylist?: readonly string[];
+    }): CaptureIngestResult;
+    runRetention(now?: number, batchSize?: number): {
+        summarized: number;
+        deleted: number;
+        checkpoints: number;
+    };
+    private materialize;
+    private insertCapturedNote;
+    private recordRevision;
+    private enqueueOutbox;
+    private finishEvent;
+    private binding;
+}

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

@@ -0,0 +1,14 @@
+import type { Database } from "bun:sqlite";
+import type { RetrievalBackend } from "../retrieval/contract";
+export type OutboxOutcome = "idle" | "succeeded" | "stale" | "quarantined" | "retry" | "dead";
+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);
+    processNext(): Promise<OutboxOutcome>;
+    private succeed;
+    private fail;
+}

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

@@ -0,0 +1,18 @@
+import type { Database } from "bun:sqlite";
+import type { RetrievalBackend, RetrievalRequest } from "../retrieval/contract";
+import type { RecallCard } from "../types";
+export interface RetrievalResult {
+    cards: RecallCard[];
+    semanticFallback: boolean;
+    rejectedBackendHits: number;
+}
+export declare class RetrievalStore {
+    private db;
+    private backend?;
+    constructor(db: Database, backend?: RetrievalBackend | undefined);
+    retrieve(request: RetrievalRequest): Promise<RetrievalResult>;
+    private lexical;
+    private graph;
+    private graphPredicates;
+    private note;
+}

package/dist/types/store.d.ts

@@ -0,0 +1,95 @@
+import type { Database } from "bun:sqlite";
+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;
+    projectID?: string;
+    projectName?: string;
+    reason?: string;
+    sizeClass?: string;
+    deleted?: boolean;
+}
+export declare class MemoryStore {
+    private db;
+    private indexBackends;
+    constructor(db: Database, indexBackends?: readonly string[]);
+    resolveProject(selector: ProjectSelector): {
+        ok: boolean;
+        project?: Project;
+        reason?: string;
+    };
+    listProjects(): ProjectSummary[];
+    createProject(nameValue: string): {
+        ok: boolean;
+        project?: Project;
+        reason?: string;
+    };
+    updateProject(projectID: string, nameValue: string): {
+        ok: boolean;
+        project?: Project;
+        reason?: string;
+    };
+    deleteProject(projectID: string, confirmProjectName: string): {
+        ok: boolean;
+        deleted?: boolean;
+        projectID?: string;
+        projectName?: string;
+        deletedCounts?: {
+            notes: number;
+            edges: number;
+            pinned: number;
+        };
+        reason?: string;
+    };
+    update(projectID: string, input: UpdateInput): UpdateResult;
+    pin(projectID: string, id: string, pinned: boolean): {
+        ok: boolean;
+        reason: string;
+        id?: undefined;
+        projectID?: undefined;
+        projectName?: undefined;
+        pinned?: undefined;
+    } | {
+        reason?: undefined;
+        ok: boolean;
+        id: string;
+        projectID: string;
+        projectName: string;
+        pinned: boolean;
+    };
+    private insertNote;
+    read(projectID: string, id: string): {
+        note?: Note;
+        edges?: Edge[];
+        reason?: string;
+    };
+    link(projectID: string, sourceID: string, targetID: string, predicate: string): {
+        projectID?: undefined;
+        projectName?: undefined;
+        ok: boolean;
+        reason: string;
+    } | {
+        reason?: undefined;
+        ok: boolean;
+        projectID: string;
+        projectName: string;
+    };
+    recall(projectID: string, query: string, limit?: number): RecallCard[];
+    private getProjectRow;
+    private projectNameExists;
+    private getNoteRow;
+    private recordCurrentRevision;
+    private enqueueOutbox;
+}

package/dist/types/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { MemoryStore } from "./store";
+export declare function registerTools(server: McpServer, store: MemoryStore): void;