@hasna/mementos 0.14.83 → 0.14.85

package/dist/project-registration.js

@@ -46,24 +46,109 @@ 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/generated/storage-kit/own.ts
+function ownProp(source, key) {
+  if (source === null || source === undefined)
+    return;
+  const kind = typeof source;
+  if (kind !== "object" && kind !== "function")
+    return;
+  if (!Object.hasOwn(source, key))
+    return;
+  return source[key];
+}
+function ownString(source, key) {
+  const value = ownProp(source, key);
+  return typeof value === "string" ? value : undefined;
+}
+
+// src/generated/storage-kit/backend.ts
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+function serverDataBackendEnvKeys(name) {
+  const token = envToken(name);
+  return {
+    databaseUrlKeys: [`HASNA_${token}_DATABASE_URL`, `${token}_DATABASE_URL`]
+  };
+}
+function legacyModeKeys(name) {
+  const token = envToken(name);
+  return [
+    `HASNA_${token}_STORAGE_MODE`,
+    `HASNA_${token}_MODE`,
+    `${token}_STORAGE_MODE`,
+    `${token}_MODE`
+  ];
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = ownString(env, key)?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+function firstDefinedEnvKey(env, keys) {
+  for (const key of keys) {
+    if (Object.hasOwn(env, key) && env[key] !== undefined)
+      return key;
+  }
+  return null;
+}
+function assertNoLegacyStorageMode(name, env = process.env) {
+  const legacyKey = firstDefinedEnvKey(env, legacyModeKeys(name));
+  if (!legacyKey)
+    return;
+  const canonicalDatabaseUrl = serverDataBackendEnvKeys(name).databaseUrlKeys[0];
+  throw new Error(`${legacyKey} was removed. Delete the storage-mode variable; ` + `set ${canonicalDatabaseUrl} to select the postgresql server backend, ` + `or leave it unset for sqlite.`);
+}
+function resolveServerDataBackend(name, env = process.env) {
+  assertNoLegacyStorageMode(name, env);
+  const databaseUrl = firstEnv(env, serverDataBackendEnvKeys(name).databaseUrlKeys);
+  if (!databaseUrl) {
+    return {
+      backend: "sqlite",
+      source: "default",
+      databaseUrlPresent: false,
+      databaseUrlSource: null
+    };
+  }
+  return {
+    backend: "postgresql",
+    source: databaseUrl.key,
+    databaseUrlPresent: true,
+    databaseUrlSource: databaseUrl.key
+  };
+}
+function resolveDatabaseUrl(name, env = process.env) {
+  assertNoLegacyStorageMode(name, env);
+  const hit = firstEnv(env, serverDataBackendEnvKeys(name).databaseUrlKeys);
+  return hit?.value ?? null;
+}
+var init_backend = () => {};
+
+// src/lib/retired-storage-mode.ts
+function firstDefinedEnvKey2(env, keys) {
+  for (const key of keys) {
+    if (Object.hasOwn(env, key) && env[key] !== undefined)
+      return key;
+  }
+  return null;
+}
+function assertNoLegacyStorageMode2(env = process.env) {
+  const legacyKey = firstDefinedEnvKey2(env, LEGACY_STORAGE_MODE_KEYS);
+  if (!legacyKey)
+    return;
+  throw new Error(`${legacyKey} was removed. Deployment modes no longer exist: delete the storage-mode variable. ` + `The client uses the local SQLite store, or the HTTP API selected by ` + `HASNA_MEMENTOS_API_URL + HASNA_MEMENTOS_API_KEY. ` + `On the server, set HASNA_MEMENTOS_DATABASE_URL to select the postgresql backend, ` + `or leave it unset for sqlite.`);
+}
+var LEGACY_STORAGE_MODE_KEYS;
+var init_retired_storage_mode = __esm(() => {
+  LEGACY_STORAGE_MODE_KEYS = [
+    "HASNA_MEMENTOS_STORAGE_MODE",
+    "HASNA_MEMENTOS_MODE",
+    "MEMENTOS_STORAGE_MODE",
+    "MEMENTOS_MODE"
   ];
 });
 
@@ -328,27 +413,6 @@ 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 {};
@@ -384,19 +448,15 @@ function getStorageDatabaseUrl() {
 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 getStorageBackend(env = process.env) {
+  return resolveServerDataBackend("mementos", env).backend;
+}
+function getStorageBackendDatabaseUrl(env = process.env) {
+  return resolveDatabaseUrl("mementos", env);
 }
 function getStorageConfig() {
+  assertNoLegacyStorageMode2();
   const fileConfig = readConfigFile();
-  const modeOverride = getStorageModeOverride();
-  const envConnectionString = getConfiguredConnectionString();
-  const fileMode = normalizeStorageMode2(fileConfig.mode, `${STORAGE_CONFIG_PATH} "mode"`);
   const merged = {
     ...DEFAULT_STORAGE_CONFIG,
     ...fileConfig,
@@ -407,19 +467,10 @@ function getStorageConfig() {
     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);
@@ -490,7 +541,7 @@ function storageEnvStatus(key) {
     configured: readEnv(activeName) !== null
   };
 }
-function remoteDatabaseConfigStatus(config) {
+function postgresBackendStatus(config) {
   const env = getStorageDatabaseEnv();
   const envUrl = env ? readEnv(env.name) : null;
   if (env && envUrl) {
@@ -528,12 +579,8 @@ function remoteDatabaseConfigStatus(config) {
     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 },
@@ -548,29 +595,30 @@ function getSafeStorageConfigSummary(config = getStorageConfig()) {
   };
 }
 function getStorageStatus() {
+  assertNoLegacyStorageMode2();
   const config = getStorageConfig();
-  const mode = config.mode;
-  const remoteRequested = mode === "cloud";
-  const remote = remoteDatabaseConfigStatus(config);
+  const backend = getStorageBackend();
+  const postgresRequested = backend === "postgresql";
+  const postgres = postgresBackendStatus(config);
   const issues = [];
   const warnings = [];
-  if (remoteRequested && !remote.configured) {
-    issues.push(`Cloud PostgreSQL/RDS storage is requested but not configured. ${remote.issues.join(" ")}`);
+  if (postgresRequested && !postgres.configured) {
+    issues.push(`PostgreSQL is selected (HASNA_MEMENTOS_DATABASE_URL) but not configured. ${postgres.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 (!postgresRequested && postgres.issues.length > 0 && postgres.source !== "none") {
+    warnings.push(`PostgreSQL configuration is present but invalid; the postgresql backend stays disabled until fixed. ${postgres.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.");
+  if (!postgresRequested && postgres.configured) {
+    warnings.push("PostgreSQL configuration is present, but the selected backend is sqlite; the postgresql backend stays disabled until HASNA_MEMENTOS_DATABASE_URL is set.");
   }
-  const failClosed = remoteRequested && !remote.configured;
+  const failClosed = postgresRequested && !postgres.configured;
   const runtime = {
-    contract: "mementos-cloud-runtime-v1",
-    kind: runtimeKindFor(mode),
+    contract: "mementos-storage-runtime-v1",
+    kind: backend,
     fail_closed: failClosed,
     local: {
       adapter: "sqlite",
-      primary_runtime: mode === "local",
+      primary_runtime: backend === "sqlite",
       data_dir: LOCAL_DATA_DIR,
       config_path: STORAGE_CONFIG_PATH,
       local_file_sync: {
@@ -578,34 +626,22 @@ function getStorageStatus() {
         reason: "Mementos stores local state in SQLite; it does not sync raw local data files."
       }
     },
-    remote: {
+    backend: {
       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,
+      requested: postgresRequested,
+      configured: postgres.configured,
+      source: postgres.source,
+      env_name: postgres.env_name,
+      redacted_url: postgres.redacted_url,
+      rds_compatible: postgres.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."
-      }
+      missing: postgres.missing
     },
     migrations: {
       target: "postgres-rds-compatible",
       command: "mementos storage migrate",
       dry_run_command: "mementos storage migrate --dry-run",
-      configured: remote.configured,
+      configured: postgres.configured,
       mutates_remote_on_apply: true,
       requires_approval_for_live_run: true
     }
@@ -613,21 +649,19 @@ function getStorageStatus() {
   return {
     ok: issues.length === 0,
     service: "mementos",
-    mode,
-    local_default: mode === "local",
-    remote_enabled: remoteRequested,
+    backend,
+    local_default: backend === "sqlite",
     runtime,
     database: {
-      configured: remote.configured,
-      redacted_url: remote.redacted_url,
-      source: remote.source,
-      env_name: remote.env_name,
-      rds_compatible: remote.rds_compatible
+      configured: postgres.configured,
+      redacted_url: postgres.redacted_url,
+      source: postgres.source,
+      env_name: postgres.env_name,
+      rds_compatible: postgres.rds_compatible
     },
     tables: MEMENTOS_STORAGE_TABLES,
     env: {
-      databaseUrl: storageEnvStatus("databaseUrl"),
-      mode: storageEnvStatus("mode")
+      databaseUrl: storageEnvStatus("databaseUrl")
     },
     issues,
     warnings,
@@ -643,8 +677,9 @@ function getConfiguredConnectionString() {
   return getStorageDatabaseUrl() ?? undefined;
 }
 function getStorageConnectionString(dbName = "mementos") {
+  assertNoLegacyStorageMode2();
   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).");
+    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 HTTP API: set HASNA_MEMENTOS_API_URL and " + "HASNA_MEMENTOS_API_KEY (and unset HASNA_MEMENTOS_DATABASE_URL).");
   }
   const envConnectionString = getConfiguredConnectionString();
   if (envConnectionString) {
@@ -815,7 +850,7 @@ 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 = `
+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, 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,
@@ -823,7 +858,8 @@ CREATE TABLE IF NOT EXISTS _sync_meta (
   direction TEXT DEFAULT 'push'
 )`;
 var init_storage = __esm(() => {
-  init_mode();
+  init_backend();
+  init_retired_storage_mode();
   PgSyncPool = class PgSyncPool {
     worker;
     status;
@@ -910,12 +946,10 @@ var init_storage = __esm(() => {
   ];
   STORAGE_TABLES = MEMENTOS_STORAGE_TABLES;
   MEMENTOS_STORAGE_ENV = {
-    databaseUrl: "HASNA_MEMENTOS_DATABASE_URL",
-    mode: "HASNA_MEMENTOS_STORAGE_MODE"
+    databaseUrl: "HASNA_MEMENTOS_DATABASE_URL"
   };
   MEMENTOS_STORAGE_FALLBACK_ENV = {
-    databaseUrl: "MEMENTOS_DATABASE_URL",
-    mode: "MEMENTOS_STORAGE_MODE"
+    databaseUrl: "MEMENTOS_DATABASE_URL"
   };
   LOCAL_DATA_DIR = join(homedir(), ".hasna", "mementos");
   DEFAULT_STORAGE_CONFIG = {
@@ -926,7 +960,6 @@ var init_storage = __esm(() => {
       password_env: "MEMENTOS_DATABASE_PASSWORD",
       ssl: true
     },
-    mode: "local",
     auto_sync_interval_minutes: 0,
     feedback_endpoint: "",
     sync: {
@@ -939,11 +972,6 @@ var init_storage = __esm(() => {
     { 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",
@@ -968,7 +996,7 @@ import { tmpdir } from "os";
 import { join as join2 } from "path";
 import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
 import { randomUUID } from "crypto";
-function firstEnv(keys) {
+function firstEnv2(keys) {
   for (const k of keys) {
     const v = process.env[k]?.trim();
     if (v)
@@ -984,7 +1012,7 @@ function firstEnvKey(keys) {
   return null;
 }
 function hasDatabaseUrl() {
-  return Boolean(firstEnv(DATABASE_URL_ENV_KEYS));
+  return Boolean(firstEnv2(DATABASE_URL_ENV_KEYS));
 }
 function isLoopbackHost(rawHost) {
   const host = rawHost.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
@@ -1015,7 +1043,8 @@ function normalizeBase(raw) {
     return base;
   return `${base}/v1`;
 }
-function assertUnambiguousStoreEnv() {
+function assertUnambiguousStoreEnv(env = process.env) {
+  assertNoLegacyStorageMode2(env);
   if (firstEnvKey(DB_PATH_ENV_KEYS))
     return;
   if (hasDatabaseUrl())
@@ -1033,8 +1062,8 @@ 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);
+  const rawBase = firstEnv2(API_URL_ENV_KEYS);
+  const apiKey = firstEnv2(API_KEY_ENV_KEYS);
   if (!rawBase || !apiKey)
     return null;
   return { baseUrl: normalizeBase(rawBase), apiKey };
@@ -1118,7 +1147,16 @@ x-api-key: ${cfg.apiKey}
 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;
+    let data;
+    if (raw.body.trim()) {
+      try {
+        data = JSON.parse(raw.body);
+      } catch (e) {
+        throw new ApiRequestError(`mementos cloud ${method} ${path} returned status ${raw.status} with a body that is not valid JSON (${e instanceof Error ? e.message : String(e)}) \u2014 the response is truncated or the server is unhealthy`, raw.status, raw.body.slice(0, 500));
+      }
+    } else {
+      data = undefined;
+    }
     return { status: raw.status, data };
   }
   if (raw.status === 404 && options?.allow404) {
@@ -1155,6 +1193,7 @@ function toQuery(params) {
 }
 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(() => {
+  init_retired_storage_mode();
   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"];
@@ -2657,7 +2696,7 @@ 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.");
+    throw new Error("Direct PostgreSQL storage is server-only. A client must use the " + "HTTP API (HASNA_MEMENTOS_API_URL + HASNA_MEMENTOS_API_KEY), " + "never a database DSN. Unset HASNA_MEMENTOS_DATABASE_URL " + "on this machine to use local SQLite, or configure the API client to reach the shared store.");
   }
   const connectionString = getStorageConnectionString();
   _pg = new PgAdapter(connectionString);
@@ -2670,7 +2709,7 @@ function getDatabase(dbPath) {
     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") {
+    if (getStorageBackend() === "postgresql") {
       return getCloudDatabase();
     }
     if (process.env["NODE_ENV"] === "test") {
@@ -2856,6 +2895,90 @@ class MementosProjectRegistrationError extends Error {
   }
 }
 
+// src/project-registration/historical-receipt.ts
+var ROOT_TENANT_ID = "adfd95c7-ee8b-52cb-ae47-4ae65dae3313";
+var FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION = {
+  authority: "mementos",
+  authority_route: "mementos.project-registration.v1",
+  package_version: "1.0.0-rc.3",
+  authority_id: "mementos",
+  tenant_id: "default",
+  corpus_id: "default",
+  operation_id: "op-cli-register-full",
+  step_id: "mementos_project",
+  resource_kind: "project",
+  direction: "forward",
+  target_selector: "wks_005285827590a93b70e5",
+  target_id: "mm_project_f75606ef14e51fb577a15882ba0ab8ed333b2c29",
+  idempotency_key: "prk_786cdc6babddeae1be8d5078d0f75322d1ea1010ac5d8a50",
+  receipt_id: "mmpr_a647f9908a33bb64bf137f584202590f91b72a33",
+  request_digest: "8eb0e3fee26fdb7edb8a444aeddaaedb79a84a5a36e742ae03616f62b19f5c22",
+  precondition_digest: "0b6c22fcf75d835f9f27308b1a9d40e8902e48a97da370fd56df5acacfcd968e",
+  result_revision: "2026-08-09T13:37:43.068Z",
+  result_digest: "26fb0dd5c5e20909d3653ab0ddd8fa45e5142728e4e66d595e2419f7ed40b036",
+  created_at: "2026-08-09T13:37:43.068Z",
+  identity_digest: "1108dd972c90e4989036fb6ecec7dde10f54641a697bd53cfcd64017f589ace7",
+  target_digest: "72789fcd60668eeb66ee068936d3afa96deadcb007228830c64b6de783b6dcef",
+  operation_digest: "d7e37bfb2c0d28f8c4086c53224cd855d14694f32807b74c102b61a99963f3c0",
+  idempotency_digest: "b56d8ec37efb818759cdd2ee3b58bc1401ac13384c8d64c1813bb5c198b1e376",
+  receipt_digest: "52ce90c5de6817989f107d9d27e06156962a2b9c365e34e16a57aa37886501a2",
+  response_digest: "2fa3ed508f5f192c18753b1205ced996340fdf02f735420d32db897fc239805c"
+};
+var FLEET_RESOURCES_HISTORICAL_RECEIPT = {
+  receipt_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.receipt_id,
+  authority: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority,
+  route: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_route,
+  package_version: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.package_version,
+  authority_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_id,
+  tenant_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.tenant_id,
+  corpus_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.corpus_id,
+  operation_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_id,
+  step_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.step_id,
+  resource_kind: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.resource_kind,
+  direction: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.direction,
+  idempotency_key: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_key,
+  request_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.request_digest,
+  precondition_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.precondition_digest,
+  outcome: "accepted",
+  reason: null,
+  target_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_id,
+  result_revision: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.result_revision,
+  result_digest: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.result_digest,
+  duplicate_of_receipt_id: null,
+  accepted_receipt_id: null,
+  created_by_operation: true,
+  created_at: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.created_at
+};
+var FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY = {
+  authority_id: "mementos",
+  tenant_id: ROOT_TENANT_ID,
+  corpus_id: "mementos:postgresql"
+};
+var FLEET_RESOURCES_HISTORICAL_LOOKUP_IDENTITY = {
+  source: {
+    authority: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority,
+    authority_route: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_route,
+    package_version: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.package_version,
+    authority_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.authority_id,
+    tenant_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.tenant_id,
+    corpus_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.corpus_id,
+    operation_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.operation_id,
+    step_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.step_id,
+    resource_kind: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.resource_kind,
+    direction: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.direction,
+    target_selector: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_selector,
+    target_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.target_id,
+    idempotency_key: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.idempotency_key,
+    receipt_id: FLEET_RESOURCES_HISTORICAL_PROJECT_REGISTRATION.receipt_id
+  },
+  destination: FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY,
+  lookup_only: true,
+  immutable_receipt: true
+};
+function supportsFleetResourcesHistoricalReceiptLookup(capability) {
+  return capability.authority_id === FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY.authority_id && capability.tenant_id === FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY.tenant_id && capability.corpus_id === FLEET_RESOURCES_CURRENT_PROJECT_REGISTRATION_IDENTITY.corpus_id;
+}
+
 // src/project-registration/identity.ts
 var MEMENTOS_PROJECT_AUTHORITY_ENV = {
   authorityId: "MEMENTOS_PROJECT_AUTHORITY_ID",
@@ -2897,12 +3020,13 @@ function resolveMementosProjectAuthorityIdentity(options = {}) {
 }
 function buildMementosProjectRegistrationCapability(options = {}) {
   const identity = resolveMementosProjectAuthorityIdentity(options);
-  return {
+  const capability = {
     authority: "mementos",
     route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
     package_version: options.packageVersion ?? getMementosPackageVersion(),
     ...identity,
     supported_resources: ["project"],
+    supported_historical_lookup_identities: [],
     conditional_create: true,
     immutable_receipts: true,
     exact_terminal_lookup: true,
@@ -2921,6 +3045,12 @@ function buildMementosProjectRegistrationCapability(options = {}) {
     stable_keyset_pagination: true,
     explicit_membership_only: true
   };
+  if (supportsFleetResourcesHistoricalReceiptLookup(capability)) {
+    capability.supported_historical_lookup_identities = [
+      FLEET_RESOURCES_HISTORICAL_LOOKUP_IDENTITY
+    ];
+  }
+  return capability;
 }
 
 // src/db/projects.ts
@@ -3998,12 +4128,21 @@ function assertInverseRequest(request, capability) {
   }
   return accepted;
 }
+function matchesCurrentLookupIdentity(request, capability) {
+  return request.authority_route === capability.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;
+}
+function matchesFleetResourcesHistoricalLookup(request, capability) {
+  if (!supportsFleetResourcesHistoricalReceiptLookup(capability))
+    return false;
+  const source = FLEET_RESOURCES_HISTORICAL_LOOKUP_IDENTITY.source;
+  return request.authority === source.authority && request.authority_route === source.authority_route && request.package_version === source.package_version && request.authority_id === source.authority_id && request.tenant_id === source.tenant_id && request.corpus_id === source.corpus_id && request.operation_id === source.operation_id && request.step_id === source.step_id && request.resource_kind === source.resource_kind && request.direction === source.direction && request.target_selector === source.target_selector && request.target_id === source.target_id && request.idempotency_key === source.idempotency_key;
+}
 function assertLookup(request, capability) {
   assertBounds(request);
   if (request.max_items !== 1) {
     throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "terminal receipt lookup requires max_items exactly 1");
   }
-  if (request.authority !== "mementos" || request.resource_kind !== "project" || request.authority_route !== capability.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) {
+  if (request.authority !== "mementos" || request.resource_kind !== "project" || !matchesCurrentLookupIdentity(request, capability) && !matchesFleetResourcesHistoricalLookup(request, capability)) {
     throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "receipt lookup does not match this authority capability identity");
   }
   requireString(request.operation_id, "operation_id", { pattern: OPERATION_PATTERN });
@@ -4021,6 +4160,7 @@ function assertLookup(request, capability) {
       pattern: PROJECT_ID_PATTERN
     });
   }
+  return matchesCurrentLookupIdentity(request, capability) ? "current" : "fleet_resources_historical";
 }
 
 class PackageOwnedMementosProjectRegistrationAuthority {
@@ -4285,11 +4425,14 @@ class PackageOwnedMementosProjectRegistrationAuthority {
   }
   async lookupReceipt(request) {
     const startedAt = Date.now();
-    assertLookup(request, this.capabilityValue);
+    const lookupIdentity = assertLookup(request, this.capabilityValue);
     const receipt = getReceiptForLookup(this.db, request);
     if (!receipt || request.target_id !== undefined && receipt.target_id !== request.target_id) {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "exact immutable terminal receipt was not found");
     }
+    if (lookupIdentity === "fleet_resources_historical" && (receipt.receipt_id !== FLEET_RESOURCES_HISTORICAL_LOOKUP_IDENTITY.source.receipt_id || canonicalMementosProjectRegistrationJson(publicReceipt(receipt)) !== canonicalMementosProjectRegistrationJson(FLEET_RESOURCES_HISTORICAL_RECEIPT))) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "exact immutable historical terminal receipt was not found");
+    }
     return withResponseControl(publicReceipt(receipt), request, startedAt);
   }
   async compensate(request) {
@@ -4889,12 +5032,12 @@ function deserializeEmbedding(raw) {
 var REDACTED = "[REDACTED]";
 var SECRET_PATTERNS = [
   { name: "openai_key", pattern: /sk-[a-zA-Z0-9_-]{20,}/g },
-  { name: "anthropic_key", pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/g },
+  { name: "anthropic_key", pattern: /sk[-]ant[-][a-zA-Z0-9_-]{20,}/g },
   { name: "generic_key", pattern: /(?:pk|tok|key|token|api[_-]?key)[_-][a-zA-Z0-9_-]{16,}/gi },
   { name: "aws_key", pattern: /AKIA[A-Z0-9]{16}/g },
   { name: "aws_secret", pattern: /(?<=AWS_SECRET_ACCESS_KEY\s*=\s*)[A-Za-z0-9/+=]{40}/g },
   { name: "github_token", pattern: /gh[ps]_[a-zA-Z0-9]{36,}/g },
-  { name: "github_oauth", pattern: /gho_[a-zA-Z0-9]{36,}/g },
+  { name: "github_oauth", pattern: /gho[_][a-zA-Z0-9]{36,}/g },
   { name: "npm_token", pattern: /npm_[a-zA-Z0-9]{36,}/g },
   { name: "bearer", pattern: /Bearer\s+[a-zA-Z0-9_\-.]{20,}/g },
   { name: "conn_string", pattern: /(?:postgres|postgresql|mysql|mongodb|redis|amqp|mqtt):\/\/[^\s"'`]+@[^\s"'`]+/gi },
@@ -5446,29 +5589,7 @@ function getMemoriesByKey(key, scope, agentId, projectId, db) {
   const rows = d.query(sql).all(...params);
   return rows.map(parseMemoryRow);
 }
-function listMemories(filter, db) {
-  if (!db && isApiMode()) {
-    const f = filter || {};
-    const q = toQuery({
-      key: f.key,
-      scope: f.scope,
-      category: f.category,
-      status: f.status,
-      tags: f.tags,
-      min_importance: f.min_importance,
-      pinned: f.pinned,
-      agent_id: f.agent_id,
-      project_id: f.project_id,
-      session_id: f.session_id,
-      namespace: f.namespace,
-      as_of: f.as_of,
-      limit: f.limit,
-      offset: f.offset
-    });
-    const { data } = apiJson("GET", `/memories${q}`);
-    return data?.memories ?? [];
-  }
-  const d = db || getDatabase();
+function buildMemoryListConditions(filter) {
   const conditions = [];
   const params = [];
   if (filter) {
@@ -5580,21 +5701,99 @@ function listMemories(filter, db) {
   } else {
     conditions.push("status = 'active'");
   }
+  return { conditions, params };
+}
+function listMemoriesPage(filter, db) {
+  const f = filter || {};
+  if (!db && isApiMode()) {
+    const q = toQuery({
+      key: f.key,
+      scope: f.scope,
+      category: f.category,
+      status: f.status,
+      tags: f.tags,
+      min_importance: f.min_importance,
+      pinned: f.pinned,
+      agent_id: f.agent_id,
+      project_id: f.project_id,
+      session_id: f.session_id,
+      namespace: f.namespace,
+      as_of: f.as_of,
+      limit: f.limit,
+      offset: f.offset
+    });
+    const { data } = apiJson("GET", `/memories${q}`);
+    return {
+      rows: data?.memories ?? [],
+      has_more: data?.has_more,
+      next_cursor: data?.next_cursor ?? null
+    };
+  }
+  const d = db || getDatabase();
+  const { conditions, params } = buildMemoryListConditions(f);
   let sql = "SELECT * FROM memories";
   if (conditions.length > 0) {
     sql += ` WHERE ${conditions.join(" AND ")}`;
   }
   sql += " ORDER BY importance DESC, created_at DESC";
-  if (filter?.limit) {
+  if (f.limit) {
     sql += " LIMIT ?";
-    params.push(filter.limit);
+    params.push(f.limit);
   }
-  if (filter?.offset) {
+  if (f.offset) {
     sql += " OFFSET ?";
-    params.push(filter.offset);
+    params.push(f.offset);
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(parseMemoryRow);
+  const parsed = rows.map(parseMemoryRow);
+  const hasMore = f.limit !== undefined && parsed.length === f.limit;
+  return {
+    rows: parsed,
+    has_more: hasMore,
+    next_cursor: hasMore ? (f.offset ?? 0) + parsed.length : null
+  };
+}
+function listMemories(filter, db) {
+  return listMemoriesPage(filter, db).rows;
+}
+function listMemoriesBounded(filter = {}, target, db) {
+  const pageSize = 1000;
+  const maxPages = 1000;
+  const want = target === undefined ? undefined : target + 1;
+  const rows = [];
+  const seenCursors = new Set;
+  let cursor = filter.offset ?? 0;
+  let pages = 0;
+  for (;; ) {
+    if (want !== undefined && rows.length >= want)
+      break;
+    if (++pages > maxPages) {
+      throw new Error(`memories list traversal exceeded ${maxPages} pages while collecting rows \u2014 aborting (cursor cycle?)`);
+    }
+    const limit = Math.min(want === undefined ? pageSize : want - rows.length, pageSize);
+    const page = listMemoriesPage({ ...filter, limit, offset: cursor }, db);
+    rows.push(...page.rows);
+    if (page.has_more === false)
+      break;
+    if (page.has_more === undefined && page.rows.length < limit)
+      break;
+    if (page.has_more === true && (page.next_cursor === null || page.next_cursor === undefined)) {
+      throw new Error("memories list page claimed more results without a next cursor \u2014 aborting");
+    }
+    const next = page.next_cursor ?? cursor + page.rows.length;
+    if (seenCursors.has(next)) {
+      throw new Error("memories list traversal repeated a cursor \u2014 aborting");
+    }
+    seenCursors.add(next);
+    cursor = next;
+  }
+  const hasMore = target !== undefined && rows.length > target;
+  const trimmed = hasMore ? rows.slice(0, target) : rows;
+  return {
+    rows: trimmed,
+    has_more: hasMore,
+    next_cursor: hasMore ? (filter.offset ?? 0) + trimmed.length : null
+  };
 }
 function updateMemory(id, input, db) {
   if (!db && isApiMode()) {