@hasna/mementos 0.14.80 → 0.14.82

package/dist/cli/index.js

@@ -6359,8 +6359,86 @@ function getMementosPackageVersion() {
 var init_package_version = () => {};
 
 // src/project-registration/types.ts
-var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
-var init_types2 = () => {};
+var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1", MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1", MEMENTOS_PROJECT_RESOURCE_ROUTE = "mementos.project-resources.v1", MEMENTOS_PROJECT_RESOURCE_KINDS;
+var init_types2 = __esm(() => {
+  MEMENTOS_PROJECT_RESOURCE_KINDS = [
+    "project",
+    "knowledge",
+    "memory",
+    "session"
+  ];
+});
+
+// src/project-registration/identity.ts
+function configuredValue(override, envKey) {
+  return override?.trim() || process.env[envKey]?.trim() || null;
+}
+function resolveMementosProjectAuthorityIdentity(options = {}) {
+  const authorityId = configuredValue(options.authorityId, MEMENTOS_PROJECT_AUTHORITY_ENV.authorityId);
+  const tenantId = configuredValue(options.tenantId, MEMENTOS_PROJECT_AUTHORITY_ENV.tenantId);
+  const corpusId = configuredValue(options.corpusId, MEMENTOS_PROJECT_AUTHORITY_ENV.corpusId);
+  if (!authorityId || !tenantId || !corpusId) {
+    const missingEnv = [];
+    if (!authorityId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.authorityId);
+    if (!tenantId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.tenantId);
+    if (!corpusId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.corpusId);
+    throw new MementosProjectAuthorityIdentityError(missingEnv);
+  }
+  return {
+    authority_id: authorityId,
+    tenant_id: tenantId,
+    corpus_id: corpusId
+  };
+}
+function buildMementosProjectRegistrationCapability(options = {}) {
+  const identity = resolveMementosProjectAuthorityIdentity(options);
+  return {
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+    package_version: options.packageVersion ?? getMementosPackageVersion(),
+    ...identity,
+    supported_resources: ["project"],
+    conditional_create: true,
+    immutable_receipts: true,
+    exact_terminal_lookup: true,
+    exact_readback: true,
+    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,
+    exact_inverse_rollback: true,
+    project_resource_enumeration: true,
+    project_resource_route: MEMENTOS_PROJECT_RESOURCE_ROUTE,
+    project_resource_kinds: ["project", "knowledge", "memory", "session"],
+    stable_keyset_pagination: true,
+    explicit_membership_only: true
+  };
+}
+var MEMENTOS_PROJECT_AUTHORITY_ENV, MementosProjectAuthorityIdentityError;
+var init_identity = __esm(() => {
+  init_package_version();
+  init_types2();
+  MEMENTOS_PROJECT_AUTHORITY_ENV = {
+    authorityId: "MEMENTOS_PROJECT_AUTHORITY_ID",
+    tenantId: "MEMENTOS_PROJECT_TENANT_ID",
+    corpusId: "MEMENTOS_PROJECT_CORPUS_ID"
+  };
+  MementosProjectAuthorityIdentityError = class MementosProjectAuthorityIdentityError extends Error {
+    missing_env;
+    code = "MEMENTOS_PROJECT_AUTHORITY_UNCONFIGURED";
+    constructor(missing_env) {
+      super("Mementos project authority identity is not configured; set " + missing_env.join(", "));
+      this.missing_env = missing_env;
+      this.name = "MementosProjectAuthorityIdentityError";
+    }
+  };
+});
 
 // src/db/projects.ts
 var exports_projects = {};
@@ -6388,6 +6466,16 @@ function parseProjectRow(row) {
     updated_at: row["updated_at"]
   };
 }
+function projectUpdateAuthority() {
+  try {
+    return resolveMementosProjectAuthorityIdentity();
+  } catch (error) {
+    if (error instanceof MementosProjectAuthorityIdentityError) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_AUTHORITY_MISMATCH", error.message, { authority_code: error.code, missing_env: error.missing_env });
+    }
+    throw error;
+  }
+}
 function canonicalizeProjectUpdateValue(value) {
   if (Array.isArray(value))
     return value.map(canonicalizeProjectUpdateValue);
@@ -6460,8 +6548,8 @@ function normalizeProjectUpdateInput(input) {
   }
   return normalized;
 }
-function assertProjectUpdateIdentity(identity) {
-  if (identity.authority_id !== PROJECT_UPDATE_AUTHORITY.authority_id || identity.tenant_id !== PROJECT_UPDATE_AUTHORITY.tenant_id || identity.corpus_id !== PROJECT_UPDATE_AUTHORITY.corpus_id) {
+function assertProjectUpdateIdentity(identity, expectedIdentity = projectUpdateAuthority()) {
+  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");
   }
 }
@@ -6470,8 +6558,8 @@ function assertBoundedIdentifier(value, field) {
     throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
   }
 }
-function assertProjectUpdateRequest(request) {
-  assertProjectUpdateIdentity(request);
+function assertProjectUpdateRequest(request, expectedIdentity = projectUpdateAuthority()) {
+  assertProjectUpdateIdentity(request, expectedIdentity);
   assertBoundedIdentifier(request.operation_id, "operation_id");
   assertBoundedIdentifier(request.step_id, "step_id");
   assertBoundedIdentifier(request.idempotency_key, "idempotency_key");
@@ -6584,7 +6672,7 @@ function makeProjectUpdateReceipt(input) {
     target_id: input.target_id,
     expected_revision: input.request.expected_revision,
     result_revision: input.after_project.updated_at,
-    result_digest: digestProjectUpdateValue(input.after_project),
+    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,
@@ -6648,8 +6736,8 @@ function listProjects(db) {
   const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
   return rows.map(parseProjectRow);
 }
-function previewProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function previewProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority()) {
+  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 });
@@ -6671,8 +6759,8 @@ function previewProjectUpdate(id, request, db) {
     receipt: null
   };
 }
-function applyProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function applyProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority(), 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 });
@@ -6733,14 +6821,15 @@ function applyProjectUpdate(id, request, db) {
       request_digest: requestDigest,
       target_id: id,
       before_project: before,
-      after_project: readback
+      after_project: readback,
+      result_digest: resultDigestForProject?.(readback)
     });
     insertProjectUpdateReceipt(d, receipt);
     return { dry_run: false, applied: true, project: readback, receipt };
   });
 }
-function rollbackProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function rollbackProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority(), 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);
@@ -6806,14 +6895,15 @@ function rollbackProjectUpdate(id, request, db) {
       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) {
-  assertProjectUpdateIdentity(identity);
+function getProjectUpdateReceipt(id, receiptId, identity = projectUpdateAuthority(), db, expectedIdentity = projectUpdateAuthority()) {
+  assertProjectUpdateIdentity(identity, expectedIdentity);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/update-receipts/lookup`, { ...identity, receipt_id: receiptId });
     return data;
@@ -6890,12 +6980,13 @@ function updateProject(id, input, db) {
     return updated ? parseProjectRow(updated) : null;
   });
 }
-var ProjectCollisionError, ProjectGuardedUpdateError, PROJECT_UPDATE_AUTHORITY, BOUNDED_IDENTIFIER;
+var ProjectCollisionError, ProjectGuardedUpdateError, BOUNDED_IDENTIFIER;
 var init_projects = __esm(() => {
   init_database();
   init_api_mode();
   init_package_version();
   init_types2();
+  init_identity();
   ProjectCollisionError = class ProjectCollisionError extends Error {
     field;
     value;
@@ -6916,11 +7007,6 @@ var init_projects = __esm(() => {
       this.name = "ProjectGuardedUpdateError";
     }
   };
-  PROJECT_UPDATE_AUTHORITY = {
-    authority_id: "mementos",
-    tenant_id: "default",
-    corpus_id: "default"
-  };
   BOUNDED_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
 });
 
@@ -8562,13 +8648,13 @@ function createRelation(input, db) {
   }
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const weight = input.weight ?? 1;
   const metadata = JSON.stringify(input.metadata ?? {});
   d.run(`INSERT INTO relations (id, source_entity_id, target_entity_id, relation_type, weight, metadata, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(source_entity_id, target_entity_id, relation_type)
-     DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp]);
+     DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata`, [id, input.source_entity_id, input.target_entity_id, input.relation_type, weight, metadata, timestamp2]);
   const row = d.query(`SELECT * FROM relations
        WHERE source_entity_id = ? AND target_entity_id = ? AND relation_type = ?`).get(input.source_entity_id, input.target_entity_id, input.relation_type);
   const relation = parseRelationRow(row);
@@ -9560,7 +9646,7 @@ function createWebhookHook(input, db) {
   }
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO webhook_hooks
        (id, type, handler_url, priority, blocking, agent_id, project_id, description, enabled, created_at, invocation_count, failure_count)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, 0, 0)`, [
@@ -9572,7 +9658,7 @@ function createWebhookHook(input, db) {
     input.agentId ?? null,
     input.projectId ?? null,
     input.description ?? null,
-    timestamp
+    timestamp2
   ]);
   return getWebhookHook(id, d);
 }
@@ -9743,7 +9829,7 @@ function parseEventRow(row) {
 function createSynthesisRun(input, db) {
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO synthesis_runs (id, triggered_by, project_id, agent_id, corpus_size, proposals_generated, proposals_accepted, proposals_rejected, status, started_at)
      VALUES (?, ?, ?, ?, ?, 0, 0, 0, 'pending', ?)`, [
     id,
@@ -9751,7 +9837,7 @@ function createSynthesisRun(input, db) {
     input.project_id ?? null,
     input.agent_id ?? null,
     input.corpus_size ?? 0,
-    timestamp
+    timestamp2
   ]);
   return getSynthesisRun(id, d);
 }
@@ -9844,7 +9930,7 @@ function updateSynthesisRun(id, updates, db) {
 function createProposal(input, db) {
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO synthesis_proposals (id, run_id, proposal_type, memory_ids, target_memory_id, proposed_changes, reasoning, confidence, status, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?)`, [
     id,
@@ -9855,7 +9941,7 @@ function createProposal(input, db) {
     JSON.stringify(input.proposed_changes),
     input.reasoning ?? null,
     input.confidence,
-    timestamp
+    timestamp2
   ]);
   return getProposal(id, d);
 }
@@ -9903,10 +9989,10 @@ function updateProposal(id, updates, db) {
 function createMetric(input, db) {
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT INTO synthesis_metrics (id, run_id, metric_type, value, baseline, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.run_id, input.metric_type, input.value, input.baseline ?? null, timestamp]);
-  return { id, run_id: input.run_id, metric_type: input.metric_type, value: input.value, baseline: input.baseline ?? null, created_at: timestamp };
+     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.run_id, input.metric_type, input.value, input.baseline ?? null, timestamp2]);
+  return { id, run_id: input.run_id, metric_type: input.metric_type, value: input.value, baseline: input.baseline ?? null, created_at: timestamp2 };
 }
 function listMetrics(run_id, db) {
   const d = db || getDatabase();
@@ -9917,7 +10003,7 @@ function recordSynthesisEvent(input, db) {
   try {
     const d = db || getDatabase();
     const id = shortUuid();
-    const timestamp = now();
+    const timestamp2 = now();
     d.run(`INSERT INTO synthesis_events (id, event_type, memory_id, agent_id, project_id, session_id, query, importance_at_time, metadata, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
       id,
@@ -9929,7 +10015,7 @@ function recordSynthesisEvent(input, db) {
       input.query ?? null,
       input.importance_at_time ?? null,
       JSON.stringify(input.metadata ?? {}),
-      timestamp
+      timestamp2
     ]);
   } catch {}
 }
@@ -10171,20 +10257,20 @@ __export(exports_contradiction, {
 });
 function invalidateFact(oldMemoryId, newMemoryId, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  d.run("UPDATE memories SET valid_until = ?, updated_at = ? WHERE id = ?", [timestamp, timestamp, oldMemoryId]);
+  const timestamp2 = now();
+  d.run("UPDATE memories SET valid_until = ?, updated_at = ? WHERE id = ?", [timestamp2, timestamp2, oldMemoryId]);
   if (newMemoryId) {
     const row = d.query("SELECT metadata FROM memories WHERE id = ?").get(newMemoryId);
     if (row) {
       const metadata = JSON.parse(row.metadata || "{}");
       metadata.supersedes_id = oldMemoryId;
-      d.run("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), timestamp, newMemoryId]);
+      d.run("UPDATE memories SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), timestamp2, newMemoryId]);
     }
   }
   return {
     invalidated_memory_id: oldMemoryId,
     new_memory_id: newMemoryId || null,
-    valid_until: timestamp,
+    valid_until: timestamp2,
     supersedes_id: oldMemoryId
   };
 }
@@ -11454,7 +11540,7 @@ function parseJobRow(row) {
 function createSessionJob(input, db) {
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const source = input.source ?? "manual";
   const metadata = JSON.stringify(input.metadata ?? {});
   d.run(`INSERT INTO session_memory_jobs
@@ -11467,7 +11553,7 @@ function createSessionJob(input, db) {
     source,
     input.transcript,
     metadata,
-    timestamp
+    timestamp2
   ]);
   return getSessionJob(id, d);
 }
@@ -11603,7 +11689,7 @@ function saveToolEvent(input, db) {
   }
   const d = db || getDatabase();
   const id = uuid();
-  const timestamp = now();
+  const timestamp2 = now();
   const metadataJson = JSON.stringify(input.metadata || {});
   d.run(`INSERT INTO tool_events (id, tool_name, action, success, error_type, error_message, tokens_used, latency_ms, context, lesson, when_to_use, agent_id, project_id, session_id, metadata, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
@@ -11622,7 +11708,7 @@ function saveToolEvent(input, db) {
     input.project_id || null,
     input.session_id || null,
     metadataJson,
-    timestamp
+    timestamp2
   ]);
   return getToolEvent(id, d);
 }
@@ -12345,7 +12431,7 @@ function registerSession(opts) {
   const pid = process.pid;
   const cwd = opts.cwd || process.cwd();
   const id = generateId();
-  const timestamp = now3();
+  const timestamp2 = now3();
   const existing = db.query("SELECT id FROM sessions WHERE pid = ? AND mcp_server = ?").get(pid, opts.mcp_server);
   if (existing) {
     db.run(`UPDATE sessions SET agent_name = ?, project_name = ?, cwd = ?,
@@ -12356,7 +12442,7 @@ function registerSession(opts) {
       opts.git_root || null,
       opts.tty || null,
       JSON.stringify(opts.metadata || {}),
-      timestamp,
+      timestamp2,
       existing.id
     ]);
     return getSession(existing.id);
@@ -12372,8 +12458,8 @@ function registerSession(opts) {
     opts.tty || null,
     opts.mcp_server,
     JSON.stringify(opts.metadata || {}),
-    timestamp,
-    timestamp
+    timestamp2,
+    timestamp2
   ]);
   return getSession(id);
 }
@@ -60777,6 +60863,7 @@ init_database();
 init_memories();
 init_package_version();
 init_schema();
+init_identity();
 import { createHash as createHash2 } from "crypto";
 
 class MemoryProjectLinkError extends Error {
@@ -60789,12 +60876,17 @@ class MemoryProjectLinkError extends Error {
     this.name = "MemoryProjectLinkError";
   }
 }
-var LINK_AUTHORITY = {
-  authority_id: "mementos",
-  tenant_id: "default",
-  corpus_id: "default"
-};
 var BOUNDED_IDENTIFIER2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+function linkAuthority() {
+  try {
+    return resolveMementosProjectAuthorityIdentity();
+  } catch (error) {
+    if (error instanceof MementosProjectAuthorityIdentityError) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH", error.message, { authority_code: error.code, missing_env: error.missing_env });
+    }
+    throw error;
+  }
+}
 function canonicalize(value) {
   if (Array.isArray(value))
     return value.map(canonicalize);
@@ -60902,7 +60994,8 @@ function receiptFromRow(row) {
   };
 }
 function assertIdentity(identity) {
-  if (identity.authority_id !== LINK_AUTHORITY.authority_id || identity.tenant_id !== LINK_AUTHORITY.tenant_id || identity.corpus_id !== LINK_AUTHORITY.corpus_id) {
+  const expectedIdentity = linkAuthority();
+  if (identity.authority_id !== expectedIdentity.authority_id || identity.tenant_id !== expectedIdentity.tenant_id || identity.corpus_id !== expectedIdentity.corpus_id) {
     throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH", "memory project link does not match this authority, tenant, and corpus");
   }
 }
@@ -61379,7 +61472,7 @@ function rollbackMemoryProjectLink(memoryId, request, db) {
     };
   });
 }
-function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = LINK_AUTHORITY, db) {
+function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = linkAuthority(), db) {
   assertIdentity(identity);
   assertBoundedIdentifier2(memoryId, "memory_id");
   assertBoundedIdentifier2(receiptId, "receipt_id");
@@ -61395,6 +61488,348 @@ function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = LINK_AUTHOR
   return receipt;
 }
 
+// src/project-registration/authority.ts
+import { createHash as createHash3 } from "crypto";
+init_projects();
+init_types2();
+init_identity();
+function canonicalMementosProjectRegistrationJson(value) {
+  return JSON.stringify(canonicalize2(value));
+}
+function canonicalize2(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize2);
+  if (!value || typeof value !== "object")
+    return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      out[key] = canonicalize2(item);
+  }
+  return out;
+}
+function digestMementosProjectRegistrationValue(value) {
+  return createHash3("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
+}
+// src/project-registration/http.ts
+init_types2();
+
+// src/project-registration/index.ts
+init_identity();
+
+// src/project-registration/project-resources.ts
+init_api_mode();
+init_database();
+init_memories();
+init_identity();
+init_types2();
+var DEFAULT_PAGE_LIMIT = 100;
+var MAX_PAGE_LIMIT = 1000;
+var CURSOR_SCHEMA = "mementos.project-resources.cursor.v1";
+
+class MementosProjectResourceError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MementosProjectResourceError";
+  }
+}
+function timestamp(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function normalizeSqlValue(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map(normalizeSqlValue);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalizeSqlValue(item)]));
+}
+function exactProject(db, projectId) {
+  const row = db.get("SELECT id, name, path, description, memory_prefix, created_at, updated_at FROM projects WHERE id = ? LIMIT 1", projectId);
+  if (!row) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_PROJECT_NOT_FOUND", `Mementos project not found: ${projectId}`, { project_id: projectId });
+  }
+  return row;
+}
+function resourceKey(resource) {
+  const rank = MEMENTOS_PROJECT_RESOURCE_KINDS.indexOf(resource.resource_kind);
+  return `${String(rank).padStart(2, "0")}:${resource.stable_id}`;
+}
+function projectResource(project) {
+  const normalized = normalizeSqlValue(project);
+  return {
+    authority: "mementos",
+    source_package: "@hasna/mementos",
+    project_id: project.id,
+    resource_kind: "project",
+    stable_id: project.id,
+    revision: timestamp(project.updated_at),
+    digest: digestMementosProjectRegistrationValue(normalized),
+    membership: "project_aggregate"
+  };
+}
+function memoryResources(db, projectId) {
+  const rows = db.all("SELECT * FROM memories WHERE project_id = ? ORDER BY id ASC", projectId);
+  return rows.map((row) => {
+    const memory = normalizeSqlValue(parseMemoryRow(row));
+    return {
+      authority: "mementos",
+      source_package: "@hasna/mementos",
+      project_id: projectId,
+      resource_kind: row["category"] === "knowledge" ? "knowledge" : "memory",
+      stable_id: String(row["id"]),
+      revision: timestamp(row["updated_at"]),
+      digest: digestMementosProjectRegistrationValue(memory),
+      membership: "explicit_project_id_or_focus"
+    };
+  });
+}
+function sessionResources(db, projectId) {
+  const rows = db.all("SELECT * FROM session_memory_jobs WHERE project_id = ? ORDER BY id ASC", projectId);
+  return rows.map((row) => {
+    const normalized = {
+      id: String(row["id"]),
+      session_id: String(row["session_id"]),
+      agent_id: row["agent_id"] === null ? null : String(row["agent_id"] ?? "") || null,
+      project_id: row["project_id"] === null ? null : String(row["project_id"] ?? "") || null,
+      source: String(row["source"]),
+      status: String(row["status"]),
+      transcript: String(row["transcript"]),
+      chunk_count: Number(row["chunk_count"]),
+      memories_extracted: Number(row["memories_extracted"]),
+      error: row["error"] === null ? null : String(row["error"] ?? "") || null,
+      metadata: typeof row["metadata"] === "string" ? JSON.parse(row["metadata"] || "{}") : normalizeSqlValue(row["metadata"] ?? {}),
+      created_at: timestamp(row["created_at"]),
+      started_at: row["started_at"] === null ? null : timestamp(row["started_at"]),
+      completed_at: row["completed_at"] === null ? null : timestamp(row["completed_at"])
+    };
+    return {
+      authority: "mementos",
+      source_package: "@hasna/mementos",
+      project_id: projectId,
+      resource_kind: "session",
+      stable_id: String(row["id"]),
+      revision: timestamp(row["completed_at"] ?? row["started_at"] ?? row["created_at"]),
+      digest: digestMementosProjectRegistrationValue(normalized),
+      membership: "explicit_project_id_or_focus"
+    };
+  });
+}
+function normalizeResourceKinds(value) {
+  if (!value)
+    return [...MEMENTOS_PROJECT_RESOURCE_KINDS];
+  if (value.length === 0) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "resource_kinds must contain at least one supported resource kind");
+  }
+  const requested = new Set(value);
+  for (const kind of requested) {
+    if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(kind)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `Unsupported Mementos project resource kind: ${kind}`);
+    }
+  }
+  return MEMENTOS_PROJECT_RESOURCE_KINDS.filter((kind) => requested.has(kind));
+}
+function normalizeLimit(value) {
+  const limit = value ?? DEFAULT_PAGE_LIMIT;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `limit must be an integer between 1 and ${MAX_PAGE_LIMIT}`);
+  }
+  return limit;
+}
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(raw) {
+  try {
+    const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+    if (parsed.schema !== CURSOR_SCHEMA || typeof parsed.project_id !== "string" || typeof parsed.collection_revision !== "string" || !Array.isArray(parsed.resource_kinds) || typeof parsed.after_key !== "string") {
+      throw new Error("invalid cursor shape");
+    }
+    return parsed;
+  } catch {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "cursor is not a valid Mementos project-resource cursor");
+  }
+}
+function localPopulation(projectId, db, resourceKinds) {
+  const project = exactProject(db, projectId);
+  const selected = new Set(resourceKinds);
+  const resources = [
+    ...selected.has("project") ? [projectResource(project)] : [],
+    ...memoryResources(db, projectId).filter((resource) => selected.has(resource.resource_kind)),
+    ...selected.has("session") ? sessionResources(db, projectId) : []
+  ].sort((left, right) => resourceKey(left).localeCompare(resourceKey(right)));
+  const collectionRevision = digestMementosProjectRegistrationValue({
+    schema: MEMENTOS_PROJECT_RESOURCE_ROUTE,
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    resource_kinds: resourceKinds,
+    resources: resources.map((resource) => ({
+      resource_kind: resource.resource_kind,
+      stable_id: resource.stable_id,
+      revision: resource.revision,
+      digest: resource.digest
+    }))
+  });
+  return { project, resources, collectionRevision };
+}
+function readMementosProjectResourcePage(projectId, options = {}, db, authorityOptions = {}) {
+  const resourceKinds = normalizeResourceKinds(options.resource_kinds);
+  const limit = normalizeLimit(options.limit);
+  if (!db && isApiMode()) {
+    const { data } = apiJson("GET", `/projects/${encodeURIComponent(projectId)}/resources${toQuery({
+      limit,
+      cursor: options.cursor ?? undefined,
+      resource_kinds: resourceKinds.join(",")
+    })}`);
+    return data;
+  }
+  const d = db ?? getDatabase();
+  const { project, resources, collectionRevision } = localPopulation(projectId, d, resourceKinds);
+  let start = 0;
+  if (options.cursor) {
+    const cursor = decodeCursor(options.cursor);
+    if (cursor.project_id !== projectId || JSON.stringify(cursor.resource_kinds) !== JSON.stringify(resourceKinds)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "cursor does not belong to this project and resource-kind selection");
+    }
+    if (cursor.collection_revision !== collectionRevision) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_COLLECTION_CHANGED", "Mementos project resource collection changed; restart from the first page", {
+        cursor_collection_revision: cursor.collection_revision,
+        current_collection_revision: collectionRevision
+      });
+    }
+    const afterIndex = resources.findIndex((resource) => resourceKey(resource) === cursor.after_key);
+    if (afterIndex < 0) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_COLLECTION_CHANGED", "Mementos project resource cursor no longer names a member; restart from the first page");
+    }
+    start = afterIndex + 1;
+  }
+  const pageResources = resources.slice(start, start + limit);
+  const hasMore = start + pageResources.length < resources.length;
+  const nextCursor = hasMore && pageResources.length > 0 ? encodeCursor({
+    schema: CURSOR_SCHEMA,
+    project_id: projectId,
+    collection_revision: collectionRevision,
+    resource_kinds: resourceKinds,
+    after_key: resourceKey(pageResources[pageResources.length - 1])
+  }) : null;
+  const capability = buildMementosProjectRegistrationCapability(authorityOptions);
+  return {
+    schema: "mementos.project-resources.v1",
+    authority: {
+      authority: capability.authority,
+      authority_id: capability.authority_id,
+      tenant_id: capability.tenant_id,
+      corpus_id: capability.corpus_id,
+      package_version: capability.package_version
+    },
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    collection_revision: collectionRevision,
+    resource_kinds: resourceKinds,
+    resources: pageResources,
+    count: pageResources.length,
+    total: resources.length,
+    limit,
+    cursor: options.cursor ?? null,
+    next_cursor: nextCursor,
+    has_more: hasMore,
+    complete: true,
+    truncated: false
+  };
+}
+function readAllMementosProjectResources(projectId, options = {}, db, authorityOptions = {}) {
+  const pageSize = normalizeLimit(options.page_size);
+  let cursor = null;
+  let first = null;
+  const resources = [];
+  const seen = new Set;
+  do {
+    const page = readMementosProjectResourcePage(projectId, {
+      limit: pageSize,
+      cursor,
+      resource_kinds: options.resource_kinds
+    }, db, authorityOptions);
+    if (!first)
+      first = page;
+    if (page.collection_revision !== first.collection_revision || page.total !== first.total || JSON.stringify(page.resource_kinds) !== JSON.stringify(first.resource_kinds)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_COLLECTION_CHANGED", "Mementos project resource collection changed during complete traversal");
+    }
+    for (const resource of page.resources) {
+      const key = resourceKey(resource);
+      if (seen.has(key)) {
+        throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INCOMPLETE", `Mementos project resource traversal returned duplicate stable ID: ${key}`);
+      }
+      seen.add(key);
+      resources.push(resource);
+    }
+    if (page.has_more && !page.next_cursor) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INCOMPLETE", "Mementos project resource page claimed more results without a continuation cursor");
+    }
+    cursor = page.next_cursor;
+  } while (cursor);
+  if (!first) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INCOMPLETE", "Mementos project resource traversal returned no first page");
+  }
+  if (resources.length !== first.total) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INCOMPLETE", `Mementos project resource traversal returned ${resources.length} of ${first.total} resources`);
+  }
+  return {
+    ...first,
+    resources,
+    count: resources.length,
+    total: resources.length,
+    limit: pageSize,
+    cursor: null,
+    next_cursor: null,
+    has_more: false,
+    complete: true,
+    truncated: false
+  };
+}
+function getMementosProjectResourceExact(projectId, resourceKind, stableId, db, authorityOptions = {}) {
+  if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(resourceKind)) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `Unsupported Mementos project resource kind: ${resourceKind}`);
+  }
+  if (!db && isApiMode()) {
+    const { data } = apiJson("GET", `/projects/${encodeURIComponent(projectId)}/resources/${encodeURIComponent(resourceKind)}/${encodeURIComponent(stableId)}`);
+    return data;
+  }
+  const d = db ?? getDatabase();
+  const { project, resources, collectionRevision } = localPopulation(projectId, d, [
+    resourceKind
+  ]);
+  const resource = resources.find((candidate) => candidate.stable_id === stableId);
+  if (!resource) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_NOT_FOUND", `Mementos ${resourceKind} resource not found in project ${projectId}: ${stableId}`, { project_id: projectId, resource_kind: resourceKind, stable_id: stableId });
+  }
+  const capability = buildMementosProjectRegistrationCapability(authorityOptions);
+  return {
+    schema: "mementos.project-resource.v1",
+    authority: {
+      authority: capability.authority,
+      authority_id: capability.authority_id,
+      tenant_id: capability.tenant_id,
+      corpus_id: capability.corpus_id,
+      package_version: capability.package_version
+    },
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    collection_revision: collectionRevision,
+    resource,
+    complete: true,
+    truncated: false
+  };
+}
+
+// src/project-registration/index.ts
+init_types2();
+
 // src/cli/commands/memory-cmd-crud.ts
 init_projects();
 init_agents();
@@ -61462,9 +61897,7 @@ function registerCrudCommands(program2) {
           throw new Error("Receipt lookup cannot be combined with link, rollback, or dry-run options");
         }
         const receipt = getMemoryProjectLinkReceipt(memoryId, lookupReceipt, {
-          authority_id: "mementos",
-          tenant_id: "default",
-          corpus_id: "default"
+          ...resolveMementosProjectAuthorityIdentity()
         });
         if (globalOpts.json)
           outputJson(receipt);
@@ -61490,9 +61923,7 @@ function registerCrudCommands(program2) {
         throw new Error("--project-id and --rollback-receipt cannot be used together");
       }
       const common = {
-        authority_id: "mementos",
-        tenant_id: "default",
-        corpus_id: "default",
+        ...resolveMementosProjectAuthorityIdentity(),
         operation_id: opts.operationId ?? idempotencyKey,
         step_id: opts.stepId ?? (rollbackReceipt ? "mementos_memory_project_link_rollback" : "mementos_memory_project_link"),
         idempotency_key: idempotencyKey,
@@ -63400,29 +63831,29 @@ function enforceQuotas(config, db) {
 }
 function archiveStale(staleDays, db) {
   const d = db || getDatabase();
-  const timestamp = now();
+  const timestamp2 = now();
   const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000).toISOString();
   const archiveWhere = `status = 'active' AND pinned = 0 AND COALESCE(accessed_at, created_at) < ?`;
   const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${archiveWhere}`).get(cutoff).c;
   if (count > 0) {
-    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${archiveWhere}`, [timestamp, cutoff]);
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${archiveWhere}`, [timestamp2, cutoff]);
   }
   return count;
 }
 function archiveUnused(days, db) {
   const d = db || getDatabase();
-  const timestamp = now();
+  const timestamp2 = now();
   const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
   const unusedWhere = `status = 'active' AND pinned = 0 AND access_count = 0 AND created_at < ?`;
   const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${unusedWhere}`).get(cutoff).c;
   if (count > 0) {
-    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${unusedWhere}`, [timestamp, cutoff]);
+    d.run(`UPDATE memories SET status = 'archived', updated_at = ? WHERE ${unusedWhere}`, [timestamp2, cutoff]);
   }
   return count;
 }
 function deprioritizeStale(days, db) {
   const d = db || getDatabase();
-  const timestamp = now();
+  const timestamp2 = now();
   const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
   const deprioWhere = `status = 'active' AND pinned = 0 AND importance > 1 AND COALESCE(accessed_at, updated_at) < ?`;
   const count = d.query(`SELECT COUNT(*) as c FROM memories WHERE ${deprioWhere}`).get(cutoff).c;
@@ -63431,7 +63862,7 @@ function deprioritizeStale(days, db) {
        SET importance = importance - 1,
            version = version + 1,
            updated_at = ?
-       WHERE ${deprioWhere}`, [timestamp, cutoff]);
+       WHERE ${deprioWhere}`, [timestamp2, cutoff]);
   }
   return count;
 }
@@ -63967,9 +64398,7 @@ function registerProjectCommands(program2) {
           process.exit(1);
         }
         const common = {
-          authority_id: "mementos",
-          tenant_id: "default",
-          corpus_id: "default",
+          ...resolveMementosProjectAuthorityIdentity(),
           operation_id: opts.operationId ?? idempotencyKey,
           step_id: opts.stepId ?? (rollbackReceipt ? "mementos_project_rollback" : "mementos_project_update"),
           idempotency_key: idempotencyKey,
@@ -64025,6 +64454,54 @@ function registerProjectCommands(program2) {
       handleError(e);
     }
   });
+  program2.command("project-resources <project-id>").description("Enumerate the complete project-owned Mementos resource population").option("--limit <n>", "Bounded page size (1-1000)", parseInt).option("--cursor <cursor>", "Opaque revision-bound continuation cursor").option("--kinds <kinds>", "Comma-separated resource kinds: project,knowledge,memory,session").option("--all", "Traverse every page and verify complete unique coverage").option("--resource-kind <kind>", "Read one exact resource kind").option("--resource-id <id>", "Read one exact stable resource ID").action((projectId, opts) => {
+    try {
+      const globalOpts = program2.opts();
+      const resourceKind = opts.resourceKind;
+      const resourceId = opts.resourceId;
+      if (Boolean(resourceKind) !== Boolean(resourceId)) {
+        throw new Error("--resource-kind and --resource-id must be provided together");
+      }
+      const resourceKinds = opts.kinds === undefined ? undefined : String(opts.kinds).split(",").map((value) => value.trim()).filter(Boolean);
+      if (resourceKinds) {
+        for (const kind of resourceKinds) {
+          if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(kind)) {
+            throw new Error(`Unsupported project resource kind: ${kind}`);
+          }
+        }
+      }
+      const result = resourceKind && resourceId ? getMementosProjectResourceExact(projectId, resourceKind, resourceId) : opts.all ? readAllMementosProjectResources(projectId, {
+        page_size: opts.limit,
+        resource_kinds: resourceKinds
+      }) : readMementosProjectResourcePage(projectId, {
+        limit: opts.limit,
+        cursor: opts.cursor,
+        resource_kinds: resourceKinds
+      });
+      if (globalOpts.json) {
+        outputJson(result);
+        return;
+      }
+      if ("resource" in result) {
+        console.log(chalk23.green("Project resource:"));
+        console.log(`  ${chalk23.bold("Project:")}    ${result.project_id}`);
+        console.log(`  ${chalk23.bold("Kind:")}       ${result.resource.resource_kind}`);
+        console.log(`  ${chalk23.bold("Stable ID:")}  ${result.resource.stable_id}`);
+        console.log(`  ${chalk23.bold("Revision:")}   ${result.resource.revision}`);
+        return;
+      }
+      console.log(chalk23.bold(`${result.count} of ${result.total} project resource${result.total === 1 ? "" : "s"}:`));
+      for (const resource of result.resources) {
+        console.log(`  ${chalk23.dim(resource.resource_kind.padEnd(9))} ${resource.stable_id}`);
+      }
+      console.log(`  ${chalk23.bold("Complete:")} ${result.complete}  ` + `${chalk23.bold("Has more:")} ${result.has_more}`);
+      if (result.next_cursor) {
+        console.log(chalk23.dim(`Next: mementos project-resources ${projectId} --cursor ${result.next_cursor}`));
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
   program2.command("inject").description("Output injection context for agent system prompts").option("--agent <name>", "Agent ID for scope filtering").option("--project <path>", "Project path for scope filtering").option("--session <id>", "Session ID for scope filtering").option("--machine <id>", "Machine ID for machine-local memory visibility").option("--max-tokens <n>", "Max approximate token budget", parseInt).option("--categories <cats>", "Comma-separated categories to include").option("--format <fmt>", "Output format: xml (default), compact, markdown, json").action((opts) => {
     try {
       const globalOpts = program2.opts();
@@ -64214,7 +64691,7 @@ function memoryResource(memory) {
     tags: memory.tags
   };
 }
-function projectResource(projectId, name, externalId) {
+function projectResource2(projectId, name, externalId) {
   return {
     kind: "project",
     id: projectId,
@@ -64320,7 +64797,7 @@ function createMementosProjectPanel(projectRef, options = {}) {
       actionResource("mementos:save", "Save project memory")
     ],
     resourceRefs: [
-      projectResource(projectId, project?.name ?? projectRef, project?.id ?? projectRef),
+      projectResource2(projectId, project?.name ?? projectRef, project?.id ?? projectRef),
       ...memories.slice(0, limit).map(memoryResource)
     ],
     renderFragment: {
@@ -66617,13 +67094,13 @@ function buildConflictKey(key, sourceMachine, updatedAt) {
   return `${key}__conflict__${machineSegment}__${timestampSegment || "0"}`;
 }
 function buildConflictClone(loser, sourceMachine, winnerId) {
-  const timestamp = new Date().toISOString();
+  const timestamp2 = new Date().toISOString();
   const tags = new Set(ensureArrayValue(loser["tags"]));
   tags.add("sync-conflict");
   tags.add(`source_machine:${sourceMachine}`);
   const metadata = ensureObjectValue(loser["metadata"]);
   metadata["sync_conflict"] = true;
-  metadata["conflict_detected_at"] = timestamp;
+  metadata["conflict_detected_at"] = timestamp2;
   metadata["conflict_original_id"] = loser["id"];
   metadata["conflict_winner_id"] = winnerId;
   metadata["conflict_source_machine"] = sourceMachine;
@@ -66635,10 +67112,10 @@ function buildConflictClone(loser, sourceMachine, winnerId) {
     metadata: JSON.stringify(metadata),
     access_count: 0,
     version: 1,
-    created_at: timestamp,
-    updated_at: timestamp,
+    created_at: timestamp2,
+    updated_at: timestamp2,
     ..."accessed_at" in loser ? { accessed_at: null } : {},
-    ..."ingested_at" in loser ? { ingested_at: timestamp } : {}
+    ..."ingested_at" in loser ? { ingested_at: timestamp2 } : {}
   }, sourceMachine);
 }
 function insertConflictCloneIfMissing(db, clone) {
@@ -67402,7 +67879,7 @@ function parseMemoryLink(row) {
 function createMemoryLink(input, db) {
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT OR IGNORE INTO memory_links (id, source_memory_id, target_memory_id, relation_type, run_id, metadata, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)`, [
     id,
@@ -67411,7 +67888,7 @@ function createMemoryLink(input, db) {
     input.relation_type,
     input.run_id ?? null,
     JSON.stringify(input.metadata ?? {}),
-    timestamp
+    timestamp2
   ]);
   const row = d.query(`SELECT * FROM memory_links
        WHERE source_memory_id = ? AND target_memory_id = ? AND relation_type = ? AND COALESCE(run_id, '') = ?
@@ -68610,8 +69087,8 @@ function makeBrainsCommand() {
       if (!existsSync11(outputDir)) {
         mkdirSync8(outputDir, { recursive: true });
       }
-      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const outputPath = join12(outputDir, `mementos-training-${timestamp}.jsonl`);
+      const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const outputPath = join12(outputDir, `mementos-training-${timestamp2}.jsonl`);
       const jsonl = result.examples.map((ex) => JSON.stringify(ex)).join(`
 `);
       writeFileSync6(outputPath, jsonl + `