@hasna/mementos 0.14.83 → 0.14.85

package/dist/diagnostics/historical-project-registration-receipt.js

@@ -0,0 +1,1656 @@
+// @bun
+// src/diagnostics/historical-project-registration-receipt.ts
+import { pathToFileURL } from "url";
+import pg2 from "pg";
+
+// src/project-registration/authority.ts
+import { createHash } from "crypto";
+
+// src/storage.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+import pg from "pg";
+function shouldUsePgSsl(connectionString) {
+  let params;
+  try {
+    params = new URL(connectionString).searchParams;
+  } catch {
+    params = new URLSearchParams(connectionString.split("?", 2)[1] ?? "");
+  }
+  const ssl = params.get("ssl")?.trim().toLowerCase();
+  const sslMode = params.get("sslmode")?.trim().toLowerCase();
+  return ["1", "true", "yes", "on", "require"].includes(ssl ?? "") || ["require", "verify-ca", "verify-full"].includes(sslMode ?? "");
+}
+function sslConfigFor(connectionString) {
+  if (!shouldUsePgSsl(connectionString))
+    return;
+  let sslMode;
+  try {
+    sslMode = new URL(connectionString).searchParams.get("sslmode")?.trim().toLowerCase() ?? undefined;
+  } catch {
+    sslMode = new URLSearchParams(connectionString.split("?", 2)[1] ?? "").get("sslmode")?.trim().toLowerCase() ?? undefined;
+  }
+  if (sslMode === "verify-ca" || sslMode === "verify-full") {
+    return { rejectUnauthorized: true };
+  }
+  return { rejectUnauthorized: false };
+}
+function stripSslParams(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    url.searchParams.delete("ssl");
+    url.searchParams.delete("sslmode");
+    return url.toString();
+  } catch {
+    return connectionString;
+  }
+}
+class PgSyncPool {
+  worker;
+  status;
+  data;
+  closed = false;
+  lastError = null;
+  static DATA_BYTES = 128 * 1024 * 1024;
+  static QUERY_TIMEOUT_MS = 60000;
+  static resolveWorkerPath() {
+    const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+    const here = fileURLToPath(new URL(".", import.meta.url));
+    const candidates = [
+      join(here, `pg-sync-worker${ext}`),
+      join(here, "..", `pg-sync-worker${ext}`),
+      join(here, "..", "..", `pg-sync-worker${ext}`)
+    ];
+    for (const candidate of candidates) {
+      if (existsSync(candidate))
+        return candidate;
+    }
+    return candidates[0];
+  }
+  constructor(connectionString) {
+    const control = new SharedArrayBuffer(8);
+    const dataSab = new SharedArrayBuffer(PgSyncPool.DATA_BYTES);
+    this.status = new Int32Array(control);
+    this.data = new Uint8Array(dataSab);
+    this.worker = new Worker(PgSyncPool.resolveWorkerPath(), {
+      workerData: {
+        dsn: stripSslParams(connectionString),
+        ssl: sslConfigFor(connectionString),
+        control,
+        data: dataSab
+      }
+    });
+    this.worker.unref();
+    this.worker.on("error", (err) => {
+      this.lastError = err;
+    });
+  }
+  query(sql, params) {
+    if (this.closed)
+      throw new Error("PgSyncPool is closed");
+    if (this.lastError)
+      throw this.lastError;
+    Atomics.store(this.status, 0, 0);
+    this.worker.postMessage({ sql, params });
+    const waitResult = Atomics.wait(this.status, 0, 0, PgSyncPool.QUERY_TIMEOUT_MS);
+    const code = Atomics.load(this.status, 0);
+    if (code === 0 || waitResult === "timed-out") {
+      if (this.lastError)
+        throw this.lastError;
+      throw new Error("PostgreSQL query timed out after 60s");
+    }
+    const len = Atomics.load(this.status, 1);
+    const payload = JSON.parse(new TextDecoder().decode(this.data.subarray(0, len)));
+    if (code === 2) {
+      throw new Error(payload.message ?? "PostgreSQL error");
+    }
+    return payload;
+  }
+  end() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.worker.terminate();
+  }
+}
+var MEMENTOS_STORAGE_ENV = {
+  databaseUrl: "HASNA_MEMENTOS_DATABASE_URL"
+};
+var MEMENTOS_STORAGE_FALLBACK_ENV = {
+  databaseUrl: "MEMENTOS_DATABASE_URL"
+};
+var LOCAL_DATA_DIR = join(homedir(), ".hasna", "mementos");
+var STORAGE_CONFIG_DIR = join(LOCAL_DATA_DIR, "storage");
+var STORAGE_CONFIG_PATH = join(STORAGE_CONFIG_DIR, "config.json");
+var DATABASE_ENV_NAMES = [
+  { name: MEMENTOS_STORAGE_ENV.databaseUrl, deprecated: false },
+  { name: MEMENTOS_STORAGE_FALLBACK_ENV.databaseUrl, deprecated: false }
+];
+var SECRET_QUERY_PARAMS = new Set([
+  "password",
+  "pass",
+  "pwd",
+  "token",
+  "secret",
+  "api_key",
+  "apikey"
+]);
+
+// src/project-registration/schema.ts
+function sqliteMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector),
+      UNIQUE(accepted_receipt_id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+  `;
+}
+function sqliteMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json TEXT NOT NULL,
+      after_project_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+  `;
+}
+
+// src/memory-project-link/schema.ts
+function sqliteMementosMemoryProjectLinkSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_memory_project_link_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.memory-project-link.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN ('accepted', 'no_change')),
+      target_memory_id TEXT NOT NULL,
+      requested_project_id TEXT NOT NULL,
+      expected_memory_version INTEGER NOT NULL,
+      expected_memory_revision TEXT NOT NULL,
+      expected_project_revision TEXT,
+      result_memory_version INTEGER NOT NULL,
+      result_memory_revision TEXT NOT NULL,
+      result_memory_digest TEXT NOT NULL,
+      result_project_revision TEXT,
+      result_project_digest TEXT,
+      accepted_receipt_id TEXT,
+      before_link_json TEXT NOT NULL,
+      after_link_json TEXT NOT NULL,
+      before_project_revision TEXT,
+      before_project_digest TEXT,
+      after_project_revision TEXT,
+      after_project_digest TEXT,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_memory_project_link_receipts_target
+      ON mementos_memory_project_link_receipts(
+        authority_id, tenant_id, corpus_id, target_memory_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_memory_project_link_receipts_immutable_update
+    BEFORE UPDATE ON mementos_memory_project_link_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos memory project link receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_memory_project_link_receipts_immutable_delete
+    BEFORE DELETE ON mementos_memory_project_link_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos memory project link receipts are immutable');
+    END;
+  `;
+}
+
+// src/db/migrations.ts
+var MEMORY_VERSION_SNAPSHOT_TRIGGER = `
+CREATE TRIGGER IF NOT EXISTS memories_version_snapshot
+BEFORE UPDATE ON memories
+WHEN NEW.version > OLD.version
+BEGIN
+  INSERT OR IGNORE INTO memory_versions (
+    id, memory_id, version, value, importance, scope, category, tags,
+    summary, pinned, status, when_to_use, created_at
+  ) VALUES (
+    lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-' ||
+      lower(hex(randomblob(2))) || '-' || lower(hex(randomblob(2))) || '-' ||
+      lower(hex(randomblob(6))),
+    OLD.id, OLD.version, OLD.value, OLD.importance, OLD.scope, OLD.category,
+    OLD.tags, OLD.summary, OLD.pinned, OLD.status, OLD.when_to_use,
+    OLD.updated_at
+  );
+END;
+`;
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    memory_prefix TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT DEFAULT 'agent',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    category TEXT NOT NULL DEFAULT 'knowledge' CHECK(category IN ('preference', 'fact', 'knowledge', 'history')),
+    scope TEXT NOT NULL DEFAULT 'private' CHECK(scope IN ('global', 'shared', 'private')),
+    summary TEXT,
+    tags TEXT DEFAULT '[]',
+    importance INTEGER NOT NULL DEFAULT 5 CHECK(importance >= 1 AND importance <= 10),
+    source TEXT NOT NULL DEFAULT 'agent' CHECK(source IN ('user', 'agent', 'system', 'auto', 'imported')),
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived', 'expired')),
+    pinned INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    session_id TEXT,
+    metadata TEXT DEFAULT '{}',
+    access_count INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    expires_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    accessed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS memory_tags (
+    memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (memory_id, tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_key
+    ON memories(key, scope, COALESCE(agent_id, ''), COALESCE(project_id, ''), COALESCE(session_id, ''));
+
+  CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+  CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+  CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+  CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+  CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+  CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned);
+  CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+  CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_memory ON memory_tags(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS memory_versions (
+    id TEXT PRIMARY KEY,
+    memory_id TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    value TEXT NOT NULL,
+    importance INTEGER NOT NULL,
+    scope TEXT NOT NULL,
+    category TEXT NOT NULL,
+    tags TEXT NOT NULL DEFAULT '[]',
+    summary TEXT,
+    pinned INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'active',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(memory_id, version)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_versions_memory ON memory_versions(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_memory_versions_version ON memory_versions(memory_id, version);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (2);
+  `,
+  `
+  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+    key, value, summary,
+    content='memories',
+    content_rowid='rowid'
+  );
+
+  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+    INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+  END;
+
+  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+    INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+    INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+  END;
+
+  INSERT INTO memories_fts(memories_fts) VALUES('rebuild');
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (3);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS search_history (
+    id TEXT PRIMARY KEY,
+    query TEXT NOT NULL,
+    result_count INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT,
+    project_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_search_history_query ON search_history(query);
+  CREATE INDEX IF NOT EXISTS idx_search_history_created ON search_history(created_at);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (4);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS entities (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL CHECK (type IN ('person','project','tool','concept','file','api','pattern','organization')),
+    description TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    project_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_entities_unique_name_type_project
+    ON entities(name, type, COALESCE(project_id, ''));
+  CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+  CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+  CREATE INDEX IF NOT EXISTS idx_entities_project ON entities(project_id);
+
+  CREATE TABLE IF NOT EXISTS relations (
+    id TEXT PRIMARY KEY,
+    source_entity_id TEXT NOT NULL,
+    target_entity_id TEXT NOT NULL,
+    relation_type TEXT NOT NULL CHECK (relation_type IN ('uses','knows','depends_on','created_by','related_to','contradicts','part_of','implements')),
+    weight REAL NOT NULL DEFAULT 1.0,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(source_entity_id, target_entity_id, relation_type),
+    FOREIGN KEY (source_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_entity_id) REFERENCES entities(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_entity_id);
+  CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_entity_id);
+  CREATE INDEX IF NOT EXISTS idx_relations_type ON relations(relation_type);
+
+  CREATE TABLE IF NOT EXISTS entity_memories (
+    entity_id TEXT NOT NULL,
+    memory_id TEXT NOT NULL,
+    role TEXT NOT NULL DEFAULT 'context' CHECK (role IN ('subject','object','context')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (entity_id, memory_id),
+    FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+  );
+  CREATE INDEX IF NOT EXISTS idx_entity_memories_memory ON entity_memories(memory_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (5);
+  `,
+  `
+  ALTER TABLE agents ADD COLUMN active_project_id TEXT REFERENCES projects(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_agents_active_project ON agents(active_project_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (6);
+  `,
+  `
+  ALTER TABLE agents ADD COLUMN session_id TEXT;
+  CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (7);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS resource_locks (
+    id TEXT PRIMARY KEY,
+    resource_type TEXT NOT NULL CHECK(resource_type IN ('project', 'memory', 'entity', 'agent', 'connector')),
+    resource_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    lock_type TEXT NOT NULL DEFAULT 'exclusive' CHECK(lock_type IN ('advisory', 'exclusive')),
+    locked_at TEXT NOT NULL DEFAULT (datetime('now')),
+    expires_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_resource_locks_exclusive
+    ON resource_locks(resource_type, resource_id)
+    WHERE lock_type = 'exclusive';
+  CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (8);
+  `,
+  `
+  ALTER TABLE memories ADD COLUMN recall_count INTEGER NOT NULL DEFAULT 0;
+  CREATE INDEX IF NOT EXISTS idx_memories_recall_count ON memories(recall_count DESC);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (9);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS synthesis_events (
+    id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL CHECK(event_type IN ('recalled','searched','saved','updated','deleted','injected')),
+    memory_id TEXT,
+    agent_id TEXT,
+    project_id TEXT,
+    session_id TEXT,
+    query TEXT,
+    importance_at_time INTEGER,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_memory ON synthesis_events(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_project ON synthesis_events(project_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_type ON synthesis_events(event_type);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_events_created ON synthesis_events(created_at);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (11);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS synthesis_runs (
+    id TEXT PRIMARY KEY,
+    triggered_by TEXT NOT NULL DEFAULT 'manual' CHECK(triggered_by IN ('scheduler','manual','threshold','hook')),
+    project_id TEXT,
+    agent_id TEXT,
+    corpus_size INTEGER NOT NULL DEFAULT 0,
+    proposals_generated INTEGER NOT NULL DEFAULT 0,
+    proposals_accepted INTEGER NOT NULL DEFAULT 0,
+    proposals_rejected INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','completed','failed','rolled_back')),
+    error TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_project ON synthesis_runs(project_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_status ON synthesis_runs(status);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_runs_started ON synthesis_runs(started_at);
+
+  CREATE TABLE IF NOT EXISTS synthesis_proposals (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES synthesis_runs(id) ON DELETE CASCADE,
+    proposal_type TEXT NOT NULL CHECK(proposal_type IN ('merge','archive','promote','update_value','add_tag','remove_duplicate')),
+    memory_ids TEXT NOT NULL DEFAULT '[]',
+    target_memory_id TEXT,
+    proposed_changes TEXT NOT NULL DEFAULT '{}',
+    reasoning TEXT,
+    confidence REAL NOT NULL DEFAULT 0.5,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','accepted','rejected','rolled_back')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    executed_at TEXT,
+    rollback_data TEXT
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_run ON synthesis_proposals(run_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_status ON synthesis_proposals(status);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_proposals_type ON synthesis_proposals(proposal_type);
+
+  CREATE TABLE IF NOT EXISTS synthesis_metrics (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES synthesis_runs(id) ON DELETE CASCADE,
+    metric_type TEXT NOT NULL,
+    value REAL NOT NULL,
+    baseline REAL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_synthesis_metrics_run ON synthesis_metrics(run_id);
+  CREATE INDEX IF NOT EXISTS idx_synthesis_metrics_type ON synthesis_metrics(metric_type);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (12);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS webhook_hooks (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    handler_url TEXT NOT NULL,
+    priority INTEGER NOT NULL DEFAULT 50,
+    blocking INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT,
+    project_id TEXT,
+    description TEXT,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    invocation_count INTEGER NOT NULL DEFAULT 0,
+    failure_count INTEGER NOT NULL DEFAULT 0
+  );
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_type ON webhook_hooks(type);
+  CREATE INDEX IF NOT EXISTS idx_webhook_hooks_enabled ON webhook_hooks(enabled);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (10);
+  `,
+  `
+CREATE TABLE IF NOT EXISTS session_memory_jobs (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  project_id TEXT,
+  source TEXT NOT NULL DEFAULT 'manual' CHECK(source IN ('claude-code','codex','manual','open-sessions')),
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','completed','failed')),
+  transcript TEXT NOT NULL,
+  chunk_count INTEGER NOT NULL DEFAULT 0,
+  memories_extracted INTEGER NOT NULL DEFAULT 0,
+  error TEXT,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  started_at TEXT,
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_status ON session_memory_jobs(status);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_agent ON session_memory_jobs(agent_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_project ON session_memory_jobs(project_id);
+CREATE INDEX IF NOT EXISTS idx_session_memory_jobs_session ON session_memory_jobs(session_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (13);
+`,
+  `
+ALTER TABLE resource_locks RENAME TO resource_locks_old;
+CREATE TABLE resource_locks (
+  id TEXT PRIMARY KEY,
+  resource_type TEXT NOT NULL CHECK(resource_type IN ('project', 'memory', 'entity', 'agent', 'connector', 'file')),
+  resource_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  lock_type TEXT NOT NULL DEFAULT 'exclusive' CHECK(lock_type IN ('advisory', 'exclusive')),
+  locked_at TEXT NOT NULL DEFAULT (datetime('now')),
+  expires_at TEXT NOT NULL
+);
+INSERT INTO resource_locks SELECT * FROM resource_locks_old;
+DROP TABLE resource_locks_old;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_resource_locks_exclusive
+  ON resource_locks(resource_type, resource_id)
+  WHERE lock_type = 'exclusive';
+CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id);
+CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at);
+INSERT OR IGNORE INTO _migrations (id) VALUES (14);
+`,
+  `
+CREATE TABLE IF NOT EXISTS machines (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  hostname TEXT NOT NULL,
+  platform TEXT NOT NULL DEFAULT 'unknown',
+  is_primary INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_machines_hostname ON machines(hostname);
+ALTER TABLE memories ADD COLUMN machine_id TEXT REFERENCES machines(id) ON DELETE SET NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_machine ON memories(machine_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (15);
+`,
+  `
+ALTER TABLE memories ADD COLUMN flag TEXT;
+CREATE INDEX IF NOT EXISTS idx_memories_flag ON memories(flag);
+INSERT OR IGNORE INTO _migrations (id) VALUES (16);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_embeddings (
+  memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+  embedding TEXT NOT NULL,
+  model TEXT NOT NULL DEFAULT 'tfidf-512',
+  dimensions INTEGER NOT NULL DEFAULT 512,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_embeddings_model ON memory_embeddings(model);
+INSERT OR IGNORE INTO _migrations (id) VALUES (17);
+`,
+  `
+ALTER TABLE memories ADD COLUMN valid_from TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN valid_until TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN ingested_at TEXT DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_valid_from ON memories(valid_from);
+CREATE INDEX IF NOT EXISTS idx_memories_valid_until ON memories(valid_until);
+UPDATE memories SET valid_from = created_at, ingested_at = created_at WHERE valid_from IS NULL;
+INSERT OR IGNORE INTO _migrations (id) VALUES (18);
+`,
+  `
+PRAGMA foreign_keys = OFF;
+ALTER TABLE memories RENAME TO memories_old;
+CREATE TABLE memories (
+  id TEXT PRIMARY KEY,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  category TEXT NOT NULL DEFAULT 'knowledge' CHECK(category IN ('preference', 'fact', 'knowledge', 'history')),
+  scope TEXT NOT NULL DEFAULT 'private' CHECK(scope IN ('global', 'shared', 'private', 'working')),
+  summary TEXT,
+  tags TEXT DEFAULT '[]',
+  importance INTEGER NOT NULL DEFAULT 5 CHECK(importance >= 1 AND importance <= 10),
+  source TEXT NOT NULL DEFAULT 'agent' CHECK(source IN ('user', 'agent', 'system', 'auto', 'imported')),
+  status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived', 'expired')),
+  pinned INTEGER NOT NULL DEFAULT 0,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  machine_id TEXT REFERENCES machines(id) ON DELETE SET NULL,
+  flag TEXT,
+  metadata TEXT DEFAULT '{}',
+  access_count INTEGER NOT NULL DEFAULT 0,
+  recall_count INTEGER NOT NULL DEFAULT 0,
+  version INTEGER NOT NULL DEFAULT 1,
+  expires_at TEXT,
+  valid_from TEXT DEFAULT NULL,
+  valid_until TEXT DEFAULT NULL,
+  ingested_at TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  accessed_at TEXT
+);
+INSERT INTO memories SELECT * FROM memories_old;
+DROP TABLE memories_old;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_key
+  ON memories(key, scope, COALESCE(agent_id, ''), COALESCE(project_id, ''), COALESCE(session_id, ''));
+CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id);
+CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned);
+CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+CREATE INDEX IF NOT EXISTS idx_memories_machine ON memories(machine_id);
+CREATE INDEX IF NOT EXISTS idx_memories_flag ON memories(flag);
+CREATE INDEX IF NOT EXISTS idx_memories_recall_count ON memories(recall_count DESC);
+CREATE INDEX IF NOT EXISTS idx_memories_valid_from ON memories(valid_from);
+CREATE INDEX IF NOT EXISTS idx_memories_valid_until ON memories(valid_until);
+
+INSERT INTO memories_fts(memories_fts) VALUES('rebuild');
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+  INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+END;
+
+PRAGMA foreign_keys = ON;
+INSERT OR IGNORE INTO _migrations (id) VALUES (19);
+`,
+  `
+PRAGMA foreign_keys = OFF;
+ALTER TABLE memories RENAME TO memories_old;
+CREATE TABLE memories (
+  id TEXT PRIMARY KEY,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  category TEXT NOT NULL DEFAULT 'knowledge' CHECK(category IN ('preference', 'fact', 'knowledge', 'history', 'procedural', 'resource')),
+  scope TEXT NOT NULL DEFAULT 'private' CHECK(scope IN ('global', 'shared', 'private', 'working')),
+  summary TEXT,
+  tags TEXT DEFAULT '[]',
+  importance INTEGER NOT NULL DEFAULT 5 CHECK(importance >= 1 AND importance <= 10),
+  source TEXT NOT NULL DEFAULT 'agent' CHECK(source IN ('user', 'agent', 'system', 'auto', 'imported')),
+  status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived', 'expired')),
+  pinned INTEGER NOT NULL DEFAULT 0,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  machine_id TEXT REFERENCES machines(id) ON DELETE SET NULL,
+  flag TEXT,
+  content_type TEXT NOT NULL DEFAULT 'text' CHECK(content_type IN ('text', 'code', 'image', 'resource')),
+  metadata TEXT DEFAULT '{}',
+  access_count INTEGER NOT NULL DEFAULT 0,
+  recall_count INTEGER NOT NULL DEFAULT 0,
+  version INTEGER NOT NULL DEFAULT 1,
+  expires_at TEXT,
+  valid_from TEXT DEFAULT NULL,
+  valid_until TEXT DEFAULT NULL,
+  ingested_at TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  accessed_at TEXT
+);
+INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, flag, metadata, access_count, recall_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at, accessed_at)
+  SELECT id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, machine_id, flag, metadata, access_count, recall_count, version, expires_at, valid_from, valid_until, ingested_at, created_at, updated_at, accessed_at FROM memories_old;
+DROP TABLE memories_old;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_key
+  ON memories(key, scope, COALESCE(agent_id, ''), COALESCE(project_id, ''), COALESCE(session_id, ''));
+CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id);
+CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned);
+CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+CREATE INDEX IF NOT EXISTS idx_memories_machine ON memories(machine_id);
+CREATE INDEX IF NOT EXISTS idx_memories_flag ON memories(flag);
+CREATE INDEX IF NOT EXISTS idx_memories_recall_count ON memories(recall_count DESC);
+CREATE INDEX IF NOT EXISTS idx_memories_valid_from ON memories(valid_from);
+CREATE INDEX IF NOT EXISTS idx_memories_valid_until ON memories(valid_until);
+CREATE INDEX IF NOT EXISTS idx_memories_content_type ON memories(content_type);
+
+INSERT INTO memories_fts(memories_fts) VALUES('rebuild');
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+END;
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, key, value, summary) VALUES('delete', old.rowid, old.key, old.value, old.summary);
+  INSERT INTO memories_fts(rowid, key, value, summary) VALUES (new.rowid, new.key, new.value, new.summary);
+END;
+
+PRAGMA foreign_keys = ON;
+INSERT OR IGNORE INTO _migrations (id) VALUES (20);
+`,
+  `
+PRAGMA foreign_keys = OFF;
+ALTER TABLE relations RENAME TO relations_old;
+CREATE TABLE relations (
+  id TEXT PRIMARY KEY,
+  source_entity_id TEXT NOT NULL,
+  target_entity_id TEXT NOT NULL,
+  relation_type TEXT NOT NULL CHECK (relation_type IN ('uses','knows','depends_on','created_by','related_to','contradicts','part_of','implements','happened_before','happened_after','caused_by','resulted_in','supersedes','version_of')),
+  weight REAL NOT NULL DEFAULT 1.0,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(source_entity_id, target_entity_id, relation_type),
+  FOREIGN KEY (source_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  FOREIGN KEY (target_entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+INSERT INTO relations SELECT * FROM relations_old;
+DROP TABLE relations_old;
+CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_type ON relations(relation_type);
+PRAGMA foreign_keys = ON;
+INSERT OR IGNORE INTO _migrations (id) VALUES (21);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_audit_log (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL,
+  memory_key TEXT,
+  operation TEXT NOT NULL CHECK(operation IN ('create','update','delete','archive','restore','read')),
+  agent_id TEXT,
+  old_value_hash TEXT,
+  new_value_hash TEXT,
+  changes TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_audit_log_memory ON memory_audit_log(memory_id);
+CREATE INDEX IF NOT EXISTS idx_audit_log_operation ON memory_audit_log(operation);
+CREATE INDEX IF NOT EXISTS idx_audit_log_agent ON memory_audit_log(agent_id);
+CREATE INDEX IF NOT EXISTS idx_audit_log_created ON memory_audit_log(created_at);
+
+CREATE TRIGGER IF NOT EXISTS audit_memory_insert AFTER INSERT ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, new_value_hash, created_at)
+  VALUES (hex(randomblob(4)), new.id, new.key, 'create', new.agent_id, hex(randomblob(16)), datetime('now'));
+END;
+
+CREATE TRIGGER IF NOT EXISTS audit_memory_update AFTER UPDATE ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, old_value_hash, new_value_hash, changes, created_at)
+  VALUES (hex(randomblob(4)), new.id, new.key, 'update', new.agent_id, hex(randomblob(16)), hex(randomblob(16)),
+    json_object('version_from', old.version, 'version_to', new.version, 'importance_from', old.importance, 'importance_to', new.importance),
+    datetime('now'));
+END;
+
+CREATE TRIGGER IF NOT EXISTS audit_memory_delete AFTER DELETE ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, old_value_hash, created_at)
+  VALUES (hex(randomblob(4)), old.id, old.key, 'delete', old.agent_id, hex(randomblob(16)), datetime('now'));
+END;
+
+INSERT OR IGNORE INTO _migrations (id) VALUES (22);
+`,
+  `
+ALTER TABLE memories ADD COLUMN namespace TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN created_by_agent TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN updated_by_agent TEXT DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories(namespace);
+CREATE INDEX IF NOT EXISTS idx_memories_created_by ON memories(created_by_agent);
+INSERT OR IGNORE INTO _migrations (id) VALUES (23);
+`,
+  `
+ALTER TABLE memories ADD COLUMN trust_score REAL NOT NULL DEFAULT 1.0;
+CREATE INDEX IF NOT EXISTS idx_memories_trust_score ON memories(trust_score);
+INSERT OR IGNORE INTO _migrations (id) VALUES (24);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_ratings (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  agent_id TEXT,
+  useful INTEGER NOT NULL DEFAULT 1,
+  context TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_ratings_memory ON memory_ratings(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_ratings_agent ON memory_ratings(agent_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (25);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_acl (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  key_pattern TEXT NOT NULL,
+  permission TEXT NOT NULL DEFAULT 'readwrite' CHECK(permission IN ('read', 'readwrite', 'admin')),
+  project_id TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_acl_agent ON memory_acl(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_acl_project ON memory_acl(project_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (26);
+`,
+  `
+ALTER TABLE memories ADD COLUMN vector_clock TEXT DEFAULT '{}';
+INSERT OR IGNORE INTO _migrations (id) VALUES (27);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_subscriptions (
+  id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  key_pattern TEXT,
+  tag_pattern TEXT,
+  scope TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_subs_agent ON memory_subscriptions(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_subs_key ON memory_subscriptions(key_pattern);
+INSERT OR IGNORE INTO _migrations (id) VALUES (28);
+`,
+  `
+PRAGMA foreign_keys = OFF;
+
+-- Fix memory_tags FK if broken
+CREATE TABLE IF NOT EXISTS _mt_fix AS SELECT * FROM memory_tags;
+DROP TABLE IF EXISTS memory_tags;
+CREATE TABLE memory_tags (
+  memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  tag TEXT NOT NULL,
+  PRIMARY KEY (memory_id, tag)
+);
+INSERT OR IGNORE INTO memory_tags SELECT * FROM _mt_fix;
+DROP TABLE _mt_fix;
+CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+CREATE INDEX IF NOT EXISTS idx_memory_tags_memory ON memory_tags(memory_id);
+
+-- Fix entity_memories FK if broken
+CREATE TABLE IF NOT EXISTS _em_fix AS SELECT * FROM entity_memories;
+DROP TABLE IF EXISTS entity_memories;
+CREATE TABLE entity_memories (
+  entity_id TEXT NOT NULL,
+  memory_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'context' CHECK (role IN ('subject','object','context')),
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (entity_id, memory_id),
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+INSERT OR IGNORE INTO entity_memories SELECT * FROM _em_fix;
+DROP TABLE _em_fix;
+CREATE INDEX IF NOT EXISTS idx_entity_memories_memory ON entity_memories(memory_id);
+
+-- Fix memory_embeddings FK if broken
+CREATE TABLE IF NOT EXISTS _me_fix AS SELECT * FROM memory_embeddings;
+DROP TABLE IF EXISTS memory_embeddings;
+CREATE TABLE memory_embeddings (
+  memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+  embedding TEXT NOT NULL,
+  model TEXT NOT NULL DEFAULT 'tfidf-512',
+  dimensions INTEGER NOT NULL DEFAULT 512,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+INSERT OR IGNORE INTO memory_embeddings SELECT * FROM _me_fix;
+DROP TABLE _me_fix;
+CREATE INDEX IF NOT EXISTS idx_memory_embeddings_model ON memory_embeddings(model);
+
+PRAGMA foreign_keys = ON;
+INSERT OR IGNORE INTO _migrations (id) VALUES (29);
+`,
+  `
+ALTER TABLE memories ADD COLUMN when_to_use TEXT DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_when_to_use ON memories(when_to_use) WHERE when_to_use IS NOT NULL;
+ALTER TABLE memory_versions ADD COLUMN when_to_use TEXT;
+INSERT OR IGNORE INTO _migrations (id) VALUES (30);
+`,
+  `
+CREATE TABLE IF NOT EXISTS tool_events (
+  id TEXT PRIMARY KEY,
+  tool_name TEXT NOT NULL,
+  action TEXT,
+  success INTEGER NOT NULL DEFAULT 1,
+  error_type TEXT CHECK(error_type IS NULL OR error_type IN ('timeout', 'permission', 'not_found', 'syntax', 'rate_limit', 'other')),
+  error_message TEXT,
+  tokens_used INTEGER,
+  latency_ms INTEGER,
+  context TEXT,
+  lesson TEXT,
+  when_to_use TEXT,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tool_events_tool_name ON tool_events(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_events_agent ON tool_events(agent_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_project ON tool_events(project_id);
+CREATE INDEX IF NOT EXISTS idx_tool_events_success ON tool_events(success);
+CREATE INDEX IF NOT EXISTS idx_tool_events_created ON tool_events(created_at);
+INSERT OR IGNORE INTO _migrations (id) VALUES (31);
+`,
+  `
+ALTER TABLE memories ADD COLUMN sequence_group TEXT DEFAULT NULL;
+ALTER TABLE memories ADD COLUMN sequence_order INTEGER DEFAULT NULL;
+CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_group) WHERE sequence_group IS NOT NULL;
+INSERT OR IGNORE INTO _migrations (id) VALUES (32);
+`,
+  `
+CREATE INDEX IF NOT EXISTS idx_machines_primary ON machines(is_primary);
+CREATE TRIGGER IF NOT EXISTS machines_single_primary_insert
+AFTER INSERT ON machines
+WHEN NEW.is_primary = 1
+BEGIN
+  UPDATE machines
+  SET is_primary = 0,
+      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
+  WHERE id != NEW.id AND is_primary = 1;
+END;
+CREATE TRIGGER IF NOT EXISTS machines_single_primary_update
+AFTER UPDATE OF is_primary ON machines
+WHEN NEW.is_primary = 1
+BEGIN
+  UPDATE machines
+  SET is_primary = 0,
+      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
+  WHERE id != NEW.id AND is_primary = 1;
+END;
+CREATE TRIGGER IF NOT EXISTS machines_prevent_delete_primary
+BEFORE DELETE ON machines
+WHEN OLD.is_primary = 1
+BEGIN
+  SELECT RAISE(ABORT, 'Primary machine cannot be deleted');
+END;
+INSERT OR IGNORE INTO _migrations (id) VALUES (33);
+`,
+  `
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  subject TEXT NOT NULL,
+  description TEXT DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+  priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('critical', 'high', 'medium', 'low')),
+  tags TEXT NOT NULL DEFAULT '[]',
+  assigned_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  parent_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  progress REAL NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 1),
+  due_at TEXT,
+  started_at TEXT,
+  completed_at TEXT,
+  failed_at TEXT,
+  error TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(assigned_agent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_id);
+
+CREATE TABLE IF NOT EXISTS task_comments (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_comments_agent ON task_comments(agent_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (34);
+`,
+  `
+CREATE TABLE IF NOT EXISTS memory_links (
+  id TEXT PRIMARY KEY,
+  source_memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  target_memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  relation_type TEXT NOT NULL CHECK(relation_type IN ('summarizes','merged_from','promotes','reflects_on','supersedes','related_to')),
+  run_id TEXT,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_links_unique ON memory_links(source_memory_id, target_memory_id, relation_type, COALESCE(run_id, ''));
+CREATE INDEX IF NOT EXISTS idx_memory_links_source ON memory_links(source_memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_links_target ON memory_links(target_memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_links_relation ON memory_links(relation_type);
+CREATE INDEX IF NOT EXISTS idx_memory_links_run ON memory_links(run_id);
+
+CREATE TABLE IF NOT EXISTS memory_consolidation_runs (
+  id TEXT PRIMARY KEY,
+  scope TEXT,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  dry_run INTEGER NOT NULL DEFAULT 1,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','completed','failed')),
+  summary TEXT NOT NULL DEFAULT '{}',
+  error TEXT,
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_runs_project ON memory_consolidation_runs(project_id);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_runs_agent ON memory_consolidation_runs(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_runs_status ON memory_consolidation_runs(status);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_runs_started ON memory_consolidation_runs(started_at);
+
+CREATE TABLE IF NOT EXISTS memory_consolidation_actions (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES memory_consolidation_runs(id) ON DELETE CASCADE,
+  action_type TEXT NOT NULL CHECK(action_type IN ('merge_duplicate','promote_semantic','summarize_cluster','decay_forget')),
+  memory_ids TEXT NOT NULL DEFAULT '[]',
+  target_memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL,
+  created_memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL,
+  reason TEXT NOT NULL,
+  planned_changes TEXT NOT NULL DEFAULT '{}',
+  applied INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_actions_run ON memory_consolidation_actions(run_id);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_actions_type ON memory_consolidation_actions(action_type);
+CREATE INDEX IF NOT EXISTS idx_memory_consolidation_actions_target ON memory_consolidation_actions(target_memory_id);
+
+CREATE TABLE IF NOT EXISTS memory_reflection_runs (
+  id TEXT PRIMARY KEY,
+  on_type TEXT NOT NULL CHECK(on_type IN ('session','task','range')),
+  source TEXT,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  dry_run INTEGER NOT NULL DEFAULT 1,
+  provider TEXT,
+  model TEXT,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','running','completed','failed')),
+  trajectory_memory_ids TEXT NOT NULL DEFAULT '[]',
+  summary TEXT,
+  error TEXT,
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  completed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_runs_source ON memory_reflection_runs(on_type, source);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_runs_project ON memory_reflection_runs(project_id);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_runs_agent ON memory_reflection_runs(agent_id);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_runs_status ON memory_reflection_runs(status);
+
+CREATE TABLE IF NOT EXISTS memory_reflection_lessons (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES memory_reflection_runs(id) ON DELETE CASCADE,
+  memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL,
+  kind TEXT NOT NULL CHECK(kind IN ('worked','failed','do_differently')),
+  lesson TEXT NOT NULL,
+  evidence TEXT NOT NULL DEFAULT '[]',
+  importance INTEGER NOT NULL DEFAULT 6 CHECK(importance >= 1 AND importance <= 10),
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_lessons_run ON memory_reflection_lessons(run_id);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_lessons_memory ON memory_reflection_lessons(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_reflection_lessons_kind ON memory_reflection_lessons(kind);
+
+INSERT OR IGNORE INTO _migrations (id) VALUES (35);
+`,
+  `
+${MEMORY_VERSION_SNAPSHOT_TRIGGER}
+INSERT OR IGNORE INTO _migrations (id) VALUES (36);
+`,
+  `
+DROP TRIGGER IF EXISTS audit_memory_insert;
+CREATE TRIGGER audit_memory_insert AFTER INSERT ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, created_at)
+  VALUES (hex(randomblob(4)), new.id, new.key, 'create', new.agent_id, datetime('now'));
+END;
+
+DROP TRIGGER IF EXISTS audit_memory_update;
+CREATE TRIGGER audit_memory_update AFTER UPDATE ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, changes, created_at)
+  VALUES (hex(randomblob(4)), new.id, new.key, 'update', new.agent_id,
+    json_object('version_from', old.version, 'version_to', new.version, 'importance_from', old.importance, 'importance_to', new.importance),
+    datetime('now'));
+END;
+
+DROP TRIGGER IF EXISTS audit_memory_delete;
+CREATE TRIGGER audit_memory_delete AFTER DELETE ON memories BEGIN
+  INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, created_at)
+  VALUES (hex(randomblob(4)), old.id, old.key, 'delete', old.agent_id, datetime('now'));
+END;
+
+UPDATE memory_audit_log SET old_value_hash = NULL
+  WHERE old_value_hash IS NOT NULL
+    AND length(old_value_hash) = 32
+    AND old_value_hash NOT GLOB '*[^0-9A-F]*';
+
+UPDATE memory_audit_log SET new_value_hash = NULL
+  WHERE new_value_hash IS NOT NULL
+    AND length(new_value_hash) = 32
+    AND new_value_hash NOT GLOB '*[^0-9A-F]*';
+
+INSERT OR IGNORE INTO _migrations (id) VALUES (37);
+`,
+  `
+${sqliteMementosProjectRegistrationSchemaSql()}
+INSERT OR IGNORE INTO _migrations (id) VALUES (38);
+`,
+  `
+  ${sqliteMementosProjectGuardedUpdateSchemaSql()}
+  INSERT OR IGNORE INTO _migrations (id) VALUES (39);
+`,
+  `
+${sqliteMementosMemoryProjectLinkSchemaSql()}
+INSERT OR IGNORE INTO _migrations (id) VALUES (40);
+`
+];
+
+// src/db/database.ts
+var ALLOWED_TABLES = new Set([
+  "memories",
+  "agents",
+  "entities",
+  "projects",
+  "relations",
+  "memory_audit_log",
+  "locks",
+  "sessions",
+  "session_memory_jobs",
+  "synthesis_runs",
+  "synthesis_proposals",
+  "tool_events",
+  "webhook_hooks"
+]);
+
+// src/project-registration/historical-receipt.ts
+var ROOT_TENANT_ID = "adfd95c7-ee8b-52cb-ae47-4ae65dae3313";
+var FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION = {
+  authority: "mementos",
+  authority_route: "mementos.project-registration.v1",
+  package_version: "1.0.0-rc.3",
+  authority_id: "mementos",
+  tenant_id: "default",
+  corpus_id: "default",
+  operation_id: "op-cli-register-full",
+  step_id: "mementos_project",
+  resource_kind: "project",
+  direction: "forward",
+  target_selector: "wks_005285827590a93b70e5",
+  target_id: "mm_project_f75606ef14e51fb577a15882ba0ab8ed333b2c29",
+  idempotency_key: "prk_786cdc6babddeae1be8d5078d0f75322d1ea1010ac5d8a50",
+  receipt_id: "mmpr_a647f9908a33bb64bf137f584202590f91b72a33",
+  request_digest: "8eb0e3fee26fdb7edb8a444aeddaaedb79a84a5a36e742ae03616f62b19f5c22",
+  precondition_digest: "0b6c22fcf75d835f9f27308b1a9d40e8902e48a97da370fd56df5acacfcd968e",
+  result_revision: "2026-08-09T13:37:43.068Z",
+  result_digest: "26fb0dd5c5e20909d3653ab0ddd8fa45e5142728e4e66d595e2419f7ed40b036",
+  created_at: "2026-08-09T13:37:43.068Z",
+  identity_digest: "1108dd972c90e4989036fb6ecec7dde10f54641a697bd53cfcd64017f589ace7",
+  target_digest: "72789fcd60668eeb66ee068936d3afa96deadcb007228830c64b6de783b6dcef",
+  operation_digest: "d7e37bfb2c0d28f8c4086c53224cd855d14694f32807b74c102b61a99963f3c0",
+  idempotency_digest: "b56d8ec37efb818759cdd2ee3b58bc1401ac13384c8d64c1813bb5c198b1e376",
+  receipt_digest: "52ce90c5de6817989f107d9d27e06156962a2b9c365e34e16a57aa37886501a2",
+  response_digest: "2fa3ed508f5f192c18753b1205ced996340fdf02f735420d32db897fc239805c"
+};
+var FLEET_RESOURCES_HISTORICAL_RECEIPT = {
+  receipt_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.receipt_id,
+  authority: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority,
+  route: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_route,
+  package_version: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.package_version,
+  authority_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_id,
+  tenant_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.tenant_id,
+  corpus_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.corpus_id,
+  operation_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_id,
+  step_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.step_id,
+  resource_kind: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.resource_kind,
+  direction: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.direction,
+  idempotency_key: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_key,
+  request_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.request_digest,
+  precondition_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.precondition_digest,
+  outcome: "accepted",
+  reason: null,
+  target_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_id,
+  result_revision: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.result_revision,
+  result_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.result_digest,
+  duplicate_of_receipt_id: null,
+  accepted_receipt_id: null,
+  created_by_operation: true,
+  created_at: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.created_at
+};
+var FLEET_RESOURCES_HISTORICAL_RESPONSE_CONTROL = {
+  response_byte_limit: 131072,
+  time_budget_ms: 1e4,
+  response_bytes: 1101,
+  elapsed_ms: 2,
+  complete: true,
+  truncated: false
+};
+var FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY = {
+  authority_id: "mementos",
+  tenant_id: ROOT_TENANT_ID,
+  corpus_id: "mementos:postgresql"
+};
+var FLEET_RESOURCES_HISTORICAL_LOOKUP_IDENTITY = {
+  source: {
+    authority: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority,
+    authority_route: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_route,
+    package_version: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.package_version,
+    authority_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_id,
+    tenant_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.tenant_id,
+    corpus_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.corpus_id,
+    operation_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_id,
+    step_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.step_id,
+    resource_kind: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.resource_kind,
+    direction: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.direction,
+    target_selector: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_selector,
+    target_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_id,
+    idempotency_key: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_key,
+    receipt_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.receipt_id
+  },
+  destination: FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY,
+  lookup_only: true,
+  immutable_receipt: true
+};
+
+// src/project-registration/authority.ts
+function canonicalMementosProjectRegistrationJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (!value || typeof value !== "object")
+    return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      out[key] = canonicalize(item);
+  }
+  return out;
+}
+function digestMementosProjectRegistrationValue(value) {
+  return createHash("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
+}
+
+// src/diagnostics/historical-project-registration-receipt.ts
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+
+class HistoricalReceiptDiagnosticError extends Error {
+  code;
+  constructor(code) {
+    super(`historical receipt diagnostic failed: ${code}`);
+    this.code = code;
+    this.name = "HistoricalReceiptDiagnosticError";
+  }
+}
+var TABLE_FINGERPRINT_SQL = `
+  SELECT
+    COUNT(*)::text AS count,
+    md5(COALESCE(
+      string_agg(
+        md5(row_to_json(receipt_row)::text),
+        '' ORDER BY receipt_row.receipt_id
+      ),
+      ''
+    )) AS digest
+  FROM mementos_project_registration_receipts AS receipt_row
+`;
+var EXACT_RECEIPT_SQL = `
+  SELECT
+    receipt_id, authority, route, package_version, authority_id, tenant_id,
+    corpus_id, operation_id, step_id, resource_kind, direction,
+    target_selector, idempotency_key, request_digest, precondition_digest,
+    normalized_call_digest, outcome, reason, target_id, result_revision,
+    result_digest, duplicate_of_receipt_id, accepted_receipt_id,
+    created_by_operation, created_at
+  FROM mementos_project_registration_receipts
+  WHERE authority_id = $1
+    AND tenant_id = $2
+    AND corpus_id = $3
+    AND operation_id = $4
+    AND step_id = $5
+    AND resource_kind = $6
+    AND direction = $7
+    AND target_selector = $8
+    AND idempotency_key = $9
+    AND target_id = $10
+  ORDER BY created_at ASC, receipt_id ASC
+  LIMIT 2
+`;
+function timestamp(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  return String(value);
+}
+function storedReceipt(row) {
+  return {
+    ...row,
+    authority: "mementos",
+    resource_kind: "project",
+    direction: String(row["direction"]),
+    outcome: String(row["outcome"]),
+    created_by_operation: row["created_by_operation"] === true || Number(row["created_by_operation"]) === 1,
+    created_at: timestamp(row["created_at"])
+  };
+}
+function publicReceipt(row) {
+  const {
+    target_selector: _targetSelector,
+    normalized_call_digest: _normalizedCallDigest,
+    ...receipt
+  } = row;
+  return receipt;
+}
+function assertEqual(actual, wanted, code) {
+  if (actual !== wanted)
+    throw new HistoricalReceiptDiagnosticError(code);
+}
+function assertDigest(actual, wanted, code) {
+  if (!SHA256_PATTERN.test(actual) || actual !== wanted) {
+    throw new HistoricalReceiptDiagnosticError(code);
+  }
+}
+async function tableFingerprint(query) {
+  const result = await query.query(TABLE_FINGERPRINT_SQL);
+  if (result.rows.length !== 1) {
+    throw new HistoricalReceiptDiagnosticError("table_fingerprint_unavailable");
+  }
+  const fingerprint = result.rows[0];
+  if (!/^\d+$/.test(fingerprint.count) || !/^[0-9a-f]{32}$/.test(fingerprint.digest)) {
+    throw new HistoricalReceiptDiagnosticError("table_fingerprint_invalid");
+  }
+  return fingerprint;
+}
+async function diagnoseHistoricalProjectRegistrationReceipt(query) {
+  await query.query("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY");
+  try {
+    const readOnly = await query.query("SHOW transaction_read_only");
+    assertEqual(readOnly.rows[0]?.transaction_read_only, "on", "transaction_not_read_only");
+    const before = await tableFingerprint(query);
+    const exact = await query.query(EXACT_RECEIPT_SQL, [
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_id,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.tenant_id,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.corpus_id,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_id,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.step_id,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.resource_kind,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.direction,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_selector,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_key,
+      FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_id
+    ]);
+    assertEqual(exact.rows.length, 1, "exact_receipt_count_not_one");
+    const stored = storedReceipt(exact.rows[0]);
+    if (!SHA256_PATTERN.test(stored.normalized_call_digest)) {
+      throw new HistoricalReceiptDiagnosticError("normalized_call_digest_invalid");
+    }
+    assertEqual(stored.target_selector, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_selector, "target_selector_mismatch");
+    const receipt = publicReceipt(stored);
+    assertEqual(canonicalMementosProjectRegistrationJson(receipt), canonicalMementosProjectRegistrationJson(FLEET_RESOURCES_HISTORICAL_RECEIPT), "receipt_content_mismatch");
+    const identityDigest = digestMementosProjectRegistrationValue({
+      authority_id: receipt.authority_id,
+      tenant_id: receipt.tenant_id,
+      corpus_id: receipt.corpus_id
+    });
+    const targetDigest = digestMementosProjectRegistrationValue({
+      authority_id: receipt.authority_id,
+      tenant_id: receipt.tenant_id,
+      corpus_id: receipt.corpus_id,
+      target_selector: stored.target_selector,
+      target_id: receipt.target_id
+    });
+    const operationDigest = digestMementosProjectRegistrationValue({
+      operation_id: receipt.operation_id,
+      step_id: receipt.step_id,
+      direction: receipt.direction
+    });
+    const idempotencyDigest = digestMementosProjectRegistrationValue({
+      idempotency_key: receipt.idempotency_key
+    });
+    const receiptDigest = digestMementosProjectRegistrationValue(receipt);
+    const responseDigest = digestMementosProjectRegistrationValue({
+      receipt,
+      response_control: FLEET_RESOURCES_HISTORICAL_RESPONSE_CONTROL
+    });
+    assertDigest(identityDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.identity_digest, "identity_digest_mismatch");
+    assertDigest(targetDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_digest, "target_digest_mismatch");
+    assertDigest(operationDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_digest, "operation_digest_mismatch");
+    assertDigest(idempotencyDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_digest, "idempotency_digest_mismatch");
+    assertDigest(receipt.result_digest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.result_digest, "result_digest_mismatch");
+    assertDigest(receiptDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.receipt_digest, "receipt_digest_mismatch");
+    assertDigest(responseDigest, FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.response_digest, "response_digest_mismatch");
+    const after = await tableFingerprint(query);
+    assertEqual(after.count, before.count, "table_count_changed");
+    assertEqual(after.digest, before.digest, "table_digest_changed");
+    return {
+      schema: "mementos.historical-project-registration-receipt-diagnostic.v1",
+      status: "PASS",
+      transaction_read_only: true,
+      exact_receipt_count: 1,
+      table_count_before: before.count,
+      table_count_after: after.count,
+      table_digest_before: before.digest,
+      table_digest_after: after.digest,
+      table_count_unchanged: true,
+      table_digest_unchanged: true,
+      authority_id: receipt.authority_id,
+      tenant_id: receipt.tenant_id,
+      corpus_id: receipt.corpus_id,
+      operation_id: receipt.operation_id,
+      step_id: receipt.step_id,
+      target_selector: stored.target_selector,
+      target_id: receipt.target_id,
+      receipt_id: receipt.receipt_id,
+      identity_digest: identityDigest,
+      target_digest: targetDigest,
+      operation_digest: operationDigest,
+      idempotency_digest: idempotencyDigest,
+      result_digest: receipt.result_digest,
+      receipt_digest: receiptDigest,
+      response_digest: responseDigest
+    };
+  } finally {
+    await query.query("ROLLBACK");
+  }
+}
+async function main() {
+  const connectionString = process.env["HASNA_MEMENTOS_DATABASE_URL"]?.trim() || process.env["DATABASE_URL"]?.trim();
+  if (!connectionString) {
+    throw new HistoricalReceiptDiagnosticError("database_url_unavailable");
+  }
+  const parsed = new URL(connectionString);
+  const sslMode = parsed.searchParams.get("sslmode")?.trim().toLowerCase();
+  const sslEnabled = ["require", "verify-ca", "verify-full"].includes(sslMode ?? "") || ["1", "true", "yes", "on"].includes(parsed.searchParams.get("ssl")?.trim().toLowerCase() ?? "");
+  parsed.searchParams.delete("ssl");
+  parsed.searchParams.delete("sslmode");
+  const pool = new pg2.Pool({
+    connectionString: parsed.toString(),
+    ssl: sslEnabled ? { rejectUnauthorized: sslMode === "verify-ca" || sslMode === "verify-full" } : undefined,
+    max: 1
+  });
+  const client = await pool.connect();
+  try {
+    const report = await diagnoseHistoricalProjectRegistrationReceipt({
+      async query(sql, values) {
+        const result = await client.query(sql, values);
+        return {
+          rows: result.rows,
+          rowCount: result.rowCount
+        };
+      }
+    });
+    process.stdout.write(`${JSON.stringify(report)}
+`);
+  } finally {
+    client.release();
+    await pool.end();
+  }
+}
+var invokedPath = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
+var invokedByBunEval = import.meta.url.endsWith("/%5Beval%5D");
+if (import.meta.url === invokedPath || invokedByBunEval) {
+  main().catch((error) => {
+    const code = error instanceof HistoricalReceiptDiagnosticError ? error.code : "unexpected_failure";
+    process.stderr.write(`historical receipt diagnostic failed: ${code}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  diagnoseHistoricalProjectRegistrationReceipt,
+  HistoricalReceiptDiagnosticError
+};