@vaur94/agz-memory 0.4.0-beta.1 → 0.4.1

package/dist/server.js

@@ -43,7 +43,7 @@ function validateProjectName(value) {
 }
 
 // src/types.ts
-var SCHEMA_VERSION = 9;
+var SCHEMA_VERSION = 10;
 var INLINE_LIMIT = 1200;
 var KINDS = ["decision", "fact", "procedure", "context", "research", "preference", "task"];
 var PREDICATES = ["SUPPORTS", "DERIVED_FROM", "PART_OF", "ABOUT", "PRECEDES", "SUPERSEDES"];
@@ -107,9 +107,12 @@ function hasTable(db, table) {
 }
 
 // src/db/backup.ts
-var BACKUP_FORMAT = "opencode2-memory-backup/1";
+var BACKUP_FORMAT = "agz-memory-backup/1";
 function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, productVersion) {
   const sourceHealth = assertHealthyDatabase(db);
+  if (sourceHealth.schemaVersion !== undefined && sourceHealth.schemaVersion !== sourceSchema) {
+    throw new Error(`backup source schema v${sourceSchema} does not match database schema v${sourceHealth.schemaVersion}`);
+  }
   const checkpoint = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
   if (checkpoint.busy !== 0)
     throw new Error("database WAL checkpoint is busy");
@@ -137,6 +140,9 @@ function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, prod
     if (JSON.stringify(backupHealth.counts) !== JSON.stringify(sourceHealth.counts)) {
       throw new Error("backup row counts differ from source database");
     }
+    if (backupHealth.schemaVersion !== undefined && backupHealth.schemaVersion !== sourceSchema) {
+      throw new Error("backup schema does not match source schema");
+    }
     const bytes = readFileSync(temporaryDatabasePath);
     const manifest = {
       format: BACKUP_FORMAT,
@@ -209,6 +215,9 @@ function verifyBackupManifest(manifestPath) {
     if (JSON.stringify(health.counts) !== JSON.stringify(manifest.counts)) {
       throw new Error("backup manifest row counts do not match");
     }
+    if (health.schemaVersion !== undefined && health.schemaVersion !== manifest.sourceSchema) {
+      throw new Error("backup manifest source schema does not match database");
+    }
   } finally {
     db.close();
   }
@@ -394,7 +403,7 @@ function acquireMigrationLock(databasePath, targetSchema, timeoutMs = 30000) {
           rmSync2(path, { recursive: true, force: true });
           throw error;
         }
-        if (!existsSync2(path))
+        if (!isAlreadyExistsError(error))
           throw error;
         if (Date.now() >= deadline) {
           const current = readMigrationLockOwner(path);
@@ -437,12 +446,84 @@ function processStartMarker(pid) {
     return;
   }
 }
+function isAlreadyExistsError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && String(error.code) === "EEXIST");
+}
 
 // src/db/migrations/v009.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 
+// src/capture/contract.ts
+import * as z from "zod/v4";
+var CAPTURE_SCHEMA = "agz-memory.capture/1";
+var SUPPORTED_OPENCODE_VERSION = "0.0.0-beta-18743";
+var CAPTURE_EVENT_MAX_BYTES = 16 * 1024;
+var CAPTURE_CONTENT_MAX_CHARACTERS = 4800;
+var CAPTURE_SUMMARY_MAX_CHARACTERS = 1200;
+var CAPTURE_SUBJECT_MAX_CHARACTERS = 240;
+var candidateSchema = z.object({
+  kind: z.enum(KINDS),
+  title: z.string().min(1).max(240),
+  summary: z.string().min(1).max(CAPTURE_SUMMARY_MAX_CHARACTERS),
+  content: z.string().min(1).max(CAPTURE_CONTENT_MAX_CHARACTERS),
+  subjectKey: z.string().min(1).max(CAPTURE_SUBJECT_MAX_CHARACTERS).optional(),
+  intent: z.enum(["create", "supersede", "ignore", "review"]),
+  targetNoteID: z.string().min(1).max(240).optional(),
+  confidence: z.number().finite().min(0).max(1),
+  evidence: z.enum(["explicit-user", "verified-outcome", "session-summary"])
+}).strict();
+var signalSchema = z.object({
+  tool: z.string().min(1).max(160),
+  status: z.enum(["completed", "error"]),
+  errorType: z.string().min(1).max(160).optional()
+}).strict();
+var captureEventSchema = z.object({
+  schema: z.literal(CAPTURE_SCHEMA),
+  idempotencyKey: z.string().regex(/^[0-9a-f]{64}$/),
+  projectID: z.uuid(),
+  bindingKey: z.string().regex(/^[0-9a-f]{64}$/),
+  kind: z.enum(["user-candidate", "assistant-candidate", "session-summary", "tool-signal"]),
+  source: z.object({
+    system: z.literal("opencode-v2"),
+    opencodeVersion: z.literal(SUPPORTED_OPENCODE_VERSION),
+    pluginVersion: z.string().min(1).max(80),
+    sessionID: z.string().min(1).max(240),
+    messageID: z.string().min(1).max(240).optional(),
+    ordinal: z.number().int().nonnegative().optional(),
+    toolCallID: z.string().min(1).max(240).optional(),
+    observedAt: z.number().int().nonnegative()
+  }).strict(),
+  candidate: candidateSchema.optional(),
+  signal: signalSchema.optional(),
+  redaction: z.object({
+    policyVersion: z.string().min(1).max(80),
+    replacements: z.number().int().nonnegative(),
+    truncated: z.boolean()
+  }).strict()
+}).strict().superRefine((event, context) => {
+  if (event.kind === "tool-signal" && !event.signal) {
+    context.addIssue({ code: "custom", message: "tool-signal requires signal" });
+  }
+  if (event.kind !== "tool-signal" && !event.candidate) {
+    context.addIssue({ code: "custom", message: `${event.kind} requires candidate` });
+  }
+  if (event.kind === "tool-signal" && event.candidate) {
+    context.addIssue({ code: "custom", message: "tool-signal cannot carry candidate" });
+  }
+  if (event.kind !== "tool-signal" && event.signal) {
+    context.addIssue({ code: "custom", message: `${event.kind} cannot carry signal` });
+  }
+});
+function parseCaptureEvent(value) {
+  const event = captureEventSchema.parse(value);
+  if (Buffer.byteLength(JSON.stringify(event), "utf8") > CAPTURE_EVENT_MAX_BYTES) {
+    throw new Error(`capture event exceeds ${CAPTURE_EVENT_MAX_BYTES} UTF-8 bytes`);
+  }
+  return event;
+}
+
 // src/db/schema.ts
-var SCHEMA_V9_TABLES = `
+var SCHEMA_TABLES = `
 CREATE TABLE IF NOT EXISTS projects (
   id TEXT PRIMARY KEY,
   name TEXT NOT NULL,
@@ -512,28 +593,7 @@ CREATE TABLE IF NOT EXISTS capture_checkpoints (
 );
 CREATE INDEX IF NOT EXISTS capture_checkpoints_due_idx
   ON capture_checkpoints(state, next_reconcile_at);
-CREATE TABLE IF NOT EXISTS capture_events (
-  idempotency_key TEXT PRIMARY KEY,
-  contract TEXT NOT NULL CHECK (contract = 'opencode2-memory.capture/1'),
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
-  event_kind TEXT NOT NULL CHECK (event_kind IN ('user-candidate','assistant-candidate','session-summary','tool-signal')),
-  source_session_id TEXT NOT NULL,
-  source_message_id TEXT,
-  source_ordinal INTEGER CHECK (source_ordinal IS NULL OR source_ordinal >= 0),
-  source_tool_call_id TEXT,
-  payload_json TEXT CHECK (payload_json IS NULL OR json_valid(payload_json)),
-  payload_hash TEXT,
-  redaction_version TEXT NOT NULL,
-  state TEXT NOT NULL CHECK (state IN ('pending','shadowed','review','materialized','duplicate','ignored','rejected','quarantined','failed','dead')),
-  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
-  note_id TEXT,
-  last_error_code TEXT,
-  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL,
-  processed_at INTEGER
-);
+${captureEventsTable()}
 CREATE INDEX IF NOT EXISTS capture_events_state_idx ON capture_events(state, updated_at);
 CREATE INDEX IF NOT EXISTS capture_events_session_idx ON capture_events(project_id, source_session_id);
 CREATE INDEX IF NOT EXISTS capture_events_note_idx ON capture_events(project_id, note_id);
@@ -617,15 +677,39 @@ CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE OF title, summary, conten
   VALUES (new.rowid, new.title, new.summary, new.content);
 END;
 `;
-function createSchemaV9(db) {
-  db.exec(SCHEMA_V9_TABLES);
+function createSchema(db) {
+  db.exec(SCHEMA_TABLES);
   db.exec(FTS_V9);
   db.query("DELETE FROM schema_state").run();
-  db.query("INSERT INTO schema_state(version) VALUES (9)").run();
+  db.query("INSERT INTO schema_state(version) VALUES (10)").run();
 }
 function rebuildFts(db) {
   db.query("INSERT INTO notes_fts(notes_fts) VALUES ('rebuild')").run();
 }
+function captureEventsTable(table = "capture_events") {
+  return `CREATE TABLE IF NOT EXISTS ${table} (
+  idempotency_key TEXT PRIMARY KEY,
+  contract TEXT NOT NULL CHECK (contract = '${CAPTURE_SCHEMA}'),
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
+  event_kind TEXT NOT NULL CHECK (event_kind IN ('user-candidate','assistant-candidate','session-summary','tool-signal')),
+  source_session_id TEXT NOT NULL,
+  source_message_id TEXT,
+  source_ordinal INTEGER CHECK (source_ordinal IS NULL OR source_ordinal >= 0),
+  source_tool_call_id TEXT,
+  payload_json TEXT CHECK (payload_json IS NULL OR json_valid(payload_json)),
+  payload_hash TEXT,
+  redaction_version TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('pending','shadowed','review','materialized','duplicate','ignored','rejected','quarantined','failed','dead')),
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+  note_id TEXT,
+  last_error_code TEXT,
+  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  processed_at INTEGER
+);`;
+}
 
 // src/db/migrations/v009.ts
 function migrateV8ToV9(db) {
@@ -694,7 +778,7 @@ function migrateV8ToV9(db) {
     ALTER TABLE notes_v9 RENAME TO notes;
     ALTER TABLE note_edges_v9 RENAME TO note_edges;
   `);
-  db.exec(SCHEMA_V9_TABLES);
+  db.exec(SCHEMA_TABLES);
   for (const note of notes) {
     const provenanceID = randomUUID3();
     db.query(`
@@ -718,6 +802,57 @@ function noteContentHash(kind, title, summary, content) {
   return createHash3("sha256").update(`${kind}\x00${title}\x00${summary}\x00${content}`, "utf8").digest("hex");
 }
 
+// src/db/migrations/v010.ts
+import { createHash as createHash4 } from "crypto";
+function migrateV9ToV10(db) {
+  const payloads = db.query("SELECT idempotency_key, payload_json FROM capture_events WHERE payload_json IS NOT NULL").all();
+  const migratedPayloads = payloads.map((row) => {
+    const event = JSON.parse(row.payload_json);
+    if (!event || typeof event !== "object" || Array.isArray(event)) {
+      throw new Error(`capture event ${row.idempotency_key} payload is not an object`);
+    }
+    event.schema = CAPTURE_SCHEMA;
+    const payload = JSON.stringify(parseCaptureEvent(event));
+    return {
+      idempotencyKey: row.idempotency_key,
+      payload,
+      payloadHash: createHash4("sha256").update(payload, "utf8").digest("hex")
+    };
+  });
+  db.exec("DROP TABLE IF EXISTS capture_events_v10");
+  db.exec(captureEventsTable("capture_events_v10"));
+  db.query(`
+    INSERT INTO capture_events_v10
+      (idempotency_key, contract, project_id, binding_key, event_kind,
+       source_session_id, source_message_id, source_ordinal, source_tool_call_id,
+       payload_json, payload_hash, redaction_version, state, attempt_count,
+       note_id, last_error_code, generation, created_at, updated_at, processed_at)
+    SELECT idempotency_key, ?, project_id, binding_key, event_kind,
+           source_session_id, source_message_id, source_ordinal, source_tool_call_id,
+           payload_json, payload_hash, redaction_version, state, attempt_count,
+           note_id, last_error_code, generation, created_at, updated_at, processed_at
+      FROM capture_events
+  `).run(CAPTURE_SCHEMA);
+  const updatePayload = db.query(`
+    UPDATE capture_events_v10
+       SET payload_json = ?, payload_hash = ?
+     WHERE idempotency_key = ?
+  `);
+  for (const row of migratedPayloads) {
+    updatePayload.run(row.payload, row.payloadHash, row.idempotencyKey);
+  }
+  db.exec(`
+    DROP TABLE capture_events;
+    ALTER TABLE capture_events_v10 RENAME TO capture_events;
+  `);
+  db.exec(SCHEMA_TABLES);
+  db.query("DELETE FROM schema_state").run();
+  db.query("INSERT INTO schema_state(version) VALUES (10)").run();
+}
+
+// src/version.ts
+var PRODUCT_VERSION = "0.4.1";
+
 // src/db.ts
 var DDL = `
 CREATE TABLE IF NOT EXISTS projects (
@@ -759,13 +894,11 @@ CREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, targe
 CREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);
 `;
 function openMemoryDatabase(path) {
-  const db = new Database2(path, { create: true });
-  chmodSync2(path, 384);
+  let db = openDatabase(path);
+  let dbOpen = true;
   let lock;
   let backup;
   try {
-    db.exec("PRAGMA busy_timeout=5000");
-    db.exec("PRAGMA journal_mode=WAL");
     const existingVersion = getSchemaVersion(db);
     if (existingVersion && existingVersion.version > SCHEMA_VERSION) {
       throw new Error(`database schema v${existingVersion.version} is newer than supported v${SCHEMA_VERSION}`);
@@ -773,19 +906,36 @@ function openMemoryDatabase(path) {
     const hasExistingData = hasLegacyV2(db) || hasTable2(db, "notes") || Boolean(existingVersion);
     if (!hasExistingData) {
       db.exec("PRAGMA foreign_keys=ON");
-      db.transaction(() => createSchemaV9(db))();
+      db.transaction(() => createSchema(db))();
       assertHealthyDatabase(db);
       return { db, close: () => db.close() };
     }
     if ((existingVersion?.version ?? 0) < SCHEMA_VERSION) {
+      db.close();
+      dbOpen = false;
       lock = acquireMigrationLock(path, SCHEMA_VERSION);
-      backup = createVerifiedBackup(db, path, existingVersion?.version ?? 2, SCHEMA_VERSION, "0.4.0-beta.1");
+      db = openDatabase(path);
+      dbOpen = true;
+      const migrationVersion = getSchemaVersion(db);
+      if (migrationVersion && migrationVersion.version > SCHEMA_VERSION) {
+        throw new Error(`database schema v${migrationVersion.version} is newer than supported v${SCHEMA_VERSION}`);
+      }
+      if ((migrationVersion?.version ?? 0) === SCHEMA_VERSION) {
+        lock.release();
+        lock = undefined;
+        db.exec("PRAGMA foreign_keys=ON");
+        db.exec(SCHEMA_TABLES);
+        db.exec(FTS_V9);
+        assertHealthyDatabase(db);
+        return { db, close: () => db.close() };
+      }
+      backup = createVerifiedBackup(db, path, migrationVersion?.version ?? 2, SCHEMA_VERSION, PRODUCT_VERSION);
       db.exec("PRAGMA foreign_keys=OFF");
-      if (!existingVersion && hasLegacyV2(db)) {
+      if (!migrationVersion && hasLegacyV2(db)) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         migrateFromV2(db, path);
-      } else if (!existingVersion) {
+      } else if (!migrationVersion) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         db.transaction(() => {
@@ -793,14 +943,18 @@ function openMemoryDatabase(path) {
           db.query("DELETE FROM schema_state").run();
           db.query("INSERT INTO schema_state (version) VALUES (8)").run();
         })();
-      } else if (existingVersion.version < 8) {
+      } else if (migrationVersion.version < 8) {
         db.exec(DDL);
         db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(id UNINDEXED, title, summary, content, tokenize='unicode61')");
         migrateToV8(db);
       }
-      const version = getSchemaVersion(db)?.version ?? 8;
-      if (version < 9)
+      let version = getSchemaVersion(db)?.version ?? 8;
+      if (version < 9) {
         db.transaction(() => migrateV8ToV9(db))();
+        version = 9;
+      }
+      if (version < 10)
+        db.transaction(() => migrateV9ToV10(db))();
       db.exec("PRAGMA foreign_keys=ON");
       if (db.query("PRAGMA foreign_keys").get().foreign_keys !== 1) {
         throw new Error("failed to enable database foreign keys");
@@ -812,13 +966,14 @@ function openMemoryDatabase(path) {
       return { db, close: () => db.close() };
     }
     db.exec("PRAGMA foreign_keys=ON");
-    db.exec(SCHEMA_V9_TABLES);
+    db.exec(SCHEMA_TABLES);
     db.exec(FTS_V9);
     assertHealthyDatabase(db);
     db.exec("PRAGMA foreign_keys=ON");
     return { db, close: () => db.close() };
   } catch (error) {
-    db.close();
+    if (dbOpen)
+      db.close();
     if (backup) {
       try {
         restoreVerifiedBackup(backup.manifestPath, path, "RESTORE_DATABASE_FROM_VERIFIED_BACKUP");
@@ -831,6 +986,18 @@ function openMemoryDatabase(path) {
     lock?.release();
   }
 }
+function openDatabase(path) {
+  const db = new Database2(path, { create: true });
+  try {
+    chmodSync2(path, 384);
+    db.exec("PRAGMA busy_timeout=5000");
+    db.exec("PRAGMA journal_mode=WAL");
+    return db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
 function getSchemaVersion(db) {
   if (!hasTable2(db, "schema_state"))
     return;
@@ -1093,29 +1260,29 @@ var MEMORY_GUIDANCE = `Use project-scoped memory for durable facts across sessio
 - 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.`;
 
 // src/tools.ts
-import * as z from "zod/v4";
+import * as z2 from "zod/v4";
 var MAX_BATCH = 10;
-var projectID = z.uuid().describe("The immutable project UUID returned by project_create or project_list.");
-var projectName = z.string().min(1).max(MAX_PROJECT_NAME_LENGTH).describe("The project's unique current name. Prefer projectID when retaining a long-lived reference.");
-var createUpdateSchema = z.object({
-  kind: z.enum(KINDS),
-  title: z.string(),
-  summary: z.string(),
-  content: z.string().optional()
+var projectID = z2.uuid().describe("The immutable project UUID returned by project_create or project_list.");
+var projectName = z2.string().min(1).max(MAX_PROJECT_NAME_LENGTH).describe("The project's unique current name. Prefer projectID when retaining a long-lived reference.");
+var createUpdateSchema = z2.object({
+  kind: z2.enum(KINDS),
+  title: z2.string(),
+  summary: z2.string(),
+  content: z2.string().optional()
 }).strict();
-var patchUpdateSchema = z.object({
-  id: z.string(),
-  kind: z.enum(KINDS).optional(),
-  title: z.string().optional(),
-  summary: z.string().optional(),
-  content: z.string().optional(),
-  delete: z.boolean().optional()
+var patchUpdateSchema = z2.object({
+  id: z2.string(),
+  kind: z2.enum(KINDS).optional(),
+  title: z2.string().optional(),
+  summary: z2.string().optional(),
+  content: z2.string().optional(),
+  delete: z2.boolean().optional()
 }).strict();
-var updateSchema = z.union([createUpdateSchema, patchUpdateSchema]);
-var linkSchema = z.object({
-  sourceID: z.string(),
-  targetID: z.string(),
-  predicate: z.enum(PREDICATES)
+var updateSchema = z2.union([createUpdateSchema, patchUpdateSchema]);
+var linkSchema = z2.object({
+  sourceID: z2.string(),
+  targetID: z2.string(),
+  predicate: z2.enum(PREDICATES)
 }).strict();
 function textResult(value) {
   return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
@@ -1128,39 +1295,39 @@ function registerTools(server, store) {
   server.registerTool("project_list", {
     title: "List memory projects",
     description: "List all memory projects with their immutable IDs, current names, note counts, and pinned-note counts. Use this before selecting a project by ID.",
-    inputSchema: z.object({}).strict(),
+    inputSchema: z2.object({}).strict(),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
   }, async () => textResult({ projects: store.listProjects() }));
   server.registerTool("project_create", {
     title: "Create a memory project",
     description: "Create an empty memory project. The returned projectID is immutable; the unique project name may be changed later.",
-    inputSchema: z.object({ projectName }).strict(),
+    inputSchema: z2.object({ projectName }).strict(),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
   }, async ({ projectName: projectName2 }) => textResult({ results: [store.createProject(projectName2)] }));
   server.registerTool("project_update", {
     title: "Rename a memory project",
     description: "Rename one project by its immutable projectID. Renaming does not change the ID or detach any notes.",
-    inputSchema: z.object({ projectID, projectName }).strict(),
+    inputSchema: z2.object({ projectID, projectName }).strict(),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   }, async ({ projectID: projectID2, projectName: projectName2 }) => textResult({ results: [store.updateProject(projectID2, projectName2)] }));
   server.registerTool("project_delete", {
     title: "Permanently delete a memory project",
     description: "DANGER: Permanently deletes the selected project and every note, pinned note, graph edge, and search record owned by it. This cannot be undone. First call project_list, verify the immutable projectID and current name, then provide both confirmation fields exactly.",
-    inputSchema: z.object({
+    inputSchema: z2.object({
       projectID,
       confirmProjectName: projectName.describe("Must exactly match the project's current case-sensitive name. This prevents deletion after an unnoticed rename or wrong-ID selection."),
-      confirmation: z.literal("DELETE_PROJECT_AND_ALL_MEMORY").describe("Required destructive-action confirmation phrase.")
+      confirmation: z2.literal("DELETE_PROJECT_AND_ALL_MEMORY").describe("Required destructive-action confirmation phrase.")
     }).strict(),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
   }, async ({ projectID: projectID2, confirmProjectName }) => textResult({ results: [store.deleteProject(projectID2, confirmProjectName)] }));
   server.registerTool("memory_recall", {
     title: "Search project memory",
     description: "Search memory only inside one project selected by immutable projectID or unique projectName. Pass one query or up to 10 queries. Indexed cards require memory_read for full content.",
-    inputSchema: z.union([
-      z.object({ projectID, query: z.string() }).strict(),
-      z.object({ projectID, queries: z.array(z.string()).min(1).max(MAX_BATCH) }).strict(),
-      z.object({ projectName, query: z.string() }).strict(),
-      z.object({ projectName, queries: z.array(z.string()).min(1).max(MAX_BATCH) }).strict()
+    inputSchema: z2.union([
+      z2.object({ projectID, query: z2.string() }).strict(),
+      z2.object({ projectID, queries: z2.array(z2.string()).min(1).max(MAX_BATCH) }).strict(),
+      z2.object({ projectName, query: z2.string() }).strict(),
+      z2.object({ projectName, queries: z2.array(z2.string()).min(1).max(MAX_BATCH) }).strict()
     ]),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
   }, async (raw) => {
@@ -1179,13 +1346,13 @@ function registerTools(server, store) {
   server.registerTool("memory_update", {
     title: "Create, patch, or delete project memory",
     description: "Create or patch notes only inside one selected project. Setting delete:true permanently deletes only the specified note from that project; verify the note ID before using delete. A batch contains up to 10 ordered, non-atomic updates: inspect every result because earlier items remain applied if a later item fails. Do not batch destructive deletes unless partial completion is acceptable. Pin state is changed only through memory_pin.",
-    inputSchema: z.union([
+    inputSchema: z2.union([
       createUpdateSchema.extend({ projectID }),
       patchUpdateSchema.extend({ projectID }),
-      z.object({ projectID, updates: z.array(updateSchema).min(1).max(MAX_BATCH) }).strict(),
+      z2.object({ projectID, updates: z2.array(updateSchema).min(1).max(MAX_BATCH) }).strict(),
       createUpdateSchema.extend({ projectName }),
       patchUpdateSchema.extend({ projectName }),
-      z.object({ projectName, updates: z.array(updateSchema).min(1).max(MAX_BATCH) }).strict()
+      z2.object({ projectName, updates: z2.array(updateSchema).min(1).max(MAX_BATCH) }).strict()
     ]),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
   }, async (raw) => {
@@ -1201,9 +1368,9 @@ function registerTools(server, store) {
   server.registerTool("memory_pin", {
     title: "Pin or unpin project memory",
     description: "Set the pinned state of one active note inside one selected project. Pinned matching notes are prioritized in recall results. This tool never deletes content.",
-    inputSchema: z.union([
-      z.object({ projectID, id: z.string(), pinned: z.boolean() }).strict(),
-      z.object({ projectName, id: z.string(), pinned: z.boolean() }).strict()
+    inputSchema: z2.union([
+      z2.object({ projectID, id: z2.string(), pinned: z2.boolean() }).strict(),
+      z2.object({ projectName, id: z2.string(), pinned: z2.boolean() }).strict()
     ]),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   }, async (raw) => {
@@ -1218,11 +1385,11 @@ function registerTools(server, store) {
   server.registerTool("memory_link", {
     title: "Link project memories",
     description: `Create one graph edge or up to 10 ordered, non-atomic edge operations between notes in the same selected project; inspect every result because earlier links remain applied if a later item fails. Cross-project links are rejected. Predicates: ${PREDICATES.join(", ")}.`,
-    inputSchema: z.union([
+    inputSchema: z2.union([
       linkSchema.extend({ projectID }),
-      z.object({ projectID, links: z.array(linkSchema).min(1).max(MAX_BATCH) }).strict(),
+      z2.object({ projectID, links: z2.array(linkSchema).min(1).max(MAX_BATCH) }).strict(),
       linkSchema.extend({ projectName }),
-      z.object({ projectName, links: z.array(linkSchema).min(1).max(MAX_BATCH) }).strict()
+      z2.object({ projectName, links: z2.array(linkSchema).min(1).max(MAX_BATCH) }).strict()
     ]),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   }, async (raw) => {
@@ -1238,11 +1405,11 @@ function registerTools(server, store) {
   server.registerTool("memory_read", {
     title: "Read project memory",
     description: "Read one note or up to 10 notes from one selected project, including full content, pin state, project identity, and same-project graph edges.",
-    inputSchema: z.union([
-      z.object({ projectID, id: z.string() }).strict(),
-      z.object({ projectID, ids: z.array(z.string()).min(1).max(MAX_BATCH) }).strict(),
-      z.object({ projectName, id: z.string() }).strict(),
-      z.object({ projectName, ids: z.array(z.string()).min(1).max(MAX_BATCH) }).strict()
+    inputSchema: z2.union([
+      z2.object({ projectID, id: z2.string() }).strict(),
+      z2.object({ projectID, ids: z2.array(z2.string()).min(1).max(MAX_BATCH) }).strict(),
+      z2.object({ projectName, id: z2.string() }).strict(),
+      z2.object({ projectName, ids: z2.array(z2.string()).min(1).max(MAX_BATCH) }).strict()
     ]),
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
   }, async (raw) => {
@@ -1262,7 +1429,7 @@ function registerTools(server, store) {
 
 // src/server.ts
 var SERVER_NAME = "agz-memory";
-var SERVER_VERSION = "0.4.0-beta.1";
+var SERVER_VERSION = PRODUCT_VERSION;
 function createMemoryServer(store) {
   const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, { instructions: MEMORY_GUIDANCE });
   registerTools(server, store);
@@ -1273,9 +1440,10 @@ function createMemoryServer(store) {
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/retrieval/derived.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/capture/redact.ts
+var REDACTION_POLICY_VERSION = "redaction/1";
 var RULES = [
   {
     name: "private-key",
@@ -1304,15 +1472,15 @@ function redactText(value, options = {}) {
   let replacements = 0;
   let highRisk = 0;
   const classes = {};
-  for (const literal2 of options.denylist ?? []) {
-    if (!literal2)
+  for (const literal3 of options.denylist ?? []) {
+    if (!literal3)
       continue;
-    const count = text.split(literal2).length - 1;
+    const count = text.split(literal3).length - 1;
     if (count === 0)
       continue;
     replacements += count;
     classes.denylist = (classes.denylist ?? 0) + count;
-    text = text.replaceAll(literal2, "[REDACTED:denylist]");
+    text = text.replaceAll(literal3, "[REDACTED:denylist]");
   }
   for (const rule of RULES) {
     text = text.replace(rule.pattern, () => {
@@ -1362,7 +1530,7 @@ function deriveDocument(source) {
   const content = redactText(source.content);
   if (title.quarantined || summary.quarantined || content.quarantined)
     return;
-  const contentHash = createHash4("sha256").update(`${source.kind}\x00${title.text}\x00${summary.text}\x00${content.text}`, "utf8").digest("hex");
+  const contentHash = createHash5("sha256").update(`${source.kind}\x00${title.text}\x00${summary.text}\x00${content.text}`, "utf8").digest("hex");
   return {
     projectID: source.projectID,
     noteID: source.noteID,
@@ -1756,6 +1924,359 @@ function toCard(note, via) {
   };
 }
 
+// src/store/capture.ts
+import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
+
+// src/capture/policy.ts
+var EXTRACTOR_VERSION = "deterministic-extractor/1";
+function canAutoWrite(candidate, redaction, allowedKinds = ["preference", "decision"], minConfidence = 0.95) {
+  return candidate.evidence === "explicit-user" && candidate.confidence >= minConfidence && allowedKinds.includes(candidate.kind) && !redaction.truncated && !redaction.quarantined && (candidate.intent === "create" || candidate.intent === "supersede");
+}
+function normalizeSubjectKey(value) {
+  return value.normalize("NFKC").trim().replace(/\s+/g, " ").toLocaleLowerCase("en-US").slice(0, 240);
+}
+
+// src/store/capture.ts
+class CaptureStore {
+  db;
+  indexBackends;
+  constructor(db, indexBackends = []) {
+    this.db = db;
+    this.indexBackends = indexBackends;
+  }
+  bindProject(input) {
+    const workspaceID = input.workspaceID ?? "";
+    const canonicalPathHash = sha256(input.canonicalDirectory);
+    const bindingKey = sha256(["opencode-v2", input.opencodeProjectID, workspaceID, canonicalPathHash].join("\x00"));
+    const project = this.db.query("SELECT id FROM projects WHERE id = ?").get(input.memoryProjectID);
+    if (!project)
+      throw new Error(`memory project ${input.memoryProjectID} not found`);
+    const existing = this.db.query(`SELECT * FROM project_bindings
+          WHERE source = 'opencode-v2' AND source_project_id = ? AND workspace_id = ?`).get(input.opencodeProjectID, workspaceID);
+    if (existing) {
+      if (existing.binding_key !== bindingKey || existing.project_id !== input.memoryProjectID || existing.canonical_path_hash !== canonicalPathHash) {
+        throw new Error("binding_conflict");
+      }
+      return { bindingKey, projectID: existing.project_id };
+    }
+    const now = Date.now();
+    this.db.query(`
+      INSERT INTO project_bindings
+        (binding_key, project_id, source, source_project_id, workspace_id,
+         canonical_path_hash, created_at, updated_at)
+      VALUES (?, ?, 'opencode-v2', ?, ?, ?, ?, ?)
+    `).run(bindingKey, input.memoryProjectID, input.opencodeProjectID, workspaceID, canonicalPathHash, now, now);
+    return { bindingKey, projectID: input.memoryProjectID };
+  }
+  checkpoint(sessionID, bindingKey, projectID2, messageID, state = "active") {
+    const binding = this.binding(bindingKey, projectID2);
+    if (!binding)
+      throw new Error("binding_conflict");
+    const now = Date.now();
+    this.db.query(`
+      INSERT INTO capture_checkpoints
+        (session_id, binding_key, project_id, state, last_message_id,
+         next_reconcile_at, failure_count, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        binding_key = excluded.binding_key,
+        project_id = excluded.project_id,
+        state = excluded.state,
+        last_message_id = COALESCE(excluded.last_message_id, capture_checkpoints.last_message_id),
+        next_reconcile_at = excluded.next_reconcile_at,
+        updated_at = excluded.updated_at
+      WHERE capture_checkpoints.binding_key = excluded.binding_key
+        AND capture_checkpoints.project_id = excluded.project_id
+    `).run(sessionID, bindingKey, projectID2, state, messageID ?? null, now, now, now);
+    const row = this.db.query("SELECT binding_key, project_id FROM capture_checkpoints WHERE session_id = ?").get(sessionID);
+    if (!row || row.binding_key !== bindingKey || row.project_id !== projectID2) {
+      throw new Error("checkpoint_binding_conflict");
+    }
+  }
+  markReconciled(sessionID, state, lastMessageID, failed = false) {
+    const now = Date.now();
+    const result = this.db.query(`
+      UPDATE capture_checkpoints
+         SET state = ?,
+             last_message_id = COALESCE(?, last_message_id),
+             last_reconciled_at = ?,
+             next_reconcile_at = ?,
+             failure_count = CASE WHEN ? THEN failure_count + 1 ELSE 0 END,
+             updated_at = ?
+       WHERE session_id = ?
+    `).run(state, lastMessageID ?? null, now, now + (failed ? 5000 : 30000), failed, now, sessionID);
+    if (result.changes === 0)
+      throw new Error(`checkpoint ${sessionID} not found`);
+  }
+  getCheckpoint(sessionID) {
+    const row = this.db.query("SELECT session_id, last_message_id, state FROM capture_checkpoints WHERE session_id = ?").get(sessionID);
+    return row ? {
+      sessionID: row.session_id,
+      ...row.last_message_id ? { lastMessageID: row.last_message_id } : {},
+      state: row.state
+    } : undefined;
+  }
+  ingest(input, mode, options = {}) {
+    const parsed = parseCaptureEvent(input);
+    if (!this.binding(parsed.bindingKey, parsed.projectID))
+      throw new Error("binding_conflict");
+    const prepared = prepareForPersistence(parsed, options.denylist);
+    const now = Date.now();
+    let result = {
+      outcome: prepared.quarantined ? "quarantined" : "shadowed",
+      idempotencyKey: parsed.idempotencyKey
+    };
+    this.db.transaction(() => {
+      const inserted = this.db.query(`
+        INSERT OR IGNORE INTO capture_events
+          (idempotency_key, contract, project_id, binding_key, event_kind,
+           source_session_id, source_message_id, source_ordinal, source_tool_call_id,
+           payload_json, payload_hash, redaction_version, state, attempt_count,
+           generation, created_at, updated_at, processed_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, ?, ?, ?)
+      `).run(prepared.event.idempotencyKey, prepared.event.schema, prepared.event.projectID, prepared.event.bindingKey, prepared.event.kind, prepared.event.source.sessionID, prepared.event.source.messageID ?? null, prepared.event.source.ordinal ?? null, prepared.event.source.toolCallID ?? null, prepared.payload, prepared.payloadHash, REDACTION_POLICY_VERSION, prepared.quarantined ? "quarantined" : "pending", now, now, prepared.quarantined ? now : null);
+      if (inserted.changes === 0) {
+        const existing = this.db.query("SELECT state, note_id FROM capture_events WHERE idempotency_key = ?").get(parsed.idempotencyKey);
+        result = {
+          outcome: "duplicate",
+          idempotencyKey: parsed.idempotencyKey,
+          ...existing.note_id ? { noteID: existing.note_id } : {},
+          existing: true
+        };
+        return;
+      }
+      if (prepared.quarantined)
+        return;
+      if (mode === "shadow") {
+        this.finishEvent(parsed.idempotencyKey, "shadowed", null, now);
+        result.outcome = "shadowed";
+        return;
+      }
+      const candidate = prepared.event.candidate;
+      if (!candidate) {
+        this.finishEvent(parsed.idempotencyKey, "shadowed", null, now);
+        result.outcome = "shadowed";
+        return;
+      }
+      if (candidate.intent === "ignore") {
+        this.finishEvent(parsed.idempotencyKey, "ignored", null, now);
+        result.outcome = "ignored";
+        return;
+      }
+      if (candidate.intent === "review" || !canAutoWrite(candidate, {
+        truncated: prepared.event.redaction.truncated,
+        quarantined: prepared.event.redaction.replacements > 0
+      }, options.allowedKinds, options.minConfidence)) {
+        this.finishEvent(parsed.idempotencyKey, "review", null, now);
+        result.outcome = "review";
+        return;
+      }
+      result = this.materialize(prepared.event, candidate, now);
+    })();
+    return result;
+  }
+  runRetention(now = Date.now(), batchSize = 100) {
+    const terminalCutoff = now - 30 * 24 * 60 * 60 * 1000;
+    const quarantineCutoff = now - 7 * 24 * 60 * 60 * 1000;
+    const summarized = this.db.query(`
+      UPDATE capture_events
+         SET payload_json = NULL, payload_hash = NULL, updated_at = ?
+       WHERE idempotency_key IN (
+         SELECT idempotency_key FROM capture_events
+          WHERE state IN ('materialized','duplicate','ignored','rejected','shadowed','review','failed','dead')
+            AND processed_at < ? AND payload_json IS NOT NULL
+          ORDER BY processed_at LIMIT ?
+       )
+    `).run(now, terminalCutoff, batchSize).changes;
+    const deleted = this.db.query(`
+      DELETE FROM capture_events
+       WHERE idempotency_key IN (
+         SELECT idempotency_key FROM capture_events
+          WHERE state = 'quarantined' AND processed_at < ?
+          ORDER BY processed_at LIMIT ?
+       )
+    `).run(quarantineCutoff, batchSize).changes;
+    const checkpoints = this.db.query(`
+      DELETE FROM capture_checkpoints
+       WHERE session_id IN (
+         SELECT session_id FROM capture_checkpoints
+          WHERE (state IN ('idle','closed') AND updated_at < ?)
+             OR (state = 'unavailable' AND updated_at < ?)
+          ORDER BY updated_at LIMIT ?
+       )
+    `).run(terminalCutoff, quarantineCutoff, batchSize).changes;
+    return { summarized, deleted, checkpoints };
+  }
+  runRetentionBacklog(now = Date.now(), batchSize = 100, maxBatches = 10) {
+    const total = { summarized: 0, deleted: 0, checkpoints: 0 };
+    for (let batch = 0;batch < maxBatches; batch++) {
+      const result = this.runRetention(now, batchSize);
+      total.summarized += result.summarized;
+      total.deleted += result.deleted;
+      total.checkpoints += result.checkpoints;
+      if (result.summarized < batchSize && result.deleted < batchSize && result.checkpoints < batchSize)
+        break;
+    }
+    return total;
+  }
+  materialize(event, candidate, now) {
+    const subjectKey = candidate.subjectKey ? normalizeSubjectKey(candidate.subjectKey) : null;
+    const hash = noteContentHash(candidate.kind, candidate.title, candidate.summary, candidate.content);
+    const existing = subjectKey ? this.db.query(`SELECT * FROM notes
+              WHERE project_id = ? AND kind = ? AND subject_key = ? AND status = 'active'`).get(event.projectID, candidate.kind, subjectKey) : undefined;
+    if (existing?.content_hash === hash) {
+      this.finishEvent(event.idempotencyKey, "duplicate", existing.id, now);
+      return { outcome: "duplicate", idempotencyKey: event.idempotencyKey, noteID: existing.id };
+    }
+    if (existing) {
+      if (candidate.intent !== "supersede" || candidate.targetNoteID !== existing.id || candidate.confidence < 0.95) {
+        this.finishEvent(event.idempotencyKey, "review", existing.id, now);
+        return { outcome: "review", idempotencyKey: event.idempotencyKey, noteID: existing.id };
+      }
+      this.db.query(`
+        UPDATE notes
+           SET status = 'superseded', current_revision = current_revision + 1, updated_at = ?
+         WHERE project_id = ? AND id = ? AND status = 'active'
+      `).run(now, event.projectID, existing.id);
+      this.recordRevision(event, existing.id, now);
+      const id2 = this.insertCapturedNote(event, candidate, subjectKey, existing.id, hash, now);
+      this.db.query(`
+        INSERT INTO note_edges
+          (id, project_id, source_id, target_id, predicate, created_at)
+        VALUES (?, ?, ?, ?, 'SUPERSEDES', ?)
+      `).run(randomUUID6(), event.projectID, id2, existing.id, now);
+      for (const backend of this.indexBackends) {
+        this.enqueueOutbox(backend, "delete-note", event.projectID, existing.id, existing.current_revision + 1, existing.content_hash, now);
+        const note2 = this.db.query("SELECT * FROM notes WHERE id = ?").get(id2);
+        this.enqueueOutbox(backend, "upsert-note", event.projectID, id2, 1, derivedHash(note2), now);
+      }
+      this.finishEvent(event.idempotencyKey, "materialized", id2, now);
+      return { outcome: "materialized", idempotencyKey: event.idempotencyKey, noteID: id2 };
+    }
+    if (candidate.intent === "supersede") {
+      this.finishEvent(event.idempotencyKey, "review", candidate.targetNoteID ?? null, now);
+      return {
+        outcome: "review",
+        idempotencyKey: event.idempotencyKey,
+        ...candidate.targetNoteID ? { noteID: candidate.targetNoteID } : {}
+      };
+    }
+    const id = this.insertCapturedNote(event, candidate, subjectKey, null, hash, now);
+    const note = this.db.query("SELECT * FROM notes WHERE id = ?").get(id);
+    for (const backend of this.indexBackends) {
+      this.enqueueOutbox(backend, "upsert-note", event.projectID, id, 1, derivedHash(note), now);
+    }
+    this.finishEvent(event.idempotencyKey, "materialized", id, now);
+    return { outcome: "materialized", idempotencyKey: event.idempotencyKey, noteID: id };
+  }
+  insertCapturedNote(event, candidate, subjectKey, supersedesID, contentHash, now) {
+    const id = randomUUID6();
+    const sizeClass = candidate.content.length <= 1200 ? "inline" : "indexed";
+    this.db.query(`
+      INSERT INTO notes
+        (id, project_id, kind, title, summary, content, size_class, pinned, status,
+         supersedes_id, current_revision, subject_key, content_hash, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 0, 'active', ?, 1, ?, ?, ?, ?)
+    `).run(id, event.projectID, candidate.kind, candidate.title, candidate.summary, candidate.content, sizeClass, supersedesID, subjectKey, contentHash, now, now);
+    this.recordRevision(event, id, now);
+    return id;
+  }
+  recordRevision(event, noteID, now) {
+    const note = this.db.query("SELECT * FROM notes WHERE project_id = ? AND id = ?").get(event.projectID, noteID);
+    const provenanceID = randomUUID6();
+    this.db.query(`
+      INSERT INTO note_provenance
+        (id, project_id, note_id, source_type, capture_event_id, source_session_id,
+         source_message_id, source_ordinal, source_tool_call_id, redaction_version,
+         extractor_version, confidence, created_at)
+      VALUES (?, ?, ?, 'opencode-capture', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(provenanceID, event.projectID, noteID, event.idempotencyKey, event.source.sessionID, event.source.messageID ?? null, event.source.ordinal ?? null, event.source.toolCallID ?? null, REDACTION_POLICY_VERSION, EXTRACTOR_VERSION, event.candidate?.confidence ?? null, now);
+    this.db.query(`
+      INSERT INTO note_revisions
+        (project_id, note_id, revision, kind, title, summary, content, size_class,
+         pinned, status, supersedes_id, subject_key, content_hash, provenance_id, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(note.project_id, note.id, note.current_revision, note.kind, note.title, note.summary, note.content, note.size_class, note.pinned, note.status, note.supersedes_id, note.subject_key, note.content_hash, provenanceID, now);
+  }
+  enqueueOutbox(backend, operation, projectID2, noteID, revision, contentHash, now) {
+    this.db.query(`
+      INSERT OR IGNORE INTO index_outbox
+        (backend, operation, project_id, note_id, revision, content_hash,
+         state, attempt_count, available_at, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)
+    `).run(backend, operation, projectID2, noteID, revision, contentHash, now, now);
+  }
+  finishEvent(idempotencyKey, state, noteID, now) {
+    this.db.query(`
+      UPDATE capture_events
+         SET state = ?, note_id = ?, updated_at = ?, processed_at = ?
+       WHERE idempotency_key = ?
+    `).run(state, noteID, now, now, idempotencyKey);
+  }
+  binding(bindingKey, projectID2) {
+    return this.db.query("SELECT * FROM project_bindings WHERE binding_key = ? AND project_id = ?").get(bindingKey, projectID2);
+  }
+}
+function prepareForPersistence(event, denylist) {
+  const copy = structuredClone(event);
+  let replacements = 0;
+  let truncated = copy.redaction.truncated;
+  let quarantined = event.redaction.policyVersion.endsWith("/quarantined");
+  if (copy.candidate) {
+    for (const field of ["title", "summary", "content", "subjectKey"]) {
+      const value = copy.candidate[field];
+      if (typeof value !== "string")
+        continue;
+      const maximum = field === "title" || field === "subjectKey" ? 240 : field === "summary" ? 1200 : 4800;
+      const result = redactText(value, { maxCharacters: maximum, denylist });
+      copy.candidate[field] = result.text;
+      replacements += result.replacements;
+      truncated ||= result.truncated;
+      quarantined ||= result.quarantined;
+    }
+  }
+  if (copy.signal) {
+    for (const field of ["tool", "errorType"]) {
+      const value = copy.signal[field];
+      if (typeof value !== "string")
+        continue;
+      const result = redactText(value, { maxCharacters: 160, denylist });
+      copy.signal[field] = result.text;
+      replacements += result.replacements;
+      truncated ||= result.truncated;
+      quarantined ||= result.quarantined;
+    }
+  }
+  copy.redaction = {
+    policyVersion: REDACTION_POLICY_VERSION,
+    replacements: copy.redaction.replacements + replacements,
+    truncated
+  };
+  const validated = parseCaptureEvent(copy);
+  const payload = quarantined ? null : JSON.stringify(validated);
+  return {
+    event: validated,
+    payload,
+    payloadHash: payload ? sha256(payload) : null,
+    quarantined,
+    additionalReplacements: replacements
+  };
+}
+function sha256(value) {
+  return createHash6("sha256").update(value, "utf8").digest("hex");
+}
+function derivedHash(note) {
+  return deriveDocument({
+    projectID: note.project_id,
+    noteID: note.id,
+    revision: note.current_revision,
+    kind: note.kind,
+    title: note.title,
+    summary: note.summary,
+    content: note.content
+  })?.contentHash ?? null;
+}
+
 // src/index.ts
 function main() {
   const { databasePath } = resolveConfig();
@@ -1764,6 +2285,16 @@ function main() {
     mkdirSync3(directory, { recursive: true });
   const opened = openMemoryDatabase(databasePath);
   const store = new MemoryStore(opened.db);
+  const capture = new CaptureStore(opened.db);
+  capture.runRetentionBacklog();
+  const retentionTimer = setInterval(() => {
+    try {
+      capture.runRetentionBacklog();
+    } catch (error) {
+      console.error(`[agz-memory] retention failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }, 60 * 60000);
+  retentionTimer.unref();
   const handle = serveStdio(() => createMemoryServer(store), {
     onerror: (error) => console.error(`[agz-memory] ${error.message}`)
   });
@@ -1772,6 +2303,7 @@ function main() {
     if (closing)
       return;
     closing = true;
+    clearInterval(retentionTimer);
     try {
       await handle.close();
     } finally {