@vaur94/agz-memory 0.4.0 → 0.5.0

package/dist/admin.js

@@ -2,16 +2,16 @@
 // @bun
 
 // src/admin/index.ts
-import { createHash as createHash6 } from "crypto";
-import { Database as Database3 } from "bun:sqlite";
+import { createHash as createHash7 } from "crypto";
+import { Database as Database4 } from "bun:sqlite";
 import {
-  existsSync as existsSync4,
-  lstatSync as lstatSync2,
-  readdirSync,
-  readFileSync as readFileSync3,
+  existsSync as existsSync5,
+  lstatSync as lstatSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
   rmSync as rmSync3
 } from "fs";
-import { basename as basename2, dirname as dirname2, resolve as resolve2 } from "path";
+import { basename as basename3, dirname as dirname3, resolve as resolve3 } from "path";
 
 // src/config.ts
 import { homedir } from "os";
@@ -22,111 +22,2736 @@ function resolveConfig(environment = process.env) {
 }
 
 // src/db.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { Database as Database2 } from "bun:sqlite";
-import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync3 } from "fs";
+import { randomUUID as randomUUID6 } from "crypto";
+import { Database as Database3 } from "bun:sqlite";
+import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync4, lstatSync as lstatSync3 } from "fs";
 
 // src/identity.ts
 import { createHash } from "crypto";
 function hashRoot(directory) {
   return createHash("sha256").update(directory).digest("hex");
 }
-
-// src/project.ts
-function cleanProjectName(value) {
-  return value.trim().replace(/\s+/g, " ");
+
+// src/project.ts
+function cleanProjectName(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function normalizeProjectName(value) {
+  return cleanProjectName(value).normalize("NFKC").toLowerCase();
+}
+
+// src/types.ts
+var SCHEMA_VERSION = 11;
+var KINDS = ["decision", "fact", "procedure", "context", "research", "preference", "task"];
+var PREDICATES = ["SUPPORTS", "DERIVED_FROM", "PART_OF", "ABOUT", "PRECEDES", "SUPERSEDES"];
+
+// src/db/backup.ts
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { Database as Database2 } from "bun:sqlite";
+import {
+  chmodSync as chmodSync2,
+  closeSync as closeSync2,
+  constants as constants2,
+  existsSync as existsSync2,
+  fstatSync,
+  fsyncSync as fsyncSync2,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  readSync,
+  renameSync as renameSync2,
+  rmSync,
+  writeFileSync as writeFileSync2,
+  writeSync
+} from "fs";
+import { basename as basename2, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { platform as platform2 } from "os";
+
+// src/db/schema.ts
+import { Database } from "bun:sqlite";
+import { randomUUID } from "crypto";
+
+// src/capture/contract.ts
+import * as z from "zod/v4";
+var CAPTURE_SCHEMA = "agz-memory.capture/2";
+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().finite().int().nonnegative().refine(Number.isSafeInteger, "must be a safe integer").optional(),
+    toolCallID: z.string().min(1).max(240).optional(),
+    observedAt: z.number().finite().int().nonnegative().refine(Number.isSafeInteger, "must be a safe integer")
+  }).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` });
+  }
+  const hasSourceField = (field) => Object.prototype.hasOwnProperty.call(event.source, field);
+  const requiredFields = event.kind === "user-candidate" ? ["messageID"] : event.kind === "assistant-candidate" ? ["messageID", "ordinal"] : event.kind === "session-summary" ? ["messageID"] : ["messageID", "toolCallID"];
+  const forbiddenFields = event.kind === "assistant-candidate" ? ["toolCallID"] : event.kind === "tool-signal" ? ["ordinal"] : ["ordinal", "toolCallID"];
+  for (const field of requiredFields) {
+    if (event.source[field] === undefined) {
+      context.addIssue({ code: "custom", message: `${event.kind} requires source.${field}` });
+    }
+  }
+  for (const field of forbiddenFields) {
+    if (hasSourceField(field)) {
+      context.addIssue({ code: "custom", message: `${event.kind} forbids source.${field}` });
+    }
+  }
+});
+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/hash.ts
+import { createHash as createHash2 } from "crypto";
+var HASH_TUPLE_MARKER = Buffer.from("agz-memory/hash-tuple", "utf8");
+var MAX_UINT32 = 4294967295;
+function hashTuple(domain, version, fields) {
+  if (typeof domain !== "string")
+    throw new TypeError("hash tuple domain must be a string");
+  if (!Number.isSafeInteger(version) || version < 0 || version > MAX_UINT32) {
+    throw new RangeError("hash tuple version must be an unsigned safe integer");
+  }
+  if (!Array.isArray(fields))
+    throw new TypeError("hash tuple fields must be an array");
+  if (fields.length > MAX_UINT32)
+    throw new RangeError("hash tuple has too many fields");
+  const domainBytes = utf8(domain);
+  const chunks = [
+    HASH_TUPLE_MARKER,
+    lengthPrefix(domainBytes),
+    uint32(version),
+    uint32(fields.length)
+  ];
+  for (const field of fields) {
+    const encoded = encodeField(field);
+    chunks.push(Buffer.from([encoded.tag]), lengthPrefix(encoded.payload));
+  }
+  return createHash2("sha256").update(Buffer.concat(chunks)).digest("hex");
+}
+function noteContentHash(kind, title, summary, content) {
+  return hashTuple("canonical-note", 2, [kind, title, summary, content]);
+}
+function encodeField(value) {
+  if (value === null)
+    return { tag: 0, payload: Buffer.alloc(0) };
+  if (typeof value === "string")
+    return { tag: 1, payload: utf8(value) };
+  if (typeof value === "boolean")
+    return { tag: 2, payload: Buffer.from([value ? 1 : 0]) };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new RangeError("hash tuple numbers must be finite");
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new RangeError("hash tuple integer numbers must be safe");
+    }
+    return { tag: 3, payload: utf8(String(value)) };
+  }
+  if (value instanceof Uint8Array)
+    return { tag: 4, payload: Buffer.from(value) };
+  throw new TypeError("hash tuple field has an unsupported type");
+}
+function utf8(value) {
+  if (!isWellFormedUnicode(value)) {
+    throw new TypeError("hash tuple strings must be well-formed Unicode");
+  }
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length > MAX_UINT32)
+    throw new RangeError("hash tuple field is too large");
+  return bytes;
+}
+function isWellFormedUnicode(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      if (index + 1 >= value.length)
+        return false;
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343)
+        return false;
+      index++;
+    } else if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function lengthPrefix(bytes) {
+  return Buffer.concat([uint32(bytes.length), Buffer.from(bytes)]);
+}
+function uint32(value) {
+  const result = Buffer.alloc(4);
+  result.writeUInt32BE(value, 0);
+  return result;
+}
+
+// src/db/schema.ts
+var APPLICATION_ID = 1095195213;
+var PRODUCT_ID = "agz-memory";
+var HASH_POLICY = "hash-tuple/2";
+var SQLITE_MANAGED_FTS_TABLES = new Set([
+  "notes_fts_config",
+  "notes_fts_data",
+  "notes_fts_docsize",
+  "notes_fts_idx"
+]);
+var SCHEMA_TABLES = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  normalized_name TEXT NOT NULL UNIQUE,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS notes (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL CHECK (kind IN ('decision','fact','procedure','context','research','preference','task')),
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  content TEXT NOT NULL,
+  size_class TEXT NOT NULL CHECK (size_class IN ('inline','indexed')),
+  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0,1)),
+  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','superseded','archived')),
+  supersedes_id TEXT,
+  current_revision INTEGER NOT NULL DEFAULT 1 CHECK (current_revision >= 1),
+  subject_key TEXT,
+  content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(project_id, id)
+);
+CREATE INDEX IF NOT EXISTS notes_project_idx ON notes(project_id, status);
+CREATE UNIQUE INDEX IF NOT EXISTS notes_active_subject_idx
+  ON notes(project_id, kind, subject_key)
+  WHERE status = 'active' AND subject_key IS NOT NULL;
+CREATE TABLE IF NOT EXISTS note_edges (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  predicate TEXT NOT NULL CHECK (predicate IN ('SUPPORTS','DERIVED_FROM','PART_OF','ABOUT','PRECEDES','SUPERSEDES')),
+  created_at INTEGER NOT NULL,
+  UNIQUE(project_id, source_id, target_id, predicate),
+  FOREIGN KEY (project_id, source_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, target_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS note_edges_source_idx ON note_edges(project_id, source_id);
+CREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, target_id);
+CREATE TABLE IF NOT EXISTS project_bindings (
+  binding_key TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  source TEXT NOT NULL CHECK (source = 'opencode-v2'),
+  source_project_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  canonical_path_hash TEXT NOT NULL CHECK (length(canonical_path_hash) = 64),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(source, source_project_id, workspace_id)
+);
+CREATE TABLE IF NOT EXISTS capture_checkpoints (
+  session_id TEXT PRIMARY KEY,
+  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  state TEXT NOT NULL CHECK (state IN ('active','idle','unavailable','closed')),
+  last_message_id TEXT,
+  last_reconciled_at INTEGER,
+  next_reconcile_at INTEGER NOT NULL,
+  failure_count INTEGER NOT NULL DEFAULT 0 CHECK (failure_count >= 0),
+  lease_owner TEXT,
+  lease_expires_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS capture_checkpoints_due_idx
+  ON capture_checkpoints(state, next_reconcile_at);
+${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);
+CREATE TABLE IF NOT EXISTS note_provenance (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  note_id TEXT NOT NULL,
+  source_type TEXT NOT NULL CHECK (source_type IN ('mcp-manual','opencode-capture','migration','legacy-import','admin')),
+  capture_event_id TEXT,
+  source_session_id TEXT,
+  source_message_id TEXT,
+  source_ordinal INTEGER,
+  source_tool_call_id TEXT,
+  redaction_version TEXT,
+  extractor_version TEXT,
+  confidence REAL CHECK (confidence IS NULL OR (confidence >= 0 AND confidence <= 1)),
+  created_at INTEGER NOT NULL,
+  UNIQUE(project_id, id),
+  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS note_revisions (
+  project_id TEXT NOT NULL,
+  note_id TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  kind TEXT NOT NULL,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  content TEXT NOT NULL,
+  size_class TEXT NOT NULL,
+  pinned INTEGER NOT NULL CHECK (pinned IN (0,1)),
+  status TEXT NOT NULL CHECK (status IN ('active','superseded','archived')),
+  supersedes_id TEXT,
+  subject_key TEXT,
+  content_hash TEXT NOT NULL,
+  provenance_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY(project_id, note_id, revision),
+  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, provenance_id) REFERENCES note_provenance(project_id, id)
+);
+CREATE TABLE IF NOT EXISTS index_outbox (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  backend TEXT NOT NULL,
+  operation TEXT NOT NULL CHECK (operation IN ('upsert-note','delete-note','purge-project')),
+  project_id TEXT NOT NULL,
+  note_id TEXT,
+  revision INTEGER,
+  content_hash TEXT,
+  state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','leased','succeeded','dead')),
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+  available_at INTEGER NOT NULL,
+  lease_owner TEXT,
+  lease_expires_at INTEGER,
+  last_error_code TEXT,
+  created_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  UNIQUE(backend, operation, project_id, note_id, revision)
+);
+CREATE INDEX IF NOT EXISTS index_outbox_due_idx
+  ON index_outbox(backend, project_id, state, available_at, id);
+CREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);
+`;
+var FTS_V9 = `
+CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+  title, summary, content,
+  content='notes', content_rowid='rowid',
+  tokenize='unicode61'
+);
+CREATE TRIGGER IF NOT EXISTS notes_fts_ai AFTER INSERT ON notes BEGIN
+  INSERT INTO notes_fts(rowid, title, summary, content)
+  VALUES (new.rowid, new.title, new.summary, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS notes_fts_ad AFTER DELETE ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)
+  VALUES ('delete', old.rowid, old.title, old.summary, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE OF title, summary, content ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)
+  VALUES ('delete', old.rowid, old.title, old.summary, old.content);
+  INSERT INTO notes_fts(rowid, title, summary, content)
+  VALUES (new.rowid, new.title, new.summary, new.content);
+END;
+`;
+var SCHEMA_V11_TABLES = `
+CREATE TABLE projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  normalized_name TEXT NOT NULL UNIQUE,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE TABLE notes (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL CHECK (kind IN ('decision','fact','procedure','context','research','preference','task')),
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  content TEXT NOT NULL,
+  size_class TEXT NOT NULL CHECK (size_class IN ('inline','indexed')),
+  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0,1)),
+  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','superseded','archived')),
+  supersedes_id TEXT,
+  current_revision INTEGER NOT NULL DEFAULT 1 CHECK (current_revision >= 1),
+  subject_key TEXT,
+  content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  UNIQUE(project_id, id),
+  FOREIGN KEY (project_id, supersedes_id) REFERENCES notes(project_id, id) ON DELETE NO ACTION
+);
+CREATE INDEX notes_project_idx ON notes(project_id, status);
+CREATE UNIQUE INDEX notes_active_subject_idx
+  ON notes(project_id, kind, subject_key)
+  WHERE status = 'active' AND subject_key IS NOT NULL;
+CREATE TABLE note_edges (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  predicate TEXT NOT NULL CHECK (predicate IN ('SUPPORTS','DERIVED_FROM','PART_OF','ABOUT','PRECEDES','SUPERSEDES')),
+  created_at INTEGER NOT NULL,
+  UNIQUE(project_id, source_id, target_id, predicate),
+  FOREIGN KEY (project_id, source_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, target_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
+);
+CREATE INDEX note_edges_source_idx ON note_edges(project_id, source_id);
+CREATE INDEX note_edges_target_idx ON note_edges(project_id, target_id);
+CREATE TABLE project_bindings (
+  binding_key TEXT NOT NULL CHECK (length(binding_key) = 64),
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  source TEXT NOT NULL CHECK (source = 'opencode-v2'),
+  source_project_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  canonical_path_hash TEXT NOT NULL CHECK (length(canonical_path_hash) = 64),
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY(binding_key, project_id),
+  UNIQUE(source, source_project_id, workspace_id)
+);
+CREATE TABLE capture_checkpoints (
+  session_id TEXT NOT NULL,
+  binding_key TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('active','idle','unavailable','closed')),
+  last_message_id TEXT,
+  last_reconciled_at INTEGER,
+  next_reconcile_at INTEGER NOT NULL,
+  failure_count INTEGER NOT NULL DEFAULT 0 CHECK (failure_count >= 0),
+  lease_owner TEXT,
+  lease_expires_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY(binding_key, session_id),
+  FOREIGN KEY (binding_key, project_id) REFERENCES project_bindings(binding_key, project_id) ON DELETE CASCADE
+);
+CREATE INDEX capture_checkpoints_due_idx
+  ON capture_checkpoints(state, next_reconcile_at);
+${captureEventsTableV11()}
+CREATE INDEX capture_events_state_idx ON capture_events(state, updated_at);
+CREATE INDEX capture_events_session_idx ON capture_events(project_id, source_session_id);
+CREATE INDEX capture_events_note_idx ON capture_events(project_id, note_id);
+CREATE TABLE note_provenance (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  note_id TEXT NOT NULL,
+  source_type TEXT NOT NULL CHECK (source_type IN ('mcp-manual','opencode-capture','migration','legacy-import','admin')),
+  capture_event_id TEXT,
+  source_session_id TEXT,
+  source_message_id TEXT,
+  source_ordinal INTEGER,
+  source_tool_call_id TEXT,
+  redaction_version TEXT,
+  extractor_version TEXT,
+  confidence REAL CHECK (confidence IS NULL OR (confidence >= 0 AND confidence <= 1)),
+  created_at INTEGER NOT NULL,
+  UNIQUE(project_id, id),
+  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE note_revisions (
+  project_id TEXT NOT NULL,
+  note_id TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  kind TEXT NOT NULL CHECK (kind IN ('decision','fact','procedure','context','research','preference','task')),
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  content TEXT NOT NULL,
+  size_class TEXT NOT NULL CHECK (size_class IN ('inline','indexed')),
+  pinned INTEGER NOT NULL CHECK (pinned IN (0,1)),
+  status TEXT NOT NULL CHECK (status IN ('active','superseded','archived')),
+  supersedes_id TEXT,
+  subject_key TEXT,
+  content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),
+  provenance_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY(project_id, note_id, revision),
+  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, provenance_id) REFERENCES note_provenance(project_id, id),
+  FOREIGN KEY (project_id, supersedes_id) REFERENCES notes(project_id, id) ON DELETE NO ACTION
+);
+CREATE TABLE index_outbox (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  backend TEXT NOT NULL,
+  operation_key TEXT NOT NULL CHECK (length(operation_key) = 64),
+  operation TEXT NOT NULL CHECK (operation IN ('upsert-note','delete-note','purge-project')),
+  project_id TEXT NOT NULL,
+  note_id TEXT,
+  revision INTEGER,
+  content_hash TEXT,
+  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0),
+  lease_generation INTEGER NOT NULL DEFAULT 0 CHECK (lease_generation >= 0),
+  fence INTEGER NOT NULL DEFAULT 0 CHECK (fence >= 0),
+  state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','leased','succeeded','dead')),
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+  available_at INTEGER NOT NULL,
+  lease_owner TEXT,
+  lease_expires_at INTEGER,
+  heartbeat_at INTEGER CHECK (heartbeat_at IS NULL OR heartbeat_at >= 0),
+  last_error_code TEXT,
+  created_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  CHECK (
+    (operation = 'upsert-note' AND note_id IS NOT NULL AND revision IS NOT NULL AND revision >= 1
+      AND content_hash IS NOT NULL AND length(content_hash) = 64)
+    OR (operation = 'delete-note' AND note_id IS NOT NULL AND revision IS NOT NULL AND revision >= 1
+      AND content_hash IS NULL)
+    OR (operation = 'purge-project' AND note_id IS NULL AND revision IS NULL AND content_hash IS NULL)
+  )
+);
+CREATE TRIGGER index_outbox_note_project_insert
+BEFORE INSERT ON index_outbox
+WHEN NEW.note_id IS NOT NULL
+ AND NEW.state IN ('pending','leased')
+ AND (NEW.operation = 'upsert-note'
+   OR EXISTS (SELECT 1 FROM notes WHERE id = NEW.note_id))
+ AND NOT EXISTS (
+   SELECT 1 FROM notes WHERE project_id = NEW.project_id AND id = NEW.note_id
+ )
+BEGIN
+  SELECT RAISE(ABORT, 'foreign key index_outbox note project mismatch');
+END;
+CREATE TRIGGER index_outbox_note_project_update
+BEFORE UPDATE OF project_id, note_id, operation ON index_outbox
+WHEN NEW.note_id IS NOT NULL
+ AND NEW.state IN ('pending','leased')
+ AND (NEW.operation = 'upsert-note'
+   OR EXISTS (SELECT 1 FROM notes WHERE id = NEW.note_id))
+ AND NOT EXISTS (
+   SELECT 1 FROM notes WHERE project_id = NEW.project_id AND id = NEW.note_id
+ )
+BEGIN
+  SELECT RAISE(ABORT, 'foreign key index_outbox note project mismatch');
+END;
+CREATE INDEX index_outbox_due_idx
+  ON index_outbox(backend, project_id, state, available_at, id);
+CREATE UNIQUE INDEX index_outbox_active_operation_idx
+  ON index_outbox(operation_key)
+  WHERE state IN ('pending','leased');
+CREATE UNIQUE INDEX index_outbox_active_upsert_idx
+  ON index_outbox(backend, project_id, note_id, revision, generation)
+  WHERE operation = 'upsert-note' AND state IN ('pending','leased');
+CREATE UNIQUE INDEX index_outbox_active_delete_idx
+  ON index_outbox(backend, project_id, note_id, revision, generation)
+  WHERE operation = 'delete-note' AND state IN ('pending','leased');
+CREATE UNIQUE INDEX index_outbox_active_purge_idx
+  ON index_outbox(backend, project_id, generation)
+  WHERE operation = 'purge-project' AND state IN ('pending','leased');
+CREATE TABLE schema_state (version INTEGER PRIMARY KEY);
+CREATE TABLE agz_meta (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  database_id TEXT NOT NULL UNIQUE,
+  product_id TEXT NOT NULL CHECK (product_id = '${PRODUCT_ID}'),
+  schema_version INTEGER NOT NULL CHECK (schema_version = 11),
+  schema_fingerprint TEXT NOT NULL CHECK (length(schema_fingerprint) = 64),
+  hash_policy TEXT NOT NULL CHECK (hash_policy = '${HASH_POLICY}'),
+  created_at INTEGER NOT NULL
+);
+`;
+function captureEventsTableV11(table = "capture_events") {
+  return `CREATE TABLE ${table} (
+  idempotency_key TEXT PRIMARY KEY CHECK (length(idempotency_key) = 64),
+  contract TEXT NOT NULL CHECK (contract = '${CAPTURE_SCHEMA}'),
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  binding_key TEXT NOT NULL,
+  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 CHECK (payload_hash IS NULL OR length(payload_hash) = 64),
+  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,
+  UNIQUE(project_id, idempotency_key),
+  CHECK (
+    (event_kind = 'user-candidate' AND source_message_id IS NOT NULL
+      AND source_ordinal IS NULL AND source_tool_call_id IS NULL)
+    OR (event_kind = 'assistant-candidate' AND source_message_id IS NOT NULL
+      AND source_ordinal IS NOT NULL AND source_tool_call_id IS NULL)
+    OR (event_kind = 'session-summary' AND source_message_id IS NOT NULL
+      AND source_ordinal IS NULL AND source_tool_call_id IS NULL)
+    OR (event_kind = 'tool-signal' AND source_message_id IS NOT NULL
+      AND source_ordinal IS NULL AND source_tool_call_id IS NOT NULL)
+  ),
+  FOREIGN KEY (binding_key, project_id) REFERENCES project_bindings(binding_key, project_id) ON DELETE CASCADE
+);
+CREATE TRIGGER ${table}_note_project_insert
+BEFORE INSERT ON ${table}
+WHEN NEW.note_id IS NOT NULL
+ AND EXISTS (SELECT 1 FROM notes WHERE id = NEW.note_id)
+ AND NOT EXISTS (SELECT 1 FROM notes WHERE project_id = NEW.project_id AND id = NEW.note_id)
+BEGIN
+  SELECT RAISE(ABORT, 'foreign key capture event note project mismatch');
+END;
+CREATE TRIGGER ${table}_note_project_update
+BEFORE UPDATE OF project_id, note_id ON ${table}
+WHEN NEW.note_id IS NOT NULL
+ AND EXISTS (SELECT 1 FROM notes WHERE id = NEW.note_id)
+ AND NOT EXISTS (SELECT 1 FROM notes WHERE project_id = NEW.project_id AND id = NEW.note_id)
+BEGIN
+  SELECT RAISE(ABORT, 'foreign key capture event note project mismatch');
+END;`;
+}
+function schemaFingerprint(db) {
+  const rows = db.query(`SELECT type, name, tbl_name, sql
+         FROM sqlite_master
+        WHERE name NOT LIKE 'sqlite_%'
+        ORDER BY type, name`).all();
+  const fields = [];
+  for (const row of rows) {
+    fields.push(row.type, row.name, row.tbl_name, SQLITE_MANAGED_FTS_TABLES.has(row.name) ? null : row.sql);
+  }
+  return hashTuple("schema-fingerprint", 2, fields);
+}
+var cachedExpectedFingerprint;
+function expectedSchemaFingerprint() {
+  if (cachedExpectedFingerprint)
+    return cachedExpectedFingerprint;
+  const db = new Database(":memory:");
+  try {
+    db.exec(SCHEMA_V11_TABLES);
+    db.exec(FTS_V9);
+    cachedExpectedFingerprint = schemaFingerprint(db);
+    return cachedExpectedFingerprint;
+  } finally {
+    db.close();
+  }
+}
+function createSchemaV11(db) {
+  db.exec(`PRAGMA application_id = ${APPLICATION_ID}`);
+  db.exec(SCHEMA_V11_TABLES);
+  db.exec(FTS_V9);
+  db.query("INSERT INTO schema_state(version) VALUES (11)").run();
+  const fingerprint = schemaFingerprint(db);
+  if (fingerprint !== expectedSchemaFingerprint()) {
+    throw new Error("schema_fingerprint_mismatch");
+  }
+  db.query(`INSERT INTO agz_meta
+       (id, database_id, product_id, schema_version, schema_fingerprint, hash_policy, created_at)
+     VALUES (1, ?, ?, 11, ?, ?, ?)`).run(randomUUID(), PRODUCT_ID, fingerprint, HASH_POLICY, Date.now());
+}
+function insertV11Identity(db, databaseID = randomUUID(), createdAt = Date.now()) {
+  const fingerprint = schemaFingerprint(db);
+  if (fingerprint !== expectedSchemaFingerprint()) {
+    throw new Error("schema_fingerprint_mismatch");
+  }
+  db.query(`INSERT INTO agz_meta
+       (id, database_id, product_id, schema_version, schema_fingerprint, hash_policy, created_at)
+     VALUES (1, ?, ?, 11, ?, ?, ?)`).run(databaseID, PRODUCT_ID, fingerprint, HASH_POLICY, createdAt);
+}
+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/health.ts
+function inspectDatabase(db) {
+  const integrity = db.query("PRAGMA integrity_check").get().integrity_check;
+  const foreignKeyViolations = db.query("PRAGMA foreign_key_check").all();
+  const schemaVersion = hasTable(db, "schema_state") ? db.query("SELECT MAX(version) AS version FROM schema_state").get().version ?? undefined : undefined;
+  const counts = {};
+  for (const table of [
+    "projects",
+    "notes",
+    "note_edges",
+    "notes_fts",
+    "project_bindings",
+    "capture_events",
+    "capture_checkpoints",
+    "note_provenance",
+    "note_revisions",
+    "index_outbox"
+  ]) {
+    if (!hasTable(db, table))
+      continue;
+    counts[table] = db.query(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
+  }
+  return { integrity, foreignKeyViolations, schemaVersion, counts };
+}
+function assertHealthyDatabase(db) {
+  const health = inspectDatabase(db);
+  if (health.integrity !== "ok") {
+    throw new Error(`database integrity check failed: ${health.integrity}`);
+  }
+  if (health.foreignKeyViolations.length > 0) {
+    throw new Error(`database foreign key check failed: ${health.foreignKeyViolations.length} violation(s)`);
+  }
+  if (health.schemaVersion === 11)
+    assertSchemaV11(db);
+  return health;
+}
+function assertSchemaV11(db) {
+  try {
+    if (!hasTable(db, "agz_meta"))
+      throw new Error("missing metadata table");
+    const applicationID = db.query("PRAGMA application_id").get().application_id;
+    if (applicationID !== APPLICATION_ID)
+      throw new Error("application id mismatch");
+    const states = db.query("SELECT version FROM schema_state").all();
+    if (states.length !== 1 || states[0]?.version !== 11)
+      throw new Error("schema state mismatch");
+    const metadata = db.query(`SELECT id, database_id, product_id, schema_version, schema_fingerprint, hash_policy, created_at
+           FROM agz_meta`).all();
+    if (metadata.length !== 1)
+      throw new Error("metadata cardinality mismatch");
+    const [meta] = metadata;
+    if (!meta || meta.id !== 1 || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(meta.database_id) || meta.product_id !== PRODUCT_ID || meta.schema_version !== 11 || meta.hash_policy !== HASH_POLICY || !/^[0-9a-f]{64}$/.test(meta.schema_fingerprint) || !Number.isSafeInteger(meta.created_at) || meta.created_at < 0) {
+      throw new Error("metadata value mismatch");
+    }
+    const expected = expectedSchemaFingerprint();
+    if (meta.schema_fingerprint !== expected || schemaFingerprint(db) !== expected) {
+      throw new Error("schema fingerprint mismatch");
+    }
+  } catch (error) {
+    if (isSQLiteBusyError(error))
+      throw error;
+    if (error instanceof Error && error.message === "schema_fingerprint_mismatch")
+      throw error;
+    throw new Error("schema_fingerprint_mismatch");
+  }
+}
+function isSQLiteBusyError(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code);
+    if (code === "SQLITE_BUSY")
+      return true;
+  }
+  return error instanceof Error && /\bdatabase is (?:busy|locked)\b/i.test(error.message);
+}
+function hasTable(db, table) {
+  const row = db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE type IN ('table','view') AND name = ?").get(table);
+  return row.count > 0;
+}
+
+// src/db/migrations/v011.ts
+import { createHash as createHash3 } from "crypto";
+
+// src/capture/identity.ts
+function captureIdempotencyKey(input) {
+  let fields;
+  if (input.kind === "user") {
+    fields = ["user", input.bindingKey, input.sessionID, input.messageID];
+  } else if (input.kind === "assistant") {
+    if (!Number.isSafeInteger(input.ordinal) || input.ordinal < 0) {
+      throw new RangeError("assistant capture ordinal must be a non-negative safe integer");
+    }
+    fields = [
+      "assistant",
+      input.bindingKey,
+      input.sessionID,
+      input.assistantMessageID,
+      input.ordinal
+    ];
+  } else if (input.kind === "tool") {
+    fields = [
+      "tool",
+      input.bindingKey,
+      input.sessionID,
+      input.assistantMessageID,
+      input.toolCallID,
+      input.terminalStatus
+    ];
+  } else {
+    fields = ["summary", input.bindingKey, input.sessionID, input.checkpointMessageID];
+  }
+  return hashTuple("capture-identity", 2, fields);
+}
+
+// src/capture/redact.ts
+var SECRET_ASSIGNMENT_KEY = String.raw`(?:[A-Za-z][A-Za-z0-9_-]*(?:password|passwd|secret|token|api[_-]?key|private[_-]?key)[A-Za-z0-9_-]*|password|passwd|secret|token|api[_-]?key|private[_-]?key)`;
+var SECRET_ASSIGNMENT_VALUE = String.raw`(?:"(?![<$\[])[^"\r\n]{8,}"|'(?![<$\[])[^'\r\n]{8,}'|(?![<$\[])[^\s,;]{8,})`;
+var RULES = [
+  {
+    name: "private-key",
+    pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |ENCRYPTED |PGP )?PRIVATE KEY(?: BLOCK)?-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |ENCRYPTED |PGP )?PRIVATE KEY(?: BLOCK)?-----/gi
+  },
+  {
+    name: "credential-uri",
+    pattern: /[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@[^\s]+/gi
+  },
+  {
+    name: "bearer",
+    pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{12,}(?=$|[^A-Za-z0-9._~+/=-])/gi
+  },
+  {
+    name: "basic-auth",
+    pattern: /Basic\s+[A-Za-z0-9+/=]{12,}(?=$|[^A-Za-z0-9+/=])/gi
+  },
+  {
+    name: "github-token",
+    pattern: /(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})(?=$|[^A-Za-z0-9_])/g
+  },
+  {
+    name: "gitlab-token",
+    pattern: /glpat-[A-Za-z0-9_-]{16,}(?=$|[^A-Za-z0-9_-])/g
+  },
+  {
+    name: "aws-access-key",
+    pattern: /(?:AKIA|ASIA)[A-Z0-9]{16}(?=$|[^A-Z0-9])/g
+  },
+  {
+    name: "jwt",
+    pattern: /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}(?=$|[^A-Za-z0-9_-])/g
+  },
+  {
+    name: "anthropic-token",
+    pattern: /sk-ant-[A-Za-z0-9_-]{20,}(?=$|[^A-Za-z0-9_-])/g
+  },
+  {
+    name: "openai-token",
+    pattern: /sk-(?!ant-)(?:proj-)?[A-Za-z0-9_-]{20,}(?=$|[^A-Za-z0-9_-])/g
+  },
+  {
+    name: "google-api-key",
+    pattern: /AIza[A-Za-z0-9_-]{30,}(?=$|[^A-Za-z0-9_-])/g
+  },
+  {
+    name: "slack-token",
+    pattern: /xox[baprs]-[A-Za-z0-9-]{32,}(?=$|[^A-Za-z0-9-])/g
+  },
+  {
+    name: "stripe-token",
+    pattern: /[sr]k_(?:live|test)_[A-Za-z0-9]{16,}(?=$|[^A-Za-z0-9])/g
+  },
+  {
+    name: "npm-token",
+    pattern: /npm_[A-Za-z0-9]{20,}(?=$|[^A-Za-z0-9])/g
+  },
+  {
+    name: "api-key-header",
+    pattern: new RegExp(String.raw`(?:x-api-key|api-key|api_key)\s*[:=]\s*${SECRET_ASSIGNMENT_VALUE}`, "gi")
+  },
+  {
+    name: "secret-assignment",
+    pattern: new RegExp(String.raw`${SECRET_ASSIGNMENT_KEY}\s*[:=]\s*${SECRET_ASSIGNMENT_VALUE}`, "gi")
+  }
+];
+function redactText(value, options = {}) {
+  const maxCharacters = normalizeLimit(options.maxCharacters);
+  const inputLength = value.length;
+  let text = value;
+  let replacements = 0;
+  let detectedSecret = false;
+  const classes = {};
+  for (const literal2 of options.denylist ?? []) {
+    if (typeof literal2 !== "string" || !literal2)
+      continue;
+    let count = 0;
+    let offset = 0;
+    while (offset <= text.length) {
+      const index = text.indexOf(literal2, offset);
+      if (index < 0)
+        break;
+      count++;
+      offset = index + literal2.length;
+    }
+    if (count === 0)
+      continue;
+    replacements += count;
+    detectedSecret = true;
+    classes.denylist = (classes.denylist ?? 0) + count;
+    text = text.replaceAll(literal2, "[REDACTED:denylist]");
+  }
+  for (const rule of RULES) {
+    rule.pattern.lastIndex = 0;
+    text = text.replace(rule.pattern, () => {
+      replacements++;
+      detectedSecret = true;
+      classes[rule.name] = (classes[rule.name] ?? 0) + 1;
+      return `[REDACTED:${rule.name}]`;
+    });
+  }
+  text = text.replace(/[A-Za-z0-9+/=_-]{32,}/g, (candidate) => {
+    if (!looksHighEntropy(candidate))
+      return candidate;
+    replacements++;
+    detectedSecret = true;
+    classes.entropy = (classes.entropy ?? 0) + 1;
+    return "[REDACTED:entropy]";
+  });
+  const truncated = Boolean(options.sourceTruncated) || inputLength > maxCharacters || text.length > maxCharacters;
+  if (text.length > maxCharacters)
+    text = truncateHead(text, maxCharacters);
+  return {
+    text,
+    replacements,
+    classes,
+    truncated,
+    quarantined: detectedSecret
+  };
+}
+function normalizeLimit(value) {
+  if (value === undefined || value === Number.POSITIVE_INFINITY)
+    return Number.MAX_SAFE_INTEGER;
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.floor(value));
+}
+function truncateHead(value, maxCharacters) {
+  if (maxCharacters <= 0)
+    return "";
+  if (value.length <= maxCharacters)
+    return value;
+  let offset = 0;
+  while (offset < value.length) {
+    const codePoint = value.codePointAt(offset);
+    const width = codePoint > 65535 ? 2 : 1;
+    if (offset + width > maxCharacters)
+      break;
+    offset += width;
+  }
+  return value.slice(0, offset);
+}
+function looksHighEntropy(value) {
+  if (!/[A-Za-z]/.test(value) || !/\d/.test(value))
+    return false;
+  const counts = new Map;
+  for (const character of value)
+    counts.set(character, (counts.get(character) ?? 0) + 1);
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const probability = count / value.length;
+    entropy -= probability * Math.log2(probability);
+  }
+  return entropy >= 4.1;
+}
+
+// src/retrieval/derived.ts
+function deriveDocument(source) {
+  const title = redactText(source.title);
+  const summary = redactText(source.summary);
+  const content = redactText(source.content);
+  const contentHash = hashTuple("derived-note", 2, [source.kind, title.text, summary.text, content.text]);
+  return {
+    projectID: source.projectID,
+    noteID: source.noteID,
+    revision: source.revision,
+    kind: source.kind,
+    title: title.text,
+    summary: summary.text,
+    content: content.text,
+    contentHash
+  };
+}
+
+// src/db/migrations/v011.ts
+var LEGACY_CAPTURE_SCHEMA = "agz-memory.capture/1";
+var CAPTURE_SCHEMAS = new Set([LEGACY_CAPTURE_SCHEMA, CAPTURE_SCHEMA]);
+var KINDS_SET = new Set(KINDS);
+var PREDICATES_SET = new Set(PREDICATES);
+function migrateV10ToV11(db) {
+  const source = readSourceRows(db);
+  const migrated = transformRows(source);
+  replaceWithV11(db, migrated);
+  console.warn(`[agz-memory] v10\u2192v11 migration complete: projects=${migrated.projects.length}, notes=${migrated.notes.length}, edges=${migrated.edges.length}, bindings=${migrated.bindings.length}, checkpoints=${migrated.checkpoints.length}, captures=${migrated.captures.length}, revisions=${migrated.revisions.length}, outbox=${migrated.outbox.length}`);
+}
+function assertV10SourceDatabase(db) {
+  transformRows(readSourceRows(db));
+}
+function readSourceRows(db) {
+  for (const table of [
+    "projects",
+    "notes",
+    "note_edges",
+    "project_bindings",
+    "capture_checkpoints",
+    "capture_events",
+    "note_provenance",
+    "note_revisions",
+    "index_outbox",
+    "schema_state"
+  ]) {
+    requireTable(db, table);
+  }
+  if (!hasTable2(db, "notes_fts"))
+    fail("notes_fts", "schema", "source_schema");
+  validateSourceObjects(db);
+  const states = selectRows(db, "schema_state", "SELECT version FROM schema_state");
+  if (states.length !== 1 || states[0]?.version !== 10)
+    fail("schema_state", "schema", "source_schema");
+  const projects = selectRows(db, "projects", "SELECT id, name, normalized_name, created_at, updated_at FROM projects ORDER BY rowid");
+  const notes = selectRows(db, "notes", `SELECT id, project_id, kind, title, summary, content, size_class, pinned, status,
+            supersedes_id, current_revision, subject_key, content_hash, created_at, updated_at
+       FROM notes ORDER BY rowid`);
+  const edges = selectRows(db, "note_edges", "SELECT id, project_id, source_id, target_id, predicate, created_at FROM note_edges ORDER BY rowid");
+  const bindings = selectRows(db, "project_bindings", `SELECT binding_key, project_id, source, source_project_id, workspace_id,
+            canonical_path_hash, created_at, updated_at
+       FROM project_bindings ORDER BY rowid`);
+  const checkpoints = selectRows(db, "capture_checkpoints", `SELECT session_id, binding_key, project_id, state, last_message_id,
+            last_reconciled_at, next_reconcile_at, failure_count, lease_owner,
+            lease_expires_at, created_at, updated_at
+       FROM capture_checkpoints ORDER BY rowid`);
+  const captures = selectRows(db, "capture_events", `SELECT 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
+       FROM capture_events ORDER BY rowid`);
+  const provenance = selectRows(db, "note_provenance", `SELECT 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
+       FROM note_provenance ORDER BY rowid`);
+  const revisions = selectRows(db, "note_revisions", `SELECT project_id, note_id, revision, kind, title, summary, content, size_class,
+            pinned, status, supersedes_id, subject_key, content_hash, provenance_id, created_at
+       FROM note_revisions ORDER BY rowid`);
+  const outbox = selectRows(db, "index_outbox", `SELECT id, backend, operation, project_id, note_id, revision, content_hash,
+            state, attempt_count, available_at, lease_owner, lease_expires_at,
+            last_error_code, created_at, completed_at
+       FROM index_outbox ORDER BY id`);
+  return { projects, notes, edges, bindings, checkpoints, captures, provenance, revisions, outbox };
+}
+function validateSourceObjects(db) {
+  const expected = new Set([
+    "index\x00capture_checkpoints_due_idx",
+    "index\x00capture_events_note_idx",
+    "index\x00capture_events_session_idx",
+    "index\x00capture_events_state_idx",
+    "index\x00index_outbox_due_idx",
+    "index\x00note_edges_source_idx",
+    "index\x00note_edges_target_idx",
+    "index\x00notes_active_subject_idx",
+    "index\x00notes_project_idx",
+    "table\x00capture_checkpoints",
+    "table\x00capture_events",
+    "table\x00index_outbox",
+    "table\x00note_edges",
+    "table\x00note_provenance",
+    "table\x00note_revisions",
+    "table\x00notes",
+    "table\x00notes_fts",
+    "table\x00notes_fts_config",
+    "table\x00notes_fts_data",
+    "table\x00notes_fts_docsize",
+    "table\x00notes_fts_idx",
+    "table\x00project_bindings",
+    "table\x00projects",
+    "table\x00schema_state",
+    "trigger\x00notes_fts_ad",
+    "trigger\x00notes_fts_ai",
+    "trigger\x00notes_fts_au"
+  ]);
+  const actual = db.query("SELECT type, name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").all();
+  if (actual.length !== expected.size || actual.some((object2) => !expected.has(`${object2.type}\x00${object2.name}`))) {
+    fail("database", "schema", "source_schema");
+  }
+}
+function transformRows(source) {
+  const projectIDs = new Set;
+  const normalizedProjectNames = new Set;
+  for (const project of source.projects) {
+    requireString(project.id, "projects", project.id, "project_id_invalid");
+    requireString(project.name, "projects", project.id, "project_name_invalid");
+    requireString(project.normalized_name, "projects", project.id, "project_name_invalid");
+    requireInteger(project.created_at, "projects", project.id, "timestamp_invalid");
+    requireInteger(project.updated_at, "projects", project.id, "timestamp_invalid");
+    if (projectIDs.has(project.id))
+      fail("projects", project.id, "duplicate_row");
+    if (normalizedProjectNames.has(project.normalized_name)) {
+      fail("projects", project.id, "duplicate_normalized_name");
+    }
+    projectIDs.add(project.id);
+    normalizedProjectNames.add(project.normalized_name);
+  }
+  const noteMap = new Map;
+  const noteIDs = new Set;
+  for (const note of source.notes) {
+    requireString(note.id, "notes", note.id, "note_id_invalid");
+    requireString(note.project_id, "notes", note.id, "project_id_invalid");
+    if (!projectIDs.has(note.project_id))
+      fail("notes", note.id, "cross_project_reference");
+    requireKind(note.kind, "notes", note.id);
+    requireString(note.title, "notes", note.id, "note_value_invalid");
+    requireString(note.summary, "notes", note.id, "note_value_invalid");
+    requireString(note.content, "notes", note.id, "note_value_invalid");
+    if (note.size_class !== "inline" && note.size_class !== "indexed") {
+      fail("notes", note.id, "note_value_invalid");
+    }
+    if (note.pinned !== 0 && note.pinned !== 1)
+      fail("notes", note.id, "note_value_invalid");
+    if (!new Set(["active", "superseded", "archived"]).has(note.status)) {
+      fail("notes", note.id, "note_value_invalid");
+    }
+    requireNullableString(note.supersedes_id, "notes", note.id, "note_value_invalid");
+    requireIntegerAtLeast(note.current_revision, 1, "notes", note.id, "revision_invalid");
+    requireNullableString(note.subject_key, "notes", note.id, "note_value_invalid");
+    requireString(note.content_hash, "notes", note.id, "hash_invalid");
+    const legacyHash = legacyNoteContentHash(note.kind, note.title, note.summary, note.content);
+    const v2Hash = noteContentHash(note.kind, note.title, note.summary, note.content);
+    if (note.content_hash !== legacyHash && note.content_hash !== v2Hash) {
+      fail("notes", note.id, "hash_invalid");
+    }
+    requireInteger(note.created_at, "notes", note.id, "timestamp_invalid");
+    requireInteger(note.updated_at, "notes", note.id, "timestamp_invalid");
+    if (noteMap.has(noteKey(note.project_id, note.id)))
+      fail("notes", note.id, "duplicate_row");
+    noteMap.set(noteKey(note.project_id, note.id), note);
+    noteIDs.add(note.id);
+  }
+  const activeSubjects = new Set;
+  for (const note of source.notes) {
+    if (note.supersedes_id !== null) {
+      const superseded = noteMap.get(noteKey(note.project_id, note.supersedes_id));
+      if (!superseded || note.supersedes_id === note.id) {
+        fail("notes", note.id, "cross_project_reference");
+      }
+    }
+    if (note.status === "active" && note.subject_key !== null) {
+      const subject = hashTuple("active-subject", 2, [note.project_id, note.kind, note.subject_key]);
+      if (activeSubjects.has(subject))
+        fail("notes", note.id, "duplicate_active_subject");
+      activeSubjects.add(subject);
+    }
+  }
+  const edges = source.edges.map((edge) => {
+    requireString(edge.id, "note_edges", edge.id, "edge_id_invalid");
+    requireString(edge.project_id, "note_edges", edge.id, "project_id_invalid");
+    requireString(edge.source_id, "note_edges", edge.id, "edge_value_invalid");
+    requireString(edge.target_id, "note_edges", edge.id, "edge_value_invalid");
+    const sourceNote = noteMap.get(noteKey(edge.project_id, edge.source_id));
+    const targetNote = noteMap.get(noteKey(edge.project_id, edge.target_id));
+    if (!projectIDs.has(edge.project_id) || !sourceNote || !targetNote) {
+      fail("note_edges", edge.id, "cross_project_reference");
+    }
+    if (!PREDICATES_SET.has(edge.predicate))
+      fail("note_edges", edge.id, "edge_value_invalid");
+    requireInteger(edge.created_at, "note_edges", edge.id, "timestamp_invalid");
+    return edge;
+  });
+  const bindingMap = new Map;
+  const bindingProjects = new Map;
+  const bindingKeys = new Set;
+  const bindings = source.bindings.map((binding) => {
+    requireHash(binding.binding_key, "project_bindings", binding.binding_key, "binding_id_invalid");
+    requireString(binding.project_id, "project_bindings", binding.binding_key, "project_id_invalid");
+    if (!projectIDs.has(binding.project_id)) {
+      fail("project_bindings", binding.binding_key, "cross_project_reference");
+    }
+    if (binding.source !== "opencode-v2")
+      fail("project_bindings", binding.binding_key, "binding_value_invalid");
+    requireString(binding.source_project_id, "project_bindings", binding.binding_key, "binding_value_invalid");
+    requireString(binding.workspace_id, "project_bindings", binding.binding_key, "binding_value_invalid");
+    requireHash(binding.canonical_path_hash, "project_bindings", binding.binding_key, "hash_invalid");
+    requireInteger(binding.created_at, "project_bindings", binding.binding_key, "timestamp_invalid");
+    requireInteger(binding.updated_at, "project_bindings", binding.binding_key, "timestamp_invalid");
+    const nextKey = hashTuple("project-binding", 2, [
+      binding.source,
+      binding.source_project_id,
+      binding.workspace_id,
+      binding.canonical_path_hash
+    ]);
+    if (bindingKeys.has(nextKey))
+      fail("project_bindings", binding.binding_key, "identity_collision");
+    bindingKeys.add(nextKey);
+    bindingMap.set(binding.binding_key, nextKey);
+    bindingProjects.set(binding.binding_key, binding.project_id);
+    return { ...binding, binding_key: nextKey };
+  });
+  const checkpointIdentities = new Set;
+  const checkpoints = source.checkpoints.map((checkpoint) => {
+    requireNonEmptyString(checkpoint.session_id, "capture_checkpoints", checkpoint.session_id, "checkpoint_id_invalid");
+    requireHash(checkpoint.binding_key, "capture_checkpoints", checkpoint.session_id, "checkpoint_value_invalid");
+    requireString(checkpoint.project_id, "capture_checkpoints", checkpoint.session_id, "project_id_invalid");
+    const nextBinding = bindingMap.get(checkpoint.binding_key);
+    if (!nextBinding || checkpoint.project_id !== bindingProjects.get(checkpoint.binding_key)) {
+      fail("capture_checkpoints", checkpoint.session_id, "cross_project_reference");
+    }
+    if (checkpoint.state !== "active" && checkpoint.state !== "idle" && checkpoint.state !== "unavailable" && checkpoint.state !== "closed") {
+      fail("capture_checkpoints", checkpoint.session_id, "checkpoint_value_invalid");
+    }
+    requireNullableString(checkpoint.last_message_id, "capture_checkpoints", checkpoint.session_id, "checkpoint_value_invalid");
+    requireNullableInteger(checkpoint.last_reconciled_at, "capture_checkpoints", checkpoint.session_id, "timestamp_invalid");
+    requireInteger(checkpoint.next_reconcile_at, "capture_checkpoints", checkpoint.session_id, "timestamp_invalid");
+    requireIntegerAtLeast(checkpoint.failure_count, 0, "capture_checkpoints", checkpoint.session_id, "checkpoint_value_invalid");
+    requireNullableString(checkpoint.lease_owner, "capture_checkpoints", checkpoint.session_id, "checkpoint_value_invalid");
+    requireNullableInteger(checkpoint.lease_expires_at, "capture_checkpoints", checkpoint.session_id, "timestamp_invalid");
+    requireInteger(checkpoint.created_at, "capture_checkpoints", checkpoint.session_id, "timestamp_invalid");
+    requireInteger(checkpoint.updated_at, "capture_checkpoints", checkpoint.session_id, "timestamp_invalid");
+    const identity = hashTuple("checkpoint-identity", 2, [nextBinding, checkpoint.session_id]);
+    if (checkpointIdentities.has(identity)) {
+      fail("capture_checkpoints", checkpoint.session_id, "identity_collision");
+    }
+    checkpointIdentities.add(identity);
+    return { ...checkpoint, binding_key: nextBinding, last_message_id: null };
+  });
+  const captureMap = new Map;
+  const captureProjects = new Map;
+  const captureKeys = new Set;
+  const captures = source.captures.map((capture) => {
+    requireHash(capture.idempotency_key, "capture_events", capture.idempotency_key, "capture_id_invalid");
+    requireString(capture.project_id, "capture_events", capture.idempotency_key, "project_id_invalid");
+    requireHash(capture.binding_key, "capture_events", capture.idempotency_key, "binding_id_invalid");
+    const nextBinding = bindingMap.get(capture.binding_key);
+    const bindingProjectID = bindingProjects.get(capture.binding_key);
+    if (!nextBinding || !bindingProjectID || capture.project_id !== bindingProjectID) {
+      fail("capture_events", capture.idempotency_key, "cross_project_reference");
+    }
+    const migrated = migrateCapture(capture, nextBinding, noteMap, noteIDs);
+    if (captureKeys.has(migrated.idempotency_key)) {
+      fail("capture_events", capture.idempotency_key, "identity_collision");
+    }
+    captureKeys.add(migrated.idempotency_key);
+    captureMap.set(capture.idempotency_key, migrated.idempotency_key);
+    captureProjects.set(capture.idempotency_key, capture.project_id);
+    return migrated;
+  });
+  const provenanceKeys = new Set;
+  const provenance = source.provenance.map((row) => {
+    requireString(row.id, "note_provenance", row.id, "provenance_id_invalid");
+    requireString(row.project_id, "note_provenance", row.id, "project_id_invalid");
+    requireString(row.note_id, "note_provenance", row.id, "note_id_invalid");
+    if (!noteMap.has(noteKey(row.project_id, row.note_id))) {
+      fail("note_provenance", row.id, "cross_project_reference");
+    }
+    if (!new Set(["mcp-manual", "opencode-capture", "migration", "legacy-import", "admin"]).has(row.source_type)) {
+      fail("note_provenance", row.id, "provenance_value_invalid");
+    }
+    requireNullableString(row.capture_event_id, "note_provenance", row.id, "provenance_value_invalid");
+    if (row.capture_event_id !== null) {
+      if (!captureMap.has(row.capture_event_id))
+        fail("note_provenance", row.id, "capture_reference_invalid");
+      if (captureProjects.get(row.capture_event_id) !== row.project_id) {
+        fail("note_provenance", row.id, "cross_project_reference");
+      }
+    }
+    requireNullableString(row.source_session_id, "note_provenance", row.id, "provenance_value_invalid");
+    requireNullableString(row.source_message_id, "note_provenance", row.id, "provenance_value_invalid");
+    requireNullableInteger(row.source_ordinal, "note_provenance", row.id, "provenance_value_invalid");
+    requireNullableString(row.source_tool_call_id, "note_provenance", row.id, "provenance_value_invalid");
+    requireNullableString(row.redaction_version, "note_provenance", row.id, "provenance_value_invalid");
+    requireNullableString(row.extractor_version, "note_provenance", row.id, "provenance_value_invalid");
+    if (row.confidence !== null && (!Number.isFinite(row.confidence) || row.confidence < 0 || row.confidence > 1)) {
+      fail("note_provenance", row.id, "provenance_value_invalid");
+    }
+    requireInteger(row.created_at, "note_provenance", row.id, "timestamp_invalid");
+    const key = noteKey(row.project_id, row.id);
+    if (provenanceKeys.has(key))
+      fail("note_provenance", row.id, "duplicate_row");
+    provenanceKeys.add(key);
+    return {
+      ...row,
+      capture_event_id: row.capture_event_id === null ? null : captureMap.get(row.capture_event_id)
+    };
+  });
+  const provenanceMap = new Map(provenance.map((row) => [noteKey(row.project_id, row.id), row]));
+  const revisionMap = new Map;
+  const revisions = source.revisions.map((revision) => {
+    requireString(revision.project_id, "note_revisions", revision.note_id, "project_id_invalid");
+    requireString(revision.note_id, "note_revisions", revision.note_id, "note_id_invalid");
+    const note = noteMap.get(noteKey(revision.project_id, revision.note_id));
+    const provenanceRow = provenanceMap.get(noteKey(revision.project_id, revision.provenance_id));
+    if (!note || !provenanceRow)
+      fail("note_revisions", revision.note_id, "cross_project_reference");
+    requireIntegerAtLeast(revision.revision, 1, "note_revisions", revision.note_id, "revision_invalid");
+    requireKind(revision.kind, "note_revisions", revision.note_id);
+    requireString(revision.title, "note_revisions", revision.note_id, "revision_value_invalid");
+    requireString(revision.summary, "note_revisions", revision.note_id, "revision_value_invalid");
+    requireString(revision.content, "note_revisions", revision.note_id, "revision_value_invalid");
+    if (revision.size_class !== "inline" && revision.size_class !== "indexed") {
+      fail("note_revisions", revision.note_id, "revision_value_invalid");
+    }
+    if (revision.pinned !== 0 && revision.pinned !== 1)
+      fail("note_revisions", revision.note_id, "revision_value_invalid");
+    if (!new Set(["active", "superseded", "archived"]).has(revision.status)) {
+      fail("note_revisions", revision.note_id, "revision_value_invalid");
+    }
+    requireNullableString(revision.supersedes_id, "note_revisions", revision.note_id, "revision_value_invalid");
+    if (revision.supersedes_id !== null) {
+      if (revision.supersedes_id === revision.note_id) {
+        fail("note_revisions", revision.note_id, "revision_value_invalid");
+      }
+      if (!noteMap.has(noteKey(revision.project_id, revision.supersedes_id))) {
+        fail("note_revisions", revision.note_id, "cross_project_reference");
+      }
+    }
+    requireNullableString(revision.subject_key, "note_revisions", revision.note_id, "revision_value_invalid");
+    requireString(revision.content_hash, "note_revisions", revision.note_id, "hash_invalid");
+    const legacyHash = legacyNoteContentHash(revision.kind, revision.title, revision.summary, revision.content);
+    const v2Hash = noteContentHash(revision.kind, revision.title, revision.summary, revision.content);
+    if (revision.content_hash !== legacyHash && revision.content_hash !== v2Hash) {
+      fail("note_revisions", revision.note_id, "hash_invalid");
+    }
+    requireInteger(revision.created_at, "note_revisions", revision.note_id, "timestamp_invalid");
+    const key = revisionKey(revision.project_id, revision.note_id, revision.revision);
+    if (revisionMap.has(key))
+      fail("note_revisions", revision.note_id, "duplicate_row");
+    const migrated = {
+      ...revision,
+      content_hash: noteContentHash(revision.kind, revision.title, revision.summary, revision.content)
+    };
+    revisionMap.set(key, migrated);
+    return migrated;
+  });
+  for (const note of source.notes) {
+    const current = revisionMap.get(revisionKey(note.project_id, note.id, note.current_revision));
+    if (!current)
+      fail("note_revisions", note.id, "revision_invalid");
+    for (let revision = 1;revision <= note.current_revision; revision++) {
+      if (!revisionMap.has(revisionKey(note.project_id, note.id, revision))) {
+        fail("note_revisions", note.id, "revision_invalid");
+      }
+    }
+    if (current.kind !== note.kind || current.title !== note.title || current.summary !== note.summary || current.content !== note.content || current.size_class !== note.size_class || current.pinned !== note.pinned || current.status !== note.status || current.supersedes_id !== note.supersedes_id || current.subject_key !== note.subject_key || current.content_hash !== noteContentHash(note.kind, note.title, note.summary, note.content)) {
+      fail("note_revisions", note.id, "revision_invalid");
+    }
+  }
+  const activeOperations = new Set;
+  const outbox = source.outbox.map((row) => {
+    requireIntegerAtLeast(row.id, 1, "index_outbox", String(row.id), "outbox_value_invalid");
+    requireNonEmptyString(row.backend, "index_outbox", String(row.id), "outbox_value_invalid");
+    requireString(row.operation, "index_outbox", String(row.id), "outbox_operation_invalid");
+    requireString(row.project_id, "index_outbox", String(row.id), "project_id_invalid");
+    requireNullableString(row.note_id, "index_outbox", String(row.id), "outbox_operation_invalid");
+    requireNullableInteger(row.revision, "index_outbox", String(row.id), "outbox_operation_invalid");
+    requireNullableString(row.content_hash, "index_outbox", String(row.id), "outbox_operation_invalid");
+    if (row.state !== "pending" && row.state !== "leased" && row.state !== "succeeded" && row.state !== "dead") {
+      fail("index_outbox", String(row.id), "outbox_value_invalid");
+    }
+    requireIntegerAtLeast(row.attempt_count, 0, "index_outbox", String(row.id), "outbox_value_invalid");
+    requireInteger(row.available_at, "index_outbox", String(row.id), "timestamp_invalid");
+    requireNullableString(row.lease_owner, "index_outbox", String(row.id), "outbox_value_invalid");
+    requireNullableInteger(row.lease_expires_at, "index_outbox", String(row.id), "timestamp_invalid");
+    requireNullableString(row.last_error_code, "index_outbox", String(row.id), "outbox_value_invalid");
+    requireInteger(row.created_at, "index_outbox", String(row.id), "timestamp_invalid");
+    requireNullableInteger(row.completed_at, "index_outbox", String(row.id), "timestamp_invalid");
+    let contentHash = null;
+    let state = row.state;
+    let leaseOwner = row.lease_owner;
+    let leaseExpiresAt = row.lease_expires_at;
+    let completedAt = row.completed_at;
+    if (row.operation === "upsert-note") {
+      if (row.note_id === null || row.revision === null || row.content_hash === null) {
+        fail("index_outbox", String(row.id), "outbox_operation_invalid");
+      }
+      requireNonEmptyString(row.note_id, "index_outbox", String(row.id), "outbox_operation_invalid");
+      requireIntegerAtLeast(row.revision, 1, "index_outbox", String(row.id), "outbox_operation_invalid");
+      requireHash(row.content_hash, "index_outbox", String(row.id), "hash_invalid");
+      const revision = revisionMap.get(revisionKey(row.project_id, row.note_id, row.revision));
+      if (!revision) {
+        contentHash = row.content_hash;
+        if (state === "pending" || state === "leased") {
+          state = "succeeded";
+          leaseOwner = null;
+          leaseExpiresAt = null;
+          completedAt = row.completed_at ?? row.created_at;
+        }
+      } else {
+        const document = deriveDocument({
+          projectID: revision.project_id,
+          noteID: revision.note_id,
+          revision: revision.revision,
+          kind: revision.kind,
+          title: revision.title,
+          summary: revision.summary,
+          content: revision.content
+        });
+        if (!document)
+          fail("index_outbox", String(row.id), "derived_identity_unavailable");
+        const legacyContentHash = legacyNoteContentHash(document.kind, document.title, document.summary, document.content);
+        if (row.content_hash !== document.contentHash && row.content_hash !== legacyContentHash) {
+          fail("index_outbox", String(row.id), "hash_invalid");
+        }
+        contentHash = document.contentHash;
+      }
+    } else if (row.operation === "delete-note") {
+      if (row.note_id === null || row.revision === null) {
+        fail("index_outbox", String(row.id), "outbox_operation_invalid");
+      }
+      requireNonEmptyString(row.note_id, "index_outbox", String(row.id), "outbox_operation_invalid");
+      requireIntegerAtLeast(row.revision, 1, "index_outbox", String(row.id), "outbox_operation_invalid");
+      if (row.content_hash !== null) {
+        requireHash(row.content_hash, "index_outbox", String(row.id), "hash_invalid");
+      }
+    } else if (row.operation === "purge-project") {
+      if (row.note_id !== null || row.revision !== null || row.content_hash !== null) {
+        fail("index_outbox", String(row.id), "outbox_operation_invalid");
+      }
+    } else {
+      fail("index_outbox", String(row.id), "outbox_operation_invalid");
+    }
+    if (state === "leased")
+      state = "pending";
+    leaseOwner = null;
+    leaseExpiresAt = null;
+    let generation = 0;
+    if (state === "pending" || state === "leased") {
+      let activeKey = hashTuple("outbox-active", 2, [
+        row.backend,
+        row.operation,
+        row.project_id,
+        row.note_id,
+        row.revision,
+        generation
+      ]);
+      while (activeOperations.has(activeKey)) {
+        generation++;
+        activeKey = hashTuple("outbox-active", 2, [
+          row.backend,
+          row.operation,
+          row.project_id,
+          row.note_id,
+          row.revision,
+          generation
+        ]);
+      }
+      activeOperations.add(activeKey);
+    }
+    const operationKey = hashTuple("outbox-operation", 2, [
+      row.backend,
+      row.operation,
+      row.project_id,
+      row.note_id,
+      row.revision,
+      contentHash,
+      generation
+    ]);
+    return {
+      ...row,
+      operation_key: operationKey,
+      content_hash: contentHash,
+      state,
+      lease_owner: leaseOwner,
+      lease_expires_at: leaseExpiresAt,
+      completed_at: completedAt,
+      generation,
+      lease_generation: 0,
+      fence: 0,
+      heartbeat_at: null
+    };
+  });
+  const migratedNotes = source.notes.map((note) => ({
+    ...note,
+    content_hash: noteContentHash(note.kind, note.title, note.summary, note.content)
+  }));
+  return {
+    projects: source.projects,
+    notes: migratedNotes,
+    edges,
+    bindings,
+    checkpoints,
+    captures,
+    provenance,
+    revisions,
+    outbox,
+    bindingMap,
+    captureMap
+  };
+}
+function migrateCapture(row, bindingKey, notes, noteIDs) {
+  requireHash(row.idempotency_key, "capture_events", row.idempotency_key, "capture_id_invalid");
+  if (!CAPTURE_SCHEMAS.has(row.contract))
+    fail("capture_events", row.idempotency_key, "capture_contract_invalid");
+  requireString(row.project_id, "capture_events", row.idempotency_key, "project_id_invalid");
+  requireString(row.event_kind, "capture_events", row.idempotency_key, "capture_identity_invalid");
+  requireNonEmptyString(row.source_session_id, "capture_events", row.idempotency_key, "capture_identity_invalid");
+  requireNullableString(row.source_message_id, "capture_events", row.idempotency_key, "capture_identity_invalid");
+  requireNullableInteger(row.source_ordinal, "capture_events", row.idempotency_key, "capture_identity_invalid");
+  requireNullableString(row.source_tool_call_id, "capture_events", row.idempotency_key, "capture_identity_invalid");
+  requireString(row.redaction_version, "capture_events", row.idempotency_key, "capture_value_invalid");
+  if (!new Set(["pending", "shadowed", "review", "materialized", "duplicate", "ignored", "rejected", "quarantined", "failed", "dead"]).has(row.state)) {
+    fail("capture_events", row.idempotency_key, "capture_value_invalid");
+  }
+  requireIntegerAtLeast(row.attempt_count, 0, "capture_events", row.idempotency_key, "capture_value_invalid");
+  if (row.note_id !== null && notes.get(noteKey(row.project_id, row.note_id)) === undefined) {
+    if (noteIDs.has(row.note_id)) {
+      fail("capture_events", row.idempotency_key, "cross_project_reference");
+    }
+  }
+  requireNullableString(row.note_id, "capture_events", row.idempotency_key, "capture_value_invalid");
+  requireNullableString(row.last_error_code, "capture_events", row.idempotency_key, "capture_value_invalid");
+  requireIntegerAtLeast(row.generation, 0, "capture_events", row.idempotency_key, "capture_value_invalid");
+  requireInteger(row.created_at, "capture_events", row.idempotency_key, "timestamp_invalid");
+  requireInteger(row.updated_at, "capture_events", row.idempotency_key, "timestamp_invalid");
+  requireNullableInteger(row.processed_at, "capture_events", row.idempotency_key, "timestamp_invalid");
+  requireNullableString(row.payload_json, "capture_events", row.idempotency_key, "payload_value_invalid");
+  requireNullableString(row.payload_hash, "capture_events", row.idempotency_key, "payload_value_invalid");
+  if (row.payload_json === null) {
+    if (row.payload_hash !== null)
+      fail("capture_events", row.idempotency_key, "payload_identity_unavailable");
+    let key;
+    try {
+      assertLegacyCaptureKey(row);
+      key = captureKeyFromColumns(row, bindingKey);
+    } catch {
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    }
+    return { ...row, idempotency_key: key, contract: CAPTURE_SCHEMA, binding_key: bindingKey };
+  }
+  if (row.payload_hash === null)
+    fail("capture_events", row.idempotency_key, "payload_identity_unavailable");
+  const legacyPayloadHash = sha256(row.payload_json);
+  const v2PayloadHash = hashTuple("capture-payload", 2, [row.payload_json]);
+  if (row.payload_hash !== legacyPayloadHash && row.payload_hash !== v2PayloadHash) {
+    fail("capture_events", row.idempotency_key, "payload_identity_mismatch");
+  }
+  let raw;
+  try {
+    const value = JSON.parse(row.payload_json);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("not an object");
+    raw = value;
+  } catch {
+    fail("capture_events", row.idempotency_key, "payload_invalid");
+  }
+  if (raw.schema !== row.contract || raw.idempotencyKey !== row.idempotency_key) {
+    fail("capture_events", row.idempotency_key, "payload_identity_mismatch");
+  }
+  if (raw.projectID !== row.project_id || raw.bindingKey !== row.binding_key || raw.kind !== row.event_kind) {
+    fail("capture_events", row.idempotency_key, "cross_project_reference");
+  }
+  const source = raw.source;
+  if (!source || typeof source !== "object" || Array.isArray(source)) {
+    fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+  }
+  let nextKey;
+  try {
+    nextKey = captureKeyFromPayload(row.event_kind, bindingKey, source, raw.signal);
+  } catch {
+    fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+  }
+  const candidate = {
+    ...raw,
+    schema: CAPTURE_SCHEMA,
+    idempotencyKey: nextKey,
+    projectID: row.project_id,
+    bindingKey
+  };
+  let parsed;
+  try {
+    parsed = parseCaptureEvent(candidate);
+  } catch {
+    fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+  }
+  if (parsed.kind !== row.event_kind || parsed.source.sessionID !== row.source_session_id || (parsed.source.messageID ?? null) !== row.source_message_id || (parsed.source.ordinal ?? null) !== row.source_ordinal || (parsed.source.toolCallID ?? null) !== row.source_tool_call_id) {
+    fail("capture_events", row.idempotency_key, "capture_identity_mismatch");
+  }
+  const payload = JSON.stringify(parsed);
+  return {
+    ...row,
+    idempotency_key: nextKey,
+    contract: CAPTURE_SCHEMA,
+    binding_key: bindingKey,
+    payload_json: payload,
+    payload_hash: capturePayloadHash(parsed)
+  };
+}
+function captureKeyFromColumns(row, bindingKey) {
+  if (row.event_kind === "user-candidate") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    if (row.source_ordinal !== null || row.source_tool_call_id !== null) {
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    }
+    return captureIdempotencyKey({
+      kind: "user",
+      bindingKey,
+      sessionID: row.source_session_id,
+      messageID: row.source_message_id
+    });
+  }
+  if (row.event_kind === "assistant-candidate") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    if (row.source_ordinal === null || row.source_tool_call_id !== null) {
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    }
+    return captureIdempotencyKey({
+      kind: "assistant",
+      bindingKey,
+      sessionID: row.source_session_id,
+      assistantMessageID: row.source_message_id,
+      ordinal: row.source_ordinal
+    });
+  }
+  if (row.event_kind === "session-summary") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    if (row.source_ordinal !== null || row.source_tool_call_id !== null) {
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    }
+    return captureIdempotencyKey({
+      kind: "summary",
+      bindingKey,
+      sessionID: row.source_session_id,
+      checkpointMessageID: row.source_message_id
+    });
+  }
+  if (row.event_kind === "tool-signal") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    if (row.source_ordinal !== null || !row.source_tool_call_id) {
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    }
+    const status = legacyToolStatus(row);
+    return captureIdempotencyKey({
+      kind: "tool",
+      bindingKey,
+      sessionID: row.source_session_id,
+      assistantMessageID: row.source_message_id,
+      toolCallID: row.source_tool_call_id,
+      terminalStatus: status
+    });
+  }
+  fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+}
+function assertLegacyCaptureKey(row) {
+  let expected;
+  if (row.event_kind === "user-candidate") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    expected = legacyCaptureKey([
+      "user",
+      row.binding_key,
+      row.source_session_id,
+      row.source_message_id
+    ]);
+  } else if (row.event_kind === "assistant-candidate") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    if (row.source_ordinal === null)
+      fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+    expected = legacyCaptureKey([
+      "assistant",
+      row.binding_key,
+      row.source_session_id,
+      row.source_message_id,
+      String(row.source_ordinal)
+    ]);
+  } else if (row.event_kind === "session-summary") {
+    requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+    expected = legacyCaptureKey([
+      "summary",
+      row.binding_key,
+      row.source_session_id,
+      row.source_message_id
+    ]);
+  } else if (row.event_kind === "tool-signal") {
+    legacyToolStatus(row);
+    return;
+  } else {
+    fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+  }
+  if (row.idempotency_key !== expected) {
+    fail("capture_events", row.idempotency_key, "capture_identity_mismatch");
+  }
+}
+function legacyToolStatus(row) {
+  requireSourceMessage(row.source_message_id, "capture_events", row.idempotency_key);
+  if (!row.source_tool_call_id)
+    fail("capture_events", row.idempotency_key, "capture_identity_invalid");
+  const completed = legacyCaptureKey([
+    "tool",
+    row.binding_key,
+    row.source_session_id,
+    row.source_message_id,
+    row.source_tool_call_id,
+    "completed"
+  ]);
+  const errored = legacyCaptureKey([
+    "tool",
+    row.binding_key,
+    row.source_session_id,
+    row.source_message_id,
+    row.source_tool_call_id,
+    "error"
+  ]);
+  if (row.idempotency_key === completed)
+    return "completed";
+  if (row.idempotency_key === errored)
+    return "error";
+  fail("capture_events", row.idempotency_key, "capture_identity_mismatch");
+}
+function legacyCaptureKey(fields) {
+  return sha256(["capture/1", ...fields].join("\x00"));
+}
+function captureKeyFromPayload(eventKind, bindingKey, source, signal) {
+  const sessionID = source.sessionID;
+  const messageID = source.messageID;
+  if (typeof sessionID !== "string" || !sessionID)
+    throw new Error("invalid source");
+  if (eventKind === "user-candidate") {
+    if (typeof messageID !== "string" || !messageID || hasOwn(source, "ordinal") || hasOwn(source, "toolCallID")) {
+      throw new Error("invalid source");
+    }
+    return captureIdempotencyKey({ kind: "user", bindingKey, sessionID, messageID });
+  }
+  if (eventKind === "assistant-candidate") {
+    if (typeof messageID !== "string" || !messageID || typeof source.ordinal !== "number" || hasOwn(source, "toolCallID")) {
+      throw new Error("invalid source");
+    }
+    return captureIdempotencyKey({
+      kind: "assistant",
+      bindingKey,
+      sessionID,
+      assistantMessageID: messageID,
+      ordinal: source.ordinal
+    });
+  }
+  if (eventKind === "session-summary") {
+    if (typeof messageID !== "string" || !messageID || hasOwn(source, "ordinal") || hasOwn(source, "toolCallID")) {
+      throw new Error("invalid source");
+    }
+    return captureIdempotencyKey({ kind: "summary", bindingKey, sessionID, checkpointMessageID: messageID });
+  }
+  if (eventKind === "tool-signal") {
+    const status = signal && typeof signal === "object" ? signal.status : undefined;
+    const toolCallID = source.toolCallID;
+    if (typeof messageID !== "string" || !messageID || typeof toolCallID !== "string" || !toolCallID || hasOwn(source, "ordinal") || status !== "completed" && status !== "error") {
+      throw new Error("invalid source");
+    }
+    return captureIdempotencyKey({
+      kind: "tool",
+      bindingKey,
+      sessionID,
+      assistantMessageID: messageID,
+      toolCallID,
+      terminalStatus: status
+    });
+  }
+  throw new Error("invalid event kind");
+}
+function replaceWithV11(db, rows) {
+  db.exec(`
+    DROP TRIGGER IF EXISTS notes_fts_ai;
+    DROP TRIGGER IF EXISTS notes_fts_ad;
+    DROP TRIGGER IF EXISTS notes_fts_au;
+    DROP TABLE IF EXISTS notes_fts;
+    DROP TABLE IF EXISTS index_outbox;
+    DROP TABLE IF EXISTS note_revisions;
+    DROP TABLE IF EXISTS note_provenance;
+    DROP TABLE IF EXISTS capture_events;
+    DROP TABLE IF EXISTS capture_checkpoints;
+    DROP TABLE IF EXISTS project_bindings;
+    DROP TABLE IF EXISTS note_edges;
+    DROP TABLE IF EXISTS notes;
+    DROP TABLE IF EXISTS projects;
+    DROP TABLE IF EXISTS schema_state;
+    DROP TABLE IF EXISTS agz_meta;
+  `);
+  db.exec(SCHEMA_V11_TABLES);
+  db.exec(FTS_V9);
+  for (const row of rows.projects) {
+    insertRow("projects", row.id, () => {
+      db.query("INSERT INTO projects (id, name, normalized_name, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(row.id, row.name, row.normalized_name, row.created_at, row.updated_at);
+    });
+  }
+  for (const row of rows.notes) {
+    insertRow("notes", row.id, () => {
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.project_id, row.kind, row.title, row.summary, row.content, row.size_class, row.pinned, row.status, row.supersedes_id, row.current_revision, row.subject_key, row.content_hash, row.created_at, row.updated_at);
+    });
+  }
+  for (const row of rows.bindings) {
+    insertRow("project_bindings", row.binding_key, () => {
+      db.query(`INSERT INTO project_bindings
+           (binding_key, project_id, source, source_project_id, workspace_id,
+            canonical_path_hash, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(row.binding_key, row.project_id, row.source, row.source_project_id, row.workspace_id, row.canonical_path_hash, row.created_at, row.updated_at);
+    });
+  }
+  for (const row of rows.checkpoints) {
+    insertRow("capture_checkpoints", row.session_id, () => {
+      db.query(`INSERT INTO capture_checkpoints
+           (session_id, binding_key, project_id, state, last_message_id,
+            last_reconciled_at, next_reconcile_at, failure_count, lease_owner,
+            lease_expires_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.session_id, row.binding_key, row.project_id, row.state, row.last_message_id, row.last_reconciled_at, row.next_reconcile_at, row.failure_count, row.lease_owner, row.lease_expires_at, row.created_at, row.updated_at);
+    });
+  }
+  for (const row of rows.captures) {
+    insertRow("capture_events", row.idempotency_key, () => {
+      db.query(`INSERT 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,
+            note_id, last_error_code, generation, created_at, updated_at, processed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.idempotency_key, row.contract, row.project_id, row.binding_key, row.event_kind, row.source_session_id, row.source_message_id, row.source_ordinal, row.source_tool_call_id, row.payload_json, row.payload_hash, row.redaction_version, row.state, row.attempt_count, row.note_id, row.last_error_code, row.generation, row.created_at, row.updated_at, row.processed_at);
+    });
+  }
+  for (const row of rows.provenance) {
+    insertRow("note_provenance", row.id, () => {
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.project_id, row.note_id, row.source_type, row.capture_event_id, row.source_session_id, row.source_message_id, row.source_ordinal, row.source_tool_call_id, row.redaction_version, row.extractor_version, row.confidence, row.created_at);
+    });
+  }
+  for (const row of rows.revisions) {
+    insertRow("note_revisions", row.note_id, () => {
+      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(row.project_id, row.note_id, row.revision, row.kind, row.title, row.summary, row.content, row.size_class, row.pinned, row.status, row.supersedes_id, row.subject_key, row.content_hash, row.provenance_id, row.created_at);
+    });
+  }
+  for (const row of rows.edges) {
+    insertRow("note_edges", row.id, () => {
+      db.query("INSERT INTO note_edges (id, project_id, source_id, target_id, predicate, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(row.id, row.project_id, row.source_id, row.target_id, row.predicate, row.created_at);
+    });
+  }
+  for (const row of rows.outbox) {
+    insertRow("index_outbox", String(row.id), () => {
+      db.query(`INSERT INTO index_outbox
+           (id, backend, operation_key, operation, project_id, note_id, revision,
+            content_hash, generation, lease_generation, fence, state, attempt_count,
+            available_at, lease_owner, lease_expires_at, heartbeat_at, last_error_code,
+            created_at, completed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.backend, row.operation_key, row.operation, row.project_id, row.note_id, row.revision, row.content_hash, row.generation, row.lease_generation, row.fence, row.state, row.attempt_count, row.available_at, row.lease_owner, row.lease_expires_at, row.heartbeat_at, row.last_error_code, row.created_at, row.completed_at);
+    });
+  }
+  rebuildFts(db);
+  db.query("INSERT INTO schema_state(version) VALUES (11)").run();
+  insertV11Identity(db);
+}
+function revisionKey(projectID, noteID, revision) {
+  return `${projectID.length}:${projectID}:${noteID.length}:${noteID}:${revision}`;
+}
+function noteKey(projectID, noteID) {
+  return `${projectID.length}:${projectID}:${noteID.length}:${noteID}`;
+}
+function requireTable(db, table) {
+  if (!hasTable2(db, table))
+    fail(table, "schema", "source_schema");
+}
+function hasTable2(db, table) {
+  const row = db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE type IN ('table','view') AND name = ?").get(table);
+  return row.count > 0;
+}
+function selectRows(db, table, sql) {
+  try {
+    return db.query(sql).all();
+  } catch {
+    fail(table, "schema", "source_schema");
+  }
+}
+function insertRow(table, identity, insert) {
+  try {
+    insert();
+  } catch {
+    fail(table, identity, "row_constraint");
+  }
+}
+function requireString(value, table, identity, code) {
+  if (typeof value !== "string")
+    fail(table, identity, code);
+}
+function requireNonEmptyString(value, table, identity, code) {
+  requireString(value, table, identity, code);
+  if (value.length === 0)
+    fail(table, identity, code);
+}
+function requireNullableString(value, table, identity, code) {
+  if (value !== null && typeof value !== "string")
+    fail(table, identity, code);
+}
+function requireInteger(value, table, identity, code) {
+  if (!Number.isSafeInteger(value))
+    fail(table, identity, code);
+}
+function requireNullableInteger(value, table, identity, code) {
+  if (value !== null && !Number.isSafeInteger(value))
+    fail(table, identity, code);
+}
+function requireIntegerAtLeast(value, minimum, table, identity, code) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum) {
+    fail(table, identity, code);
+  }
+}
+function requireHash(value, table, identity, code) {
+  if (typeof value !== "string" || !/^[0-9a-f]{64}$/i.test(value))
+    fail(table, identity, code);
+}
+function requireKind(value, table, identity) {
+  if (typeof value !== "string" || !KINDS_SET.has(value))
+    fail(table, identity, "kind_invalid");
+}
+function requireSourceMessage(value, table, identity) {
+  if (typeof value !== "string" || !value)
+    fail(table, identity, "capture_identity_invalid");
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function legacyNoteContentHash(kind, title, summary, content) {
+  return createHash3("sha256").update(`${kind}\x00${title}\x00${summary}\x00${content}`, "utf8").digest("hex");
+}
+function sha256(value) {
+  return createHash3("sha256").update(value, "utf8").digest("hex");
+}
+function capturePayloadHash(event) {
+  const canonical = structuredClone(event);
+  canonical.source.observedAt = 0;
+  return hashTuple("capture-payload", 2, [JSON.stringify(canonical)]);
+}
+function fail(table, identity, code) {
+  const safeIdentity = typeof identity === "string" && /^[A-Za-z0-9._:-]{1,120}$/.test(identity) ? identity : "redacted";
+  throw new Error(`schema_v11_migration_${code} table=${table} row=${safeIdentity}`);
+}
+
+// src/db/legacy-health.ts
+var V2_TABLES = [
+  "memory_items",
+  "memory_versions",
+  "memory_identities",
+  "document_sources",
+  "document_chunks",
+  "memories",
+  "memory_links",
+  "memory_edges",
+  "memory_associations"
+];
+var PRE_V8_OBJECTS = new Set([
+  "index:note_edges_source_idx",
+  "index:note_edges_target_idx",
+  "index:notes_project_idx",
+  "table:note_edges",
+  "table:notes",
+  "table:notes_fts",
+  "table:notes_fts_config",
+  "table:notes_fts_content",
+  "table:notes_fts_data",
+  "table:notes_fts_docsize",
+  "table:notes_fts_idx",
+  "table:projects",
+  "table:schema_state",
+  ...V2_TABLES.map((table) => `table:${table}`)
+]);
+var PRE_V8_COLUMNS = {
+  schema_state: ["version"],
+  projects: ["id", "name", "normalized_name", "created_at", "updated_at"],
+  notes: [
+    "id",
+    "project_id",
+    "kind",
+    "title",
+    "summary",
+    "content",
+    "size_class",
+    "status",
+    "supersedes_id",
+    "created_at",
+    "updated_at"
+  ],
+  note_edges: ["id", "project_id", "source_id", "target_id", "predicate", "created_at"],
+  notes_fts: ["id", "title", "summary", "content"]
+};
+var V2_COLUMNS = {
+  memory_items: [
+    "id",
+    "identity_id",
+    "subject_key",
+    "kind",
+    "lifecycle_state",
+    "current_version_id",
+    "created_at",
+    "updated_at"
+  ],
+  memory_versions: ["id", "summary", "content"],
+  memory_identities: ["id", "project_id"]
+};
+var V8_OBJECTS = new Set([
+  "table:note_edges",
+  "table:notes",
+  "table:notes_fts",
+  "table:notes_fts_config",
+  "table:notes_fts_content",
+  "table:notes_fts_data",
+  "table:notes_fts_docsize",
+  "table:notes_fts_idx",
+  "table:projects",
+  "table:schema_state"
+]);
+var V9_V10_OBJECTS = new Set([
+  "index:capture_checkpoints_due_idx",
+  "index:capture_events_note_idx",
+  "index:capture_events_session_idx",
+  "index:capture_events_state_idx",
+  "index:index_outbox_due_idx",
+  "index:note_edges_source_idx",
+  "index:note_edges_target_idx",
+  "index:notes_active_subject_idx",
+  "index:notes_project_idx",
+  "table:capture_checkpoints",
+  "table:capture_events",
+  "table:index_outbox",
+  "table:note_edges",
+  "table:note_provenance",
+  "table:note_revisions",
+  "table:notes",
+  "table:notes_fts",
+  "table:notes_fts_config",
+  "table:notes_fts_data",
+  "table:notes_fts_docsize",
+  "table:notes_fts_idx",
+  "table:project_bindings",
+  "table:projects",
+  "table:schema_state",
+  "trigger:notes_fts_ad",
+  "trigger:notes_fts_ai",
+  "trigger:notes_fts_au"
+]);
+var V9_V10_COLUMNS = {
+  schema_state: ["version"],
+  projects: ["id", "name", "normalized_name", "created_at", "updated_at"],
+  notes: [
+    "id",
+    "project_id",
+    "kind",
+    "title",
+    "summary",
+    "content",
+    "size_class",
+    "pinned",
+    "status",
+    "supersedes_id",
+    "current_revision",
+    "subject_key",
+    "content_hash",
+    "created_at",
+    "updated_at"
+  ],
+  note_edges: ["id", "project_id", "source_id", "target_id", "predicate", "created_at"],
+  project_bindings: [
+    "binding_key",
+    "project_id",
+    "source",
+    "source_project_id",
+    "workspace_id",
+    "canonical_path_hash",
+    "created_at",
+    "updated_at"
+  ],
+  capture_checkpoints: [
+    "session_id",
+    "binding_key",
+    "project_id",
+    "state",
+    "last_message_id",
+    "last_reconciled_at",
+    "next_reconcile_at",
+    "failure_count",
+    "lease_owner",
+    "lease_expires_at",
+    "created_at",
+    "updated_at"
+  ],
+  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",
+    "note_id",
+    "last_error_code",
+    "generation",
+    "created_at",
+    "updated_at",
+    "processed_at"
+  ],
+  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"
+  ],
+  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"
+  ],
+  index_outbox: [
+    "id",
+    "backend",
+    "operation",
+    "project_id",
+    "note_id",
+    "revision",
+    "content_hash",
+    "state",
+    "attempt_count",
+    "available_at",
+    "lease_owner",
+    "lease_expires_at",
+    "last_error_code",
+    "created_at",
+    "completed_at"
+  ]
+};
+function assertLegacySchemaIdentity(db, version) {
+  if (version < 2 || version > 10)
+    throw new Error("unrecognized_database");
+  const applicationID = db.query("PRAGMA application_id").get().application_id;
+  if (applicationID !== 0 || tableExists(db, "agz_meta"))
+    throw new Error("unrecognized_database");
+  if (version === 2 && tableExists(db, "memory_items")) {
+    assertV2Identity(db);
+    assertHealthyDatabase(db);
+    return;
+  }
+  if (version < 8) {
+    assertPreV8Identity(db, version);
+    assertHealthyDatabase(db);
+    return;
+  }
+  const states = db.query("SELECT version FROM schema_state").all();
+  if (states.length !== 1 || states[0]?.version !== version)
+    throw new Error("unrecognized_database");
+  const rows = db.query("SELECT type, name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").all();
+  const actual = new Set(rows.map((row) => `${row.type}:${row.name}`));
+  const allowed = version === 8 ? V8_OBJECTS : V9_V10_OBJECTS;
+  const required = version === 8 ? V8_OBJECTS : new Set([...V9_V10_OBJECTS].filter((name) => !name.startsWith("index:capture_events_")));
+  if (actual.size > allowed.size || [...actual].some((name) => !allowed.has(name)) || [...required].some((name) => !actual.has(name))) {
+    throw new Error("unrecognized_database");
+  }
+  const columns = version === 8 ? {
+    projects: V9_V10_COLUMNS.projects,
+    notes: V9_V10_COLUMNS.notes.filter((name) => !["current_revision", "subject_key", "content_hash"].includes(name)),
+    note_edges: V9_V10_COLUMNS.note_edges,
+    schema_state: V9_V10_COLUMNS.schema_state
+  } : V9_V10_COLUMNS;
+  for (const [table, expected] of Object.entries(columns)) {
+    const actualColumns = db.query(`PRAGMA table_info(${table})`).all().map((row) => row.name);
+    if (JSON.stringify(actualColumns) !== JSON.stringify(expected)) {
+      throw new Error("unrecognized_database");
+    }
+  }
+  assertHealthyDatabase(db);
+  if (version === 10)
+    assertV10SourceDatabase(db);
+}
+function assertV2Identity(db) {
+  const rows = db.query("SELECT type, name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").all();
+  const allowed = new Set(V2_TABLES.map((table) => `table:${table}`));
+  const actual = new Set(rows.map((row) => `${row.type}:${row.name}`));
+  if ([...actual].some((name) => !allowed.has(name)))
+    throw new Error("unrecognized_database");
+  for (const [table, expected] of Object.entries(V2_COLUMNS)) {
+    assertColumns(db, table, expected);
+  }
 }
-function normalizeProjectName(value) {
-  return cleanProjectName(value).normalize("NFKC").toLowerCase();
+function assertPreV8Identity(db, version) {
+  const rows = db.query("SELECT type, name FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").all();
+  const actual = new Set(rows.map((row) => `${row.type}:${row.name}`));
+  const required = ["table:notes", "table:note_edges", "table:schema_state"];
+  if ([...actual].some((name) => !PRE_V8_OBJECTS.has(name)) || required.some((name) => !actual.has(name)) || version === 7 && !actual.has("table:projects")) {
+    throw new Error("unrecognized_database");
+  }
+  const states = db.query("SELECT version FROM schema_state").all();
+  if (states.length !== 1 || states[0]?.version !== version)
+    throw new Error("unrecognized_database");
+  const noteColumns = columns(db, "notes");
+  const expectedNotes = [...PRE_V8_COLUMNS.notes];
+  const expectedPinnedNotes = [...expectedNotes.slice(0, 7), "pinned", ...expectedNotes.slice(7)];
+  if (JSON.stringify(noteColumns) !== JSON.stringify(expectedNotes) && JSON.stringify(noteColumns) !== JSON.stringify(expectedPinnedNotes)) {
+    throw new Error("unrecognized_database");
+  }
+  assertColumns(db, "note_edges", PRE_V8_COLUMNS.note_edges);
+  assertColumns(db, "schema_state", PRE_V8_COLUMNS.schema_state);
+  if (tableExists(db, "projects"))
+    assertColumns(db, "projects", PRE_V8_COLUMNS.projects);
+  if (tableExists(db, "notes_fts"))
+    assertColumns(db, "notes_fts", PRE_V8_COLUMNS.notes_fts);
+}
+function assertColumns(db, table, expected) {
+  if (JSON.stringify(columns(db, table)) !== JSON.stringify(expected)) {
+    throw new Error("unrecognized_database");
+  }
+}
+function columns(db, table) {
+  return db.query(`PRAGMA table_info(${table})`).all().map((row) => row.name);
+}
+function tableExists(db, table) {
+  return db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?").get(table).count > 0;
 }
 
-// src/types.ts
-var SCHEMA_VERSION = 10;
-var KINDS = ["decision", "fact", "procedure", "context", "research", "preference", "task"];
-var PREDICATES = ["SUPPORTS", "DERIVED_FROM", "PART_OF", "ABOUT", "PRECEDES", "SUPERSEDES"];
-
-// src/db/backup.ts
-import { createHash as createHash2, randomUUID } from "crypto";
-import { Database } from "bun:sqlite";
+// src/db/maintenance.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import {
   chmodSync,
   closeSync,
-  copyFileSync,
+  constants,
   existsSync,
   fsyncSync,
   lstatSync,
   mkdirSync,
   openSync,
   readFileSync,
+  readdirSync,
   renameSync,
-  rmSync,
+  rmdirSync,
+  unlinkSync,
   writeFileSync
 } from "fs";
-import { basename, dirname, join as join2, resolve } from "path";
-
-// src/db/health.ts
-function inspectDatabase(db) {
-  const integrity = db.query("PRAGMA integrity_check").get().integrity_check;
-  const foreignKeyViolations = db.query("PRAGMA foreign_key_check").all();
-  const schemaVersion = hasTable(db, "schema_state") ? db.query("SELECT MAX(version) AS version FROM schema_state").get().version ?? undefined : undefined;
-  const counts = {};
-  for (const table of [
-    "projects",
-    "notes",
-    "note_edges",
-    "notes_fts",
-    "project_bindings",
-    "capture_events",
-    "capture_checkpoints",
-    "note_provenance",
-    "note_revisions",
-    "index_outbox"
-  ]) {
-    if (!hasTable(db, table))
+import { hostname, platform } from "os";
+import { basename, dirname, join as join2, parse, resolve } from "path";
+function acquireDatabaseLease(databasePath) {
+  const canonicalPath = canonicalDatabasePath(databasePath);
+  const gatePath = maintenanceGatePath(canonicalPath);
+  const leaseDirectory = databaseLeaseDirectory(canonicalPath);
+  assertNoSymbolicLinks(dirname(canonicalPath));
+  assertNoSymbolicLinks(canonicalPath, true);
+  assertProtocolPath(gatePath, "maintenance gate", true);
+  if (existsSync(gatePath))
+    throw new Error("maintenance_gate_active");
+  ensurePrivateDirectory(leaseDirectory, "database lease registry");
+  const owner = ownerRecord();
+  const temporaryPath = join2(leaseDirectory, `.${owner.ownerID}.tmp`);
+  const leasePath = join2(leaseDirectory, `${owner.ownerID}.json`);
+  try {
+    writeExclusiveRecord(temporaryPath, owner);
+    renameSync(temporaryPath, leasePath);
+    fsyncPath(leaseDirectory);
+    assertProtocolPath(gatePath, "maintenance gate", true);
+    if (existsSync(gatePath)) {
+      removeOwnedRecord(leasePath, owner.ownerID);
+      throw new Error("maintenance_gate_active");
+    }
+  } catch (error) {
+    removeFreshRecord(temporaryPath);
+    removeOwnedRecord(leasePath, owner.ownerID);
+    throw error;
+  }
+  let released = false;
+  return {
+    databasePath: canonicalPath,
+    release: () => {
+      if (released)
+        return;
+      removeOwnedRecord(leasePath, owner.ownerID);
+      released = true;
+    }
+  };
+}
+function acquireMaintenanceGate(databasePath, recovery) {
+  const canonicalPath = canonicalDatabasePath(databasePath);
+  const gatePath = maintenanceGatePath(canonicalPath);
+  const leaseDirectory = databaseLeaseDirectory(canonicalPath);
+  assertNoSymbolicLinks(dirname(canonicalPath));
+  assertNoSymbolicLinks(canonicalPath, true);
+  assertProtocolPath(gatePath, "maintenance gate", true);
+  assertProtocolPath(leaseDirectory, "database lease registry", true);
+  const owner = ownerRecord();
+  let created = false;
+  let gateStat;
+  try {
+    mkdirSync(gatePath, { mode: 448 });
+    created = true;
+    gateStat = lstatSync(gatePath);
+  } catch (error) {
+    if (!isAlreadyExists(error))
+      throw error;
+    gateStat = claimStaleGate(gatePath, owner, recovery);
+  }
+  const ownerPath = join2(gatePath, "owner.json");
+  try {
+    if (created) {
+      writeExclusiveRecord(ownerPath, owner);
+      fsyncPath(gatePath);
+    }
+    rejectActiveLeases(leaseDirectory);
+  } catch (error) {
+    removeFreshGate(gatePath, owner.ownerID, gateStat.dev, gateStat.ino);
+    throw error;
+  }
+  let released = false;
+  let retained = false;
+  const assertOwned = () => {
+    if (released)
+      throw new Error("maintenance_gate_not_owned");
+    const record = readOwnerRecord(ownerPath, "maintenance gate owner");
+    if (record.ownerID !== owner.ownerID)
+      throw new Error("maintenance_gate_not_owned");
+  };
+  return {
+    databasePath: canonicalPath,
+    assertOwned,
+    retain: () => {
+      assertOwned();
+      replaceOwnerRecord(ownerPath, owner.ownerID, {
+        ...owner,
+        state: "recovery-required"
+      });
+      retained = true;
+    },
+    release: () => {
+      if (released || retained)
+        return;
+      assertOwned();
+      removeOwnedGate(gatePath, owner.ownerID);
+      released = true;
+    }
+  };
+}
+function recoverStaleMaintenanceGate(databasePath, validate) {
+  const canonicalPath = canonicalDatabasePath(databasePath);
+  if (!existsSync(maintenanceGatePath(canonicalPath)))
+    return false;
+  const gate = acquireMaintenanceGate(canonicalPath);
+  try {
+    validate();
+  } catch (error) {
+    gate.retain();
+    throw error;
+  } finally {
+    gate.release();
+  }
+  return true;
+}
+function assertMaintenanceGateFor(gate, databasePath) {
+  if (gate.databasePath !== canonicalDatabasePath(databasePath)) {
+    throw new Error("maintenance_gate_target_mismatch");
+  }
+  gate.assertOwned();
+}
+function canonicalDatabasePath(path) {
+  const absolute = resolve(path);
+  const parent = dirname(absolute);
+  assertNoSymbolicLinks(parent);
+  return join2(resolve(parent), basename(absolute));
+}
+function ensureDatabaseParent(path) {
+  const parent = dirname(resolve(path));
+  assertNoSymbolicLinks(parent);
+  const existed = existsSync(parent);
+  mkdirSync(parent, { recursive: true, mode: 448 });
+  assertNoSymbolicLinks(parent);
+  if (!existed)
+    chmodSync(parent, 448);
+  const stat = lstatSync(parent);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error("database parent must be a directory");
+  }
+  if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new Error("database parent must be owned by the current user");
+  }
+  if (platform() !== "win32" && (stat.mode & 18) !== 0) {
+    throw new Error("database parent must not be group or world writable");
+  }
+}
+function assertNoSymbolicLinks(path, allowMissingLeaf = false) {
+  const absolute = resolve(path);
+  const root = parse(absolute).root;
+  const parts = absolute.slice(root.length).split(/[\\/]+/).filter(Boolean);
+  let current = root;
+  for (let index = 0;index < parts.length; index++) {
+    current = join2(current, parts[index]);
+    try {
+      const stat = lstatSync(current);
+      if (stat.isSymbolicLink())
+        throw new Error(`symbolic links are not allowed: ${current}`);
+    } catch (error) {
+      if (isMissing(error) && (allowMissingLeaf ? index === parts.length - 1 : true))
+        return;
+      throw error;
+    }
+  }
+}
+function maintenanceGatePath(databasePath) {
+  return `${databasePath}.maintenance`;
+}
+function databaseLeaseDirectory(databasePath) {
+  return `${databasePath}.leases`;
+}
+function ensurePrivateDirectory(path, label) {
+  assertProtocolPath(path, label, true);
+  if (!existsSync(path)) {
+    try {
+      mkdirSync(path, { recursive: false, mode: 448 });
+    } catch (error) {
+      if (!isAlreadyExists(error))
+        throw error;
+    }
+  }
+  const stat = lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error(`${label} must be a directory`);
+  if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new Error(`${label} must be owned by the current user`);
+  }
+  chmodSync(path, 448);
+}
+function assertProtocolPath(path, label, allowMissing) {
+  assertNoSymbolicLinks(path, allowMissing);
+  if (!existsSync(path))
+    return;
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink())
+    throw new Error(`${label} must not be a symbolic link`);
+}
+function writeExclusiveRecord(path, owner) {
+  writeFileSync(path, `${JSON.stringify(owner)}
+`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  fsyncPath(path);
+}
+function rejectActiveLeases(leaseDirectory) {
+  if (!existsSync(leaseDirectory))
+    return;
+  const directoryStat = lstatSync(leaseDirectory);
+  if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) {
+    throw new Error("database lease registry must be a directory");
+  }
+  for (const entry of readdirSync(leaseDirectory)) {
+    if (!entry.endsWith(".json"))
       continue;
-    counts[table] = db.query(`SELECT COUNT(*) AS count FROM ${table}`).get().count;
+    const leasePath = join2(leaseDirectory, entry);
+    const before = lstatSync(leasePath);
+    if (!before.isFile() || before.isSymbolicLink())
+      throw new Error("database lease must be a regular file");
+    const lease = readOwnerRecord(leasePath, "database lease");
+    if (ownerIsActive(lease))
+      throw new Error("active_database_handles");
+    const after = lstatSync(leasePath);
+    if (before.dev !== after.dev || before.ino !== after.ino) {
+      throw new Error("database lease changed during stale-owner verification");
+    }
+    unlinkSync(leasePath);
   }
-  return { integrity, foreignKeyViolations, schemaVersion, counts };
+  fsyncPath(leaseDirectory);
 }
-function assertHealthyDatabase(db) {
-  const health = inspectDatabase(db);
-  if (health.integrity !== "ok") {
-    throw new Error(`database integrity check failed: ${health.integrity}`);
+function ownerStatus(owner) {
+  if (owner.state === "recovery-required")
+    return "recovery-required";
+  if (owner.hostname !== hostname())
+    return "unverifiable";
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ESRCH") {
+      return "stale";
+    }
+    return "unverifiable";
   }
-  if (health.foreignKeyViolations.length > 0) {
-    throw new Error(`database foreign key check failed: ${health.foreignKeyViolations.length} violation(s)`);
+  const currentStart = processStartMarker(owner.pid);
+  if (owner.processStart === null || currentStart === null)
+    return "unverifiable";
+  return owner.processStart === currentStart ? "active" : "stale";
+}
+function ownerIsActive(owner) {
+  return ownerStatus(owner) !== "stale";
+}
+function ownerRecord() {
+  return {
+    ownerID: randomUUID2(),
+    pid: process.pid,
+    processStart: processStartMarker(process.pid),
+    hostname: hostname(),
+    createdAt: Date.now(),
+    state: "active"
+  };
+}
+function processStartMarker(pid) {
+  if (platform() !== "linux")
+    return null;
+  try {
+    const value = readFileSync(`/proc/${pid}/stat`, "utf8");
+    const close = value.lastIndexOf(")");
+    const fields = value.slice(close + 1).trim().split(/\s+/);
+    const startTime = fields[19];
+    return startTime ? `linux:${startTime}` : null;
+  } catch {
+    return null;
   }
-  return health;
 }
-function hasTable(db, table) {
-  const row = db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE type IN ('table','view') AND name = ?").get(table);
-  return row.count > 0;
+function readOwnerRecord(path, label) {
+  const stat = lstatSync(path);
+  if (!stat.isFile() || stat.isSymbolicLink())
+    throw new Error(`${label} must be a regular file`);
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (typeof parsed.ownerID !== "string" || !parsed.ownerID || !Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || parsed.processStart !== null && (typeof parsed.processStart !== "string" || !parsed.processStart) || typeof parsed.hostname !== "string" || !parsed.hostname || !Number.isSafeInteger(parsed.createdAt) || parsed.createdAt < 0 || parsed.state !== undefined && parsed.state !== "active" && parsed.state !== "recovery-required") {
+    throw new Error(`${label} is invalid`);
+  }
+  return { ...parsed, state: parsed.state ?? "active" };
+}
+function claimStaleGate(gatePath, owner, recovery) {
+  const gate = lstatSync(gatePath);
+  if (!gate.isDirectory() || gate.isSymbolicLink()) {
+    throw new Error("maintenance gate must be a directory");
+  }
+  const ownerPath = join2(gatePath, "owner.json");
+  const claimPath = join2(gatePath, "takeover.json");
+  acquireTakeoverClaim(claimPath, owner);
+  try {
+    const before = lstatSync(ownerPath);
+    const previous = readOwnerRecord(ownerPath, "maintenance gate owner");
+    const status = ownerStatus(previous);
+    if (status === "active")
+      throw new Error("maintenance_gate_active");
+    if (status === "unverifiable")
+      throw new Error("maintenance_gate_unverifiable");
+    if (status === "recovery-required") {
+      if (recovery?.ownerID !== previous.ownerID || recovery.confirmation !== "RECOVER_RETAINED_MAINTENANCE_GATE") {
+        throw new Error("maintenance_gate_recovery_required");
+      }
+    }
+    const currentGate = lstatSync(gatePath);
+    const currentOwner = lstatSync(ownerPath);
+    if (currentGate.dev !== gate.dev || currentGate.ino !== gate.ino || currentOwner.dev !== before.dev || currentOwner.ino !== before.ino || readOwnerRecord(ownerPath, "maintenance gate owner").ownerID !== previous.ownerID) {
+      throw new Error("maintenance gate changed during stale-owner verification");
+    }
+    renameSync(claimPath, ownerPath);
+    fsyncPath(gatePath);
+    return { dev: gate.dev, ino: gate.ino };
+  } catch (error) {
+    removeOwnedRecord(claimPath, owner.ownerID);
+    throw error;
+  }
+}
+function acquireTakeoverClaim(path, owner) {
+  for (let attempt = 0;attempt < 2; attempt++) {
+    try {
+      writeExclusiveRecord(path, owner);
+      return;
+    } catch (error) {
+      if (!isAlreadyExists(error))
+        throw error;
+      const before = lstatSync(path);
+      const existing = readOwnerRecord(path, "maintenance takeover owner");
+      const status = ownerStatus(existing);
+      if (status === "active")
+        throw new Error("maintenance_gate_active");
+      if (status !== "stale")
+        throw new Error("maintenance_gate_unverifiable");
+      const after = lstatSync(path);
+      if (before.dev !== after.dev || before.ino !== after.ino) {
+        throw new Error("maintenance takeover changed during stale-owner verification");
+      }
+      unlinkSync(path);
+      fsyncPath(dirname(path));
+    }
+  }
+  throw new Error("maintenance_gate_active");
+}
+function replaceOwnerRecord(ownerPath, ownerID, replacement) {
+  const temporary = `${ownerPath}.${ownerID}.tmp`;
+  try {
+    writeExclusiveRecord(temporary, replacement);
+    if (readOwnerRecord(ownerPath, "maintenance gate owner").ownerID !== ownerID) {
+      throw new Error("maintenance_gate_not_owned");
+    }
+    renameSync(temporary, ownerPath);
+    fsyncPath(dirname(ownerPath));
+  } catch (error) {
+    removeFreshRecord(temporary);
+    throw error;
+  }
+}
+function removeOwnedRecord(path, ownerID) {
+  try {
+    if (readOwnerRecord(path, "owner record").ownerID !== ownerID)
+      return;
+    unlinkSync(path);
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+function removeOwnedGate(gatePath, ownerID) {
+  const ownerPath = join2(gatePath, "owner.json");
+  try {
+    if (readOwnerRecord(ownerPath, "maintenance gate owner").ownerID !== ownerID)
+      return;
+    unlinkSync(ownerPath);
+    rmdirSync(gatePath);
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+function removeFreshRecord(path) {
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      return;
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid())
+      return;
+    unlinkSync(path);
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+function removeFreshGate(gatePath, ownerID, device, inode) {
+  try {
+    const gate = lstatSync(gatePath);
+    if (!gate.isDirectory() || gate.isSymbolicLink() || gate.dev !== device || gate.ino !== inode)
+      return;
+    const ownerPath = join2(gatePath, "owner.json");
+    try {
+      const record = readOwnerRecord(ownerPath, "maintenance gate owner");
+      if (record.ownerID !== ownerID)
+        return;
+      unlinkSync(ownerPath);
+    } catch (error) {
+      if (!isMissing(error))
+        removeFreshRecord(ownerPath);
+    }
+    rmdirSync(gatePath);
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+function fsyncPath(path) {
+  const stat = lstatSync(path);
+  if (platform() === "win32" && stat.isDirectory())
+    return;
+  const descriptor = openSync(path, platform() === "win32" ? constants.O_RDWR : constants.O_RDONLY);
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function isMissing(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+function isAlreadyExists(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
 }
 
 // src/db/backup.ts
 var BACKUP_FORMAT = "agz-memory-backup/1";
 function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, productVersion) {
   const sourceHealth = assertHealthyDatabase(db);
+  try {
+    assertManifestSourceSchema(db, sourceHealth.schemaVersion, sourceSchema);
+  } catch {
+    throw new Error(`backup source schema v${sourceSchema} does not match database schema v${sourceHealth.schemaVersion ?? "unknown"}`);
+  }
   const checkpoint = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
   if (checkpoint.busy !== 0)
     throw new Error("database WAL checkpoint is busy");
   const backupDirectory = `${databasePath}.backup`;
-  mkdirSync(backupDirectory, { recursive: true, mode: 448 });
-  chmodSync(backupDirectory, 448);
+  assertNoSymbolicLinks(databasePath);
+  assertNoSymbolicLinks(backupDirectory, true);
+  mkdirSync2(backupDirectory, { recursive: true, mode: 448 });
+  const backupRootStat = lstatSync2(backupDirectory);
+  if (!backupRootStat.isDirectory() || backupRootStat.isSymbolicLink()) {
+    throw new Error("backup root must be a directory and not a symbolic link");
+  }
+  chmodSync2(backupDirectory, 448);
   const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const stem = `schema-v${sourceSchema}-${stamp}-${randomUUID()}`;
-  const finalDatabasePath = join2(backupDirectory, `${stem}.sqlite`);
-  const finalManifestPath = join2(backupDirectory, `${stem}.manifest.json`);
+  const stem = `schema-v${sourceSchema}-${stamp}-${randomUUID3()}`;
+  const finalDatabasePath = join3(backupDirectory, `${stem}.sqlite`);
+  const finalManifestPath = join3(backupDirectory, `${stem}.manifest.json`);
   const temporaryDatabasePath = `${finalDatabasePath}.tmp`;
   const temporaryManifestPath = `${finalManifestPath}.tmp`;
   try {
     db.exec(`VACUUM INTO '${escapeSql(temporaryDatabasePath)}'`);
-    chmodSync(temporaryDatabasePath, 384);
-    const verification = new Database(temporaryDatabasePath, { readonly: true });
+    chmodSync2(temporaryDatabasePath, 384);
+    const verification = new Database2(temporaryDatabasePath, { readonly: true });
     let backupHealth;
     let sqliteVersion;
     try {
       backupHealth = assertHealthyDatabase(verification);
+      assertManifestSourceSchema(verification, backupHealth.schemaVersion, sourceSchema);
       sqliteVersion = verification.query("SELECT sqlite_version() AS version").get().version;
     } finally {
       verification.close();
@@ -134,7 +2759,7 @@ 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");
     }
-    const bytes = readFileSync(temporaryDatabasePath);
+    const digest = hashRegularFile(temporaryDatabasePath);
     const manifest = {
       format: BACKUP_FORMAT,
       productVersion,
@@ -142,22 +2767,22 @@ function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, prod
       targetSchema,
       createdAt: new Date().toISOString(),
       sqliteVersion,
-      databaseFile: basename(finalDatabasePath),
-      sha256: createHash2("sha256").update(bytes).digest("hex"),
-      size: bytes.byteLength,
+      databaseFile: basename2(finalDatabasePath),
+      sha256: digest.sha256,
+      size: digest.size,
       counts: backupHealth.counts,
       integrity: "ok",
       foreignKeyViolations: 0
     };
-    writeFileSync(temporaryManifestPath, `${JSON.stringify(manifest, null, 2)}
+    writeFileSync2(temporaryManifestPath, `${JSON.stringify(manifest, null, 2)}
 `, {
       mode: 384
     });
-    fsyncPath(temporaryDatabasePath);
-    fsyncPath(temporaryManifestPath);
-    renameSync(temporaryDatabasePath, finalDatabasePath);
-    renameSync(temporaryManifestPath, finalManifestPath);
-    fsyncPath(backupDirectory);
+    fsyncPath2(temporaryDatabasePath);
+    fsyncPath2(temporaryManifestPath);
+    renameSync2(temporaryDatabasePath, finalDatabasePath);
+    renameSync2(temporaryManifestPath, finalManifestPath);
+    fsyncPath2(backupDirectory);
     return { databasePath: finalDatabasePath, manifestPath: finalManifestPath, manifest };
   } catch (error) {
     rmSync(temporaryDatabasePath, { force: true });
@@ -166,16 +2791,20 @@ function createVerifiedBackup(db, databasePath, sourceSchema, targetSchema, prod
   }
 }
 function verifyBackupManifest(manifestPath) {
-  const resolvedManifestPath = resolve(manifestPath);
-  const manifestStat = lstatSync(resolvedManifestPath);
+  assertNoSymbolicLinks(manifestPath);
+  const resolvedManifestPath = resolve2(manifestPath);
+  const manifestStat = lstatSync2(resolvedManifestPath);
   if (!manifestStat.isFile() || manifestStat.isSymbolicLink()) {
     throw new Error("backup manifest must be a regular file");
   }
-  const manifest = JSON.parse(readFileSync(resolvedManifestPath, "utf8"));
+  const manifest = JSON.parse(readFileSync2(resolvedManifestPath, "utf8"));
   if (manifest.format !== BACKUP_FORMAT) {
     throw new Error("unsupported backup manifest format");
   }
-  if (typeof manifest.databaseFile !== "string" || !manifest.databaseFile || basename(manifest.databaseFile) !== manifest.databaseFile) {
+  if (!Number.isSafeInteger(manifest.sourceSchema) || manifest.sourceSchema < 2 || manifest.sourceSchema > 11) {
+    throw new Error("backup manifest source schema is invalid");
+  }
+  if (typeof manifest.databaseFile !== "string" || !manifest.databaseFile || basename2(manifest.databaseFile) !== manifest.databaseFile) {
     throw new Error("backup databaseFile must be a basename");
   }
   if (typeof manifest.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(manifest.sha256)) {
@@ -184,82 +2813,91 @@ function verifyBackupManifest(manifestPath) {
   if (!Number.isSafeInteger(manifest.size) || manifest.size < 0) {
     throw new Error("backup manifest size is invalid");
   }
-  const manifestDirectory = dirname(resolvedManifestPath);
-  const databasePath = resolve(manifestDirectory, manifest.databaseFile);
-  if (dirname(databasePath) !== manifestDirectory) {
+  const manifestDirectory = dirname2(resolvedManifestPath);
+  const databasePath = resolve2(manifestDirectory, manifest.databaseFile);
+  if (dirname2(databasePath) !== manifestDirectory) {
     throw new Error("backup database file must stay inside the manifest directory");
   }
-  if (!existsSync(databasePath))
+  if (!existsSync2(databasePath))
     throw new Error("backup database file is missing");
-  const databaseStat = lstatSync(databasePath);
+  const databaseStat = lstatSync2(databasePath);
   if (!databaseStat.isFile() || databaseStat.isSymbolicLink()) {
     throw new Error("backup database must be a regular file");
   }
-  const bytes = readFileSync(databasePath);
-  const hash = createHash2("sha256").update(bytes).digest("hex");
-  if (hash !== manifest.sha256 || databaseStat.size !== manifest.size) {
+  const digest = hashRegularFile(databasePath);
+  if (digest.sha256 !== manifest.sha256 || digest.size !== manifest.size || databaseStat.size !== manifest.size) {
     throw new Error("backup hash or size mismatch");
   }
-  const db = new Database(databasePath, { readonly: true });
+  const db = new Database2(databasePath, { readonly: true });
   try {
     const health = assertHealthyDatabase(db);
     if (JSON.stringify(health.counts) !== JSON.stringify(manifest.counts)) {
       throw new Error("backup manifest row counts do not match");
     }
+    assertManifestSourceSchema(db, health.schemaVersion, manifest.sourceSchema);
   } finally {
     db.close();
   }
   return { databasePath, manifestPath: resolvedManifestPath, manifest };
 }
-function restoreVerifiedBackup(manifestPath, targetPath, confirmation) {
+function restoreVerifiedBackup(manifestPath, targetPath, confirmation, existingGate, expectedSha256) {
   if (confirmation !== "RESTORE_DATABASE_FROM_VERIFIED_BACKUP") {
     throw new Error("invalid restore confirmation");
   }
+  ensureDatabaseParent(targetPath);
+  const gate = existingGate ?? acquireMaintenanceGate(targetPath);
+  const releaseGate = existingGate === undefined;
+  try {
+    return restoreUnderGate(manifestPath, targetPath, gate, expectedSha256);
+  } finally {
+    if (releaseGate)
+      gate.release();
+  }
+}
+function restoreUnderGate(manifestPath, targetPath, gate, expectedSha256) {
+  assertMaintenanceGateFor(gate, targetPath);
   const verified = verifyBackupManifest(manifestPath);
-  mkdirSync(dirname(targetPath), { recursive: true, mode: 448 });
-  const temporary = `${targetPath}.restore-${randomUUID()}.tmp`;
-  const preserved = `${targetPath}.failed-restore-source-${Date.now()}-${randomUUID()}`;
+  if (expectedSha256 !== undefined && verified.manifest.sha256 !== expectedSha256) {
+    throw new Error("restore manifest hash mismatch");
+  }
+  mkdirSync2(dirname2(targetPath), { recursive: true, mode: 448 });
+  const temporary = `${targetPath}.restore-${randomUUID3()}.tmp`;
+  const preserved = `${targetPath}.failed-restore-source-${Date.now()}-${randomUUID3()}`;
   const movedSidecars = [];
   let hasPreservedSource = false;
   let preservedSourceHealthy = false;
   let targetInstalled = false;
   try {
-    copyFileSync(verified.databasePath, temporary);
-    chmodSync(temporary, 384);
-    fsyncPath(temporary);
-    if (existsSync(targetPath)) {
+    copyVerifiedSource(verified, temporary);
+    if (existsSync2(targetPath)) {
       preservedSourceHealthy = checkpointSource(targetPath);
-      copyFileSync(targetPath, preserved);
-      chmodSync(preserved, 384);
-      fsyncPath(preserved);
-      if (preservedSourceHealthy)
-        verifyDatabaseFile(preserved);
+      copyRegularFile(targetPath, preserved);
       for (const suffix of ["-wal", "-shm"]) {
         const source = `${targetPath}${suffix}`;
-        if (!existsSync(source))
+        if (!existsSync2(source))
           continue;
         const preservedSidecar = `${preserved}${suffix}`;
-        copyFileSync(source, preservedSidecar);
-        chmodSync(preservedSidecar, 384);
-        fsyncPath(preservedSidecar);
+        copyRegularFile(source, preservedSidecar);
       }
-      fsyncPath(dirname(targetPath));
+      if (preservedSourceHealthy)
+        verifyDatabaseFile(preserved);
+      fsyncPath2(dirname2(targetPath));
       hasPreservedSource = true;
     }
     for (const suffix of ["-wal", "-shm"]) {
       const source = `${targetPath}${suffix}`;
-      if (!existsSync(source))
+      if (!existsSync2(source))
         continue;
-      const quarantine = `${source}.quarantine-${randomUUID()}`;
-      renameSync(source, quarantine);
+      const quarantine = `${source}.quarantine-${randomUUID3()}`;
+      quarantineRegularFile(source, quarantine);
       movedSidecars.push({ source, quarantine });
     }
-    renameSync(temporary, targetPath);
+    renameSync2(temporary, targetPath);
     targetInstalled = true;
-    fsyncPath(dirname(targetPath));
-    verifyDatabaseFile(targetPath);
+    fsyncPath2(dirname2(targetPath));
+    verifyInstalledBackup(targetPath, verified.manifest);
     for (const { quarantine } of movedSidecars) {
-      rmSync(quarantine, { recursive: true, force: true });
+      unlinkRegularFile(quarantine);
     }
   } catch (error) {
     const rollbackErrors = [];
@@ -267,62 +2905,231 @@ function restoreVerifiedBackup(manifestPath, targetPath, confirmation) {
     if (targetInstalled) {
       try {
         for (const suffix of ["-wal", "-shm"]) {
-          rmSync(`${targetPath}${suffix}`, { recursive: true, force: true });
+          unlinkRegularFile(`${targetPath}${suffix}`, true);
         }
         if (hasPreservedSource) {
-          const rollback = `${targetPath}.rollback-${randomUUID()}.tmp`;
-          copyFileSync(preserved, rollback);
-          chmodSync(rollback, 384);
-          fsyncPath(rollback);
-          rmSync(targetPath, { force: true });
-          renameSync(rollback, targetPath);
+          const rollback = `${targetPath}.rollback-${randomUUID3()}.tmp`;
+          copyRegularFile(preserved, rollback);
+          unlinkRegularFile(targetPath);
+          renameSync2(rollback, targetPath);
         } else {
-          rmSync(targetPath, { force: true });
+          unlinkRegularFile(targetPath);
         }
       } catch (rollbackError) {
         rollbackErrors.push(rollbackError);
       }
     }
     for (const { source, quarantine } of movedSidecars.reverse()) {
-      if (!existsSync(quarantine))
+      if (!existsSync2(quarantine))
         continue;
       try {
-        rmSync(source, { recursive: true, force: true });
-        renameSync(quarantine, source);
+        if (existsSync2(source))
+          throw new Error("restore sidecar path was replaced during rollback");
+        renameSync2(quarantine, source);
       } catch (rollbackError) {
         rollbackErrors.push(rollbackError);
       }
     }
     if (targetInstalled && hasPreservedSource && preservedSourceHealthy && rollbackErrors.length === 0) {
       try {
-        fsyncPath(dirname(targetPath));
+        fsyncPath2(dirname2(targetPath));
         verifyDatabaseFile(targetPath);
       } catch (rollbackError) {
         rollbackErrors.push(rollbackError);
       }
     }
     if (rollbackErrors.length > 0) {
+      gate.retain();
       throw new AggregateError([error, ...rollbackErrors], "restore failed and rollback was incomplete");
     }
     throw error;
   }
-  return preserved;
+  return preserved;
+}
+function copyVerifiedSource(verified, target) {
+  assertNoSymbolicLinks(verified.databasePath);
+  const source = openSync2(verified.databasePath, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  let destination;
+  try {
+    const before = fstatSync(source);
+    if (!before.isFile())
+      throw new Error("backup database must be a regular file");
+    destination = openSync2(target, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+    const hash = createHash4("sha256");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let size = 0;
+    while (true) {
+      const read = readSync(source, buffer, 0, buffer.byteLength, null);
+      if (read === 0)
+        break;
+      hash.update(buffer.subarray(0, read));
+      let written = 0;
+      while (written < read) {
+        written += writeSync(destination, buffer, written, read - written);
+      }
+      size += read;
+    }
+    const after = fstatSync(source);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size) {
+      throw new Error("backup database changed while it was copied");
+    }
+    if (size !== verified.manifest.size || hash.digest("hex") !== verified.manifest.sha256) {
+      throw new Error("backup hash or size mismatch during restore copy");
+    }
+    fsyncSync2(destination);
+  } finally {
+    if (destination !== undefined)
+      closeSync2(destination);
+    closeSync2(source);
+  }
+  chmodSync2(target, 384);
+  verifyDatabaseMatchesManifest(target, verified.manifest);
+}
+function verifyDatabaseMatchesManifest(path, manifest) {
+  const db = new Database2(path, { readonly: true });
+  try {
+    const health = assertHealthyDatabase(db);
+    assertManifestSourceSchema(db, health.schemaVersion, manifest.sourceSchema);
+    if (JSON.stringify(health.counts) !== JSON.stringify(manifest.counts)) {
+      throw new Error("backup manifest row counts do not match");
+    }
+  } finally {
+    db.close();
+  }
+}
+function verifyInstalledBackup(path, manifest) {
+  const digest = hashRegularFile(path);
+  if (digest.size !== manifest.size) {
+    throw new Error("installed backup size does not match manifest");
+  }
+  if (digest.sha256 !== manifest.sha256) {
+    throw new Error("installed backup hash does not match manifest");
+  }
+  verifyDatabaseMatchesManifest(path, manifest);
+}
+function assertManifestSourceSchema(db, actualSchema, sourceSchema) {
+  if (!Number.isSafeInteger(sourceSchema) || sourceSchema < 2 || sourceSchema > 11) {
+    throw new Error("backup manifest source schema does not match database");
+  }
+  if (actualSchema === sourceSchema) {
+    if (sourceSchema >= 2 && sourceSchema <= 10) {
+      try {
+        assertLegacySchemaIdentity(db, sourceSchema);
+      } catch {
+        throw new Error("backup manifest source schema does not match database");
+      }
+    }
+    return;
+  }
+  if (sourceSchema === 2 && actualSchema === undefined && hasTable3(db, "memory_items")) {
+    try {
+      assertLegacySchemaIdentity(db, sourceSchema);
+      return;
+    } catch {
+      throw new Error("backup manifest source schema does not match database");
+    }
+  }
+  throw new Error("backup manifest source schema does not match database");
+}
+function hasTable3(db, table) {
+  return db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?").get(table).count > 0;
+}
+function hashRegularFile(path) {
+  const descriptor = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    const before = fstatSync(descriptor);
+    if (!before.isFile())
+      throw new Error(`${path} must be a regular file`);
+    const hash = createHash4("sha256");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let size = 0;
+    while (true) {
+      const read = readSync(descriptor, buffer, 0, buffer.byteLength, null);
+      if (read === 0)
+        break;
+      hash.update(buffer.subarray(0, read));
+      size += read;
+    }
+    const after = fstatSync(descriptor);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || size !== after.size) {
+      throw new Error(`${path} changed while it was hashed`);
+    }
+    return { sha256: hash.digest("hex"), size };
+  } finally {
+    closeSync2(descriptor);
+  }
+}
+function copyRegularFile(sourcePath, targetPath) {
+  assertNoSymbolicLinks(sourcePath);
+  const source = openSync2(sourcePath, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  let target;
+  try {
+    const before = fstatSync(source);
+    if (!before.isFile())
+      throw new Error(`${sourcePath} must be a regular file`);
+    target = openSync2(targetPath, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    while (true) {
+      const read = readSync(source, buffer, 0, buffer.byteLength, null);
+      if (read === 0)
+        break;
+      let written = 0;
+      while (written < read)
+        written += writeSync(target, buffer, written, read - written);
+    }
+    const after = fstatSync(source);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size) {
+      throw new Error(`${sourcePath} changed while it was copied`);
+    }
+    fsyncSync2(target);
+  } finally {
+    if (target !== undefined)
+      closeSync2(target);
+    closeSync2(source);
+  }
+}
+function quarantineRegularFile(source, quarantine) {
+  const before = lstatSync2(source);
+  if (!before.isFile() || before.isSymbolicLink()) {
+    throw new Error("database sidecar must be a regular file");
+  }
+  renameSync2(source, quarantine);
+  const after = lstatSync2(quarantine);
+  if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
+    throw new Error("database sidecar changed while it was quarantined");
+  }
+}
+function unlinkRegularFile(path, allowMissing = false) {
+  try {
+    const stat = lstatSync2(path);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      throw new Error(`${path} must be a regular file`);
+    rmSync(path);
+  } catch (error) {
+    if (allowMissing && error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
 }
 function escapeSql(value) {
   return value.replaceAll("'", "''");
 }
-function fsyncPath(path) {
-  const descriptor = openSync(path, "r");
+function fsyncPath2(path) {
+  const stat = lstatSync2(path);
+  if (platform2() === "win32" && stat.isDirectory())
+    return;
+  const descriptor = openSync2(path, platform2() === "win32" ? "r+" : "r");
   try {
-    fsyncSync(descriptor);
+    fsyncSync2(descriptor);
   } finally {
-    closeSync(descriptor);
+    closeSync2(descriptor);
   }
 }
 function checkpointSource(path) {
   let db;
   try {
-    db = new Database(path);
+    db = new Database2(path);
     const checkpoint = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
     if (checkpoint.busy !== 0)
       throw new Error("source database WAL checkpoint is busy");
@@ -341,7 +3148,7 @@ function checkpointSource(path) {
   }
 }
 function verifyDatabaseFile(path) {
-  const db = new Database(path, { readonly: true });
+  const db = new Database2(path, { readonly: true });
   try {
     assertHealthyDatabase(db);
   } finally {
@@ -358,40 +3165,40 @@ function isBusyError(error) {
 }
 
 // src/db/migration-lock.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { hostname } from "os";
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { hostname as hostname2 } from "os";
 function migrationLockPath(databasePath) {
   return `${databasePath}.migration.lock`;
 }
 function acquireMigrationLock(databasePath, targetSchema, timeoutMs = 30000) {
   const path = migrationLockPath(databasePath);
   const owner = {
-    ownerID: randomUUID2(),
+    ownerID: randomUUID4(),
     pid: process.pid,
-    processStartMarker: processStartMarker(process.pid) ?? "unavailable",
-    hostname: hostname(),
+    processStartMarker: processStartMarker2(process.pid) ?? "unavailable",
+    hostname: hostname2(),
     startedAt: Date.now(),
     targetSchema
   };
   const deadline = Date.now() + timeoutMs;
   const stagedOwner = `${path}.owner-${owner.ownerID}.tmp`;
-  writeFileSync2(stagedOwner, `${JSON.stringify(owner, null, 2)}
+  writeFileSync3(stagedOwner, `${JSON.stringify(owner, null, 2)}
 `, { mode: 384 });
   try {
     while (true) {
       let created = false;
       try {
-        mkdirSync2(path, { mode: 448 });
+        mkdirSync3(path, { mode: 448 });
         created = true;
-        renameSync2(stagedOwner, `${path}/owner.json`);
+        renameSync3(stagedOwner, `${path}/owner.json`);
         break;
       } catch (error) {
         if (created) {
           rmSync2(path, { recursive: true, force: true });
           throw error;
         }
-        if (!existsSync2(path))
+        if (!isAlreadyExistsError(error))
           throw error;
         if (Date.now() >= deadline) {
           const current = readMigrationLockOwner(path);
@@ -421,7 +3228,7 @@ function acquireMigrationLock(databasePath, targetSchema, timeoutMs = 30000) {
 }
 function readMigrationLockOwner(path) {
   try {
-    return JSON.parse(readFileSync2(`${path}/owner.json`, "utf8"));
+    return JSON.parse(readFileSync3(`${path}/owner.json`, "utf8"));
   } catch {
     return;
   }
@@ -433,300 +3240,43 @@ function breakMigrationLock(databasePath, ownerID, confirmation) {
   const path = migrationLockPath(databasePath);
   const owner = readMigrationLockOwner(path);
   if (!owner) {
-    if (ownerID !== "ORPHANED" || !existsSync2(path))
+    if (ownerID !== "ORPHANED" || !existsSync3(path))
       throw new Error("migration lock owner mismatch");
     rmSync2(path, { recursive: true, force: true });
     return;
   }
   if (owner.ownerID !== ownerID)
     throw new Error("migration lock owner mismatch");
-  if (owner.hostname === hostname() && processIsAlive(owner.pid)) {
-    const currentMarker = processStartMarker(owner.pid);
+  if (owner.hostname === hostname2() && processIsAlive(owner.pid)) {
+    const currentMarker = processStartMarker2(owner.pid);
     if (!currentMarker || currentMarker === owner.processStartMarker) {
       throw new Error(`migration lock process ${owner.pid} is still alive`);
     }
   }
   rmSync2(path, { recursive: true, force: true });
 }
-function processStartMarker(pid) {
+function processStartMarker2(pid) {
   try {
-    const fields = readFileSync2(`/proc/${pid}/stat`, "utf8").trim().split(/\s+/);
+    const fields = readFileSync3(`/proc/${pid}/stat`, "utf8").trim().split(/\s+/);
     return fields[21];
   } catch {
     return;
   }
 }
 function processIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// 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_TABLES = `
-CREATE TABLE IF NOT EXISTS projects (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  normalized_name TEXT NOT NULL UNIQUE,
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS notes (
-  id TEXT PRIMARY KEY,
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  kind TEXT NOT NULL CHECK (kind IN ('decision','fact','procedure','context','research','preference','task')),
-  title TEXT NOT NULL,
-  summary TEXT NOT NULL,
-  content TEXT NOT NULL,
-  size_class TEXT NOT NULL CHECK (size_class IN ('inline','indexed')),
-  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0,1)),
-  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','superseded','archived')),
-  supersedes_id TEXT,
-  current_revision INTEGER NOT NULL DEFAULT 1 CHECK (current_revision >= 1),
-  subject_key TEXT,
-  content_hash TEXT NOT NULL CHECK (length(content_hash) = 64),
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL,
-  UNIQUE(project_id, id)
-);
-CREATE INDEX IF NOT EXISTS notes_project_idx ON notes(project_id, status);
-CREATE UNIQUE INDEX IF NOT EXISTS notes_active_subject_idx
-  ON notes(project_id, kind, subject_key)
-  WHERE status = 'active' AND subject_key IS NOT NULL;
-CREATE TABLE IF NOT EXISTS note_edges (
-  id TEXT PRIMARY KEY,
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  source_id TEXT NOT NULL,
-  target_id TEXT NOT NULL,
-  predicate TEXT NOT NULL CHECK (predicate IN ('SUPPORTS','DERIVED_FROM','PART_OF','ABOUT','PRECEDES','SUPERSEDES')),
-  created_at INTEGER NOT NULL,
-  UNIQUE(project_id, source_id, target_id, predicate),
-  FOREIGN KEY (project_id, source_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
-  FOREIGN KEY (project_id, target_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS note_edges_source_idx ON note_edges(project_id, source_id);
-CREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, target_id);
-CREATE TABLE IF NOT EXISTS project_bindings (
-  binding_key TEXT PRIMARY KEY,
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  source TEXT NOT NULL CHECK (source = 'opencode-v2'),
-  source_project_id TEXT NOT NULL,
-  workspace_id TEXT NOT NULL,
-  canonical_path_hash TEXT NOT NULL CHECK (length(canonical_path_hash) = 64),
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL,
-  UNIQUE(source, source_project_id, workspace_id)
-);
-CREATE TABLE IF NOT EXISTS capture_checkpoints (
-  session_id TEXT PRIMARY KEY,
-  binding_key TEXT NOT NULL REFERENCES project_bindings(binding_key) ON DELETE CASCADE,
-  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  state TEXT NOT NULL CHECK (state IN ('active','idle','unavailable','closed')),
-  last_message_id TEXT,
-  last_reconciled_at INTEGER,
-  next_reconcile_at INTEGER NOT NULL,
-  failure_count INTEGER NOT NULL DEFAULT 0 CHECK (failure_count >= 0),
-  lease_owner TEXT,
-  lease_expires_at INTEGER,
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-CREATE INDEX IF NOT EXISTS capture_checkpoints_due_idx
-  ON capture_checkpoints(state, next_reconcile_at);
-${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);
-CREATE TABLE IF NOT EXISTS note_provenance (
-  id TEXT PRIMARY KEY,
-  project_id TEXT NOT NULL,
-  note_id TEXT NOT NULL,
-  source_type TEXT NOT NULL CHECK (source_type IN ('mcp-manual','opencode-capture','migration','legacy-import','admin')),
-  capture_event_id TEXT,
-  source_session_id TEXT,
-  source_message_id TEXT,
-  source_ordinal INTEGER,
-  source_tool_call_id TEXT,
-  redaction_version TEXT,
-  extractor_version TEXT,
-  confidence REAL CHECK (confidence IS NULL OR (confidence >= 0 AND confidence <= 1)),
-  created_at INTEGER NOT NULL,
-  UNIQUE(project_id, id),
-  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE
-);
-CREATE TABLE IF NOT EXISTS note_revisions (
-  project_id TEXT NOT NULL,
-  note_id TEXT NOT NULL,
-  revision INTEGER NOT NULL CHECK (revision >= 1),
-  kind TEXT NOT NULL,
-  title TEXT NOT NULL,
-  summary TEXT NOT NULL,
-  content TEXT NOT NULL,
-  size_class TEXT NOT NULL,
-  pinned INTEGER NOT NULL CHECK (pinned IN (0,1)),
-  status TEXT NOT NULL CHECK (status IN ('active','superseded','archived')),
-  supersedes_id TEXT,
-  subject_key TEXT,
-  content_hash TEXT NOT NULL,
-  provenance_id TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  PRIMARY KEY(project_id, note_id, revision),
-  FOREIGN KEY (project_id, note_id) REFERENCES notes(project_id, id) ON DELETE CASCADE,
-  FOREIGN KEY (project_id, provenance_id) REFERENCES note_provenance(project_id, id)
-);
-CREATE TABLE IF NOT EXISTS index_outbox (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  backend TEXT NOT NULL,
-  operation TEXT NOT NULL CHECK (operation IN ('upsert-note','delete-note','purge-project')),
-  project_id TEXT NOT NULL,
-  note_id TEXT,
-  revision INTEGER,
-  content_hash TEXT,
-  state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','leased','succeeded','dead')),
-  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
-  available_at INTEGER NOT NULL,
-  lease_owner TEXT,
-  lease_expires_at INTEGER,
-  last_error_code TEXT,
-  created_at INTEGER NOT NULL,
-  completed_at INTEGER,
-  UNIQUE(backend, operation, project_id, note_id, revision)
-);
-CREATE INDEX IF NOT EXISTS index_outbox_due_idx
-  ON index_outbox(backend, project_id, state, available_at, id);
-CREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);
-`;
-var FTS_V9 = `
-CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
-  title, summary, content,
-  content='notes', content_rowid='rowid',
-  tokenize='unicode61'
-);
-CREATE TRIGGER IF NOT EXISTS notes_fts_ai AFTER INSERT ON notes BEGIN
-  INSERT INTO notes_fts(rowid, title, summary, content)
-  VALUES (new.rowid, new.title, new.summary, new.content);
-END;
-CREATE TRIGGER IF NOT EXISTS notes_fts_ad AFTER DELETE ON notes BEGIN
-  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)
-  VALUES ('delete', old.rowid, old.title, old.summary, old.content);
-END;
-CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE OF title, summary, content ON notes BEGIN
-  INSERT INTO notes_fts(notes_fts, rowid, title, summary, content)
-  VALUES ('delete', old.rowid, old.title, old.summary, old.content);
-  INSERT INTO notes_fts(rowid, title, summary, content)
-  VALUES (new.rowid, new.title, new.summary, new.content);
-END;
-`;
-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 (10)").run();
-}
-function rebuildFts(db) {
-  db.query("INSERT INTO notes_fts(notes_fts) VALUES ('rebuild')").run();
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
 }
-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
-);`;
+function isAlreadyExistsError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && String(error.code) === "EEXIST");
 }
 
 // src/db/migrations/v009.ts
+import { createHash as createHash5, randomUUID as randomUUID5 } from "crypto";
 function migrateV8ToV9(db) {
   const notes = db.query("SELECT * FROM notes ORDER BY rowid").all();
   db.exec(`
@@ -779,7 +3329,7 @@ function migrateV8ToV9(db) {
   `);
   const hashes = new Map;
   for (const note of notes) {
-    const hash = noteContentHash(note.kind, note.title, note.summary, note.content);
+    const hash = noteContentHash2(note.kind, note.title, note.summary, note.content);
     hashes.set(note.id, hash);
     insert.run(note.id, note.project_id, note.kind, note.title, note.summary, note.content, note.size_class, note.pinned, note.status, note.supersedes_id, hash, note.created_at, note.updated_at);
   }
@@ -795,7 +3345,7 @@ function migrateV8ToV9(db) {
   `);
   db.exec(SCHEMA_TABLES);
   for (const note of notes) {
-    const provenanceID = randomUUID3();
+    const provenanceID = randomUUID5();
     db.query(`
       INSERT INTO note_provenance
         (id, project_id, note_id, source_type, created_at)
@@ -813,12 +3363,12 @@ function migrateV8ToV9(db) {
   db.query("DELETE FROM schema_state").run();
   db.query("INSERT INTO schema_state(version) VALUES (9)").run();
 }
-function noteContentHash(kind, title, summary, content) {
-  return createHash3("sha256").update(`${kind}\x00${title}\x00${summary}\x00${content}`, "utf8").digest("hex");
+function noteContentHash2(kind, title, summary, content) {
+  return createHash5("sha256").update(`${kind}\x00${title}\x00${summary}\x00${content}`, "utf8").digest("hex");
 }
 
 // src/db/migrations/v010.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash6 } 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) => {
@@ -831,7 +3381,7 @@ function migrateV9ToV10(db) {
     return {
       idempotencyKey: row.idempotency_key,
       payload,
-      payloadHash: createHash4("sha256").update(payload, "utf8").digest("hex")
+      payloadHash: createHash6("sha256").update(payload, "utf8").digest("hex")
     };
   });
   db.exec("DROP TABLE IF EXISTS capture_events_v10");
@@ -866,7 +3416,7 @@ function migrateV9ToV10(db) {
 }
 
 // src/version.ts
-var PRODUCT_VERSION = "0.4.0";
+var PRODUCT_VERSION = "0.5.0";
 
 // src/db.ts
 var DDL = `
@@ -908,34 +3458,152 @@ CREATE INDEX IF NOT EXISTS note_edges_source_idx ON note_edges(project_id, sourc
 CREATE INDEX IF NOT EXISTS note_edges_target_idx ON note_edges(project_id, target_id);
 CREATE TABLE IF NOT EXISTS schema_state (version INTEGER PRIMARY KEY);
 `;
+var PRE_OPEN_PROBE_TIMEOUT_MS = 5000;
 function openMemoryDatabase(path) {
-  const db = new Database2(path, { create: true });
-  chmodSync2(path, 384);
-  let lock;
+  ensureDatabaseParent(path);
+  assertSupportedDatabaseBeforeOpen(path);
+  recoverStaleMaintenanceGate(path, () => assertSupportedDatabaseBeforeOpen(path));
+  let lock = acquireMigrationLock(path, SCHEMA_VERSION);
+  let lease = acquireDatabaseLease(path);
+  let db;
+  try {
+    assertSupportedDatabaseBeforeOpen(path);
+    db = openDatabase(path);
+  } catch (error) {
+    lease.release();
+    lock.release();
+    throw error;
+  }
+  let dbOpen = true;
+  let maintenance;
   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}`);
     }
-    const hasExistingData = hasLegacyV2(db) || hasTable2(db, "notes") || Boolean(existingVersion);
-    if (!hasExistingData) {
+    const hasObjects = hasApplicationObjects(db);
+    if (!hasObjects) {
+      db.close();
+      dbOpen = false;
+      lease.release();
+      lease = undefined;
+      lease = acquireDatabaseLease(path);
+      assertSupportedDatabaseBeforeOpen(path);
+      db = openDatabase(path);
+      dbOpen = true;
+      if (hasApplicationObjects(db)) {
+        const initializedVersion = getSchemaVersion(db);
+        if (initializedVersion?.version !== SCHEMA_VERSION) {
+          throw new Error("database changed during initialization");
+        }
+        db.exec("PRAGMA foreign_keys=ON");
+        assertHealthyDatabase(db);
+        lock.release();
+        lock = undefined;
+        const opened3 = openedWithLease(db, lease);
+        lease = undefined;
+        return opened3;
+      }
+      db.exec("PRAGMA foreign_keys=ON");
+      db.exec(`PRAGMA application_id = ${APPLICATION_ID}`);
+      db.transaction(() => createSchemaV11(db))();
+      assertHealthyDatabase(db);
+      lock.release();
+      lock = undefined;
+      const opened2 = openedWithLease(db, lease);
+      lease = undefined;
+      return opened2;
+    }
+    const hasV11Marker = hasV11IdentityMarker(db);
+    if (!existingVersion && hasV11Marker) {
+      assertSchemaV11(db);
+    }
+    if (existingVersion && existingVersion.version < SCHEMA_VERSION && hasV11Marker) {
+      assertSchemaV11(db);
+    }
+    if (!existingVersion && !hasLegacyV2(db))
+      throw new Error("unrecognized_database");
+    if (existingVersion?.version === SCHEMA_VERSION) {
       db.exec("PRAGMA foreign_keys=ON");
-      db.transaction(() => createSchema(db))();
       assertHealthyDatabase(db);
-      return { db, close: () => db.close() };
+      lock.release();
+      lock = undefined;
+      const opened2 = openedWithLease(db, lease);
+      lease = undefined;
+      return opened2;
     }
     if ((existingVersion?.version ?? 0) < SCHEMA_VERSION) {
-      lock = acquireMigrationLock(path, SCHEMA_VERSION);
-      backup = createVerifiedBackup(db, path, existingVersion?.version ?? 2, SCHEMA_VERSION, PRODUCT_VERSION);
+      db.close();
+      dbOpen = false;
+      lease.release();
+      lease = undefined;
+      lease = acquireDatabaseLease(path);
+      assertSupportedDatabaseBeforeOpen(path);
+      db = openDatabase(path);
+      dbOpen = true;
+      let 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 && hasV11IdentityMarker(db))
+        assertSchemaV11(db);
+      if (migrationVersion && migrationVersion.version < SCHEMA_VERSION && hasV11IdentityMarker(db)) {
+        assertSchemaV11(db);
+      }
+      if (!migrationVersion && !hasLegacyV2(db))
+        throw new Error("unrecognized_database");
+      if ((migrationVersion?.version ?? 0) === SCHEMA_VERSION) {
+        db.exec("PRAGMA foreign_keys=ON");
+        assertHealthyDatabase(db);
+        lock.release();
+        lock = undefined;
+        const opened3 = openedWithLease(db, lease);
+        lease = undefined;
+        return opened3;
+      }
+      db.close();
+      dbOpen = false;
+      lease.release();
+      lease = undefined;
+      maintenance = acquireMaintenanceGate(path);
+      assertSupportedDatabaseBeforeOpen(path);
+      db = openDatabase(path);
+      dbOpen = true;
+      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 && hasV11IdentityMarker(db))
+        assertSchemaV11(db);
+      if (migrationVersion && migrationVersion.version < SCHEMA_VERSION && hasV11IdentityMarker(db)) {
+        assertSchemaV11(db);
+      }
+      if (!migrationVersion && !hasLegacyV2(db))
+        throw new Error("unrecognized_database");
+      if ((migrationVersion?.version ?? 0) === SCHEMA_VERSION) {
+        db.close();
+        dbOpen = false;
+        const handoff2 = handoffMaintenanceToLease(path, maintenance);
+        maintenance = undefined;
+        db = handoff2.db;
+        dbOpen = true;
+        lease = handoff2.lease;
+        db.exec("PRAGMA foreign_keys=ON");
+        assertHealthyDatabase(db);
+        lock.release();
+        lock = undefined;
+        const opened3 = openedWithLease(db, lease);
+        lease = undefined;
+        return opened3;
+      }
+      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(() => {
@@ -943,7 +3611,7 @@ 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);
@@ -953,46 +3621,219 @@ function openMemoryDatabase(path) {
         db.transaction(() => migrateV8ToV9(db))();
         version = 9;
       }
-      if (version < 10)
+      if (version < 10) {
         db.transaction(() => migrateV9ToV10(db))();
+        version = 10;
+      }
+      if (version < SCHEMA_VERSION) {
+        db.transaction(() => {
+          db.exec(`PRAGMA application_id = ${APPLICATION_ID}`);
+          migrateV10ToV11(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");
       }
       assertHealthyDatabase(db);
       console.warn(`[agz-memory] migrated to v${SCHEMA_VERSION} (backup: ${backup.manifestPath})`);
+      backup = undefined;
+      db.close();
+      dbOpen = false;
+      const handoff = handoffMaintenanceToLease(path, maintenance);
+      maintenance = undefined;
+      db = handoff.db;
+      dbOpen = true;
+      lease = handoff.lease;
+      db.exec("PRAGMA foreign_keys=ON");
+      assertHealthyDatabase(db);
       lock.release();
       lock = undefined;
-      return { db, close: () => db.close() };
+      const opened2 = openedWithLease(db, lease);
+      lease = undefined;
+      return opened2;
     }
     db.exec("PRAGMA foreign_keys=ON");
-    db.exec(SCHEMA_TABLES);
-    db.exec(FTS_V9);
     assertHealthyDatabase(db);
     db.exec("PRAGMA foreign_keys=ON");
-    return { db, close: () => db.close() };
+    lock.release();
+    lock = undefined;
+    const opened = openedWithLease(db, lease);
+    lease = undefined;
+    return opened;
   } catch (error) {
-    db.close();
+    if (dbOpen)
+      db.close();
     if (backup) {
       try {
-        restoreVerifiedBackup(backup.manifestPath, path, "RESTORE_DATABASE_FROM_VERIFIED_BACKUP");
+        restoreVerifiedBackup(backup.manifestPath, path, "RESTORE_DATABASE_FROM_VERIFIED_BACKUP", maintenance);
       } catch (restoreError) {
         throw new AggregateError([error, restoreError], "migration and automatic restore failed");
       }
     }
     throw error;
   } finally {
+    lease?.release();
+    maintenance?.release();
     lock?.release();
   }
 }
+function openReadOnlyMemoryDatabase(path) {
+  assertSupportedDatabaseBeforeOpen(path);
+  recoverStaleMaintenanceGate(path, () => assertSupportedDatabaseBeforeOpen(path));
+  const lease = acquireDatabaseLease(path);
+  try {
+    assertSupportedDatabaseBeforeOpen(path);
+    assertDatabasePath(path);
+    const db = new Database3(path, { readonly: true });
+    try {
+      assertDatabasePath(path);
+      assertSupportedDatabase(db);
+      db.exec("PRAGMA busy_timeout=5000");
+      return openedWithLease(db, lease);
+    } catch (error) {
+      db.close();
+      throw error;
+    }
+  } catch (error) {
+    lease.release();
+    throw error;
+  }
+}
+function handoffMaintenanceToLease(path, maintenance) {
+  maintenance.release();
+  const lease = acquireDatabaseLease(path);
+  try {
+    return { db: openDatabase(path), lease };
+  } catch (error) {
+    lease.release();
+    throw error;
+  }
+}
+function openedWithLease(db, lease) {
+  let closed = false;
+  return {
+    db,
+    close: () => {
+      if (closed)
+        return;
+      closed = true;
+      try {
+        db.close();
+      } finally {
+        lease.release();
+      }
+    }
+  };
+}
+function openDatabase(path) {
+  assertDatabasePath(path);
+  const db = new Database3(path, { create: true });
+  try {
+    assertDatabasePath(path);
+    db.exec("PRAGMA query_only=ON");
+    assertSupportedDatabase(db);
+    db.exec("PRAGMA query_only=OFF");
+    chmodSync3(path, 384);
+    db.exec("PRAGMA busy_timeout=5000");
+    db.exec("PRAGMA journal_mode=WAL");
+    return db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+function assertSupportedDatabaseBeforeOpen(path) {
+  const deadline = Date.now() + PRE_OPEN_PROBE_TIMEOUT_MS;
+  while (true) {
+    try {
+      assertSupportedDatabaseBeforeOpenOnce(path);
+      return;
+    } catch (error) {
+      if (!isSQLiteBusyError(error) || Date.now() >= deadline)
+        throw error;
+      Bun.sleepSync(Math.min(50, Math.max(1, deadline - Date.now())));
+    }
+  }
+}
+function assertSupportedDatabaseBeforeOpenOnce(path) {
+  assertDatabasePath(path);
+  if (!existsSync4(path))
+    return;
+  const db = new Database3(path, { readonly: true });
+  try {
+    assertDatabasePath(path);
+    assertSupportedDatabase(db);
+  } finally {
+    db.close();
+  }
+}
+function assertSupportedDatabase(db) {
+  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}`);
+  }
+  if (!hasApplicationObjects(db))
+    return;
+  const hasV11Marker = hasV11IdentityMarker(db);
+  if (!existingVersion) {
+    if (!hasLegacyV2(db))
+      throw new Error("unrecognized_database");
+    assertLegacySchemaIdentity(db, 2);
+    return;
+  }
+  if (existingVersion.version === SCHEMA_VERSION || hasV11Marker) {
+    assertSchemaV11(db);
+    return;
+  }
+  if (existingVersion.version < 2 || existingVersion.version > 10) {
+    throw new Error("unrecognized_database");
+  }
+  assertLegacySchemaIdentity(db, existingVersion.version);
+}
+function assertDatabasePath(path) {
+  try {
+    if (lstatSync3(path).isSymbolicLink()) {
+      throw new Error("database path must not be a symbolic link");
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
 function getSchemaVersion(db) {
-  if (!hasTable2(db, "schema_state"))
+  if (!hasTable4(db, "schema_state"))
     return;
-  return db.query("SELECT version FROM schema_state ORDER BY version DESC LIMIT 1").get();
+  let rows;
+  try {
+    rows = db.query("SELECT version FROM schema_state").all();
+  } catch (error) {
+    if (isSQLiteBusyError(error))
+      throw error;
+    throw new Error("unrecognized_database");
+  }
+  if (rows.length !== 1 || typeof rows[0]?.version !== "number" || !Number.isSafeInteger(rows[0].version)) {
+    throw new Error("unrecognized_database");
+  }
+  return { version: rows[0].version };
 }
 function migrateToV8(db) {
   db.transaction(() => {
     adoptLegacyProjectIDs(db);
+    importLegacyAssociations(db);
+    if (hasColumn(db, "notes", "current_revision")) {
+      dropLegacyV2Tables(db);
+      db.query("DELETE FROM schema_state").run();
+      db.query("INSERT INTO schema_state (version) VALUES (8)").run();
+      return;
+    }
+    db.exec(`
+      DROP TRIGGER IF EXISTS notes_fts_ai;
+      DROP TRIGGER IF EXISTS notes_fts_ad;
+      DROP TRIGGER IF EXISTS notes_fts_au;
+      DROP TABLE IF EXISTS notes_fts;
+    `);
     const pinned = hasColumn(db, "notes", "pinned") ? "pinned" : "0";
     db.exec(`
       CREATE TABLE notes_v7 (
@@ -1037,7 +3878,7 @@ function migrateToV8(db) {
       ALTER TABLE notes_v7 RENAME TO notes;
       ALTER TABLE note_edges_v7 RENAME TO note_edges;
     `);
-    importLegacyAssociations(db);
+    dropLegacyV2Tables(db);
     db.query("DELETE FROM schema_state").run();
     db.query("INSERT INTO schema_state (version) VALUES (8)").run();
   })();
@@ -1047,7 +3888,7 @@ function adoptLegacyProjectIDs(db) {
   for (const { id: legacyID } of existingProjects) {
     if (isUUID(legacyID))
       continue;
-    const id = randomUUID4();
+    const id = randomUUID6();
     db.query("UPDATE projects SET id = ? WHERE id = ?").run(id, legacyID);
     db.query("UPDATE notes SET project_id = ? WHERE project_id = ?").run(id, legacyID);
     db.query("UPDATE note_edges SET project_id = ? WHERE project_id = ?").run(id, legacyID);
@@ -1056,7 +3897,7 @@ function adoptLegacyProjectIDs(db) {
   for (const { project_id: legacyID } of rows) {
     if (db.query("SELECT id FROM projects WHERE id = ?").get(legacyID))
       continue;
-    const id = randomUUID4();
+    const id = randomUUID6();
     const name = uniqueLegacyProjectName(db, legacyID);
     const now = Date.now();
     db.query("INSERT INTO projects (id, name, normalized_name, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(id, name, normalizeProjectName(name), now, now);
@@ -1081,9 +3922,18 @@ function hasColumn(db, table, column) {
   return rows.some((row) => row.name === column);
 }
 function hasLegacyV2(db) {
-  return hasTable2(db, "memory_items");
+  return hasTable4(db, "memory_items");
 }
-function hasTable2(db, table) {
+function hasApplicationObjects(db) {
+  const row = db.query("SELECT COUNT(*) AS count FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'").get();
+  return row.count > 0;
+}
+function hasV11IdentityMarker(db) {
+  if (hasTable4(db, "agz_meta"))
+    return true;
+  return db.query("PRAGMA application_id").get().application_id === APPLICATION_ID;
+}
+function hasTable4(db, table) {
   const row = db.query("SELECT COUNT(*) AS n FROM sqlite_master WHERE type='table' AND name = ?").get(table);
   return (row?.n ?? 0) > 0;
 }
@@ -1105,26 +3955,42 @@ var KIND_MAP = {
 };
 function migrateFromV2(db, path) {
   const requiredTables = ["memory_items", "memory_versions", "memory_identities"];
-  const missingTables = requiredTables.filter((table) => !hasTable2(db, table));
+  const missingTables = requiredTables.filter((table) => !hasTable4(db, table));
   if (missingTables.length > 0) {
     throw new Error(`unsupported legacy schema; missing tables: ${missingTables.join(", ")}`);
   }
   const backup = `${path}.v2-backup`;
-  if (!existsSync3(backup)) {
+  if (!existsSync4(backup)) {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
     copyFileSync2(path, backup);
   }
   db.transaction(() => {
     migrateFromV2Data(db, backup, {
-      documents: ["document_sources", "document_chunks", "memories"].every((table) => hasTable2(db, table)),
-      links: hasTable2(db, "memory_links"),
-      edges: hasTable2(db, "memory_edges")
+      documents: ["document_sources", "document_chunks", "memories"].every((table) => hasTable4(db, table)),
+      links: hasTable4(db, "memory_links"),
+      edges: hasTable4(db, "memory_edges")
     });
     adoptLegacyProjectIDs(db);
+    dropLegacyV2Tables(db);
     db.query("DELETE FROM schema_state").run();
     db.query("INSERT INTO schema_state (version) VALUES (8)").run();
   })();
 }
+function dropLegacyV2Tables(db) {
+  for (const table of [
+    "document_chunks",
+    "document_sources",
+    "memories",
+    "memory_associations",
+    "memory_edges",
+    "memory_links",
+    "memory_identities",
+    "memory_versions",
+    "memory_items"
+  ]) {
+    db.exec(`DROP TABLE IF EXISTS ${table}`);
+  }
+}
 function migrateFromV2Data(db, backup, options) {
   const now = Date.now();
   db.query("DELETE FROM notes_fts").run();
@@ -1168,7 +4034,7 @@ function migrateFromV2Data(db, backup, options) {
     const content = source.body ?? "";
     if (!content.trim())
       continue;
-    const id = randomUUID4();
+    const id = randomUUID6();
     db.query(`INSERT INTO notes (id, project_id, kind, title, summary, content, size_class, status, supersedes_id, created_at, updated_at)
        VALUES (?, ?, 'research', ?, ?, ?, 'indexed', 'active', NULL, ?, ?)`).run(id, source.project_root ? hashRoot(source.project_root) : "legacy", source.title, content.slice(0, 200), content, source.created_at, source.updated_at);
     db.query("INSERT INTO notes_fts (id, title, summary, content) VALUES (?, ?, ?, ?)").run(id, source.title, content.slice(0, 200), content);
@@ -1207,7 +4073,7 @@ function migrateFromV2Data(db, backup, options) {
   console.warn(`[agz-memory] v2\u2192v3 migration complete: ${migratedNotes} notes, ${migratedEdges} edges (backup: ${backup})`);
 }
 function importLegacyAssociations(db) {
-  if (!hasTable2(db, "memory_associations"))
+  if (!hasTable4(db, "memory_associations"))
     return 0;
   const associations = db.query(`SELECT id, left_item_id, right_item_id, kind, created_at
          FROM memory_associations
@@ -1247,6 +4113,13 @@ function doctorDatabase(db) {
     failures.push("schema_newer_than_runtime");
   else if (health.schemaVersion < SCHEMA_VERSION)
     warnings.push("schema_upgrade_required");
+  if (health.schemaVersion === SCHEMA_VERSION) {
+    try {
+      assertSchemaV11(db);
+    } catch {
+      failures.push("schema_fingerprint_mismatch");
+    }
+  }
   if (hasTable(db, "notes_fts") && hasTable(db, "notes")) {
     invariants.notes = count(db, "SELECT COUNT(*) AS count FROM notes");
     invariants.fts = count(db, "SELECT COUNT(*) AS count FROM notes_fts");
@@ -1261,6 +4134,34 @@ function doctorDatabase(db) {
           AND r.note_id = n.id
           AND r.revision = n.current_revision
         WHERE r.note_id IS NULL`);
+    invariants.noteContentHashMismatches = canonicalHashMismatches(db, "notes");
+    invariants.revisionContentHashMismatches = canonicalHashMismatches(db, "note_revisions");
+    invariants.currentRevisionMismatches = count(db, `SELECT COUNT(*) AS count
+         FROM notes n
+         JOIN note_revisions r
+           ON r.project_id = n.project_id
+          AND r.note_id = n.id
+          AND r.revision = n.current_revision
+        WHERE n.kind IS NOT r.kind
+           OR n.title IS NOT r.title
+           OR n.summary IS NOT r.summary
+           OR n.content IS NOT r.content
+           OR n.size_class IS NOT r.size_class
+           OR n.pinned IS NOT r.pinned
+           OR n.status IS NOT r.status
+           OR n.supersedes_id IS NOT r.supersedes_id
+           OR n.subject_key IS NOT r.subject_key
+           OR n.content_hash IS NOT r.content_hash`);
+    invariants.revisionGaps = count(db, `SELECT COUNT(*) AS count FROM (
+         SELECT n.project_id, n.id
+           FROM notes n
+           LEFT JOIN note_revisions r
+             ON r.project_id = n.project_id AND r.note_id = n.id
+          GROUP BY n.project_id, n.id, n.current_revision
+         HAVING COUNT(r.revision) <> n.current_revision
+             OR MIN(r.revision) IS NOT 1
+             OR MAX(r.revision) IS NOT n.current_revision
+       )`);
     invariants.missingProvenance = count(db, `SELECT COUNT(*) AS count
          FROM note_revisions r
          LEFT JOIN note_provenance p
@@ -1273,120 +4174,104 @@ function doctorDatabase(db) {
          HAVING COUNT(DISTINCT project_id) > 1
        )`);
     invariants.deadOutbox = count(db, "SELECT COUNT(*) AS count FROM index_outbox WHERE state = 'dead'");
+    invariants.invalidOutboxOperations = count(db, `SELECT COUNT(*) AS count FROM index_outbox
+        WHERE (operation = 'upsert-note'
+               AND (note_id IS NULL OR revision IS NULL OR revision < 1
+                    OR content_hash IS NULL OR length(content_hash) <> 64))
+           OR (operation = 'delete-note'
+               AND (note_id IS NULL OR revision IS NULL OR revision < 1
+                    OR content_hash IS NOT NULL))
+           OR (operation = 'purge-project'
+               AND (note_id IS NOT NULL OR revision IS NOT NULL OR content_hash IS NOT NULL))
+           OR operation NOT IN ('upsert-note', 'delete-note', 'purge-project')`);
+    invariants.invalidOutboxLeases = count(db, `SELECT COUNT(*) AS count FROM index_outbox
+        WHERE (state = 'leased' AND (lease_owner IS NULL OR lease_expires_at IS NULL))
+           OR (state <> 'leased'
+               AND (lease_owner IS NOT NULL OR lease_expires_at IS NOT NULL OR heartbeat_at IS NOT NULL))`);
+    invariants.orphanedOutboxProjects = count(db, `SELECT COUNT(*) AS count FROM index_outbox o
+        LEFT JOIN projects p ON p.id = o.project_id
+       WHERE p.id IS NULL`);
+    invariants.outboxOperationKeyMismatches = outboxOperationKeyMismatches(db);
+    invariants.derivedHashMismatches = derivedHashMismatches(db);
     invariants.dueCheckpoints = count(db, "SELECT COUNT(*) AS count FROM capture_checkpoints WHERE next_reconcile_at <= ? AND state = 'active'", Date.now());
     for (const [name, value] of Object.entries(invariants)) {
-      if (["missingCurrentRevisions", "missingProvenance", "bindingConflicts"].includes(name) && value > 0) {
+      if ([
+        "missingCurrentRevisions",
+        "noteContentHashMismatches",
+        "revisionContentHashMismatches",
+        "currentRevisionMismatches",
+        "revisionGaps",
+        "missingProvenance",
+        "bindingConflicts",
+        "invalidOutboxOperations",
+        "invalidOutboxLeases",
+        "outboxOperationKeyMismatches",
+        "derivedHashMismatches"
+      ].includes(name) && value > 0) {
         failures.push(name);
       }
     }
   }
   return { ok: failures.length === 0, health, warnings, failures, invariants };
 }
+function canonicalHashMismatches(db, table) {
+  const rows = db.query(`SELECT kind, title, summary, content, content_hash FROM ${table}`).iterate();
+  let mismatches = 0;
+  for (const row of rows) {
+    if (row.content_hash !== noteContentHash(row.kind, row.title, row.summary, row.content)) {
+      mismatches++;
+    }
+  }
+  return mismatches;
+}
 function count(db, sql, ...bindings) {
   return db.query(sql).get(...bindings).count;
 }
-
-// src/retrieval/derived.ts
-import { createHash as createHash5 } from "crypto";
-
-// src/capture/redact.ts
-var RULES = [
-  {
-    name: "private-key",
-    pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/gi,
-    highRisk: true
-  },
-  {
-    name: "credential-uri",
-    pattern: /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@[^\s]+/gi,
-    highRisk: true
-  },
-  { name: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi },
-  { name: "basic-auth", pattern: /\bBasic\s+[A-Za-z0-9+/=]{12,}/gi },
-  { name: "github-token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g },
-  { name: "gitlab-token", pattern: /\bglpat-[A-Za-z0-9_-]{16,}\b/g },
-  { name: "aws-access-key", pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g },
-  { name: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g },
-  {
-    name: "secret-assignment",
-    pattern: /\b(?:PASSWORD|PASSWD|SECRET|TOKEN|API_KEY|PRIVATE_KEY)\s*[:=]\s*["']?[^\s,"']{8,}["']?/gi
-  }
-];
-function redactText(value, options = {}) {
-  const maxCharacters = options.maxCharacters ?? Number.MAX_SAFE_INTEGER;
-  let text = value;
-  let replacements = 0;
-  let highRisk = 0;
-  const classes = {};
-  for (const literal2 of options.denylist ?? []) {
-    if (!literal2)
-      continue;
-    const count2 = text.split(literal2).length - 1;
-    if (count2 === 0)
-      continue;
-    replacements += count2;
-    classes.denylist = (classes.denylist ?? 0) + count2;
-    text = text.replaceAll(literal2, "[REDACTED:denylist]");
-  }
-  for (const rule of RULES) {
-    text = text.replace(rule.pattern, () => {
-      replacements++;
-      classes[rule.name] = (classes[rule.name] ?? 0) + 1;
-      if (rule.highRisk)
-        highRisk++;
-      return `[REDACTED:${rule.name}]`;
-    });
+function outboxOperationKeyMismatches(db) {
+  const rows = db.query(`SELECT backend, operation, project_id, note_id, revision, content_hash,
+              generation, operation_key
+         FROM index_outbox
+        ORDER BY id`).all();
+  let mismatches = 0;
+  for (const row of rows) {
+    const expected = hashTuple("outbox-operation", 2, [
+      row.backend,
+      row.operation,
+      row.project_id,
+      row.note_id,
+      row.revision,
+      row.content_hash,
+      row.generation
+    ]);
+    if (row.operation_key !== expected)
+      mismatches++;
   }
-  text = text.replace(/\b[A-Za-z0-9+/=_-]{32,}\b/g, (candidate) => {
-    if (!looksHighEntropy(candidate))
-      return candidate;
-    replacements++;
-    classes.entropy = (classes.entropy ?? 0) + 1;
-    return "[REDACTED:entropy]";
-  });
-  const truncated = text.length > maxCharacters;
-  if (truncated)
-    text = text.slice(0, maxCharacters);
-  return {
-    text,
-    replacements,
-    classes,
-    truncated,
-    quarantined: highRisk > 0 || replacements >= 3
-  };
+  return mismatches;
 }
-function looksHighEntropy(value) {
-  if (!/[A-Za-z]/.test(value) || !/\d/.test(value))
-    return false;
-  const counts = new Map;
-  for (const character of value)
-    counts.set(character, (counts.get(character) ?? 0) + 1);
-  let entropy = 0;
-  for (const count2 of counts.values()) {
-    const probability = count2 / value.length;
-    entropy -= probability * Math.log2(probability);
+function derivedHashMismatches(db) {
+  const rows = db.query(`SELECT o.content_hash, n.project_id, n.id, n.current_revision,
+              n.kind, n.title, n.summary, n.content
+         FROM index_outbox o
+         JOIN notes n ON n.project_id = o.project_id AND n.id = o.note_id
+        WHERE o.operation = 'upsert-note'
+          AND o.state IN ('pending', 'leased')
+          AND n.status = 'active'
+          AND n.current_revision = o.revision`).all();
+  let mismatches = 0;
+  for (const row of rows) {
+    const document = deriveDocument({
+      projectID: row.project_id,
+      noteID: row.id,
+      revision: row.current_revision,
+      kind: row.kind,
+      title: row.title,
+      summary: row.summary,
+      content: row.content
+    });
+    if (!document || document.contentHash !== row.content_hash)
+      mismatches++;
   }
-  return entropy >= 4.1;
-}
-
-// src/retrieval/derived.ts
-function deriveDocument(source) {
-  const title = redactText(source.title);
-  const summary = redactText(source.summary);
-  const content = redactText(source.content);
-  if (title.quarantined || summary.quarantined || content.quarantined)
-    return;
-  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,
-    revision: source.revision,
-    kind: source.kind,
-    title: title.text,
-    summary: summary.text,
-    content: content.text,
-    contentHash
-  };
+  return mismatches;
 }
 
 // src/admin/index.ts
@@ -1397,24 +4282,24 @@ async function runAdmin(argv = process.argv.slice(2)) {
     throw new Error("admin command is required");
   if (command === "doctor") {
     requireExistingDatabase(databasePath);
-    const db = new Database3(databasePath, { readonly: true });
+    const opened = openReadOnlyMemoryDatabase(databasePath);
     try {
-      return doctorDatabase(db);
+      return doctorDatabase(opened.db);
     } finally {
-      db.close();
+      opened.close();
     }
   }
   if (command === "backup" && subcommand !== "prune") {
     requireExistingDatabase(databasePath);
-    const lock = acquireMigrationLock(databasePath, readSchemaVersion(databasePath));
-    const db = new Database3(databasePath);
-    try {
-      const version = schemaVersion(db);
-      return createVerifiedBackup(db, databasePath, version, version, PRODUCT_VERSION);
-    } finally {
-      db.close();
-      lock.release();
-    }
+    return withExclusiveMaintenance(databasePath, readSchemaVersion(databasePath), () => {
+      const db = new Database4(databasePath);
+      try {
+        const version = schemaVersion(db);
+        return createVerifiedBackup(db, databasePath, version, version, PRODUCT_VERSION);
+      } finally {
+        db.close();
+      }
+    });
   }
   if (command === "upgrade") {
     if (option(argv, "--to") !== String(SCHEMA_VERSION)) {
@@ -1440,13 +4325,22 @@ async function runAdmin(argv = process.argv.slice(2)) {
     }
     if (expectedHash !== verified.manifest.sha256)
       throw new Error("restore manifest hash mismatch");
-    const lock = acquireMigrationLock(databasePath, verified.manifest.sourceSchema);
-    try {
-      const preservedPath = restoreVerifiedBackup(manifestPath, databasePath, confirmation);
-      return { restored: true, preservedPath, manifest: verified.manifest };
-    } finally {
-      lock.release();
+    const maintenanceOwner = option(argv, "--maintenance-owner");
+    const maintenanceConfirmation = option(argv, "--maintenance-confirm");
+    if (maintenanceOwner === undefined !== (maintenanceConfirmation === undefined)) {
+      throw new Error("retained maintenance recovery requires both owner and confirmation");
+    }
+    const recovery = maintenanceOwner && maintenanceConfirmation ? {
+      ownerID: maintenanceOwner,
+      confirmation: maintenanceConfirmation
+    } : undefined;
+    if (recovery && recovery.confirmation !== "RECOVER_RETAINED_MAINTENANCE_GATE") {
+      throw new Error("invalid retained maintenance recovery confirmation");
     }
+    return withExclusiveMaintenance(databasePath, verified.manifest.sourceSchema, (maintenance) => {
+      const preservedPath = restoreVerifiedBackup(manifestPath, databasePath, confirmation, maintenance, expectedHash);
+      return { restored: true, preservedPath, manifest: verified.manifest };
+    }, recovery);
   }
   if (command === "unlock") {
     const ownerID = option(argv, "--owner");
@@ -1465,14 +4359,26 @@ async function runAdmin(argv = process.argv.slice(2)) {
     try {
       const now = Date.now();
       let queued = 0;
-      const notes = opened.db.query("SELECT * FROM notes WHERE status = 'active' ORDER BY project_id, id").all();
+      let purges = 0;
+      const quarantined = {};
+      let generation = 0;
       const insert = opened.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 (?, 'upsert-note', ?, ?, ?, ?, 'pending', 0, ?, ?)
+        INSERT INTO index_outbox
+          (backend, operation_key, operation, project_id, note_id, revision, content_hash,
+           generation, lease_generation, fence, state, attempt_count, available_at,
+           heartbeat_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 'pending', 0, ?, NULL, ?)
       `);
-      opened.db.transaction(() => {
+      opened.db.exec("BEGIN IMMEDIATE");
+      try {
+        generation = opened.db.query("SELECT COALESCE(MAX(generation), 0) + 1 AS generation FROM index_outbox WHERE backend = ?").get(backend).generation;
+        const projects = opened.db.query("SELECT id FROM projects ORDER BY id").all();
+        const notes = opened.db.query("SELECT * FROM notes WHERE status = 'active' ORDER BY project_id, id").all();
+        for (const project of projects) {
+          const operation = "purge-project";
+          const operationKey = outboxOperationKey(backend, operation, project.id, null, null, null, generation);
+          purges += insert.run(backend, operationKey, operation, project.id, null, null, null, generation, now, now).changes;
+        }
         for (const note of notes) {
           const document = deriveDocument({
             projectID: note.project_id,
@@ -1483,10 +4389,22 @@ async function runAdmin(argv = process.argv.slice(2)) {
             summary: note.summary,
             content: note.content
           });
-          queued += insert.run(backend, note.project_id, note.id, note.current_revision, document?.contentHash ?? null, now, now).changes;
+          if (!document) {
+            quarantined.derived_document_unavailable = (quarantined.derived_document_unavailable ?? 0) + 1;
+            continue;
+          }
+          const operation = "upsert-note";
+          const operationKey = outboxOperationKey(backend, operation, note.project_id, note.id, note.current_revision, document.contentHash, generation);
+          queued += insert.run(backend, operationKey, operation, note.project_id, note.id, note.current_revision, document.contentHash, generation, now, now).changes;
         }
-      })();
-      return { backend, queued };
+        opened.db.exec("COMMIT");
+      } catch (error) {
+        try {
+          opened.db.exec("ROLLBACK");
+        } catch {}
+        throw error;
+      }
+      return { backend, generation, purges, queued, quarantined };
     } finally {
       opened.close();
     }
@@ -1504,7 +4422,8 @@ async function runAdmin(argv = process.argv.slice(2)) {
     return withDatabase(databasePath, (db) => {
       const result = db.query(`UPDATE index_outbox
               SET state = 'pending', available_at = ?, lease_owner = NULL,
-                  lease_expires_at = NULL, last_error_code = NULL
+                  lease_expires_at = NULL, heartbeat_at = NULL,
+                  completed_at = NULL, last_error_code = NULL
             WHERE id = ? AND state = 'dead'`).run(Date.now(), id);
       return { id, retried: result.changes === 1 };
     });
@@ -1516,28 +4435,30 @@ async function runAdmin(argv = process.argv.slice(2)) {
     }));
   }
   if (command === "backup" && subcommand === "prune") {
-    const entries = backupEntries(databasePath);
-    const root = resolve2(`${databasePath}.backup`);
-    const digest = createHash6("sha256").update(`${resolve2(databasePath)}\x00${root}
-${entries.map((entry) => `${basename2(entry.manifest)}\x00${basename2(entry.database)}\x00${entry.sha256}\x00${entry.size}\x00${entry.manifestHash}`).join(`
+    return withExclusiveMaintenance(databasePath, SCHEMA_VERSION, () => {
+      const entries = backupEntries(databasePath);
+      const root = resolve3(`${databasePath}.backup`);
+      const digest = createHash7("sha256").update(`${resolve3(databasePath)}\x00${root}
+${entries.map((entry) => `${basename3(entry.manifest)}\x00${basename3(entry.database)}\x00${entry.sha256}\x00${entry.size}\x00${entry.manifestHash}`).join(`
 `)}`).digest("hex");
-    if (option(argv, "--confirm") !== "DELETE_VERIFIED_BACKUPS") {
-      return { dryRun: true, digest, backups: entries };
-    }
-    if (option(argv, "--digest") !== digest)
-      throw new Error("backup prune digest mismatch");
-    const currentEntries = entries.map((entry) => {
-      const current = verifiedBackupEntry(root, entry.manifest);
-      if (current.database !== entry.database || current.sha256 !== entry.sha256 || current.size !== entry.size || current.manifestHash !== entry.manifestHash) {
-        throw new Error(`backup changed after confirmation: ${basename2(entry.manifest)}`);
+      if (option(argv, "--confirm") !== "DELETE_VERIFIED_BACKUPS") {
+        return { dryRun: true, digest, backups: entries };
+      }
+      if (option(argv, "--digest") !== digest)
+        throw new Error("backup prune digest mismatch");
+      const currentEntries = entries.map((entry) => {
+        const current = verifiedBackupEntry(root, entry.manifest);
+        if (current.database !== entry.database || current.sha256 !== entry.sha256 || current.size !== entry.size || current.manifestHash !== entry.manifestHash) {
+          throw new Error(`backup changed after confirmation: ${basename3(entry.manifest)}`);
+        }
+        return current;
+      });
+      for (const current of currentEntries) {
+        rmSync3(current.database, { force: true });
+        rmSync3(current.manifest, { force: true });
       }
-      return current;
+      return { deleted: entries.length, digest };
     });
-    for (const current of currentEntries) {
-      rmSync3(current.database, { force: true });
-      rmSync3(current.manifest, { force: true });
-    }
-    return { deleted: entries.length, digest };
   }
   throw new Error(`unknown admin command: ${argv.join(" ")}`);
 }
@@ -1549,16 +4470,29 @@ function withDatabase(databasePath, action) {
     opened.close();
   }
 }
+function withExclusiveMaintenance(databasePath, schemaVersion, action, recovery) {
+  const lock = acquireMigrationLock(databasePath, schemaVersion);
+  try {
+    const maintenance = acquireMaintenanceGate(databasePath, recovery);
+    try {
+      return action(maintenance);
+    } finally {
+      maintenance.release();
+    }
+  } finally {
+    lock.release();
+  }
+}
 function option(argv, name) {
   const index = argv.indexOf(name);
   return index >= 0 ? argv[index + 1] : undefined;
 }
 function requireExistingDatabase(databasePath) {
-  if (!existsSync4(databasePath))
+  if (!existsSync5(databasePath))
     throw new Error(`database does not exist: ${databasePath}`);
 }
 function readSchemaVersion(databasePath) {
-  const db = new Database3(databasePath, { readonly: true });
+  const db = new Database4(databasePath, { readonly: true });
   try {
     return schemaVersion(db);
   } finally {
@@ -1572,27 +4506,27 @@ function schemaVersion(db) {
   return row.version;
 }
 function assertInsideBackupRoot(databasePath, manifestPath) {
-  const root = resolve2(`${databasePath}.backup`);
-  const candidate = resolve2(manifestPath);
-  if (dirname2(candidate) !== root)
+  const root = resolve3(`${databasePath}.backup`);
+  const candidate = resolve3(manifestPath);
+  if (dirname3(candidate) !== root)
     throw new Error("manifest must be inside the database backup directory");
 }
 function backupEntries(databasePath) {
-  const root = resolve2(`${databasePath}.backup`);
-  if (!existsSync4(root))
+  const root = resolve3(`${databasePath}.backup`);
+  if (!existsSync5(root))
     return [];
-  return readdirSync(root).filter((name) => name.endsWith(".manifest.json")).sort().map((name) => verifiedBackupEntry(root, resolve2(root, name)));
+  return readdirSync2(root).filter((name) => name.endsWith(".manifest.json")).sort().map((name) => verifiedBackupEntry(root, resolve3(root, name)));
 }
 function verifiedBackupEntry(root, manifest) {
-  const candidate = resolve2(manifest);
-  if (dirname2(candidate) !== root)
+  const candidate = resolve3(manifest);
+  if (dirname3(candidate) !== root)
     throw new Error("backup manifest escaped the backup directory");
-  const stat = lstatSync2(candidate);
+  const stat = lstatSync4(candidate);
   if (!stat.isFile() || stat.isSymbolicLink())
     throw new Error("backup manifest must be a regular file");
-  const bytes = readFileSync3(candidate);
+  const bytes = readFileSync4(candidate);
   const verified = verifyBackupManifest(candidate);
-  if (dirname2(verified.databasePath) !== root) {
+  if (dirname3(verified.databasePath) !== root) {
     throw new Error("backup database escaped the backup directory");
   }
   return {
@@ -1600,9 +4534,20 @@ function verifiedBackupEntry(root, manifest) {
     database: verified.databasePath,
     sha256: verified.manifest.sha256,
     size: verified.manifest.size,
-    manifestHash: createHash6("sha256").update(bytes).digest("hex")
+    manifestHash: createHash7("sha256").update(bytes).digest("hex")
   };
 }
+function outboxOperationKey(backend, operation, projectID, noteID, revision, contentHash, generation) {
+  return hashTuple("outbox-operation", 2, [
+    backend,
+    operation,
+    projectID,
+    noteID,
+    revision,
+    contentHash,
+    generation
+  ]);
+}
 if (import.meta.main) {
   try {
     const result = await runAdmin();