@hasna/mementos 0.14.80 → 0.14.81

package/dist/project-registration.js

@@ -46,6 +46,1138 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/generated/storage-kit/mode.ts
+function normalizeStorageMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return { mode: "local", deprecatedAlias: null };
+  if (normalized === "cloud")
+    return { mode: "cloud", deprecatedAlias: null };
+  if (DEPRECATED_STORAGE_MODE_ALIASES.includes(normalized)) {
+    return { mode: "cloud", deprecatedAlias: normalized };
+  }
+  throw new Error(`Unknown storage mode: ${value}. Use local or cloud.`);
+}
+var DEPRECATED_STORAGE_MODE_ALIASES;
+var init_mode = __esm(() => {
+  DEPRECATED_STORAGE_MODE_ALIASES = [
+    "remote",
+    "hybrid",
+    "self_hosted"
+  ];
+});
+
+// src/storage.ts
+import { Database } from "bun:sqlite";
+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 markServerContext() {
+  _serverContext = true;
+}
+function resetServerContextForTests() {
+  if (process.env["NODE_ENV"] !== "test") {
+    throw new Error("resetServerContextForTests is only available under NODE_ENV=test");
+  }
+  _serverContext = false;
+}
+function isServerContext() {
+  return _serverContext;
+}
+function normalizeParams(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((value) => value === undefined ? null : value);
+}
+
+class SqliteAdapter {
+  db;
+  constructor(path) {
+    this.db = new Database(path, { create: true });
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+  }
+  run(sql, ...params) {
+    const result = this.db.prepare(sql).run(...normalizeParams(params));
+    return {
+      changes: result.changes,
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+  get(sql, ...params) {
+    return this.db.prepare(sql).get(...normalizeParams(params));
+  }
+  all(sql, ...params) {
+    return this.db.prepare(sql).all(...normalizeParams(params));
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  query(sql) {
+    return this.db.query(sql);
+  }
+  prepare(sql) {
+    const statement = this.db.prepare(sql);
+    return {
+      run: (...params) => {
+        const result = statement.run(...normalizeParams(params));
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid
+        };
+      },
+      get: (...params) => statement.get(...normalizeParams(params)),
+      all: (...params) => statement.all(...normalizeParams(params)),
+      finalize: () => {
+        statement.finalize();
+      }
+    };
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  get raw() {
+    return this.db;
+  }
+}
+function translateSql(sql) {
+  let parameterIndex = 0;
+  let translated = sql.replace(/\?/g, () => `$${++parameterIndex}`);
+  const ISO_FMT = `'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'`;
+  translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, `to_char(now() AT TIME ZONE 'UTC', ${ISO_FMT})`);
+  translated = translated.replace(/datetime\s*\(\s*'now'\s*,\s*'(-?\d+)\s+(minutes?|hours?|days?|seconds?)'\s*\)/gi, (_match, amount, unit) => {
+    const parsed = parseInt(String(amount), 10);
+    const absolute = Math.abs(parsed);
+    const normalizedUnit = String(unit).toLowerCase().replace(/s$/, "");
+    const pluralUnit = absolute === 1 ? normalizedUnit : `${normalizedUnit}s`;
+    const op = parsed < 0 ? "-" : "+";
+    return `to_char((now() ${op} INTERVAL '${absolute} ${pluralUnit}') AT TIME ZONE 'UTC', ${ISO_FMT})`;
+  });
+  translated = translated.replace(/COALESCE\s*\(\s*accessed_at\s*,\s*(created_at|updated_at)\s*\)/gi, (_match, col) => `COALESCE(accessed_at, to_char(${col} AT TIME ZONE 'UTC', ${ISO_FMT}))`);
+  translated = translated.replace(/lower\s*\(\s*hex\s*\(\s*randomblob\s*\(\s*\d+\s*\)\s*\)\s*\)/gi, "gen_random_uuid()::text");
+  translated = translated.replace(/\bIFNULL\s*\(/gi, "COALESCE(");
+  translated = translated.replace(/\bINSTR\s*\(/gi, "STRPOS(");
+  if (/INSERT\s+OR\s+IGNORE\s+INTO/i.test(translated)) {
+    translated = translated.replace(/INSERT\s+OR\s+IGNORE\s+INTO/gi, "INSERT INTO");
+    translated = translated.replace(/;?\s*$/, " ON CONFLICT DO NOTHING");
+  }
+  translated = translated.replace(/INSERT\s+OR\s+REPLACE\s+INTO/gi, "INSERT INTO");
+  translated = translated.replace(/COALESCE\s*\(\s*pinned\s*,\s*0\s*\)/gi, "COALESCE(pinned, FALSE)");
+  const BOOLEAN_COLUMNS = [
+    "pinned",
+    "success",
+    "is_primary",
+    "blocking",
+    "enabled",
+    "useful",
+    "dry_run",
+    "applied"
+  ];
+  for (const col of BOOLEAN_COLUMNS) {
+    translated = translated.replace(new RegExp(`\\b${col}\\s*=\\s*1\\b`, "gi"), `${col} = TRUE`);
+    translated = translated.replace(new RegExp(`\\b${col}\\s*=\\s*0\\b`, "gi"), `${col} = FALSE`);
+  }
+  return translated;
+}
+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;
+  }
+}
+function makePool(connectionString) {
+  return new pg.Pool({
+    connectionString: stripSslParams(connectionString),
+    ssl: sslConfigFor(connectionString)
+  });
+}
+
+class PgAdapter {
+  pool;
+  constructor(input) {
+    this.pool = typeof input === "string" ? new PgSyncPool(input) : input;
+  }
+  run(sql, ...params) {
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return {
+      changes: result.rowCount ?? 0,
+      lastInsertRowid: result.rows?.[0]?.id ?? 0
+    };
+  }
+  get(sql, ...params) {
+    const result = this.pool.query(translateSql(sql), normalizeParams(params));
+    return result.rows[0] ?? null;
+  }
+  all(sql, ...params) {
+    return this.pool.query(translateSql(sql), normalizeParams(params)).rows;
+  }
+  exec(sql) {
+    this.pool.query(sql, []);
+  }
+  prepare(sql) {
+    return {
+      run: (...params) => this.run(sql, ...params),
+      get: (...params) => this.get(sql, ...params),
+      all: (...params) => this.all(sql, ...params),
+      finalize: () => {}
+    };
+  }
+  query(sql) {
+    return this.prepare(sql);
+  }
+  close() {
+    this.pool.end();
+  }
+  transaction(fn) {
+    this.pool.query("BEGIN", []);
+    try {
+      const value = fn();
+      this.pool.query("COMMIT", []);
+      return value;
+    } catch (error) {
+      try {
+        this.pool.query("ROLLBACK", []);
+      } catch {}
+      throw error;
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
+
+class PgAdapterAsync {
+  pool;
+  constructor(input) {
+    this.pool = typeof input === "string" ? makePool(input) : input;
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translateSql(sql), normalizeParams(params));
+    return {
+      changes: result.rowCount ?? 0,
+      lastInsertRowid: result.rows?.[0]?.id ?? 0
+    };
+  }
+  async get(sql, ...params) {
+    const result = await this.pool.query(translateSql(sql), normalizeParams(params));
+    return result.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translateSql(sql), normalizeParams(params));
+    return result.rows;
+  }
+  async exec(sql) {
+    await this.pool.query(sql);
+  }
+  async close() {
+    await this.pool.end();
+  }
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const value = await fn(client);
+      await client.query("COMMIT");
+      return value;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  get raw() {
+    return this.pool;
+  }
+}
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : null;
+}
+function warnDeprecatedStorageMode(alias) {
+  if (warnedDeprecatedModes.has(alias))
+    return;
+  warnedDeprecatedModes.add(alias);
+  process.emitWarning(`${MEMENTOS_STORAGE_ENV.mode}="${alias}" is deprecated; use "cloud". ` + `"${alias}" now maps to pure-remote cloud storage. The local<->remote ` + `sync path is deprecated and is not the fleet cutover path.`, { type: "DeprecationWarning", code: "MEMENTOS_STORAGE_MODE_ALIAS" });
+}
+function normalizeStorageMode2(value, source) {
+  if (!value || !value.trim())
+    return null;
+  let normalized;
+  try {
+    normalized = normalizeStorageMode(value);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`mementos: ${source}=${value} is not a valid mode. ${detail}`);
+  }
+  if (normalized.deprecatedAlias) {
+    warnDeprecatedStorageMode(normalized.deprecatedAlias);
+  }
+  return normalized.mode;
+}
+function readConfigFile() {
+  if (!existsSync(STORAGE_CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(STORAGE_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getConfigDir() {
+  return STORAGE_CONFIG_DIR;
+}
+function getConfigPath() {
+  return STORAGE_CONFIG_PATH;
+}
+function getStorageDatabaseEnv() {
+  for (const env of DATABASE_ENV_NAMES) {
+    if (readEnv(env.name))
+      return env;
+  }
+  return null;
+}
+function getStorageEnvName(key) {
+  const canonical = MEMENTOS_STORAGE_ENV[key];
+  const fallback = MEMENTOS_STORAGE_FALLBACK_ENV[key];
+  return readEnv(canonical) || !readEnv(fallback) ? canonical : fallback;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) : null;
+}
+function getStorageDatabaseEnvName() {
+  return getStorageEnvName("databaseUrl");
+}
+function getStorageModeOverride() {
+  for (const env of MODE_ENV_NAMES) {
+    const value = normalizeStorageMode2(readEnv(env.name) ?? undefined, env.name);
+    if (value)
+      return value;
+  }
+  return null;
+}
+function getStorageConfig() {
+  const fileConfig = readConfigFile();
+  const modeOverride = getStorageModeOverride();
+  const envConnectionString = getConfiguredConnectionString();
+  const fileMode = normalizeStorageMode2(fileConfig.mode, `${STORAGE_CONFIG_PATH} "mode"`);
+  const merged = {
+    ...DEFAULT_STORAGE_CONFIG,
+    ...fileConfig,
+    rds: {
+      ...DEFAULT_STORAGE_CONFIG.rds,
+      ...fileConfig.rds ?? {}
+    },
+    sync: {
+      ...DEFAULT_STORAGE_CONFIG.sync,
+      ...fileConfig.sync ?? {}
+    },
+    mode: fileMode ?? DEFAULT_STORAGE_CONFIG.mode
+  };
+  if (modeOverride) {
+    merged.mode = modeOverride;
+  } else if (envConnectionString && merged.mode === "local") {
+    merged.mode = "cloud";
+  }
+  return merged;
+}
+function getStorageMode() {
+  return getStorageConfig().mode;
+}
+function isSecretQueryParam(key) {
+  const normalized = key.trim().toLowerCase();
+  return SECRET_QUERY_PARAMS.has(normalized) || /(?:secret|token|password|passphrase|credential|api[_-]?key|apikey|private[_-]?key|auth|session)/i.test(normalized);
+}
+function redactDatabaseUrl(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    const url = new URL(value);
+    if (url.password) {
+      url.password = "***";
+    }
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (isSecretQueryParam(key)) {
+        url.searchParams.set(key, "***");
+      }
+    }
+    return url.toString();
+  } catch {
+    return value.replace(/:[^:@/\s]+@/, ":***@").replace(/([?&\s][^=&\s]*(?:secret|token|password|passphrase|credential|api[_-]?key|apikey|private[_-]?key|auth|session)[^=&\s]*=)[^&\s]+/gi, "$1***");
+  }
+}
+function validatePostgresConnectionString(value) {
+  const redactedUrl = redactDatabaseUrl(value);
+  if (!value) {
+    return {
+      ok: false,
+      redacted_url: redactedUrl,
+      issues: ["Missing PostgreSQL/RDS connection string."]
+    };
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return {
+      ok: false,
+      redacted_url: redactedUrl,
+      issues: ["PostgreSQL/RDS connection string must be a valid postgres:// or postgresql:// URL."]
+    };
+  }
+  if (url.protocol !== "postgres:" && url.protocol !== "postgresql:") {
+    return {
+      ok: false,
+      redacted_url: redactedUrl,
+      issues: ["PostgreSQL/RDS connection string must use postgres:// or postgresql://."]
+    };
+  }
+  if (!url.hostname) {
+    return {
+      ok: false,
+      redacted_url: redactedUrl,
+      issues: ["PostgreSQL/RDS connection string must include a host."]
+    };
+  }
+  return {
+    ok: true,
+    redacted_url: redactedUrl,
+    issues: []
+  };
+}
+function storageEnvStatus(key) {
+  const activeName = getStorageEnvName(key);
+  return {
+    name: MEMENTOS_STORAGE_ENV[key],
+    active_name: activeName,
+    configured: readEnv(activeName) !== null
+  };
+}
+function remoteDatabaseConfigStatus(config) {
+  const env = getStorageDatabaseEnv();
+  const envUrl = env ? readEnv(env.name) : null;
+  if (env && envUrl) {
+    const validation = validatePostgresConnectionString(envUrl);
+    return {
+      configured: validation.ok,
+      source: "env",
+      env_name: env.name,
+      redacted_url: validation.redacted_url,
+      missing: [],
+      issues: validation.issues,
+      rds_compatible: validation.ok
+    };
+  }
+  const missing = [];
+  if (!config.rds.host) {
+    missing.push("storage.rds.host");
+  }
+  if (!config.rds.username) {
+    missing.push("storage.rds.username");
+  }
+  if (!readEnv(config.rds.password_env)) {
+    missing.push(config.rds.password_env);
+  }
+  const configured = missing.length === 0;
+  const redactedUrl = configured ? `postgres://${config.rds.username}:***@${config.rds.host}:${config.rds.port}/mementos${config.rds.ssl ? "?sslmode=require" : ""}` : null;
+  const issues = missing.length === 0 ? [] : [`Missing ${missing.join(", ")}.`];
+  return {
+    configured,
+    source: config.rds.host || config.rds.username ? "config-file" : "none",
+    env_name: null,
+    redacted_url: redactedUrl,
+    missing,
+    issues,
+    rds_compatible: configured
+  };
+}
+function runtimeKindFor(mode) {
+  return mode === "cloud" ? "cloud-postgres" : "local-sqlite";
+}
+function getSafeStorageConfigSummary(config = getStorageConfig()) {
+  return {
+    mode: config.mode,
+    auto_sync_interval_minutes: config.auto_sync_interval_minutes,
+    feedback_endpoint_configured: config.feedback_endpoint.trim() !== "",
+    sync: { ...config.sync },
+    rds: {
+      host_configured: config.rds.host.trim() !== "",
+      port: config.rds.port,
+      username_configured: config.rds.username.trim() !== "",
+      password_env: config.rds.password_env,
+      password_configured: readEnv(config.rds.password_env) !== null,
+      ssl: config.rds.ssl
+    }
+  };
+}
+function getStorageStatus() {
+  const config = getStorageConfig();
+  const mode = config.mode;
+  const remoteRequested = mode === "cloud";
+  const remote = remoteDatabaseConfigStatus(config);
+  const issues = [];
+  const warnings = [];
+  if (remoteRequested && !remote.configured) {
+    issues.push(`Cloud PostgreSQL/RDS storage is requested but not configured. ${remote.issues.join(" ")}`);
+  }
+  if (mode === "local" && remote.issues.length > 0 && remote.source !== "none") {
+    warnings.push(`Cloud PostgreSQL/RDS configuration is present but invalid; cloud runtime stays disabled until fixed. ${remote.issues.join(" ")}`);
+  }
+  if (mode === "local" && remote.configured) {
+    warnings.push("Cloud PostgreSQL/RDS configuration is present, but storage mode is local; cloud runtime stays disabled until mode is cloud.");
+  }
+  const failClosed = remoteRequested && !remote.configured;
+  const runtime = {
+    contract: "mementos-cloud-runtime-v1",
+    kind: runtimeKindFor(mode),
+    fail_closed: failClosed,
+    local: {
+      adapter: "sqlite",
+      primary_runtime: mode === "local",
+      data_dir: LOCAL_DATA_DIR,
+      config_path: STORAGE_CONFIG_PATH,
+      local_file_sync: {
+        supported: false,
+        reason: "Mementos stores local state in SQLite; it does not sync raw local data files."
+      }
+    },
+    remote: {
+      adapter: "postgres",
+      purpose: "primary-runtime",
+      requested: remoteRequested,
+      configured: remote.configured,
+      source: remote.source,
+      env_name: remote.env_name,
+      redacted_url: remote.redacted_url,
+      rds_compatible: remote.rds_compatible,
+      fail_closed: failClosed,
+      missing: remote.missing
+    },
+    object_storage: {
+      s3: {
+        supported: false,
+        mutation_allowed: false,
+        reason: "No S3 object-storage adapter is part of this runtime."
+      },
+      aws: {
+        mutation_allowed: false,
+        reason: "Diagnostics do not store sensitive values, change AWS resources, deploy, or mutate production data."
+      }
+    },
+    migrations: {
+      target: "postgres-rds-compatible",
+      command: "mementos storage migrate",
+      dry_run_command: "mementos storage migrate --dry-run",
+      configured: remote.configured,
+      mutates_remote_on_apply: true,
+      requires_approval_for_live_run: true
+    }
+  };
+  return {
+    ok: issues.length === 0,
+    service: "mementos",
+    mode,
+    local_default: mode === "local",
+    remote_enabled: remoteRequested,
+    runtime,
+    database: {
+      configured: remote.configured,
+      redacted_url: remote.redacted_url,
+      source: remote.source,
+      env_name: remote.env_name,
+      rds_compatible: remote.rds_compatible
+    },
+    tables: MEMENTOS_STORAGE_TABLES,
+    env: {
+      databaseUrl: storageEnvStatus("databaseUrl"),
+      mode: storageEnvStatus("mode")
+    },
+    issues,
+    warnings,
+    no_network: true
+  };
+}
+function saveStorageConfig(config) {
+  mkdirSync(STORAGE_CONFIG_DIR, { recursive: true });
+  writeFileSync(STORAGE_CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function getConfiguredConnectionString() {
+  return getStorageDatabaseUrl() ?? undefined;
+}
+function getStorageConnectionString(dbName = "mementos") {
+  if (!isServerContext()) {
+    throw new Error("Refusing to construct an RDS Postgres DSN outside the mementos-serve server. " + "The raw database DSN is NEVER distributed to client machines. " + "Clients must use the self-hosted HTTP API: set HASNA_MEMENTOS_API_URL and " + "HASNA_MEMENTOS_API_KEY (and unset HASNA_MEMENTOS_DATABASE_URL / HASNA_MEMENTOS_STORAGE_MODE).");
+  }
+  const envConnectionString = getConfiguredConnectionString();
+  if (envConnectionString) {
+    const validation = validatePostgresConnectionString(envConnectionString);
+    if (!validation.ok) {
+      throw new Error(`Remote storage database is not configured. ${validation.issues.join(" ")}`);
+    }
+    return envConnectionString;
+  }
+  const config = getStorageConfig();
+  const { host, port, username, password_env, ssl } = config.rds;
+  const missing = [];
+  if (!host) {
+    missing.push("storage.rds.host");
+  }
+  if (!username) {
+    missing.push("storage.rds.username");
+  }
+  if (missing.length > 0) {
+    throw new Error(`Remote storage database is not configured. Missing ${missing.join(", ")}. Set HASNA_MEMENTOS_DATABASE_URL or configure ~/.hasna/mementos/storage/config.json.`);
+  }
+  const password = process.env[password_env];
+  if (!password) {
+    throw new Error(`Remote storage database password is not set. Export ${password_env}.`);
+  }
+  const sslParam = ssl ? "?sslmode=require" : "";
+  return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
+}
+function isSyncExcludedTable(table) {
+  return SYNC_EXCLUDED_TABLE_PATTERNS.some((pattern) => pattern.test(table));
+}
+function listSqliteTables(db) {
+  const rows = db.all("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name");
+  return rows.map((row) => row.name);
+}
+function ensureSyncMetaTable(db) {
+  db.exec(SYNC_META_TABLE_SQL);
+}
+function getSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  return db.get("SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta WHERE table_name = ?", table);
+}
+function upsertSyncMeta(db, meta) {
+  ensureSyncMetaTable(db);
+  const existing = db.get("SELECT table_name FROM _sync_meta WHERE table_name = ?", meta.table_name);
+  if (existing) {
+    db.run("UPDATE _sync_meta SET last_synced_at = ?, last_synced_row_count = ?, direction = ? WHERE table_name = ?", meta.last_synced_at, meta.last_synced_row_count, meta.direction, meta.table_name);
+    return;
+  }
+  db.run("INSERT INTO _sync_meta (table_name, last_synced_at, last_synced_row_count, direction) VALUES (?, ?, ?, ?)", meta.table_name, meta.last_synced_at, meta.last_synced_row_count, meta.direction);
+}
+function transferRows(target, table, rows, options) {
+  const primaryKey = options.primaryKey ?? "id";
+  const conflictColumn = options.conflictColumn ?? "updated_at";
+  let written = 0;
+  let skipped = 0;
+  const errors = [];
+  if (rows.length === 0) {
+    return { written, skipped, errors };
+  }
+  const columns = Object.keys(rows[0] ?? {});
+  if (!columns.includes(primaryKey)) {
+    return {
+      written,
+      skipped,
+      errors: [`Table "${table}" has no "${primaryKey}" column; skipping`]
+    };
+  }
+  const hasConflictColumn = columns.includes(conflictColumn);
+  for (const row of rows) {
+    try {
+      const existing = target.get(`SELECT "${primaryKey}"${hasConflictColumn ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
+      if (existing) {
+        if (hasConflictColumn && existing[conflictColumn] && row[conflictColumn]) {
+          const existingTime = Date.parse(String(existing[conflictColumn]));
+          const incomingTime = Date.parse(String(row[conflictColumn]));
+          if (Number.isFinite(existingTime) && Number.isFinite(incomingTime) && existingTime >= incomingTime) {
+            skipped++;
+            continue;
+          }
+        }
+        const updateColumns = columns.filter((column) => column !== primaryKey);
+        const setClauses = updateColumns.map((column) => `"${column}" = ?`).join(", ");
+        target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...updateColumns.map((column) => row[column]), row[primaryKey]);
+      } else {
+        const placeholders = columns.map(() => "?").join(", ");
+        const columnList = columns.map((column) => `"${column}"`).join(", ");
+        target.run(`INSERT INTO "${table}" (${columnList}) VALUES (${placeholders})`, ...columns.map((column) => row[column]));
+      }
+      written++;
+    } catch (error) {
+      errors.push(`Row ${String(row[primaryKey] ?? "unknown")}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { written, skipped, errors };
+}
+function incrementalSyncPush(local, remote, tables, options = {}) {
+  return runIncrementalSync("push", local, remote, local, tables, options);
+}
+function incrementalSyncPull(remote, local, tables, options = {}) {
+  return runIncrementalSync("pull", remote, local, local, tables, options);
+}
+function runIncrementalSync(direction, source, target, metaDb, tables, options) {
+  const conflictColumn = options.conflictColumn ?? "updated_at";
+  const batchSize = options.batchSize ?? 500;
+  const results = [];
+  ensureSyncMetaTable(metaDb);
+  for (const table of tables) {
+    const stat = {
+      table,
+      total_rows: 0,
+      synced_rows: 0,
+      skipped_rows: 0,
+      errors: [],
+      first_sync: false
+    };
+    try {
+      const countResult = source.get(`SELECT COUNT(*) as cnt FROM "${table}"`);
+      stat.total_rows = countResult?.cnt ?? 0;
+      const meta = getSyncMeta(metaDb, table);
+      let rows;
+      if (meta?.last_synced_at) {
+        try {
+          rows = source.all(`SELECT * FROM "${table}" WHERE "${conflictColumn}" > ?`, meta.last_synced_at);
+        } catch {
+          rows = source.all(`SELECT * FROM "${table}"`);
+          stat.first_sync = true;
+        }
+      } else {
+        rows = source.all(`SELECT * FROM "${table}"`);
+        stat.first_sync = true;
+      }
+      for (let offset = 0;offset < rows.length; offset += batchSize) {
+        const batch = rows.slice(offset, offset + batchSize);
+        const result = transferRows(target, table, batch, options);
+        stat.synced_rows += result.written;
+        stat.skipped_rows += result.skipped;
+        stat.errors.push(...result.errors);
+      }
+      if (rows.length === 0) {
+        stat.skipped_rows = stat.total_rows;
+      }
+      upsertSyncMeta(metaDb, {
+        table_name: table,
+        last_synced_at: new Date().toISOString(),
+        last_synced_row_count: stat.synced_rows,
+        direction
+      });
+    } catch (error) {
+      stat.errors.push(`Table "${table}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+    results.push(stat);
+  }
+  return results;
+}
+function getSyncMetaAll(db) {
+  ensureSyncMetaTable(db);
+  return db.all("SELECT table_name, last_synced_at, last_synced_row_count, direction FROM _sync_meta ORDER BY table_name");
+}
+function getSyncMetaForTable(db, table) {
+  return getSyncMeta(db, table);
+}
+function resetSyncMeta(db, table) {
+  ensureSyncMetaTable(db);
+  db.run("DELETE FROM _sync_meta WHERE table_name = ?", table);
+}
+function resetAllSyncMeta(db) {
+  ensureSyncMetaTable(db);
+  db.run("DELETE FROM _sync_meta");
+}
+var _serverContext = false, PgSyncPool, MEMENTOS_STORAGE_TABLES, STORAGE_TABLES, MEMENTOS_STORAGE_ENV, MEMENTOS_STORAGE_FALLBACK_ENV, LOCAL_DATA_DIR, DEFAULT_STORAGE_CONFIG, STORAGE_CONFIG_DIR, STORAGE_CONFIG_PATH, DATABASE_ENV_NAMES, MODE_ENV_NAMES, warnedDeprecatedModes, SECRET_QUERY_PARAMS, getMementosStorageStatus, SYNC_EXCLUDED_TABLE_PATTERNS, SYNC_META_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _sync_meta (
+  table_name TEXT PRIMARY KEY,
+  last_synced_at TEXT,
+  last_synced_row_count INTEGER DEFAULT 0,
+  direction TEXT DEFAULT 'push'
+)`;
+var init_storage = __esm(() => {
+  init_mode();
+  PgSyncPool = 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();
+    }
+  };
+  MEMENTOS_STORAGE_TABLES = [
+    "projects",
+    "agents",
+    "machines",
+    "sessions",
+    "entities",
+    "memories",
+    "relations",
+    "entity_memories",
+    "memory_tags",
+    "memory_versions",
+    "memory_embeddings",
+    "tool_events",
+    "resource_locks",
+    "memory_ratings"
+  ];
+  STORAGE_TABLES = MEMENTOS_STORAGE_TABLES;
+  MEMENTOS_STORAGE_ENV = {
+    databaseUrl: "HASNA_MEMENTOS_DATABASE_URL",
+    mode: "HASNA_MEMENTOS_STORAGE_MODE"
+  };
+  MEMENTOS_STORAGE_FALLBACK_ENV = {
+    databaseUrl: "MEMENTOS_DATABASE_URL",
+    mode: "MEMENTOS_STORAGE_MODE"
+  };
+  LOCAL_DATA_DIR = join(homedir(), ".hasna", "mementos");
+  DEFAULT_STORAGE_CONFIG = {
+    rds: {
+      host: "",
+      port: 5432,
+      username: "",
+      password_env: "MEMENTOS_DATABASE_PASSWORD",
+      ssl: true
+    },
+    mode: "local",
+    auto_sync_interval_minutes: 0,
+    feedback_endpoint: "",
+    sync: {
+      schedule_minutes: 0
+    }
+  };
+  STORAGE_CONFIG_DIR = join(LOCAL_DATA_DIR, "storage");
+  STORAGE_CONFIG_PATH = join(STORAGE_CONFIG_DIR, "config.json");
+  DATABASE_ENV_NAMES = [
+    { name: MEMENTOS_STORAGE_ENV.databaseUrl, deprecated: false },
+    { name: MEMENTOS_STORAGE_FALLBACK_ENV.databaseUrl, deprecated: false }
+  ];
+  MODE_ENV_NAMES = [
+    { name: MEMENTOS_STORAGE_ENV.mode, deprecated: false },
+    { name: MEMENTOS_STORAGE_FALLBACK_ENV.mode, deprecated: false }
+  ];
+  warnedDeprecatedModes = new Set;
+  SECRET_QUERY_PARAMS = new Set([
+    "password",
+    "pass",
+    "pwd",
+    "token",
+    "secret",
+    "api_key",
+    "apikey"
+  ]);
+  getMementosStorageStatus = getStorageStatus;
+  SYNC_EXCLUDED_TABLE_PATTERNS = [
+    /^sqlite_/,
+    /_fts$/,
+    /_fts_/,
+    /^_sync_/,
+    /^_pg_migrations$/
+  ];
+});
+
+// src/db/api-mode.ts
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
+import { randomUUID } from "crypto";
+function firstEnv(keys) {
+  for (const k of keys) {
+    const v = process.env[k]?.trim();
+    if (v)
+      return v;
+  }
+  return;
+}
+function firstEnvKey(keys) {
+  for (const k of keys) {
+    if (process.env[k]?.trim())
+      return k;
+  }
+  return null;
+}
+function hasDatabaseUrl() {
+  return Boolean(firstEnv(DATABASE_URL_ENV_KEYS));
+}
+function isLoopbackHost(rawHost) {
+  const host = rawHost.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+  return host === "localhost" || host === "::1" || /^127\./.test(host);
+}
+function assertRequestAllowedUnderTest(baseUrl) {
+  if (process.env["NODE_ENV"] !== "test")
+    return;
+  if (process.env[ALLOW_REMOTE_API_IN_TESTS_ENV]?.trim())
+    return;
+  let host;
+  try {
+    host = new URL(baseUrl).hostname;
+  } catch {
+    host = "";
+  }
+  if (host && isLoopbackHost(host))
+    return;
+  throw new Error("api-mode: REFUSING to make a cloud request from a test process \u2014 this would write to or read " + "from the SHARED PRODUCTION memory store, where test fixtures are indistinguishable from real " + `memories.
+` + `  host           : ${host || "(unparseable base URL)"}
+` + `  how this happens: a selector set at module scope (after the bun test preload ran), or \`bun test\` ` + `invoked from a directory with no bunfig.toml so the preload never loaded.
+` + "  fix            : build the child/process env via src/test-support/store-isolation.ts, or point the " + `suite at a loopback stub.
+` + `  override       : set ${ALLOW_REMOTE_API_IN_TESTS_ENV}=1 only for a test that must reach a remote endpoint.`);
+}
+function normalizeBase(raw) {
+  let base = raw.trim().replace(/\/+$/, "");
+  if (/\/(v1|api)$/.test(base))
+    return base;
+  return `${base}/v1`;
+}
+function assertUnambiguousStoreEnv() {
+  if (firstEnvKey(DB_PATH_ENV_KEYS))
+    return;
+  if (hasDatabaseUrl())
+    return;
+  const urlKey = firstEnvKey(API_URL_ENV_KEYS);
+  const keyKey = firstEnvKey(API_KEY_ENV_KEYS);
+  if (urlKey && !keyKey) {
+    throw new MementosStoreConfigError(`${urlKey} points at the cloud memory store but ${API_KEY_ENV_KEYS[0]} is not set. ` + `Refusing to serve the on-box SQLite store in its place, because it holds a different ` + `dataset. Set ${API_KEY_ENV_KEYS[0]} to reach the cloud store. If you meant to use the ` + `on-box SQLite store, unset ${urlKey} or set ${DB_PATH_ENV_KEYS[0]} explicitly.`);
+  }
+  if (keyKey && !urlKey) {
+    throw new MementosStoreConfigError(`${keyKey} is set but ${API_URL_ENV_KEYS[0]} is not, so the cloud memory store cannot be ` + `reached. Refusing to serve the on-box SQLite store in its place, because it holds a ` + `different dataset. Set ${API_URL_ENV_KEYS[0]} to reach the cloud store. If you meant to ` + `use the on-box SQLite store, unset ${keyKey} or set ${DB_PATH_ENV_KEYS[0]} explicitly.`);
+  }
+}
+function getApiConfig() {
+  assertUnambiguousStoreEnv();
+  if (firstEnvKey(DB_PATH_ENV_KEYS))
+    return null;
+  const rawBase = firstEnv(API_URL_ENV_KEYS);
+  const apiKey = firstEnv(API_KEY_ENV_KEYS);
+  if (!rawBase || !apiKey)
+    return null;
+  return { baseUrl: normalizeBase(rawBase), apiKey };
+}
+function isApiMode() {
+  if (hasDatabaseUrl())
+    return false;
+  return getApiConfig() !== null;
+}
+function apiRequestRaw(method, path, body) {
+  const cfg = getApiConfig();
+  if (!cfg)
+    throw new Error("api-mode: not configured (HASNA_MEMENTOS_API_URL / HASNA_MEMENTOS_API_KEY)");
+  assertRequestAllowedUnderTest(cfg.baseUrl);
+  const url = `${cfg.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  const hasBody = body !== undefined && body !== null;
+  const timeout = process.env["HASNA_MEMENTOS_API_TIMEOUT"] || DEFAULT_TIMEOUT_S;
+  const headerLines = `Authorization: Bearer ${cfg.apiKey}
+x-api-key: ${cfg.apiKey}
+`;
+  const args = [
+    "curl",
+    "-sS",
+    "--fail-with-body",
+    "-m",
+    timeout,
+    "-X",
+    method,
+    "-H",
+    "@-",
+    "-H",
+    "Content-Type: application/json",
+    "-H",
+    "Accept: application/json",
+    "-w",
+    "\\n%{http_code}"
+  ];
+  let bodyFile;
+  if (hasBody) {
+    bodyFile = join3(tmpdir(), `mem-req-${process.pid}-${randomUUID()}.json`);
+    writeFileSync2(bodyFile, JSON.stringify(body), { mode: 384 });
+    args.push("--data-binary", `@${bodyFile}`);
+  }
+  args.push(url);
+  const childEnv = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === undefined)
+      continue;
+    if (k === "HASNA_MEMENTOS_API_KEY" || k === "MEMENTOS_API_KEY")
+      continue;
+    childEnv[k] = v;
+  }
+  let out = "";
+  let err = "";
+  try {
+    const proc = Bun.spawnSync(args, {
+      stdin: Buffer.from(headerLines),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: childEnv
+    });
+    out = proc.stdout ? new TextDecoder().decode(proc.stdout) : "";
+    err = proc.stderr ? new TextDecoder().decode(proc.stderr) : "";
+  } finally {
+    if (bodyFile) {
+      try {
+        unlinkSync(bodyFile);
+      } catch {}
+    }
+  }
+  const nl = out.lastIndexOf(`
+`);
+  const codeStr = nl >= 0 ? out.slice(nl + 1).trim() : "";
+  const respBody = nl >= 0 ? out.slice(0, nl) : out;
+  const status = parseInt(codeStr, 10);
+  if (!Number.isFinite(status) || status === 0) {
+    throw new ApiRequestError(`mementos cloud request failed (${method} ${path}): ${err.trim() || "no HTTP status"}`, 0, respBody);
+  }
+  return { status, body: respBody };
+}
+function apiJson(method, path, body, options) {
+  const raw = apiRequestRaw(method, path, body);
+  if (raw.status >= 200 && raw.status < 300) {
+    const data = raw.body.trim() ? JSON.parse(raw.body) : undefined;
+    return { status: raw.status, data };
+  }
+  if (raw.status === 404 && options?.allow404) {
+    return { status: 404, data: undefined };
+  }
+  let msg = `mementos cloud ${method} ${path} \u2192 ${raw.status}`;
+  try {
+    const parsed = JSON.parse(raw.body);
+    if (parsed.error || parsed.message)
+      msg += `: ${parsed.error || parsed.message}`;
+  } catch {
+    if (raw.body.trim())
+      msg += `: ${raw.body.slice(0, 200)}`;
+  }
+  throw new ApiRequestError(msg, raw.status, raw.body);
+}
+function toQuery(params) {
+  const sp = new URLSearchParams;
+  for (const [k, v] of Object.entries(params)) {
+    if (v === undefined || v === null || v === "")
+      continue;
+    if (Array.isArray(v)) {
+      if (v.length === 0)
+        continue;
+      sp.set(k, v.join(","));
+    } else if (typeof v === "boolean") {
+      sp.set(k, v ? "true" : "false");
+    } else {
+      sp.set(k, String(v));
+    }
+  }
+  const s = sp.toString();
+  return s ? `?${s}` : "";
+}
+var API_URL_ENV_KEYS, API_KEY_ENV_KEYS, DATABASE_URL_ENV_KEYS, ALLOW_REMOTE_API_IN_TESTS_ENV = "MEMENTOS_ALLOW_REMOTE_API_IN_TESTS", DB_PATH_ENV_KEYS, MementosStoreConfigError, ApiRequestError, DEFAULT_TIMEOUT_S = "45";
+var init_api_mode = __esm(() => {
+  API_URL_ENV_KEYS = ["HASNA_MEMENTOS_API_URL", "MEMENTOS_API_URL"];
+  API_KEY_ENV_KEYS = ["HASNA_MEMENTOS_API_KEY", "MEMENTOS_API_KEY"];
+  DATABASE_URL_ENV_KEYS = ["HASNA_MEMENTOS_DATABASE_URL", "MEMENTOS_DATABASE_URL"];
+  DB_PATH_ENV_KEYS = ["HASNA_MEMENTOS_DB_PATH", "MEMENTOS_DB_PATH"];
+  MementosStoreConfigError = class MementosStoreConfigError extends Error {
+    code = "MEMENTOS_STORE_CONFIG";
+    constructor(message) {
+      super(message);
+      this.name = "MementosStoreConfigError";
+    }
+  };
+  ApiRequestError = class ApiRequestError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+      super(message);
+      this.status = status;
+      this.body = body;
+      this.name = "ApiRequestError";
+    }
+  };
+});
+
 // src/project-registration/schema.ts
 function sqliteMementosProjectRegistrationSchemaSql() {
   return `
@@ -319,22 +1451,1375 @@ function postgresMementosProjectGuardedUpdateSchemaSql() {
   `;
 }
 
+// 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;
+  `;
+}
+function postgresMementosMemoryProjectLinkSchemaSql() {
+  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 JSONB NOT NULL,
+      after_link_json JSONB NOT NULL,
+      before_project_revision TEXT,
+      before_project_digest TEXT,
+      after_project_revision TEXT,
+      after_project_digest TEXT,
+      created_at TIMESTAMPTZ 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 OR REPLACE FUNCTION mementos_memory_project_link_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos memory project link receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_memory_project_link_receipts_immutable
+      ON mementos_memory_project_link_receipts;
+    CREATE TRIGGER mementos_memory_project_link_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_memory_project_link_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_memory_project_link_receipts_immutable();
+  `;
+}
+var MEMENTOS_MEMORY_PROJECT_LINK_ROUTE = "mementos.memory-project-link.v1", MEMORY_PROJECT_LINK_RECEIPT_COLUMNS;
+var init_schema = __esm(() => {
+  MEMORY_PROJECT_LINK_RECEIPT_COLUMNS = [
+    "receipt_id",
+    "authority",
+    "route",
+    "package_version",
+    "authority_id",
+    "tenant_id",
+    "corpus_id",
+    "operation_id",
+    "step_id",
+    "direction",
+    "idempotency_key",
+    "request_digest",
+    "outcome",
+    "target_memory_id",
+    "requested_project_id",
+    "expected_memory_version",
+    "expected_memory_revision",
+    "expected_project_revision",
+    "result_memory_version",
+    "result_memory_revision",
+    "result_memory_digest",
+    "result_project_revision",
+    "result_project_digest",
+    "accepted_receipt_id",
+    "before_link_json",
+    "after_link_json",
+    "before_project_revision",
+    "before_project_digest",
+    "after_project_revision",
+    "after_project_digest",
+    "created_at"
+  ];
+});
+
+// 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;
+`, MIGRATIONS;
+var init_migrations = __esm(() => {
+  init_schema();
+  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 exports_database = {};
+__export(exports_database, {
+  uuid: () => uuid,
+  shortUuid: () => shortUuid,
+  resolvePartialId: () => resolvePartialId,
+  resetDatabase: () => resetDatabase,
+  now: () => now,
+  getDbPath: () => getDbPath,
+  getDatabase: () => getDatabase,
+  escapeLikePrefix: () => escapeLikePrefix,
+  closeDatabase: () => closeDatabase
+});
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync } from "fs";
+import { dirname as dirname2, join as join4, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestMementosDb(startDir) {
+  let dir = resolve(startDir);
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  const legacyHomeDb = resolve(home, ".mementos", "mementos.db");
+  while (true) {
+    const candidate = join4(dir, ".mementos", "mementos.db");
+    if (existsSync2(candidate) && resolve(candidate) !== legacyHomeDb)
+      return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync2(join4(dir, ".git")))
+      return dir;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function migrateGlobalDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  const newDir = join4(home, ".hasna", "mementos");
+  const oldDir = join4(home, ".mementos");
+  if (!existsSync2(newDir) && existsSync2(oldDir)) {
+    mkdirSync2(join4(home, ".hasna"), { recursive: true });
+    cpSync(oldDir, newDir, { recursive: true });
+  }
+}
+function getDbPath() {
+  for (const key of DB_PATH_ENV_KEYS) {
+    const envPath = process.env[key]?.trim();
+    if (envPath)
+      return envPath;
+  }
+  const cwd = process.cwd();
+  const nearest = findNearestMementosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join4(gitRoot, ".mementos", "mementos.db");
+    }
+  }
+  migrateGlobalDir();
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join4(home, ".hasna", "mementos", "mementos.db");
+}
+function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
+  const dir = dirname2(resolve(filePath));
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function getCloudDatabase() {
+  if (_pg)
+    return _pg;
+  if (!isServerContext()) {
+    throw new Error("Direct Postgres (cloud) storage is server-only. A client must use the " + "self-hosted HTTP API (HASNA_MEMENTOS_API_URL + HASNA_MEMENTOS_API_KEY), " + "never a database DSN. Unset HASNA_MEMENTOS_DATABASE_URL / HASNA_MEMENTOS_STORAGE_MODE " + "on this machine to use local SQLite, or configure the API client to reach the cloud.");
+  }
+  const connectionString = getStorageConnectionString();
+  _pg = new PgAdapter(connectionString);
+  return _pg;
+}
+function getDatabase(dbPath) {
+  if (!dbPath) {
+    if (_pg)
+      return _pg;
+    if (isApiMode()) {
+      throw new Error("mementos is in API mode (HASNA_MEMENTOS_API_URL + HASNA_MEMENTOS_API_KEY set) " + "but this operation tried to open a local SQLite database. That would create a " + "split-brain local island instead of using the shared cloud store. This op must " + "route through the API client (src/db/api-mode.ts); if it needs a server endpoint " + "that does not exist yet, add it to src/server and redeploy. To use local storage " + "instead, unset HASNA_MEMENTOS_API_URL / HASNA_MEMENTOS_API_KEY.");
+    }
+    if (getStorageMode() === "cloud") {
+      return getCloudDatabase();
+    }
+    if (process.env["NODE_ENV"] === "test") {
+      const hasExplicitDbPath = DB_PATH_ENV_KEYS.some((key) => process.env[key]?.trim());
+      if (!hasExplicitDbPath) {
+        throw new Error("REFUSING-UNPINNED-TEST-OPEN: a test process tried to open the default local " + `SQLite store (${getDbPath()}) with no explicit dbPath argument and no ` + `${DB_PATH_ENV_KEYS.join("/")} set. Pass an explicit dbPath (e.g. ":memory:" ` + "or a scratch file), or set one of those env keys to a scratch path, before " + "calling getDatabase(). This guard exists because an unpinned test process " + "would otherwise silently read and write the real, shared, on-disk memory " + "store (todos 57b8b8c5).");
+      }
+    }
+  }
+  const path = dbPath || getDbPath();
+  if (_db) {
+    if (_dbPath === path)
+      return _db;
+    _db.close();
+    _db = null;
+  }
+  _dbPath = path;
+  ensureDir(path);
+  _db = new SqliteAdapter(path);
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  _db.run("PRAGMA wal_autocheckpoint = 100");
+  runMigrations(_db);
+  _db.run(`CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      try {
+        applyMigration(db, i);
+      } catch (e) {
+        console.warn(`[mementos] Migration ${i + 1} failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  } catch {
+    for (let i = 0;i < MIGRATIONS.length; i++) {
+      try {
+        applyMigration(db, i);
+      } catch (e) {
+        console.warn(`[mementos] Migration ${i + 1} failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+}
+function applyMigration(db, index) {
+  if (index === 32) {
+    ensureMachinePrimaryColumn(db);
+  }
+  db.exec(MIGRATIONS[index]);
+}
+function ensureMachinePrimaryColumn(db) {
+  const columns = db.query("PRAGMA table_info(machines)").all();
+  if (columns.length === 0 || columns.some((column) => column.name === "is_primary")) {
+    return;
+  }
+  db.exec("ALTER TABLE machines ADD COLUMN is_primary INTEGER NOT NULL DEFAULT 0");
+}
+function closeDatabase() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+  if (_pg) {
+    _pg.close();
+    _pg = null;
+  }
+}
+function resetDatabase() {
+  _db = null;
+  _pg = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function escapeLikePrefix(s) {
+  return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function resolvePartialId(db, table, partialId) {
+  if (!ALLOWED_TABLES.has(table)) {
+    throw new Error(`Invalid table name: ${table}`);
+  }
+  if (partialId === "")
+    return null;
+  if (partialId.length >= 36) {
+    const row = db.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
+    return row?.id ?? null;
+  }
+  const rows = db.query(`SELECT id FROM ${table} WHERE id LIKE ? ESCAPE '\\'`).all(`${escapeLikePrefix(partialId)}%`);
+  if (rows.length === 1) {
+    return rows[0].id;
+  }
+  return null;
+}
+var _db = null, _dbPath = null, _pg = null, ALLOWED_TABLES;
+var init_database = __esm(() => {
+  init_storage();
+  init_api_mode();
+  init_migrations();
+  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/authority.ts
-import { createHash } from "crypto";
-import { resolve } from "path";
+import { createHash as createHash2 } from "crypto";
+import { resolve as resolve2 } from "path";
 
 // src/lib/package-version.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function getMementosPackageVersion() {
-  const here = dirname(fileURLToPath(import.meta.url));
+  const here = dirname(fileURLToPath2(import.meta.url));
   for (const candidate of [
-    join(here, "..", "..", "package.json"),
-    join(here, "..", "package.json")
+    join2(here, "..", "..", "package.json"),
+    join2(here, "..", "package.json")
   ]) {
     try {
-      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      const parsed = JSON.parse(readFileSync2(candidate, "utf8"));
       if (typeof parsed.version === "string" && parsed.version.trim())
         return parsed.version;
     } catch {}
@@ -342,6 +2827,508 @@ function getMementosPackageVersion() {
   return "0.0.0";
 }
 
+// src/db/projects.ts
+init_database();
+init_api_mode();
+import { createHash } from "crypto";
+
+// src/project-registration/types.ts
+var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1";
+var MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
+var MEMENTOS_PROJECT_REGISTRATION_SCHEMA_VERSION = 1;
+var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
+
+class MementosProjectRegistrationError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MementosProjectRegistrationError";
+  }
+}
+
+// src/db/projects.ts
+function parseProjectRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    memory_prefix: row["memory_prefix"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+
+class ProjectCollisionError extends Error {
+  field;
+  value;
+  constructor(field, value) {
+    super(`Project ${field} already exists: ${value}`);
+    this.field = field;
+    this.value = value;
+    this.name = "ProjectCollisionError";
+  }
+}
+
+class ProjectGuardedUpdateError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ProjectGuardedUpdateError";
+  }
+}
+var PROJECT_UPDATE_AUTHORITY = {
+  authority_id: "mementos",
+  tenant_id: "default",
+  corpus_id: "default"
+};
+var BOUNDED_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+function canonicalizeProjectUpdateValue(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalizeProjectUpdateValue);
+  if (!value || typeof value !== "object")
+    return value;
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      output[key] = canonicalizeProjectUpdateValue(item);
+  }
+  return output;
+}
+function canonicalProjectUpdateJson(value) {
+  return JSON.stringify(canonicalizeProjectUpdateValue(value));
+}
+function digestProjectUpdateValue(value) {
+  return createHash("sha256").update(canonicalProjectUpdateJson(value)).digest("hex");
+}
+function timestampString(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function parseProjectJson(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  return parsed;
+}
+function projectUpdateReceiptFromRow(row) {
+  return {
+    receipt_id: String(row["receipt_id"]),
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    package_version: String(row["package_version"]),
+    authority_id: String(row["authority_id"]),
+    tenant_id: String(row["tenant_id"]),
+    corpus_id: String(row["corpus_id"]),
+    operation_id: String(row["operation_id"]),
+    step_id: String(row["step_id"]),
+    direction: row["direction"],
+    idempotency_key: String(row["idempotency_key"]),
+    request_digest: String(row["request_digest"]),
+    outcome: "accepted",
+    target_id: String(row["target_id"]),
+    expected_revision: timestampString(row["expected_revision"]),
+    result_revision: timestampString(row["result_revision"]),
+    result_digest: String(row["result_digest"]),
+    accepted_receipt_id: row["accepted_receipt_id"] === null ? null : String(row["accepted_receipt_id"]),
+    before_project: parseProjectJson(row["before_project_json"]),
+    after_project: parseProjectJson(row["after_project_json"]),
+    created_at: timestampString(row["created_at"])
+  };
+}
+function normalizeProjectUpdateInput(input) {
+  const normalized = {};
+  if (input.name !== undefined)
+    normalized.name = input.name.trim();
+  if (input.path !== undefined)
+    normalized.path = input.path.trim();
+  if (input.description !== undefined)
+    normalized.description = input.description;
+  if (input.memory_prefix !== undefined)
+    normalized.memory_prefix = input.memory_prefix;
+  if (Object.keys(normalized).length === 0) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", "At least one project field must be provided");
+  }
+  if (normalized.name !== undefined && normalized.name.length === 0) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", "Project name cannot be empty");
+  }
+  if (normalized.path !== undefined && normalized.path.length === 0) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", "Project path cannot be empty");
+  }
+  return normalized;
+}
+function assertProjectUpdateIdentity(identity, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  if (identity.authority_id !== expectedIdentity.authority_id || identity.tenant_id !== expectedIdentity.tenant_id || identity.corpus_id !== expectedIdentity.corpus_id) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_AUTHORITY_MISMATCH", "guarded project update does not match this authority, tenant, and corpus");
+  }
+}
+function assertBoundedIdentifier(value, field) {
+  if (!BOUNDED_IDENTIFIER.test(value)) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
+  }
+}
+function assertProjectUpdateRequest(request, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateIdentity(request, expectedIdentity);
+  assertBoundedIdentifier(request.operation_id, "operation_id");
+  assertBoundedIdentifier(request.step_id, "step_id");
+  assertBoundedIdentifier(request.idempotency_key, "idempotency_key");
+  if (!request.expected_revision || request.expected_revision.length > 128) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", "expected_revision is required and must be bounded");
+  }
+}
+function getProjectByExactId(id, db) {
+  const row = db.query("SELECT * FROM projects WHERE id = ? LIMIT 1").get(id);
+  return row ? parseProjectRow(row) : null;
+}
+function assertNoProjectCollision(id, input, db) {
+  if (input.name !== undefined) {
+    const collision = db.query("SELECT id FROM projects WHERE LOWER(name) = LOWER(?) AND id != ? LIMIT 1").get(input.name, id);
+    if (collision) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_COLLISION", `Project name already exists: ${input.name}`, { field: "name" });
+    }
+  }
+  if (input.path !== undefined) {
+    const collision = db.query("SELECT id FROM projects WHERE path = ? AND id != ? LIMIT 1").get(input.path, id);
+    if (collision) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_COLLISION", `Project path already exists: ${input.path}`, { field: "path" });
+    }
+  }
+}
+function nextProjectRevision(previous) {
+  const candidate = now();
+  const previousMs = Date.parse(previous);
+  const candidateMs = Date.parse(candidate);
+  if (Number.isFinite(previousMs) && Number.isFinite(candidateMs) && candidateMs <= previousMs) {
+    return new Date(previousMs + 1).toISOString();
+  }
+  return candidate;
+}
+function projectWithUpdates(project, updates, revision) {
+  return {
+    ...project,
+    ...updates.name !== undefined ? { name: updates.name } : {},
+    ...updates.path !== undefined ? { path: updates.path } : {},
+    ...updates.description !== undefined ? { description: updates.description } : {},
+    ...updates.memory_prefix !== undefined ? { memory_prefix: updates.memory_prefix } : {},
+    updated_at: revision
+  };
+}
+function findProjectUpdateReceiptByKey(db, identity, direction, idempotencyKey) {
+  const row = db.query(`
+    SELECT * FROM mementos_project_update_receipts
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND direction = ? AND idempotency_key = ?
+    LIMIT 1
+  `).get(identity.authority_id, identity.tenant_id, identity.corpus_id, direction, idempotencyKey);
+  return row ? projectUpdateReceiptFromRow(row) : null;
+}
+function findProjectUpdateReceiptById(db, identity, receiptId) {
+  const row = db.query(`
+    SELECT * FROM mementos_project_update_receipts
+    WHERE receipt_id = ? AND authority_id = ? AND tenant_id = ? AND corpus_id = ?
+    LIMIT 1
+  `).get(receiptId, identity.authority_id, identity.tenant_id, identity.corpus_id);
+  return row ? projectUpdateReceiptFromRow(row) : null;
+}
+function insertProjectUpdateReceipt(db, receipt) {
+  db.run(`
+    INSERT INTO mementos_project_update_receipts (
+      receipt_id, authority, route, package_version, authority_id, tenant_id,
+      corpus_id, operation_id, step_id, direction, idempotency_key,
+      request_digest, outcome, target_id, expected_revision, result_revision,
+      result_digest, accepted_receipt_id, before_project_json,
+      after_project_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `, [
+    receipt.receipt_id,
+    receipt.authority,
+    receipt.route,
+    receipt.package_version,
+    receipt.authority_id,
+    receipt.tenant_id,
+    receipt.corpus_id,
+    receipt.operation_id,
+    receipt.step_id,
+    receipt.direction,
+    receipt.idempotency_key,
+    receipt.request_digest,
+    receipt.outcome,
+    receipt.target_id,
+    receipt.expected_revision,
+    receipt.result_revision,
+    receipt.result_digest,
+    receipt.accepted_receipt_id,
+    canonicalProjectUpdateJson(receipt.before_project),
+    canonicalProjectUpdateJson(receipt.after_project),
+    receipt.created_at
+  ]);
+}
+function makeProjectUpdateReceipt(input) {
+  const createdAt = now();
+  const logical = {
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    package_version: getMementosPackageVersion(),
+    authority_id: input.request.authority_id,
+    tenant_id: input.request.tenant_id,
+    corpus_id: input.request.corpus_id,
+    operation_id: input.request.operation_id,
+    step_id: input.request.step_id,
+    direction: input.direction,
+    idempotency_key: input.request.idempotency_key,
+    request_digest: input.request_digest,
+    outcome: "accepted",
+    target_id: input.target_id,
+    expected_revision: input.request.expected_revision,
+    result_revision: input.after_project.updated_at,
+    result_digest: input.result_digest ?? digestProjectUpdateValue(input.after_project),
+    accepted_receipt_id: input.accepted_receipt_id ?? null,
+    before_project: input.before_project,
+    after_project: input.after_project,
+    created_at: createdAt
+  };
+  return {
+    receipt_id: `mpur_${digestProjectUpdateValue(logical).slice(0, 40)}`,
+    ...logical
+  };
+}
+function registerProject(name, path, description, memoryPrefix, db) {
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", "/projects", {
+      name,
+      path,
+      description,
+      memory_prefix: memoryPrefix
+    });
+    return data;
+  }
+  const d = db || getDatabase();
+  const timestamp = now();
+  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    return parseProjectRow(existing);
+  }
+  const id = uuid();
+  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(idOrPath, db) {
+  if (!db && isApiMode()) {
+    const { status, data } = apiJson("GET", `/projects/${encodeURIComponent(idOrPath)}`, undefined, { allow404: true });
+    if (status === 404 || !data)
+      return null;
+    return data;
+  }
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE LOWER(name) = ?").get(idOrPath.toLowerCase());
+  if (row)
+    return parseProjectRow(row);
+  return null;
+}
+function listProjects(db) {
+  if (!db && isApiMode()) {
+    const { data } = apiJson("GET", "/projects");
+    return data?.projects ?? [];
+  }
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProjectRow);
+}
+function previewProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateRequest(request, expectedIdentity);
+  const normalized = normalizeProjectUpdateInput(request.updates);
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: true });
+    return data;
+  }
+  const d = db || getDatabase();
+  const project = getProjectByExactId(id, d);
+  if (!project) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_NOT_FOUND", `Project not found by exact stable ID: ${id}`);
+  }
+  if (project.updated_at !== request.expected_revision) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_STALE_REVISION", "Project revision changed before the guarded update dry run", { expected_revision: request.expected_revision, current_revision: project.updated_at });
+  }
+  assertNoProjectCollision(id, normalized, d);
+  return {
+    dry_run: true,
+    applied: false,
+    project: projectWithUpdates(project, normalized, project.updated_at),
+    receipt: null
+  };
+}
+function applyProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY, resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
+  const normalized = normalizeProjectUpdateInput(request.updates);
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: false });
+    return data;
+  }
+  const d = db || getDatabase();
+  const requestDigest = digestProjectUpdateValue({
+    ...request,
+    target_id: id,
+    direction: "forward",
+    updates: normalized
+  });
+  return d.transaction(() => {
+    const prior = findProjectUpdateReceiptByKey(d, request, "forward", request.idempotency_key);
+    if (prior) {
+      if (prior.request_digest !== requestDigest || prior.target_id !== id) {
+        throw new ProjectGuardedUpdateError("PROJECT_UPDATE_IDEMPOTENCY_MISMATCH", "caller idempotency key is already bound to a different request");
+      }
+      const current = getProjectByExactId(id, d);
+      if (!current || canonicalProjectUpdateJson(current) !== canonicalProjectUpdateJson(prior.after_project)) {
+        throw new ProjectGuardedUpdateError("PROJECT_UPDATE_ACCEPTED_TARGET_DRIFTED", "accepted guarded update target drifted after its immutable receipt");
+      }
+      return { dry_run: false, applied: true, project: prior.after_project, receipt: prior };
+    }
+    const before = getProjectByExactId(id, d);
+    if (!before) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_NOT_FOUND", `Project not found by exact stable ID: ${id}`);
+    }
+    if (before.updated_at !== request.expected_revision) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_STALE_REVISION", "Project revision changed before the guarded update", { expected_revision: request.expected_revision, current_revision: before.updated_at });
+    }
+    assertNoProjectCollision(id, normalized, d);
+    const revision = nextProjectRevision(before.updated_at);
+    const after = projectWithUpdates(before, normalized, revision);
+    const result = d.run(`
+      UPDATE projects
+      SET name = ?, path = ?, description = ?, memory_prefix = ?, updated_at = ?
+      WHERE id = ? AND updated_at = ?
+    `, [
+      after.name,
+      after.path,
+      after.description,
+      after.memory_prefix,
+      after.updated_at,
+      id,
+      request.expected_revision
+    ]);
+    if (result.changes !== 1) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_STALE_REVISION", "Project compare-and-swap did not update exactly one row");
+    }
+    const readback = getProjectByExactId(id, d);
+    if (!readback || canonicalProjectUpdateJson(readback) !== canonicalProjectUpdateJson(after)) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_ACCEPTED_TARGET_DRIFTED", "Project guarded update did not read back exactly under the stable ID");
+    }
+    const receipt = makeProjectUpdateReceipt({
+      request: { ...request, updates: normalized },
+      direction: "forward",
+      request_digest: requestDigest,
+      target_id: id,
+      before_project: before,
+      after_project: readback,
+      result_digest: resultDigestForProject?.(readback)
+    });
+    insertProjectUpdateReceipt(d, receipt);
+    return { dry_run: false, applied: true, project: readback, receipt };
+  });
+}
+function rollbackProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY, resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
+  assertBoundedIdentifier(request.accepted_receipt_id, "accepted_receipt_id");
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-rollback`, request);
+    return data;
+  }
+  const d = db || getDatabase();
+  const requestDigest = digestProjectUpdateValue({
+    ...request,
+    target_id: id,
+    direction: "rollback"
+  });
+  return d.transaction(() => {
+    const prior = findProjectUpdateReceiptByKey(d, request, "rollback", request.idempotency_key);
+    if (prior) {
+      if (prior.request_digest !== requestDigest || prior.target_id !== id) {
+        throw new ProjectGuardedUpdateError("PROJECT_UPDATE_IDEMPOTENCY_MISMATCH", "caller idempotency key is already bound to a different rollback request");
+      }
+      const current2 = getProjectByExactId(id, d);
+      if (!current2 || canonicalProjectUpdateJson(current2) !== canonicalProjectUpdateJson(prior.after_project)) {
+        throw new ProjectGuardedUpdateError("PROJECT_UPDATE_ACCEPTED_TARGET_DRIFTED", "accepted rollback target drifted after its immutable receipt");
+      }
+      return { dry_run: false, applied: true, project: prior.after_project, receipt: prior };
+    }
+    const accepted = findProjectUpdateReceiptById(d, request, request.accepted_receipt_id);
+    if (!accepted || accepted.direction !== "forward" || accepted.target_id !== id) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_RECEIPT_NOT_FOUND", "accepted forward update receipt was not found for this exact project");
+    }
+    const current = getProjectByExactId(id, d);
+    if (!current) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_NOT_FOUND", `Project not found by exact stable ID: ${id}`);
+    }
+    if (current.updated_at !== request.expected_revision || canonicalProjectUpdateJson(current) !== canonicalProjectUpdateJson(accepted.after_project)) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_STALE_REVISION", "Project no longer matches the accepted forward receipt", { expected_revision: request.expected_revision, current_revision: current.updated_at });
+    }
+    assertNoProjectCollision(id, accepted.before_project, d);
+    const restored = accepted.before_project;
+    const result = d.run(`
+      UPDATE projects
+      SET name = ?, path = ?, description = ?, memory_prefix = ?,
+          created_at = ?, updated_at = ?
+      WHERE id = ? AND updated_at = ?
+    `, [
+      restored.name,
+      restored.path,
+      restored.description,
+      restored.memory_prefix,
+      restored.created_at,
+      restored.updated_at,
+      id,
+      request.expected_revision
+    ]);
+    if (result.changes !== 1) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_STALE_REVISION", "Project rollback compare-and-swap did not update exactly one row");
+    }
+    const readback = getProjectByExactId(id, d);
+    if (!readback || canonicalProjectUpdateJson(readback) !== canonicalProjectUpdateJson(restored)) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_ACCEPTED_TARGET_DRIFTED", "Project rollback did not restore the exact prior row");
+    }
+    const receipt = makeProjectUpdateReceipt({
+      request,
+      direction: "rollback",
+      request_digest: requestDigest,
+      target_id: id,
+      before_project: current,
+      after_project: readback,
+      result_digest: resultDigestForProject?.(readback),
+      accepted_receipt_id: accepted.receipt_id
+    });
+    insertProjectUpdateReceipt(d, receipt);
+    return { dry_run: false, applied: true, project: readback, receipt };
+  });
+}
+function getProjectUpdateReceipt(id, receiptId, identity = PROJECT_UPDATE_AUTHORITY, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateIdentity(identity, expectedIdentity);
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/update-receipts/lookup`, { ...identity, receipt_id: receiptId });
+    return data;
+  }
+  const d = db || getDatabase();
+  const receipt = findProjectUpdateReceiptById(d, identity, receiptId);
+  if (!receipt || receipt.target_id !== id) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_RECEIPT_NOT_FOUND", "immutable project update receipt was not found for this exact project");
+  }
+  return receipt;
+}
+
 // src/project-registration/project-references.ts
 var MEMENTOS_PROJECT_REFERENCE_SURFACES = [
   { key: "memories", table: "memories", column: "project_id" },
@@ -396,23 +3383,6 @@ function deleteMementosProjectIfUnreferenced(db, projectId) {
   return result.changes;
 }
 
-// src/project-registration/types.ts
-var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1";
-var MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
-var MEMENTOS_PROJECT_REGISTRATION_SCHEMA_VERSION = 1;
-var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
-
-class MementosProjectRegistrationError extends Error {
-  code;
-  details;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "MementosProjectRegistrationError";
-  }
-}
-
 // src/project-registration/authority.ts
 var WORKSPACE_ID_PATTERN = /^wks_[A-Za-z0-9][A-Za-z0-9_-]{11,}$/;
 var OPERATION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
@@ -447,10 +3417,10 @@ function canonicalize(value) {
   return out;
 }
 function digestMementosProjectRegistrationValue(value) {
-  return createHash("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
+  return createHash2("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
 }
 function digestOwnedPath(path) {
-  return createHash("sha256").update(path).digest("hex");
+  return createHash2("sha256").update(path).digest("hex");
 }
 function deriveMementosProjectRegistrationIdempotencyKey(input) {
   return `prk_${digestMementosProjectRegistrationValue({
@@ -485,9 +3455,9 @@ function assertWithinBounds(value, bounds, startedAt) {
   }
   return { response_bytes: bytes, elapsed_ms: elapsed };
 }
-function withResponseControl(receipt, bounds, startedAt) {
+function withBoundedResponseControl(payload, bounds, startedAt) {
   const result = {
-    receipt,
+    ...payload,
     response_control: {
       response_byte_limit: bounds.response_byte_limit,
       time_budget_ms: bounds.time_budget_ms,
@@ -510,6 +3480,9 @@ function withResponseControl(receipt, bounds, startedAt) {
   result.response_control.elapsed_ms = measured.elapsed_ms;
   return result;
 }
+function withResponseControl(receipt, bounds, startedAt) {
+  return withBoundedResponseControl({ receipt }, bounds, startedAt);
+}
 function requireString(value, field, options = {}) {
   const min = options.min ?? 1;
   const max = options.max ?? 512;
@@ -531,11 +3504,85 @@ function ownedPath(target) {
   }
   const path = target.withOwnedPath((value) => value);
   requireString(path, "target path", { max: 4096 });
-  if (path !== resolve(path)) {
+  if (path !== resolve2(path)) {
     throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target path must already be canonical and absolute");
   }
   return path;
 }
+function guardedAuthorityIdentity(capability) {
+  return {
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id
+  };
+}
+function assertGuardedAuthorityRequest(targetId, request, capability) {
+  assertBounds(request);
+  requireString(targetId, "target_id", { min: 8, max: 128, pattern: OPERATION_PATTERN });
+  if (request.authority !== "mementos" || request.authority_route !== MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE || request.package_version !== capability.package_version || request.authority_id !== capability.authority_id || request.tenant_id !== capability.tenant_id || request.corpus_id !== capability.corpus_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "guarded project request does not match this authority capability identity");
+  }
+  return guardedAuthorityIdentity(capability);
+}
+function assertGuardedOperationFields(request) {
+  requireString(request.operation_id, "operation_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.step_id, "step_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.expected_revision, "expected_revision", { max: 128 });
+}
+function assertGuardedUpdateRequest(targetId, request, capability) {
+  const identity = assertGuardedAuthorityRequest(targetId, request, capability);
+  assertGuardedOperationFields(request);
+  if (!request.updates || typeof request.updates !== "object") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "guarded project updates must contain exactly one private path handle");
+  }
+  exactKeys(request.updates, ["path"], "updates");
+  return { identity, path: ownedPath(request.updates.path) };
+}
+function publicGuardedUpdateReceipt(receipt, capability) {
+  return {
+    receipt_id: receipt.receipt_id,
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    package_version: capability.package_version,
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    operation_id: receipt.operation_id,
+    step_id: receipt.step_id,
+    direction: receipt.direction,
+    idempotency_key: receipt.idempotency_key,
+    request_digest: receipt.request_digest,
+    outcome: "accepted",
+    target_id: receipt.target_id,
+    expected_revision: receipt.expected_revision,
+    result_revision: receipt.result_revision,
+    result_digest: receipt.result_digest,
+    accepted_receipt_id: receipt.accepted_receipt_id,
+    created_at: receipt.created_at
+  };
+}
+function guardedProjectError(cause) {
+  if (cause instanceof MementosProjectRegistrationError)
+    throw cause;
+  if (cause instanceof ProjectGuardedUpdateError) {
+    const code = cause.code === "PROJECT_UPDATE_INVALID_INPUT" ? "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT" : cause.code === "PROJECT_UPDATE_AUTHORITY_MISMATCH" ? "MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH" : cause.code === "PROJECT_UPDATE_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND" : cause.code === "PROJECT_UPDATE_RECEIPT_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND" : "MEMENTOS_PROJECT_REGISTRATION_CONFLICT";
+    throw new MementosProjectRegistrationError(code, "guarded project operation was rejected without exposing private project data", { project_update_code: cause.code });
+  }
+  throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation failed before a bounded public result was available");
+}
 function normalizedCallDigest(request) {
   return digestMementosProjectRegistrationValue({
     authority_route: request.authority_route,
@@ -562,7 +3609,7 @@ function publicReceipt(row) {
   const { target_selector: _selector, normalized_call_digest: _digest, ...receipt } = row;
   return receipt;
 }
-function timestampString(value) {
+function timestampString2(value) {
   return value instanceof Date ? value.toISOString() : String(value);
 }
 function receiptFromRow(row) {
@@ -571,14 +3618,14 @@ function receiptFromRow(row) {
     authority: "mementos",
     resource_kind: "project",
     created_by_operation: row["created_by_operation"] === true || Number(row["created_by_operation"]) === 1,
-    created_at: timestampString(row["created_at"])
+    created_at: timestampString2(row["created_at"])
   };
 }
 function bindingFromRow(row) {
   return {
     ...row,
-    created_at: timestampString(row["created_at"]),
-    updated_at: timestampString(row["updated_at"])
+    created_at: timestampString2(row["created_at"]),
+    updated_at: timestampString2(row["updated_at"])
   };
 }
 function getStoredReceipt(db, receiptId) {
@@ -620,7 +3667,7 @@ function getBinding(db, capability, targetSelector) {
   `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
   return row ? bindingFromRow(row) : null;
 }
-function getProjectByExactId(db, id) {
+function getProjectByExactId2(db, id) {
   const row = db.get("SELECT * FROM projects WHERE id = ? LIMIT 1", id);
   if (!row)
     return null;
@@ -630,13 +3677,13 @@ function getProjectByExactId(db, id) {
     path: String(row["path"]),
     description: row["description"] === null ? null : String(row["description"]),
     memory_prefix: row["memory_prefix"] === null ? null : String(row["memory_prefix"]),
-    created_at: timestampString(row["created_at"]),
-    updated_at: timestampString(row["updated_at"])
+    created_at: timestampString2(row["created_at"]),
+    updated_at: timestampString2(row["updated_at"])
   };
 }
 function getProjectByPath(db, path) {
   const row = db.get("SELECT * FROM projects WHERE path = ? LIMIT 1", path);
-  return row ? getProjectByExactId(db, String(row["id"])) : null;
+  return row ? getProjectByExactId2(db, String(row["id"])) : null;
 }
 function projectRecord(db, project, references = mementosProjectReferenceCounts(db, project.id)) {
   return {
@@ -665,7 +3712,7 @@ function targetId(capability, selector) {
 function receiptId(input) {
   return `mmpr_${digestMementosProjectRegistrationValue(input).slice(0, 40)}`;
 }
-function makeReceipt(request, capability, callDigest, now, values) {
+function makeReceipt(request, capability, callDigest, now2, values) {
   const withoutId = {
     authority: "mementos",
     route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
@@ -694,7 +3741,7 @@ function makeReceipt(request, capability, callDigest, now, values) {
   return {
     receipt_id: receiptId(withoutId),
     ...withoutId,
-    created_at: now
+    created_at: now2
   };
 }
 function insertReceipt(db, receipt) {
@@ -719,7 +3766,7 @@ function insertReceipt(db, receipt) {
   }
   return stored;
 }
-function insertBinding(db, request, callDigest, now) {
+function insertBinding(db, request, callDigest, now2) {
   const result = db.run(`
     INSERT INTO mementos_project_registration_bindings (
       authority_id, tenant_id, corpus_id, resource_kind, target_selector,
@@ -730,7 +3777,7 @@ function insertBinding(db, request, callDigest, now) {
     ) VALUES (?, ?, ?, 'project', ?, ?, ?, 'forward', ?, ?, ?, ?, 'pending',
       NULL, NULL, NULL, NULL, NULL, ?, ?)
     ON CONFLICT DO NOTHING
-  `, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector, request.operation_id, request.step_id, request.idempotency_key, request.request_digest, request.precondition_digest, callDigest, now, now);
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector, request.operation_id, request.step_id, request.idempotency_key, request.request_digest, request.precondition_digest, callDigest, now2, now2);
   return result.changes === 1;
 }
 function lockBinding(db, capability, targetSelector) {
@@ -742,26 +3789,26 @@ function lockBinding(db, capability, targetSelector) {
   `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
   return result.changes === 1;
 }
-function setBindingAccepted(db, request, receipt, now) {
+function setBindingAccepted(db, request, receipt, now2) {
   const result = db.run(`
     UPDATE mementos_project_registration_bindings
     SET state = 'accepted', target_id = ?, accepted_receipt_id = ?,
       result_revision = ?, result_digest = ?, updated_at = ?
     WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
       AND resource_kind = 'project' AND target_selector = ? AND state = 'pending'
-  `, receipt.target_id, receipt.receipt_id, receipt.result_revision, receipt.result_digest, now, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector);
+  `, receipt.target_id, receipt.receipt_id, receipt.result_revision, receipt.result_digest, now2, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector);
   if (result.changes !== 1) {
     throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not pending at acceptance");
   }
 }
-function setBindingRemoved(db, accepted, inverseReceiptId, now) {
+function setBindingRemoved(db, accepted, inverseReceiptId, now2) {
   const result = db.run(`
     UPDATE mementos_project_registration_bindings
     SET state = 'removed', removed_receipt_id = ?, updated_at = ?
     WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
       AND resource_kind = 'project' AND target_selector = ?
       AND state = 'accepted' AND accepted_receipt_id = ?
-  `, inverseReceiptId, now, accepted.authority_id, accepted.tenant_id, accepted.corpus_id, accepted.target_selector, accepted.receipt_id);
+  `, inverseReceiptId, now2, accepted.authority_id, accepted.tenant_id, accepted.corpus_id, accepted.target_selector, accepted.receipt_id);
   if (result.changes !== 1) {
     throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not accepted at inverse");
   }
@@ -922,6 +3969,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       conditional_inverse: true,
       ambiguous_outcome_reconciliation: true,
       guarded_update: true,
+      guarded_update_route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
       no_write_dry_run: true,
       expected_revision_compare_and_swap: true,
       caller_idempotency: true,
@@ -956,7 +4004,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
     if (accepted.normalized_call_digest !== callDigest) {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "accepted operation/step identity is bound to a different request");
     }
-    const project = accepted.target_id ? getProjectByExactId(this.db, accepted.target_id) : null;
+    const project = accepted.target_id ? getProjectByExactId2(this.db, accepted.target_id) : null;
     if (!project || project.path !== path) {
       return this.terminal(request, callDigest, "accepted_target_missing_or_replaced", {
         target_id: accepted.target_id
@@ -983,6 +4031,90 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       supported_resources: ["project"]
     };
   }
+  boundedGuardedUpdateResult(targetId2, project, receipt, bounds, startedAt) {
+    if (!receipt || project.id !== targetId2 || receipt.target_id !== targetId2) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation did not return its exact immutable receipt");
+    }
+    if (project.updated_at !== receipt.result_revision) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project result revision did not match its immutable receipt");
+    }
+    const record = {
+      target_id: targetId2,
+      revision: receipt.result_revision,
+      digest: receipt.result_digest
+    };
+    return withBoundedResponseControl({
+      dry_run: false,
+      applied: true,
+      record,
+      receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+    }, bounds, startedAt);
+  }
+  async guardedUpdateProject(targetId2, request) {
+    const startedAt = Date.now();
+    const { identity, path } = assertGuardedUpdateRequest(targetId2, request, this.capabilityValue);
+    try {
+      const result = applyProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        updates: { path }
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async getGuardedProjectUpdateReceipt(targetId2, receiptId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    requireString(receiptId2, "receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const receipt = getProjectUpdateReceipt(targetId2, receiptId2, identity, this.db, identity);
+      return withBoundedResponseControl({
+        receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+      }, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async rollbackGuardedProjectUpdate(targetId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    assertGuardedOperationFields(request);
+    if (!request.accepted_receipt || typeof request.accepted_receipt !== "object") {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback requires the exact sanitized accepted receipt");
+    }
+    requireString(request.accepted_receipt.receipt_id, "accepted_receipt.receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const internalAccepted = getProjectUpdateReceipt(targetId2, request.accepted_receipt.receipt_id, identity, this.db, identity);
+      const accepted = publicGuardedUpdateReceipt(internalAccepted, this.capabilityValue);
+      if (accepted.direction !== "forward" || accepted.target_id !== targetId2 || request.expected_revision !== accepted.result_revision || canonicalMementosProjectRegistrationJson(request.accepted_receipt) !== canonicalMementosProjectRegistrationJson(accepted)) {
+        throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback receipt does not exactly match the accepted forward update");
+      }
+      const result = rollbackProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        accepted_receipt_id: accepted.receipt_id
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
   async create(request) {
     const startedAt = Date.now();
     const path = assertForwardRequest(request, this.capabilityValue);
@@ -1001,14 +4133,14 @@ class PackageOwnedMementosProjectRegistrationAuthority {
         if (accepted) {
           return this.duplicateForwardOrTerminal(request, callDigest, path, accepted);
         }
-        const existing = getProjectByPath(this.db, path) ?? getProjectByExactId(this.db, targetId(this.capabilityValue, request.target_selector));
+        const existing = getProjectByPath(this.db, path) ?? getProjectByExactId2(this.db, targetId(this.capabilityValue, request.target_selector));
         if (existing) {
           return this.terminal(request, callDigest, "target_preexists", {
             target_id: existing.id
           });
         }
-        const now = this.now();
-        const insertedBinding = insertBinding(this.db, request, callDigest, now);
+        const now2 = this.now();
+        const insertedBinding = insertBinding(this.db, request, callDigest, now2);
         if (!lockBinding(this.db, this.capabilityValue, request.target_selector)) {
           throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding disappeared before it could be locked");
         }
@@ -1034,17 +4166,17 @@ class PackageOwnedMementosProjectRegistrationAuthority {
             INSERT INTO projects (
               id, name, path, description, memory_prefix, created_at, updated_at
             ) VALUES (?, ?, ?, ?, ?, ?, ?)
-          `, id, request.project_name, path, null, request.project_slug, now, now);
+          `, id, request.project_name, path, null, request.project_slug, now2, now2);
         } catch (cause) {
           throw new WriteBoundaryError("before_object_write", cause);
         }
         this.writeBoundary("after_object_write", request);
-        const project = getProjectByExactId(this.db, id);
+        const project = getProjectByExactId2(this.db, id);
         if (!project || project.path !== path) {
           throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "project write did not read back by its full id");
         }
         const record = projectRecord(this.db, project);
-        const acceptedReceipt = makeReceipt(request, this.capabilityValue, callDigest, now, {
+        const acceptedReceipt = makeReceipt(request, this.capabilityValue, callDigest, now2, {
           outcome: "accepted",
           target_id: record.target_id,
           result_revision: record.revision,
@@ -1059,7 +4191,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
           throw new WriteBoundaryError("before_receipt_write", cause);
         }
         this.writeBoundary("after_receipt_write", request);
-        setBindingAccepted(this.db, request, inserted, now);
+        setBindingAccepted(this.db, request, inserted, now2);
         return inserted;
       });
     } catch (error) {
@@ -1079,12 +4211,12 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
     }
     requireString(request.target_id, "target_id", {
-      min: 51,
-      max: 51,
-      pattern: PROJECT_ID_PATTERN
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
     });
     const path = ownedPath(request.target);
-    const project = getProjectByExactId(this.db, request.target_id);
+    const project = getProjectByExactId2(this.db, request.target_id);
     if (!project || project.path !== path) {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "exact full-id project readback did not resolve the owned path");
     }
@@ -1153,7 +4285,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
             accepted_receipt_id: storedAccepted.receipt_id
           });
         }
-        const project = getProjectByExactId(this.db, storedAccepted.target_id);
+        const project = getProjectByExactId2(this.db, storedAccepted.target_id);
         if (!project) {
           return this.terminal(request, callDigest, "target_missing", {
             target_id: storedAccepted.target_id,
@@ -1188,7 +4320,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
           throw new WriteBoundaryError("before_object_write", cause);
         }
         if (deleted !== 1) {
-          const remaining = getProjectByExactId(this.db, storedAccepted.target_id);
+          const remaining = getProjectByExactId2(this.db, storedAccepted.target_id);
           if (remaining && hasMementosProjectReferences(mementosProjectReferenceCounts(this.db, storedAccepted.target_id))) {
             return this.terminal(request, callDigest, "target_has_dependents", {
               target_id: storedAccepted.target_id,
@@ -1250,7 +4382,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
     if (!inverse || inverse.outcome !== "accepted" || inverse.accepted_receipt_id !== accepted.receipt_id || inverse.result_revision !== "absent" || !inverse.result_digest) {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "accepted conditional inverse receipt was not found");
     }
-    if (getProjectByExactId(this.db, accepted.target_id)) {
+    if (getProjectByExactId2(this.db, accepted.target_id)) {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "inverse verification found the accepted target still present");
     }
     const verification = {
@@ -1340,6 +4472,31 @@ function fromWireReadRequest(body) {
     target: new WirePathHandle(canonicalPath)
   };
 }
+function fromWireGuardedUpdateRequest(body) {
+  const { target_id: targetId2, updates, ...request } = body;
+  if (typeof targetId2 !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target_id is required on the private guarded-update transport");
+  }
+  if (!updates || typeof updates !== "object" || Array.isArray(updates) || typeof updates["path"] !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "updates.path is required on the private guarded-update transport");
+  }
+  return {
+    targetId: targetId2,
+    request: {
+      ...request,
+      updates: {
+        path: new WirePathHandle(String(updates["path"]))
+      }
+    }
+  };
+}
+function exactWireIdentifier(body, field) {
+  const value = body[field];
+  if (typeof value !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} is required on the guarded-update transport`);
+  }
+  return value;
+}
 async function handleMementosProjectRegistrationHttpRequest(request, url, authority, basePath = "/v1/project-registration") {
   const path = url.pathname;
   if (path !== basePath && !path.startsWith(`${basePath}/`))
@@ -1374,6 +4531,21 @@ async function handleMementosProjectRegistrationHttpRequest(request, url, author
     if (action === "verify-inverse") {
       return json({ verification: await authority.verifyInverse(fromWireRequest(body)) });
     }
+    if (action === "projects/guarded-update") {
+      const guarded = fromWireGuardedUpdateRequest(body);
+      return json(await authority.guardedUpdateProject(guarded.targetId, guarded.request));
+    }
+    if (action === "projects/update-receipts/lookup") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const receiptId2 = exactWireIdentifier(body, "receipt_id");
+      const { target_id: _targetId, receipt_id: _receiptId, ...lookup } = body;
+      return json(await authority.getGuardedProjectUpdateReceipt(targetId2, receiptId2, lookup));
+    }
+    if (action === "projects/guarded-rollback") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const { target_id: _targetId, ...rollback } = body;
+      return json(await authority.rollbackGuardedProjectUpdate(targetId2, rollback));
+    }
     return json({
       error: "unknown Mementos project-registration route",
       code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
@@ -1406,6 +4578,15 @@ function toWireRequest(request) {
     canonical_path: extractPath(target)
   };
 }
+function toWireGuardedUpdateRequest(targetId2, request) {
+  return {
+    ...request,
+    target_id: targetId2,
+    updates: {
+      path: extractPath(request.updates.path)
+    }
+  };
+}
 
 class MementosProjectRegistrationHttpClient {
   authority = "mementos";
@@ -1467,6 +4648,24 @@ class MementosProjectRegistrationHttpClient {
     });
     return body.verification;
   }
+  async guardedUpdateProject(targetId2, request) {
+    return this.request("/projects/guarded-update", {
+      method: "POST",
+      body: JSON.stringify(toWireGuardedUpdateRequest(targetId2, request))
+    });
+  }
+  async getGuardedProjectUpdateReceipt(targetId2, receiptId2, request) {
+    return this.request("/projects/update-receipts/lookup", {
+      method: "POST",
+      body: JSON.stringify({ ...request, target_id: targetId2, receipt_id: receiptId2 })
+    });
+  }
+  async rollbackGuardedProjectUpdate(targetId2, request) {
+    return this.request("/projects/guarded-rollback", {
+      method: "POST",
+      body: JSON.stringify({ ...request, target_id: targetId2 })
+    });
+  }
 }
 function createMementosProjectRegistrationHttpClient(options) {
   return new MementosProjectRegistrationHttpClient(options);