@hasna/mementos 0.14.74 → 0.14.78

package/dist/cli/index.js

@@ -3210,6 +3210,395 @@ var init_api_mode = __esm(() => {
   };
 });
 
+// src/project-registration/schema.ts
+function sqliteMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector),
+      UNIQUE(accepted_receipt_id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation BOOLEAN NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT UNIQUE,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TIMESTAMPTZ NOT NULL,
+      updated_at TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE OR REPLACE FUNCTION mementos_project_registration_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project registration receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_registration_receipts_immutable
+      ON mementos_project_registration_receipts;
+    CREATE TRIGGER mementos_project_registration_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_registration_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_registration_receipts_immutable();
+  `;
+}
+function sqliteMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json TEXT NOT NULL,
+      after_project_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json JSONB NOT NULL,
+      after_project_json JSONB NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE OR REPLACE FUNCTION mementos_project_update_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project update receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_update_receipts_immutable
+      ON mementos_project_update_receipts;
+    CREATE TRIGGER mementos_project_update_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_update_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_update_receipts_immutable();
+  `;
+}
+
+// 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";
+var init_schema = () => {};
+
 // src/db/migrations.ts
 var MEMORY_VERSION_SNAPSHOT_TRIGGER = `
 CREATE TRIGGER IF NOT EXISTS memories_version_snapshot
@@ -3230,6 +3619,7 @@ BEGIN
 END;
 `, MIGRATIONS;
 var init_migrations = __esm(() => {
+  init_schema();
   MIGRATIONS = [
     `
   CREATE TABLE IF NOT EXISTS projects (
@@ -4130,6 +4520,51 @@ 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);
 `
   ];
 });
@@ -5701,13 +6136,247 @@ var init_memories = __esm(() => {
   init_api_mode();
 });
 
+// src/db/agents.ts
+function parseAgentRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    session_id: row["session_id"] || null,
+    description: row["description"] || null,
+    role: row["role"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    active_project_id: row["active_project_id"] || null,
+    created_at: row["created_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function registerAgent(name, sessionId, description, role, projectId, db) {
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", "/agents", {
+      name,
+      session_id: sessionId,
+      description,
+      role,
+      project_id: projectId
+    });
+    return data;
+  }
+  const d = db || getDatabase();
+  const timestamp = now();
+  const normalizedName = name.trim().toLowerCase();
+  if (projectId) {
+    const resolvedProjectId = resolvePartialId(d, "projects", projectId);
+    if (!resolvedProjectId) {
+      throw new Error(`Project not found: ${projectId}`);
+    }
+    projectId = resolvedProjectId;
+  }
+  const existing = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
+  if (existing) {
+    const existingId = existing["id"];
+    const existingSessionId = existing["session_id"] || null;
+    const existingLastSeen = existing["last_seen_at"];
+    if (sessionId && existingSessionId && existingSessionId !== sessionId) {
+      const lastSeenMs = new Date(existingLastSeen).getTime();
+      const nowMs = Date.now();
+      if (nowMs - lastSeenMs < CONFLICT_WINDOW_MS) {
+        throw new AgentConflictError({
+          existing_id: existingId,
+          existing_name: normalizedName,
+          last_seen_at: existingLastSeen,
+          session_hint: existingSessionId.slice(0, 8),
+          working_dir: null
+        });
+      }
+    }
+    d.run("UPDATE agents SET last_seen_at = ?, session_id = ? WHERE id = ?", [
+      timestamp,
+      sessionId ?? existingSessionId,
+      existingId
+    ]);
+    if (description) {
+      d.run("UPDATE agents SET description = ? WHERE id = ?", [description, existingId]);
+    }
+    if (role) {
+      d.run("UPDATE agents SET role = ? WHERE id = ?", [role, existingId]);
+    }
+    if (projectId !== undefined) {
+      d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [projectId, existingId]);
+    }
+    return getAgent(existingId, d);
+  }
+  const id = shortUuid();
+  d.run("INSERT INTO agents (id, name, session_id, description, role, active_project_id, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, normalizedName, sessionId ?? null, description || null, role || "agent", projectId ?? null, timestamp, timestamp]);
+  return getAgent(id, d);
+}
+function getAgent(idOrName, db) {
+  if (!db && isApiMode()) {
+    const { status, data } = apiJson("GET", `/agents/${encodeURIComponent(idOrName)}`, undefined, { allow404: true });
+    if (status === 404 || !data)
+      return null;
+    return data;
+  }
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
+  if (row)
+    return parseAgentRow(row);
+  row = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(idOrName.trim().toLowerCase());
+  if (row)
+    return parseAgentRow(row);
+  const rows = d.query("SELECT * FROM agents WHERE id LIKE ? ESCAPE '\\'").all(`${escapeLikePrefix(idOrName)}%`);
+  if (rows.length === 1)
+    return parseAgentRow(rows[0]);
+  return null;
+}
+function normalizedAgentListFilter(filter) {
+  const limit = Number.isFinite(filter.limit) ? Math.max(0, Math.floor(filter.limit)) : undefined;
+  const offset = Number.isFinite(filter.offset) ? Math.max(0, Math.floor(filter.offset)) : undefined;
+  return { limit, offset };
+}
+function isDatabaseAdapter(value) {
+  return typeof value === "object" && value !== null && "query" in value && typeof value.query === "function";
+}
+function paginatedAgentQuery(baseSql, baseParams, filter) {
+  const { limit, offset } = normalizedAgentListFilter(filter);
+  let sql = `${baseSql} ORDER BY created_at ASC, id ASC`;
+  const params = [...baseParams];
+  if (limit !== undefined) {
+    sql += " LIMIT ?";
+    params.push(limit);
+  } else if ((offset ?? 0) > 0) {
+    sql += " LIMIT ?";
+    params.push(UNBOUNDED_AGENT_LIST_LIMIT);
+  }
+  if ((offset ?? 0) > 0) {
+    sql += " OFFSET ?";
+    params.push(offset);
+  }
+  return { sql, params };
+}
+function listAgents(filterOrDb = {}, db) {
+  const explicitDb = isDatabaseAdapter(filterOrDb) ? filterOrDb : db;
+  const filter = isDatabaseAdapter(filterOrDb) ? {} : filterOrDb;
+  const normalized = normalizedAgentListFilter(filter);
+  if (!explicitDb && isApiMode()) {
+    const q = toQuery({
+      limit: normalized.limit,
+      offset: normalized.offset
+    });
+    const { data } = apiJson("GET", `/agents${q}`);
+    return data?.agents ?? [];
+  }
+  const d = explicitDb || getDatabase();
+  const { sql, params } = paginatedAgentQuery("SELECT * FROM agents", [], normalized);
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseAgentRow);
+}
+function touchAgent(idOrName, db) {
+  if (!db && isApiMode()) {
+    const agent2 = getAgent(idOrName);
+    if (!agent2)
+      return;
+    apiJson("PATCH", `/agents/${encodeURIComponent(agent2.id)}`, {});
+    return;
+  }
+  const d = db || getDatabase();
+  const agent = getAgent(idOrName, d);
+  if (!agent)
+    return;
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), agent.id]);
+}
+function updateAgent(id, updates, db) {
+  if (!db && isApiMode()) {
+    const { status, data } = apiJson("PATCH", `/agents/${encodeURIComponent(id)}`, updates, { allow404: true });
+    if (status === 404 || !data)
+      return null;
+    return data;
+  }
+  const d = db || getDatabase();
+  const agent = getAgent(id, d);
+  if (!agent)
+    return null;
+  const timestamp = now();
+  if (updates.name) {
+    const normalizedNewName = updates.name.trim().toLowerCase();
+    if (normalizedNewName !== agent.name) {
+      const existing = d.query("SELECT id FROM agents WHERE LOWER(name) = ? AND id != ?").get(normalizedNewName, agent.id);
+      if (existing) {
+        throw new Error(`Agent name already taken: ${normalizedNewName}`);
+      }
+      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
+    }
+  }
+  if (updates.description !== undefined) {
+    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
+  }
+  if (updates.role !== undefined) {
+    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
+  }
+  if (updates.metadata !== undefined) {
+    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
+  }
+  if ("active_project_id" in updates) {
+    let resolvedProjectId = updates.active_project_id ?? null;
+    if (resolvedProjectId) {
+      const fullId = resolvePartialId(d, "projects", resolvedProjectId);
+      if (!fullId) {
+        throw new Error(`Project not found: ${resolvedProjectId}`);
+      }
+      resolvedProjectId = fullId;
+    }
+    d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [resolvedProjectId, agent.id]);
+  }
+  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
+  return getAgent(agent.id, d);
+}
+var CONFLICT_WINDOW_MS, UNBOUNDED_AGENT_LIST_LIMIT;
+var init_agents = __esm(() => {
+  init_types();
+  init_database();
+  init_api_mode();
+  CONFLICT_WINDOW_MS = 30 * 60 * 1000;
+  UNBOUNDED_AGENT_LIST_LIMIT = Number.MAX_SAFE_INTEGER;
+});
+
+// src/lib/package-version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getMementosPackageVersion() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  for (const candidate of [
+    join5(here, "..", "..", "package.json"),
+    join5(here, "..", "package.json")
+  ]) {
+    try {
+      const parsed = JSON.parse(readFileSync2(candidate, "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.trim())
+        return parsed.version;
+    } catch {}
+  }
+  return "0.0.0";
+}
+var init_package_version = () => {};
+
+// src/project-registration/types.ts
+var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
+var init_types2 = () => {};
+
 // src/db/projects.ts
 var exports_projects = {};
 __export(exports_projects, {
+  updateProject: () => updateProject,
+  rollbackProjectUpdate: () => rollbackProjectUpdate,
   registerProject: () => registerProject,
+  previewProjectUpdate: () => previewProjectUpdate,
   listProjects: () => listProjects,
-  getProject: () => getProject
+  getProjectUpdateReceipt: () => getProjectUpdateReceipt,
+  getProject: () => getProject,
+  applyProjectUpdate: () => applyProjectUpdate,
+  ProjectGuardedUpdateError: () => ProjectGuardedUpdateError,
+  ProjectCollisionError: () => ProjectCollisionError
 });
+import { createHash } from "crypto";
 function parseProjectRow(row) {
   return {
     id: row["id"],
@@ -5719,6 +6388,213 @@ function parseProjectRow(row) {
     updated_at: row["updated_at"]
   };
 }
+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) {
+  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) {
+    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) {
+  assertProjectUpdateIdentity(request);
+  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: 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", {
@@ -5772,9 +6648,280 @@ 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);
+  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) {
+  assertProjectUpdateRequest(request);
+  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
+    });
+    insertProjectUpdateReceipt(d, receipt);
+    return { dry_run: false, applied: true, project: readback, receipt };
+  });
+}
+function rollbackProjectUpdate(id, request, db) {
+  assertProjectUpdateRequest(request);
+  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,
+      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);
+  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;
+}
+function updateProject(id, input, db) {
+  let normalizedInput;
+  try {
+    normalizedInput = normalizeProjectUpdateInput(input);
+  } catch (error) {
+    if (error instanceof ProjectGuardedUpdateError)
+      throw new Error(error.message);
+    throw error;
+  }
+  if (!db && isApiMode()) {
+    const { status, data } = apiJson("PATCH", `/projects/${encodeURIComponent(id)}`, normalizedInput, { allow404: true });
+    if (status === 404 || !data)
+      return null;
+    if (data.id !== id) {
+      throw new Error(`Project update did not persist for ${id}: server returned a different stable ID (${data.id})`);
+    }
+    for (const field of ["name", "path", "description", "memory_prefix"]) {
+      if (normalizedInput[field] !== undefined && data[field] !== normalizedInput[field]) {
+        throw new Error(`Project update did not persist for ${id}: ${field} remained ${JSON.stringify(data[field])}`);
+      }
+    }
+    return data;
+  }
+  const d = db || getDatabase();
+  return d.transaction(() => {
+    const existingRow = d.query("SELECT * FROM projects WHERE id = ?").get(id);
+    if (!existingRow)
+      return null;
+    const existing = parseProjectRow(existingRow);
+    const nextName = normalizedInput.name;
+    const nextPath = normalizedInput.path;
+    if (nextName !== undefined) {
+      const collision = d.query("SELECT id FROM projects WHERE LOWER(name) = LOWER(?) AND id != ?").get(nextName, existing.id);
+      if (collision)
+        throw new ProjectCollisionError("name", nextName);
+    }
+    if (nextPath !== undefined) {
+      const collision = d.query("SELECT id FROM projects WHERE path = ? AND id != ?").get(nextPath, existing.id);
+      if (collision)
+        throw new ProjectCollisionError("path", nextPath);
+    }
+    const sets = ["updated_at = ?"];
+    const values = [now()];
+    if (nextName !== undefined) {
+      sets.push("name = ?");
+      values.push(nextName);
+    }
+    if (nextPath !== undefined) {
+      sets.push("path = ?");
+      values.push(nextPath);
+    }
+    if (normalizedInput.description !== undefined) {
+      sets.push("description = ?");
+      values.push(normalizedInput.description);
+    }
+    if (normalizedInput.memory_prefix !== undefined) {
+      sets.push("memory_prefix = ?");
+      values.push(normalizedInput.memory_prefix);
+    }
+    values.push(existing.id);
+    d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, values);
+    const updated = d.query("SELECT * FROM projects WHERE id = ?").get(existing.id);
+    return updated ? parseProjectRow(updated) : null;
+  });
+}
+var ProjectCollisionError, ProjectGuardedUpdateError, PROJECT_UPDATE_AUTHORITY, BOUNDED_IDENTIFIER;
 var init_projects = __esm(() => {
   init_database();
   init_api_mode();
+  init_package_version();
+  init_types2();
+  ProjectCollisionError = class ProjectCollisionError extends Error {
+    field;
+    value;
+    constructor(field, value) {
+      super(`Project ${field} already exists: ${value}`);
+      this.field = field;
+      this.value = value;
+      this.name = "ProjectCollisionError";
+    }
+  };
+  ProjectGuardedUpdateError = class ProjectGuardedUpdateError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+      super(message);
+      this.code = code;
+      this.details = details;
+      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}$/;
 });
 
 // src/db/entities.ts
@@ -5993,6 +7140,7 @@ __export(exports_helpers, {
   resolveMemoryId: () => resolveMemoryId,
   resolveKeyOrId: () => resolveKeyOrId,
   resolveEntityArg: () => resolveEntityArg,
+  resolveAgentFilter: () => resolveAgentFilter,
   readFileConfig: () => readFileConfig,
   printPageHint: () => printPageHint,
   positiveIntOrDefault: () => positiveIntOrDefault,
@@ -6023,13 +7171,13 @@ __export(exports_helpers, {
   DEFAULT_COMPACT_LIMIT: () => DEFAULT_COMPACT_LIMIT
 });
 import chalk from "chalk";
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join5, resolve as resolve2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function getPackageVersion() {
   try {
-    const pkgPath = join5(dirname2(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkgPath = join6(dirname3(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -6259,8 +7407,19 @@ function resolveMemoryId(partialId) {
   }
   return id;
 }
+function resolveAgentFilter(nameOrId) {
+  if (!nameOrId)
+    return;
+  const agent = getAgent(nameOrId);
+  if (agent)
+    return agent.id;
+  process.stderr.write(`Warning: no agent named '${nameOrId}' is registered, so this empty result may be a
+` + `         mistyped name rather than an empty set. Check with 'mementos agents'.
+`);
+  return nameOrId;
+}
 function resolveKeyOrId(keyOrId, opts, globalOpts) {
-  const agentId = opts.agent || globalOpts.agent;
+  const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
   const projectPath = opts.project || globalOpts.project;
   let projectId;
   if (projectPath) {
@@ -6545,7 +7704,7 @@ function validateConfigKeyValue(key, value, DEFAULT_CONFIG) {
 }
 function getConfigPath() {
   const { homedir: homedir3 } = __require("os");
-  return join5(homedir3(), ".hasna", "mementos", "config.json");
+  return join6(homedir3(), ".hasna", "mementos", "config.json");
 }
 function readFileConfig() {
   const { existsSync: existsSync4 } = __require("fs");
@@ -6553,7 +7712,7 @@ function readFileConfig() {
   if (!existsSync4(configPath))
     return {};
   try {
-    const data = JSON.parse(readFileSync2(configPath, "utf-8"));
+    const data = JSON.parse(readFileSync3(configPath, "utf-8"));
     if (data === null || typeof data !== "object" || Array.isArray(data)) {
       throw new Error("expected a JSON object");
     }
@@ -6566,7 +7725,7 @@ function readFileConfig() {
 function writeFileConfig(data) {
   const { existsSync: existsSync4, writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = __require("fs");
   const configPath = getConfigPath();
-  const dir = dirname2(configPath);
+  const dir = dirname3(configPath);
   if (!existsSync4(dir))
     mkdirSync3(dir, { recursive: true });
   writeFileSync3(configPath, JSON.stringify(data, null, 2) + `
@@ -6577,6 +7736,7 @@ var init_helpers = __esm(() => {
   init_database();
   init_api_mode();
   init_memories();
+  init_agents();
   init_projects();
   init_entities();
   scopeColor = {
@@ -6607,194 +7767,6 @@ var init_helpers = __esm(() => {
   VALID_CATEGORIES = ["preference", "fact", "knowledge", "history"];
 });
 
-// src/db/agents.ts
-var exports_agents = {};
-__export(exports_agents, {
-  updateAgent: () => updateAgent,
-  touchAgent: () => touchAgent,
-  registerAgent: () => registerAgent,
-  listAgentsByProject: () => listAgentsByProject,
-  listAgents: () => listAgents,
-  getAgent: () => getAgent
-});
-function parseAgentRow(row) {
-  return {
-    id: row["id"],
-    name: row["name"],
-    session_id: row["session_id"] || null,
-    description: row["description"] || null,
-    role: row["role"] || null,
-    metadata: JSON.parse(row["metadata"] || "{}"),
-    active_project_id: row["active_project_id"] || null,
-    created_at: row["created_at"],
-    last_seen_at: row["last_seen_at"]
-  };
-}
-function registerAgent(name, sessionId, description, role, projectId, db) {
-  if (!db && isApiMode()) {
-    const { data } = apiJson("POST", "/agents", {
-      name,
-      session_id: sessionId,
-      description,
-      role,
-      project_id: projectId
-    });
-    return data;
-  }
-  const d = db || getDatabase();
-  const timestamp = now();
-  const normalizedName = name.trim().toLowerCase();
-  if (projectId) {
-    const resolvedProjectId = resolvePartialId(d, "projects", projectId);
-    if (!resolvedProjectId) {
-      throw new Error(`Project not found: ${projectId}`);
-    }
-    projectId = resolvedProjectId;
-  }
-  const existing = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(normalizedName);
-  if (existing) {
-    const existingId = existing["id"];
-    const existingSessionId = existing["session_id"] || null;
-    const existingLastSeen = existing["last_seen_at"];
-    if (sessionId && existingSessionId && existingSessionId !== sessionId) {
-      const lastSeenMs = new Date(existingLastSeen).getTime();
-      const nowMs = Date.now();
-      if (nowMs - lastSeenMs < CONFLICT_WINDOW_MS) {
-        throw new AgentConflictError({
-          existing_id: existingId,
-          existing_name: normalizedName,
-          last_seen_at: existingLastSeen,
-          session_hint: existingSessionId.slice(0, 8),
-          working_dir: null
-        });
-      }
-    }
-    d.run("UPDATE agents SET last_seen_at = ?, session_id = ? WHERE id = ?", [
-      timestamp,
-      sessionId ?? existingSessionId,
-      existingId
-    ]);
-    if (description) {
-      d.run("UPDATE agents SET description = ? WHERE id = ?", [description, existingId]);
-    }
-    if (role) {
-      d.run("UPDATE agents SET role = ? WHERE id = ?", [role, existingId]);
-    }
-    if (projectId !== undefined) {
-      d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [projectId, existingId]);
-    }
-    return getAgent(existingId, d);
-  }
-  const id = shortUuid();
-  d.run("INSERT INTO agents (id, name, session_id, description, role, active_project_id, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, normalizedName, sessionId ?? null, description || null, role || "agent", projectId ?? null, timestamp, timestamp]);
-  return getAgent(id, d);
-}
-function getAgent(idOrName, db) {
-  if (!db && isApiMode()) {
-    const { status, data } = apiJson("GET", `/agents/${encodeURIComponent(idOrName)}`, undefined, { allow404: true });
-    if (status === 404 || !data)
-      return null;
-    return data;
-  }
-  const d = db || getDatabase();
-  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
-  if (row)
-    return parseAgentRow(row);
-  row = d.query("SELECT * FROM agents WHERE LOWER(name) = ?").get(idOrName.trim().toLowerCase());
-  if (row)
-    return parseAgentRow(row);
-  const rows = d.query("SELECT * FROM agents WHERE id LIKE ? ESCAPE '\\'").all(`${escapeLikePrefix(idOrName)}%`);
-  if (rows.length === 1)
-    return parseAgentRow(rows[0]);
-  return null;
-}
-function listAgents(db) {
-  if (!db && isApiMode()) {
-    const { data } = apiJson("GET", "/agents");
-    return data?.agents ?? [];
-  }
-  const d = db || getDatabase();
-  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
-  return rows.map(parseAgentRow);
-}
-function touchAgent(idOrName, db) {
-  if (!db && isApiMode()) {
-    const agent2 = getAgent(idOrName);
-    if (!agent2)
-      return;
-    apiJson("PATCH", `/agents/${encodeURIComponent(agent2.id)}`, {});
-    return;
-  }
-  const d = db || getDatabase();
-  const agent = getAgent(idOrName, d);
-  if (!agent)
-    return;
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), agent.id]);
-}
-function listAgentsByProject(projectId, db) {
-  if (!db && isApiMode()) {
-    const q = toQuery({ project_id: projectId });
-    const { data } = apiJson("GET", `/agents${q}`);
-    return data?.agents ?? [];
-  }
-  const d = db || getDatabase();
-  const resolvedId = resolvePartialId(d, "projects", projectId) || projectId;
-  const rows = d.query("SELECT * FROM agents WHERE active_project_id = ? ORDER BY last_seen_at DESC").all(resolvedId);
-  return rows.map(parseAgentRow);
-}
-function updateAgent(id, updates, db) {
-  if (!db && isApiMode()) {
-    const { status, data } = apiJson("PATCH", `/agents/${encodeURIComponent(id)}`, updates, { allow404: true });
-    if (status === 404 || !data)
-      return null;
-    return data;
-  }
-  const d = db || getDatabase();
-  const agent = getAgent(id, d);
-  if (!agent)
-    return null;
-  const timestamp = now();
-  if (updates.name) {
-    const normalizedNewName = updates.name.trim().toLowerCase();
-    if (normalizedNewName !== agent.name) {
-      const existing = d.query("SELECT id FROM agents WHERE LOWER(name) = ? AND id != ?").get(normalizedNewName, agent.id);
-      if (existing) {
-        throw new Error(`Agent name already taken: ${normalizedNewName}`);
-      }
-      d.run("UPDATE agents SET name = ? WHERE id = ?", [normalizedNewName, agent.id]);
-    }
-  }
-  if (updates.description !== undefined) {
-    d.run("UPDATE agents SET description = ? WHERE id = ?", [updates.description, agent.id]);
-  }
-  if (updates.role !== undefined) {
-    d.run("UPDATE agents SET role = ? WHERE id = ?", [updates.role, agent.id]);
-  }
-  if (updates.metadata !== undefined) {
-    d.run("UPDATE agents SET metadata = ? WHERE id = ?", [JSON.stringify(updates.metadata), agent.id]);
-  }
-  if ("active_project_id" in updates) {
-    let resolvedProjectId = updates.active_project_id ?? null;
-    if (resolvedProjectId) {
-      const fullId = resolvePartialId(d, "projects", resolvedProjectId);
-      if (!fullId) {
-        throw new Error(`Project not found: ${resolvedProjectId}`);
-      }
-      resolvedProjectId = fullId;
-    }
-    d.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [resolvedProjectId, agent.id]);
-  }
-  d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [timestamp, agent.id]);
-  return getAgent(agent.id, d);
-}
-var CONFLICT_WINDOW_MS;
-var init_agents = __esm(() => {
-  init_types();
-  init_database();
-  init_api_mode();
-  CONFLICT_WINDOW_MS = 30 * 60 * 1000;
-});
-
 // src/lib/poll.ts
 var exports_poll = {};
 __export(exports_poll, {
@@ -11304,11 +12276,11 @@ __export(exports_session_registry, {
   cleanStaleSessions: () => cleanStaleSessions
 });
 import { existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 function getDb() {
   if (_db2)
     return _db2;
-  const dir = dirname5(DB_PATH);
+  const dir = dirname6(DB_PATH);
   if (!existsSync8(dir))
     mkdirSync5(dir, { recursive: true });
   _db2 = new SqliteAdapter(DB_PATH);
@@ -11484,12 +12456,13 @@ function closeRegistry() {
 var DB_PATH, _db2 = null;
 var init_session_registry = __esm(() => {
   init_storage();
-  DB_PATH = join8(process.env["HOME"] || process.env["USERPROFILE"] || "~", ".open-sessions-registry.db");
+  DB_PATH = join9(process.env["HOME"] || process.env["USERPROFILE"] || "~", ".open-sessions-registry.db");
 });
 
 // src/db/pg-migrations.ts
 var PG_MIGRATIONS;
 var init_pg_migrations = __esm(() => {
+  init_schema();
   PG_MIGRATIONS = [
     `
   CREATE TABLE IF NOT EXISTS projects (
@@ -12222,6 +13195,47 @@ var init_pg_migrations = __esm(() => {
     EXECUTE FUNCTION snapshot_memory_version();
 
   INSERT INTO _migrations (id) VALUES (36) ON CONFLICT DO NOTHING;
+  `,
+    `
+  CREATE OR REPLACE FUNCTION audit_memory_insert() RETURNS trigger AS $$
+  BEGIN
+    INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, new_value_hash, created_at)
+    VALUES (gen_random_uuid()::text, NEW.id, NEW.key, 'create', NEW.agent_id, md5(COALESCE(NEW.value, '')), NOW());
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  CREATE OR REPLACE FUNCTION audit_memory_update() RETURNS trigger AS $$
+  BEGIN
+    INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, old_value_hash, new_value_hash, changes, created_at)
+    VALUES (gen_random_uuid()::text, NEW.id, NEW.key, 'update', NEW.agent_id, md5(COALESCE(OLD.value, '')), md5(COALESCE(NEW.value, '')),
+      json_build_object('version_from', OLD.version, 'version_to', NEW.version, 'importance_from', OLD.importance, 'importance_to', NEW.importance)::text,
+      NOW());
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  CREATE OR REPLACE FUNCTION audit_memory_delete() RETURNS trigger AS $$
+  BEGIN
+    INSERT INTO memory_audit_log (id, memory_id, memory_key, operation, agent_id, old_value_hash, created_at)
+    VALUES (gen_random_uuid()::text, OLD.id, OLD.key, 'delete', OLD.agent_id, md5(COALESCE(OLD.value, '')), NOW());
+    RETURN OLD;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  INSERT INTO _migrations (id) VALUES (37) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ${postgresMementosProjectRegistrationSchemaSql()}
+  INSERT INTO _migrations (id) VALUES (38) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ${postgresMementosProjectGuardedUpdateSchemaSql()}
+  INSERT INTO _migrations (id) VALUES (39) ON CONFLICT DO NOTHING;
+  `,
+    `
+  ${postgresMementosMemoryProjectLinkSchemaSql()}
+  INSERT INTO _migrations (id) VALUES (40) ON CONFLICT DO NOTHING;
   `
   ];
 });
@@ -13371,7 +14385,7 @@ var handleResult = (ctx, result) => {
 }, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, ZodReadonly, late, ZodFirstPartyTypeKind, instanceOfType = (cls, params = {
   message: `Input not instance of ${cls.name}`
 }) => custom((data) => data instanceof cls, params), stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType, ostring = () => stringType().optional(), onumber = () => numberType().optional(), oboolean = () => booleanType().optional(), coerce, NEVER;
-var init_types2 = __esm(() => {
+var init_types3 = __esm(() => {
   init_ZodError();
   init_errors();
   init_errorUtil();
@@ -16292,7 +17306,7 @@ var init_external = __esm(() => {
   init_parseUtil();
   init_typeAliases();
   init_util();
-  init_types2();
+  init_types3();
   init_ZodError();
 });
 
@@ -58951,9 +59965,9 @@ var {
 
 // src/cli/index.tsx
 init_database();
-import { readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname7, join as join12 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname8, join as join13 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/db/machines.ts
 init_database();
@@ -59753,11 +60767,638 @@ init_helpers();
 init_database();
 init_api_mode();
 init_memories();
-init_projects();
-init_agents();
 import chalk2 from "chalk";
 import { resolve as resolve3 } from "path";
 
+// src/db/memory-project-link.ts
+init_storage();
+init_api_mode();
+init_database();
+init_memories();
+init_package_version();
+init_schema();
+import { createHash as createHash2 } from "crypto";
+
+class MemoryProjectLinkError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    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 canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  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] = canonicalize(item);
+  }
+  return output;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function digest(value) {
+  return createHash2("sha256").update(canonicalJson(value)).digest("hex");
+}
+function timestampString2(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function nullableTimestamp(value) {
+  return value === null || value === undefined ? null : timestampString2(value);
+}
+function normalizeMemoryTimestamps(memory) {
+  return {
+    ...memory,
+    created_at: timestampString2(memory.created_at),
+    updated_at: timestampString2(memory.updated_at),
+    accessed_at: nullableTimestamp(memory.accessed_at),
+    expires_at: nullableTimestamp(memory.expires_at),
+    valid_from: nullableTimestamp(memory.valid_from),
+    valid_until: nullableTimestamp(memory.valid_until),
+    ingested_at: nullableTimestamp(memory.ingested_at)
+  };
+}
+function parseProjectRow2(row) {
+  return {
+    id: String(row["id"]),
+    name: String(row["name"]),
+    path: String(row["path"]),
+    description: row["description"] === null ? null : String(row["description"] ?? "") || null,
+    memory_prefix: row["memory_prefix"] === null ? null : String(row["memory_prefix"] ?? "") || null,
+    created_at: timestampString2(row["created_at"]),
+    updated_at: timestampString2(row["updated_at"])
+  };
+}
+function memoryMutationState(memory) {
+  const { access_count: _accessCount, accessed_at: _accessedAt, ...state } = memory;
+  return state;
+}
+function memoryDigest(memory) {
+  return digest(memoryMutationState(memory));
+}
+function projectDigest(project) {
+  return digest(project);
+}
+function snapshot(memory) {
+  return {
+    memory_id: memory.id,
+    project_id: memory.project_id,
+    memory_version: memory.version,
+    memory_revision: timestampString2(memory.updated_at),
+    memory_digest: memoryDigest(memory)
+  };
+}
+function parseSnapshot(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  return parsed;
+}
+function receiptFromRow(row) {
+  return {
+    receipt_id: String(row["receipt_id"]),
+    authority: "mementos",
+    route: MEMENTOS_MEMORY_PROJECT_LINK_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: row["outcome"],
+    target_memory_id: String(row["target_memory_id"]),
+    requested_project_id: String(row["requested_project_id"]),
+    expected_memory_version: Number(row["expected_memory_version"]),
+    expected_memory_revision: timestampString2(row["expected_memory_revision"]),
+    expected_project_revision: nullableTimestamp(row["expected_project_revision"]),
+    result_memory_version: Number(row["result_memory_version"]),
+    result_memory_revision: timestampString2(row["result_memory_revision"]),
+    result_memory_digest: String(row["result_memory_digest"]),
+    result_project_revision: nullableTimestamp(row["result_project_revision"]),
+    result_project_digest: row["result_project_digest"] === null ? null : String(row["result_project_digest"]),
+    accepted_receipt_id: row["accepted_receipt_id"] === null ? null : String(row["accepted_receipt_id"]),
+    before_link: parseSnapshot(row["before_link_json"]),
+    after_link: parseSnapshot(row["after_link_json"]),
+    before_project_revision: nullableTimestamp(row["before_project_revision"]),
+    before_project_digest: row["before_project_digest"] === null ? null : String(row["before_project_digest"]),
+    after_project_revision: nullableTimestamp(row["after_project_revision"]),
+    after_project_digest: row["after_project_digest"] === null ? null : String(row["after_project_digest"]),
+    created_at: timestampString2(row["created_at"])
+  };
+}
+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) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH", "memory project link does not match this authority, tenant, and corpus");
+  }
+}
+function assertBoundedIdentifier2(value, field) {
+  if (!BOUNDED_IDENTIFIER2.test(value)) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
+  }
+}
+function assertMemoryGuard(version, revision) {
+  if (!Number.isSafeInteger(version) || version < 1) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_INVALID_INPUT", "expected_memory_version must be a positive safe integer");
+  }
+  if (!revision || revision.length > 128) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_INVALID_INPUT", "expected_memory_revision is required and must be bounded");
+  }
+}
+function assertForwardRequest(request) {
+  assertIdentity(request);
+  assertBoundedIdentifier2(request.operation_id, "operation_id");
+  assertBoundedIdentifier2(request.step_id, "step_id");
+  assertBoundedIdentifier2(request.idempotency_key, "idempotency_key");
+  assertBoundedIdentifier2(request.target_project_id, "target_project_id");
+  assertMemoryGuard(request.expected_memory_version, request.expected_memory_revision);
+  if (!request.expected_project_revision || request.expected_project_revision.length > 128) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_INVALID_INPUT", "expected_project_revision is required and must be bounded");
+  }
+}
+function assertRollbackRequest(request) {
+  assertIdentity(request);
+  assertBoundedIdentifier2(request.operation_id, "operation_id");
+  assertBoundedIdentifier2(request.step_id, "step_id");
+  assertBoundedIdentifier2(request.idempotency_key, "idempotency_key");
+  assertBoundedIdentifier2(request.accepted_receipt_id, "accepted_receipt_id");
+  assertMemoryGuard(request.expected_memory_version, request.expected_memory_revision);
+}
+function forwardRequestDigest(memoryId, request) {
+  return digest({
+    authority_id: request.authority_id,
+    tenant_id: request.tenant_id,
+    corpus_id: request.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    idempotency_key: request.idempotency_key,
+    expected_memory_version: request.expected_memory_version,
+    expected_memory_revision: request.expected_memory_revision,
+    target_project_id: request.target_project_id,
+    expected_project_revision: request.expected_project_revision,
+    direction: "forward",
+    target_memory_id: memoryId
+  });
+}
+function rollbackRequestDigest(memoryId, request) {
+  return digest({
+    authority_id: request.authority_id,
+    tenant_id: request.tenant_id,
+    corpus_id: request.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    idempotency_key: request.idempotency_key,
+    expected_memory_version: request.expected_memory_version,
+    expected_memory_revision: request.expected_memory_revision,
+    accepted_receipt_id: request.accepted_receipt_id,
+    direction: "rollback",
+    target_memory_id: memoryId
+  });
+}
+function forUpdateSuffix(db, lock) {
+  return lock && db instanceof PgAdapter ? " FOR UPDATE" : "";
+}
+function getMemoryByExactId(id, db, lock = false) {
+  const row = db.query(`SELECT * FROM memories WHERE id = ? LIMIT 1${forUpdateSuffix(db, lock)}`).get(id);
+  return row ? normalizeMemoryTimestamps(parseMemoryRow(row)) : null;
+}
+function getProjectByExactId2(id, db, lock = false) {
+  const row = db.query(`SELECT * FROM projects WHERE id = ? LIMIT 1${forUpdateSuffix(db, lock)}`).get(id);
+  return row ? parseProjectRow2(row) : null;
+}
+function lockProjects(ids, db) {
+  const projects = new Map;
+  const uniqueIds = [...new Set(ids.filter((id) => Boolean(id)))].sort();
+  for (const id of uniqueIds) {
+    const project = getProjectByExactId2(id, db, true);
+    if (!project) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_PROJECT_NOT_FOUND", `Project not found by exact stable ID: ${id}`);
+    }
+    projects.set(id, project);
+  }
+  return projects;
+}
+function assertMemoryPrecondition(memory, expectedVersion, expectedRevision) {
+  if (memory.version !== expectedVersion || memory.updated_at !== expectedRevision) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_MEMORY", "Memory changed before the guarded project link", {
+      expected_memory_version: expectedVersion,
+      current_memory_version: memory.version,
+      expected_memory_revision: expectedRevision,
+      current_memory_revision: memory.updated_at
+    });
+  }
+}
+function assertProjectPrecondition(project, expectedRevision) {
+  if (project.updated_at !== expectedRevision) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_PROJECT", "Project changed before the guarded memory link", {
+      expected_project_revision: expectedRevision,
+      current_project_revision: project.updated_at
+    });
+  }
+}
+function assertNoTargetBucketCollision(memory, projectId, db) {
+  const collision = db.query(`
+    SELECT id FROM memories
+    WHERE id != ? AND key = ? AND scope = ?
+      AND COALESCE(agent_id, '') = COALESCE(?, '')
+      AND COALESCE(project_id, '') = COALESCE(?, '')
+      AND COALESCE(session_id, '') = COALESCE(?, '')
+    LIMIT 1
+  `).get(memory.id, memory.key, memory.scope, memory.agent_id, projectId, memory.session_id);
+  if (collision) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_COLLISION", "Linking this memory would collide with another memory in the target project bucket", { collision_id: collision.id });
+  }
+}
+function nextRevision(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 findReceiptByKey(db, identity, direction, idempotencyKey) {
+  const row = db.query(`
+    SELECT * FROM mementos_memory_project_link_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 ? receiptFromRow(row) : null;
+}
+function findReceiptById(db, identity, receiptId) {
+  const row = db.query(`
+    SELECT * FROM mementos_memory_project_link_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 ? receiptFromRow(row) : null;
+}
+function insertReceipt(db, receipt) {
+  db.run(`
+    INSERT INTO mementos_memory_project_link_receipts (
+      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
+    ) 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_memory_id,
+    receipt.requested_project_id,
+    receipt.expected_memory_version,
+    receipt.expected_memory_revision,
+    receipt.expected_project_revision,
+    receipt.result_memory_version,
+    receipt.result_memory_revision,
+    receipt.result_memory_digest,
+    receipt.result_project_revision,
+    receipt.result_project_digest,
+    receipt.accepted_receipt_id,
+    canonicalJson(receipt.before_link),
+    canonicalJson(receipt.after_link),
+    receipt.before_project_revision,
+    receipt.before_project_digest,
+    receipt.after_project_revision,
+    receipt.after_project_digest,
+    receipt.created_at
+  ]);
+}
+function makeReceipt(input) {
+  const beforeLink = snapshot(input.beforeMemory);
+  const afterLink = snapshot(input.afterMemory);
+  const logical = {
+    authority: "mementos",
+    route: MEMENTOS_MEMORY_PROJECT_LINK_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.requestDigest,
+    outcome: input.outcome,
+    target_memory_id: input.targetMemoryId,
+    requested_project_id: input.requestedProjectId,
+    expected_memory_version: input.request.expected_memory_version,
+    expected_memory_revision: input.request.expected_memory_revision,
+    expected_project_revision: input.expectedProjectRevision,
+    result_memory_version: afterLink.memory_version,
+    result_memory_revision: afterLink.memory_revision,
+    result_memory_digest: afterLink.memory_digest,
+    result_project_revision: input.afterProject?.updated_at ?? null,
+    result_project_digest: input.afterProject ? projectDigest(input.afterProject) : null,
+    accepted_receipt_id: input.acceptedReceiptId ?? null,
+    before_link: beforeLink,
+    after_link: afterLink,
+    before_project_revision: input.beforeProject?.updated_at ?? null,
+    before_project_digest: input.beforeProject ? projectDigest(input.beforeProject) : null,
+    after_project_revision: input.afterProject?.updated_at ?? null,
+    after_project_digest: input.afterProject ? projectDigest(input.afterProject) : null
+  };
+  return {
+    receipt_id: `mmpl_${digest(logical).slice(0, 40)}`,
+    ...logical,
+    created_at: now()
+  };
+}
+function sameSnapshot(memory, expected) {
+  return canonicalJson(snapshot(memory)) === canonicalJson(expected);
+}
+function assertProjectSnapshot(project, revision, expectedDigest) {
+  if (!revision && !expectedDigest) {
+    if (project) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_ACCEPTED_TARGET_DRIFTED", "receipt expected no linked project but a project row was resolved");
+    }
+    return;
+  }
+  if (!project || project.updated_at !== revision || projectDigest(project) !== expectedDigest) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_PROJECT", "Project no longer matches the immutable memory-link receipt", { expected_project_revision: revision, current_project_revision: project?.updated_at ?? null });
+  }
+}
+function replayResult(db, receipt, requestDigest, memoryId) {
+  if (receipt.request_digest !== requestDigest || receipt.target_memory_id !== memoryId) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_IDEMPOTENCY_MISMATCH", "caller idempotency key is already bound to a different memory project-link request");
+  }
+  const memory = getMemoryByExactId(memoryId, db);
+  if (!memory || !sameSnapshot(memory, receipt.after_link)) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_ACCEPTED_TARGET_DRIFTED", "accepted memory project-link target drifted after its immutable receipt");
+  }
+  const project = receipt.after_link.project_id ? getProjectByExactId2(receipt.after_link.project_id, db) : null;
+  assertProjectSnapshot(project, receipt.after_project_revision, receipt.after_project_digest);
+  return {
+    dry_run: false,
+    applied: receipt.outcome === "accepted",
+    no_change: receipt.outcome === "no_change",
+    memory,
+    project,
+    receipt
+  };
+}
+function previewMemoryProjectLink(memoryId, request, db) {
+  assertForwardRequest(request);
+  assertBoundedIdentifier2(memoryId, "memory_id");
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/memories/${encodeURIComponent(memoryId)}/guarded-project-link`, { ...request, dry_run: true });
+    return data;
+  }
+  const d = db || getDatabase();
+  const memory = getMemoryByExactId(memoryId, d);
+  if (!memory) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_MEMORY_NOT_FOUND", `Memory not found by exact stable ID: ${memoryId}`);
+  }
+  const project = getProjectByExactId2(request.target_project_id, d);
+  if (!project) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_PROJECT_NOT_FOUND", `Project not found by exact stable ID: ${request.target_project_id}`);
+  }
+  assertMemoryPrecondition(memory, request.expected_memory_version, request.expected_memory_revision);
+  assertProjectPrecondition(project, request.expected_project_revision);
+  const noChange = memory.project_id === project.id;
+  if (!noChange)
+    assertNoTargetBucketCollision(memory, project.id, d);
+  return {
+    dry_run: true,
+    applied: false,
+    no_change: noChange,
+    memory: noChange ? memory : { ...memory, project_id: project.id },
+    project,
+    receipt: null
+  };
+}
+function applyMemoryProjectLink(memoryId, request, db) {
+  assertForwardRequest(request);
+  assertBoundedIdentifier2(memoryId, "memory_id");
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/memories/${encodeURIComponent(memoryId)}/guarded-project-link`, { ...request, dry_run: false });
+    return data;
+  }
+  const d = db || getDatabase();
+  const requestDigest = forwardRequestDigest(memoryId, request);
+  return d.transaction(() => {
+    const prior = findReceiptByKey(d, request, "forward", request.idempotency_key);
+    if (prior)
+      return replayResult(d, prior, requestDigest, memoryId);
+    const before = getMemoryByExactId(memoryId, d, true);
+    if (!before) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_MEMORY_NOT_FOUND", `Memory not found by exact stable ID: ${memoryId}`);
+    }
+    const committedPrior = findReceiptByKey(d, request, "forward", request.idempotency_key);
+    if (committedPrior)
+      return replayResult(d, committedPrior, requestDigest, memoryId);
+    assertMemoryPrecondition(before, request.expected_memory_version, request.expected_memory_revision);
+    const projects = lockProjects([before.project_id, request.target_project_id], d);
+    const targetProject = projects.get(request.target_project_id);
+    const beforeProject = before.project_id ? projects.get(before.project_id) : null;
+    assertProjectPrecondition(targetProject, request.expected_project_revision);
+    const noChange = before.project_id === request.target_project_id;
+    if (noChange) {
+      const receipt2 = makeReceipt({
+        request,
+        direction: "forward",
+        requestDigest,
+        outcome: "no_change",
+        targetMemoryId: memoryId,
+        requestedProjectId: request.target_project_id,
+        expectedProjectRevision: request.expected_project_revision,
+        beforeMemory: before,
+        afterMemory: before,
+        beforeProject,
+        afterProject: targetProject
+      });
+      insertReceipt(d, receipt2);
+      return {
+        dry_run: false,
+        applied: false,
+        no_change: true,
+        memory: before,
+        project: targetProject,
+        receipt: receipt2
+      };
+    }
+    assertNoTargetBucketCollision(before, targetProject.id, d);
+    const revision = nextRevision(before.updated_at);
+    const result = d.run(`
+      UPDATE memories
+      SET project_id = ?, updated_at = ?
+      WHERE id = ? AND version = ? AND updated_at = ?
+        AND COALESCE(project_id, '') = COALESCE(?, '')
+    `, [
+      targetProject.id,
+      revision,
+      memoryId,
+      before.version,
+      before.updated_at,
+      before.project_id
+    ]);
+    if (result.changes === 0) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_MEMORY", "Memory project-link compare-and-swap did not update exactly one row");
+    }
+    const after = getMemoryByExactId(memoryId, d);
+    const expectedAfter = { ...before, project_id: targetProject.id, updated_at: revision };
+    if (!after || canonicalJson(memoryMutationState(after)) !== canonicalJson(memoryMutationState(expectedAfter))) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_ACCEPTED_TARGET_DRIFTED", "Memory project link did not read back exactly under the stable ID");
+    }
+    const receipt = makeReceipt({
+      request,
+      direction: "forward",
+      requestDigest,
+      outcome: "accepted",
+      targetMemoryId: memoryId,
+      requestedProjectId: request.target_project_id,
+      expectedProjectRevision: request.expected_project_revision,
+      beforeMemory: before,
+      afterMemory: after,
+      beforeProject,
+      afterProject: targetProject
+    });
+    insertReceipt(d, receipt);
+    return {
+      dry_run: false,
+      applied: true,
+      no_change: false,
+      memory: after,
+      project: targetProject,
+      receipt
+    };
+  });
+}
+function rollbackMemoryProjectLink(memoryId, request, db) {
+  assertRollbackRequest(request);
+  assertBoundedIdentifier2(memoryId, "memory_id");
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/memories/${encodeURIComponent(memoryId)}/guarded-project-link-rollback`, request);
+    return data;
+  }
+  const d = db || getDatabase();
+  const requestDigest = rollbackRequestDigest(memoryId, request);
+  return d.transaction(() => {
+    const prior = findReceiptByKey(d, request, "rollback", request.idempotency_key);
+    if (prior)
+      return replayResult(d, prior, requestDigest, memoryId);
+    const accepted = findReceiptById(d, request, request.accepted_receipt_id);
+    if (!accepted || accepted.direction !== "forward" || accepted.target_memory_id !== memoryId) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_RECEIPT_NOT_FOUND", "accepted forward link receipt was not found for this exact memory");
+    }
+    if (accepted.outcome !== "accepted") {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_RECEIPT_NOT_ROLLBACKABLE", "a no-change memory project-link receipt has no mutation to roll back");
+    }
+    const current = getMemoryByExactId(memoryId, d, true);
+    if (!current) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_MEMORY_NOT_FOUND", `Memory not found by exact stable ID: ${memoryId}`);
+    }
+    const committedPrior = findReceiptByKey(d, request, "rollback", request.idempotency_key);
+    if (committedPrior)
+      return replayResult(d, committedPrior, requestDigest, memoryId);
+    assertMemoryPrecondition(current, request.expected_memory_version, request.expected_memory_revision);
+    if (!sameSnapshot(current, accepted.after_link)) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_MEMORY", "Memory no longer matches the accepted forward link receipt");
+    }
+    const projects = lockProjects([accepted.after_link.project_id, accepted.before_link.project_id], d);
+    const beforeProject = accepted.after_link.project_id ? projects.get(accepted.after_link.project_id) : null;
+    const afterProject = accepted.before_link.project_id ? projects.get(accepted.before_link.project_id) : null;
+    assertProjectSnapshot(beforeProject, accepted.after_project_revision, accepted.after_project_digest);
+    assertProjectSnapshot(afterProject, accepted.before_project_revision, accepted.before_project_digest);
+    assertNoTargetBucketCollision(current, accepted.before_link.project_id, d);
+    const result = d.run(`
+      UPDATE memories
+      SET project_id = ?, updated_at = ?
+      WHERE id = ? AND version = ? AND updated_at = ?
+        AND COALESCE(project_id, '') = COALESCE(?, '')
+    `, [
+      accepted.before_link.project_id,
+      accepted.before_link.memory_revision,
+      memoryId,
+      current.version,
+      current.updated_at,
+      current.project_id
+    ]);
+    if (result.changes === 0) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_STALE_MEMORY", "Memory project-link rollback compare-and-swap did not update exactly one row");
+    }
+    const restored = getMemoryByExactId(memoryId, d);
+    if (!restored || !sameSnapshot(restored, accepted.before_link)) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_ACCEPTED_TARGET_DRIFTED", "Memory project-link rollback did not restore the exact prior linkage");
+    }
+    const receipt = makeReceipt({
+      request,
+      direction: "rollback",
+      requestDigest,
+      outcome: "accepted",
+      targetMemoryId: memoryId,
+      requestedProjectId: accepted.requested_project_id,
+      expectedProjectRevision: null,
+      beforeMemory: current,
+      afterMemory: restored,
+      beforeProject,
+      afterProject,
+      acceptedReceiptId: accepted.receipt_id
+    });
+    insertReceipt(d, receipt);
+    return {
+      dry_run: false,
+      applied: true,
+      no_change: false,
+      memory: restored,
+      project: afterProject,
+      receipt
+    };
+  });
+}
+function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = LINK_AUTHORITY, db) {
+  assertIdentity(identity);
+  assertBoundedIdentifier2(memoryId, "memory_id");
+  assertBoundedIdentifier2(receiptId, "receipt_id");
+  if (!db && isApiMode()) {
+    const { data } = apiJson("POST", `/memories/${encodeURIComponent(memoryId)}/project-link-receipts/lookup`, { ...identity, receipt_id: receiptId });
+    return data;
+  }
+  const d = db || getDatabase();
+  const receipt = findReceiptById(d, identity, receiptId);
+  if (!receipt || receipt.target_memory_id !== memoryId) {
+    throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_RECEIPT_NOT_FOUND", "immutable memory project-link receipt was not found for this exact memory");
+  }
+  return receipt;
+}
+
+// src/cli/commands/memory-cmd-crud.ts
+init_projects();
+init_agents();
+
 // src/lib/duration.ts
 var UNIT_MS = {
   s: 1000,
@@ -59807,6 +61448,92 @@ init_types();
 init_helpers();
 function registerCrudCommands(program2) {
   const handleError = makeHandleError(program2);
+  program2.command("link-project <memory-id>").description("Guardedly link an existing memory to an existing project").option("--project-id <id>", "Exact stable ID of the existing target project").option("--expected-memory-version <n>", "Exact memory version required for compare-and-set", parseInt).option("--expected-memory-revision <revision>", "Exact memory updated_at revision required for compare-and-set").option("--expected-project-revision <revision>", "Exact target project updated_at revision required for compare-and-set").option("--idempotency-key <key>", "Caller-owned key for one guarded link or rollback").option("--operation-id <id>", "Operation identifier (defaults to the idempotency key)").option("--step-id <id>", "Step identifier").option("--dry-run", "Validate and preview the guarded link without writing").option("--rollback-receipt <id>", "Restore the exact prior linkage from an accepted receipt").option("--lookup-receipt <id>", "Read one immutable receipt for this exact memory").action((memoryId, opts) => {
+    try {
+      const globalOpts = program2.opts();
+      const rollbackReceipt = opts.rollbackReceipt;
+      const lookupReceipt = opts.lookupReceipt;
+      const projectId = opts.projectId;
+      if (rollbackReceipt && lookupReceipt) {
+        throw new Error("--rollback-receipt and --lookup-receipt cannot be used together");
+      }
+      if (lookupReceipt) {
+        if (opts.dryRun || projectId || rollbackReceipt) {
+          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"
+        });
+        if (globalOpts.json)
+          outputJson(receipt);
+        else {
+          console.log(chalk2.green("Memory project-link receipt:"));
+          console.log(`  ${chalk2.bold("Receipt:")} ${receipt.receipt_id}`);
+          console.log(`  ${chalk2.bold("Memory:")}  ${receipt.target_memory_id}`);
+          console.log(`  ${chalk2.bold("Before:")}  ${receipt.before_link.project_id ?? "none"}`);
+          console.log(`  ${chalk2.bold("After:")}   ${receipt.after_link.project_id ?? "none"}`);
+        }
+        return;
+      }
+      const expectedMemoryVersion = opts.expectedMemoryVersion;
+      const expectedMemoryRevision = opts.expectedMemoryRevision;
+      const idempotencyKey = opts.idempotencyKey;
+      if (!expectedMemoryVersion || !expectedMemoryRevision || !idempotencyKey) {
+        throw new Error("--expected-memory-version, --expected-memory-revision, and --idempotency-key are required");
+      }
+      if (opts.dryRun && rollbackReceipt) {
+        throw new Error("Dry-run memory project-link rollback is not supported");
+      }
+      if (projectId && rollbackReceipt) {
+        throw new Error("--project-id and --rollback-receipt cannot be used together");
+      }
+      const common = {
+        authority_id: "mementos",
+        tenant_id: "default",
+        corpus_id: "default",
+        operation_id: opts.operationId ?? idempotencyKey,
+        step_id: opts.stepId ?? (rollbackReceipt ? "mementos_memory_project_link_rollback" : "mementos_memory_project_link"),
+        idempotency_key: idempotencyKey,
+        expected_memory_version: expectedMemoryVersion,
+        expected_memory_revision: expectedMemoryRevision
+      };
+      let result;
+      if (rollbackReceipt) {
+        result = rollbackMemoryProjectLink(memoryId, {
+          ...common,
+          accepted_receipt_id: rollbackReceipt
+        });
+      } else {
+        const expectedProjectRevision = opts.expectedProjectRevision;
+        if (!projectId || !expectedProjectRevision) {
+          throw new Error("--project-id and --expected-project-revision are required for a memory project link");
+        }
+        const request = {
+          ...common,
+          target_project_id: projectId,
+          expected_project_revision: expectedProjectRevision
+        };
+        result = opts.dryRun ? previewMemoryProjectLink(memoryId, request) : applyMemoryProjectLink(memoryId, request);
+      }
+      if (globalOpts.json) {
+        outputJson(result);
+      } else {
+        const label = result.dry_run ? "Memory project-link preview:" : result.no_change ? "Memory already linked:" : "Memory project linkage updated:";
+        console.log(chalk2.green(label));
+        console.log(`  ${chalk2.bold("Memory:")}   ${result.memory.id}`);
+        console.log(`  ${chalk2.bold("Project:")}  ${result.memory.project_id ?? "none"}`);
+        console.log(`  ${chalk2.bold("Version:")}  ${result.memory.version}`);
+        console.log(`  ${chalk2.bold("Revision:")} ${result.memory.updated_at}`);
+        if (result.receipt) {
+          console.log(`  ${chalk2.bold("Receipt:")}  ${result.receipt.receipt_id}`);
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
   program2.command("save <key> <value>").description("Save a memory (create or upsert)").option("-c, --category <cat>", `Category: ${MEMORY_CATEGORIES.join(", ")}`).option("--scope <scope>", `Scope: ${MEMORY_SCOPES.join(", ")}`).option("--importance <n>", "Importance 1-10", parseInt).option("--tags <tags>", "Comma-separated tags").option("--summary <text>", "Brief summary").option("--ttl <duration>", "Time-to-live: 30s, 5m, 2h, 1d, 1w, or milliseconds").option("--source <src>", "Source: user, agent, system, auto, imported").option("--template <name>", "Apply a template: correction, preference, decision, learning").option("--dedupe <mode>", "Conflict handling: merge (default, upsert the matching row), create (fork a new row under the same key), error").action((key, value, opts) => {
     try {
       const globalOpts = program2.opts();
@@ -60205,7 +61932,7 @@ function registerTailCommand(program2) {
     try {
       const globalOpts = program2.opts();
       const jsonMode = !!globalOpts.json;
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       let projectId;
       if (projectPath) {
@@ -60361,14 +62088,7 @@ function registerSearchCommand(program2) {
         if (project)
           projectId = project.id;
       }
-      const agentName = opts.agent || globalOpts.agent;
-      let agentId;
-      if (agentName) {
-        const { getAgent: getAgent2 } = (init_agents(), __toCommonJS(exports_agents));
-        const agent = getAgent2(agentName);
-        if (agent)
-          agentId = agent.id;
-      }
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const filter = {
         scope: opts.scope,
         category: opts.category,
@@ -60642,7 +62362,7 @@ function registerRecallCommand(program2) {
   program2.command("recall <key>").alias("get").description("Recall a memory by exact key (use --fuzzy to fall back to the nearest match)").option("--scope <scope>", "Scope filter").option("--agent <name>", "Agent filter").option("--project <path>", "Project filter").option("--fuzzy", "If the exact key is absent, return the nearest match instead (exits 2)").action((key, opts) => {
     try {
       const globalOpts = program2.opts();
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       let projectId;
       if (projectPath) {
@@ -60715,7 +62435,7 @@ function registerListCommand(program2) {
       const requestedLimit = opts.limit;
       const limit = positiveIntOrDefault(requestedLimit, isStructured ? 50 : DEFAULT_COMPACT_LIMIT);
       const offset = cursorOrOffset(opts.cursor, opts.offset);
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       let projectId;
       if (projectPath) {
@@ -61080,7 +62800,6 @@ mementos report \u2014 last ${days} days
 import chalk15 from "chalk";
 import { resolve as resolve9 } from "path";
 init_projects();
-init_agents();
 init_helpers();
 function registerStaleCommand(program2) {
   const handleError = makeHandleError(program2);
@@ -61099,13 +62818,7 @@ function registerStaleCommand(program2) {
         if (project)
           projectId = project.id;
       }
-      const agentName = opts.agent || globalOpts.agent;
-      let agentId;
-      if (agentName) {
-        const agent = getAgent(agentName);
-        if (agent)
-          agentId = agent.id;
-      }
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const rows = getStaleMemories({
         days,
         project_id: projectId,
@@ -61234,7 +62947,7 @@ function registerContextCommand(program2) {
       const scope = opts.scope;
       const categoriesRaw = opts.categories;
       const categories = categoriesRaw ? categoriesRaw.split(",").map((c) => c.trim()) : undefined;
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       const visibleMachineId = resolveVisibleMachineId(opts.machine);
       let projectId;
@@ -61359,7 +63072,7 @@ function registerExportCommand(program2) {
   program2.command("export").description("Export memories as JSON").option("--scope <scope>", "Scope filter").option("-c, --category <cat>", "Category filter").option("--agent <name>", "Agent filter").option("--project <path>", "Project filter").action((opts) => {
     try {
       const globalOpts = program2.opts();
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       let projectId;
       if (projectPath) {
@@ -61387,7 +63100,7 @@ init_memories();
 init_helpers();
 import chalk18 from "chalk";
 import { resolve as resolve12 } from "path";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 function registerImportCommand(program2) {
   const handleError = makeHandleError(program2);
   program2.command("import [file]").description("Import memories from a JSON file or stdin (use '-' or pipe data)").option("--overwrite", "Overwrite existing memories (default: merge)").action(async (file, opts) => {
@@ -61397,7 +63110,7 @@ function registerImportCommand(program2) {
       if (file === "-" || !file && !process.stdin.isTTY) {
         raw = await Bun.stdin.text();
       } else if (file) {
-        raw = readFileSync3(resolve12(file), "utf-8");
+        raw = readFileSync4(resolve12(file), "utf-8");
       } else {
         console.error(chalk18.red("No input: provide a file path, use '-' for stdin, or pipe data."));
         process.exit(1);
@@ -61427,9 +63140,9 @@ function registerImportCommand(program2) {
 import chalk19 from "chalk";
 
 // src/lib/config.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, cpSync as cpSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, cpSync as cpSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname3, join as join6, resolve as resolve13 } from "path";
+import { basename, dirname as dirname4, join as join7, resolve as resolve13 } from "path";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
@@ -61492,11 +63205,11 @@ function isValidCategory(value) {
   return VALID_CATEGORIES2.includes(value);
 }
 function loadConfig() {
-  const configPath = join6(homeDir(), ".hasna", "mementos", "config.json");
+  const configPath = join7(homeDir(), ".hasna", "mementos", "config.json");
   let fileConfig = {};
   if (existsSync4(configPath)) {
     try {
-      const raw = readFileSync4(configPath, "utf-8");
+      const raw = readFileSync5(configPath, "utf-8");
       fileConfig = JSON.parse(raw);
     } catch {}
   }
@@ -61522,11 +63235,11 @@ function findFileWalkingUp(filename) {
   let dir = process.cwd();
   const legacyHomeMementosDb = resolve13(homeDir(), ".mementos", "mementos.db");
   while (true) {
-    const candidate = join6(dir, filename);
+    const candidate = join7(dir, filename);
     if (existsSync4(candidate) && resolve13(candidate) !== legacyHomeMementosDb) {
       return candidate;
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) {
       return null;
     }
@@ -61536,10 +63249,10 @@ function findFileWalkingUp(filename) {
 function findGitRoot2() {
   let dir = process.cwd();
   while (true) {
-    if (existsSync4(join6(dir, ".git"))) {
+    if (existsSync4(join7(dir, ".git"))) {
       return dir;
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) {
       return null;
     }
@@ -61547,17 +63260,17 @@ function findGitRoot2() {
   }
 }
 function profilesDir() {
-  return join6(homeDir(), ".hasna", "mementos", "profiles");
+  return join7(homeDir(), ".hasna", "mementos", "profiles");
 }
 function globalConfigPath() {
-  return join6(homeDir(), ".hasna", "mementos", "config.json");
+  return join7(homeDir(), ".hasna", "mementos", "config.json");
 }
 function readGlobalConfig() {
   const p = globalConfigPath();
   if (!existsSync4(p))
     return {};
   try {
-    return JSON.parse(readFileSync4(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return {};
   }
@@ -61567,7 +63280,7 @@ function readGlobalConfigForWrite() {
   if (!existsSync4(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync4(p, "utf-8"));
+    const data = JSON.parse(readFileSync5(p, "utf-8"));
     if (data === null || typeof data !== "object" || Array.isArray(data)) {
       throw new Error("expected a JSON object");
     }
@@ -61579,7 +63292,7 @@ function readGlobalConfigForWrite() {
 }
 function writeGlobalConfig(data) {
   const p = globalConfigPath();
-  ensureDir2(dirname3(p));
+  ensureDir2(dirname4(p));
   writeFileSync3(p, JSON.stringify(data, null, 2), "utf-8");
 }
 function getActiveProfile() {
@@ -61605,7 +63318,7 @@ function listProfiles() {
   return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
 }
 function deleteProfile(name) {
-  const dbPath = join6(profilesDir(), `${name}.db`);
+  const dbPath = join7(profilesDir(), `${name}.db`);
   if (!existsSync4(dbPath))
     return false;
   unlinkSync2(dbPath);
@@ -61615,10 +63328,10 @@ function deleteProfile(name) {
 }
 function getDbPath2() {
   const _home = homeDir();
-  const _newDir = join6(_home, ".hasna", "mementos");
-  const _oldDir = join6(_home, ".mementos");
+  const _newDir = join7(_home, ".hasna", "mementos");
+  const _oldDir = join7(_home, ".mementos");
   if (!existsSync4(_newDir) && existsSync4(_oldDir)) {
-    mkdirSync3(join6(_home, ".hasna"), { recursive: true });
+    mkdirSync3(join7(_home, ".hasna"), { recursive: true });
     cpSync2(_oldDir, _newDir, { recursive: true });
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
@@ -61627,30 +63340,30 @@ function getDbPath2() {
       return envDbPath;
     }
     const resolved = resolve13(envDbPath);
-    ensureDir2(dirname3(resolved));
+    ensureDir2(dirname4(resolved));
     return resolved;
   }
   const profile = getActiveProfile();
   if (profile) {
-    const profilePath = join6(profilesDir(), `${profile}.db`);
-    ensureDir2(dirname3(profilePath));
+    const profilePath = join7(profilesDir(), `${profile}.db`);
+    ensureDir2(dirname4(profilePath));
     return profilePath;
   }
   const dbScope = process.env["MEMENTOS_DB_SCOPE"];
   if (dbScope === "project") {
     const gitRoot = findGitRoot2();
     if (gitRoot) {
-      const dbPath = join6(gitRoot, ".mementos", "mementos.db");
-      ensureDir2(dirname3(dbPath));
+      const dbPath = join7(gitRoot, ".mementos", "mementos.db");
+      ensureDir2(dirname4(dbPath));
       return dbPath;
     }
   }
-  const found = findFileWalkingUp(join6(".mementos", "mementos.db"));
+  const found = findFileWalkingUp(join7(".mementos", "mementos.db"));
   if (found) {
     return found;
   }
-  const fallback = join6(homeDir(), ".hasna", "mementos", "mementos.db");
-  ensureDir2(dirname3(fallback));
+  const fallback = join7(homeDir(), ".hasna", "mementos", "mementos.db");
+  ensureDir2(dirname4(fallback));
   return fallback;
 }
 function ensureDir2(dir) {
@@ -61771,7 +63484,7 @@ function registerCleanCommand(program2) {
 init_database();
 init_helpers();
 import chalk20 from "chalk";
-import { resolve as resolve14, dirname as dirname4 } from "path";
+import { resolve as resolve14, dirname as dirname5 } from "path";
 import { existsSync as existsSync5, statSync, copyFileSync, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
 function registerBackupCommand(program2) {
   const handleError = makeHandleError(program2);
@@ -61838,7 +63551,7 @@ function registerBackupCommand(program2) {
         const ts = now3.toISOString().replace(/[-:T]/g, "").replace(/\..+/, "").slice(0, 15);
         dest = resolve14(backupsDir, `mementos-${ts}.db`);
       }
-      const destDir = dirname4(dest);
+      const destDir = dirname5(dest);
       if (!existsSync5(destDir)) {
         mkdirSync4(destDir, { recursive: true });
       }
@@ -61920,8 +63633,8 @@ function registerRestoreCommand(program2) {
       }
       let backupCount = 0;
       try {
-        const { Database: Database2 } = __require("bun:sqlite");
-        const backupDb = new Database2(source, { readonly: true });
+        const { Database: Database3 } = __require("bun:sqlite");
+        const backupDb = new Database3(source, { readonly: true });
         const row = backupDb.query("SELECT COUNT(*) as count FROM memories").get();
         backupCount = row?.count ?? 0;
         backupDb.close();
@@ -62050,14 +63763,17 @@ function registerAgentCommands(program2) {
   program2.command("agents").description("List all registered agents").option("--limit <n>", "Max results (compact default: 20)", parseInt).option("--cursor <n>", "Cursor offset for the next page", parseInt).option("--offset <n>", "Offset for pagination", parseInt).action((opts) => {
     try {
       const globalOpts = program2.opts();
-      const allAgents = listAgents();
       const limit = positiveIntOrDefault(opts.limit, DEFAULT_COMPACT_LIMIT);
       const offset = cursorOrOffset(opts.cursor, opts.offset) ?? 0;
-      const agents = globalOpts.json ? allAgents : allAgents.slice(offset, offset + limit + 1);
+      const explicitPagination = opts.limit !== undefined || opts.cursor !== undefined || opts.offset !== undefined;
+      const agents = listAgents({
+        limit: globalOpts.json ? explicitPagination ? limit : undefined : limit + 1,
+        offset
+      });
       const hasMore = !globalOpts.json && agents.length > limit;
       const displayAgents = hasMore ? agents.slice(0, limit) : agents;
       if (globalOpts.json) {
-        outputJson(allAgents);
+        outputJson(agents);
         return;
       }
       if (displayAgents.length === 0) {
@@ -62194,9 +63910,13 @@ import { resolve as resolve16 } from "path";
 init_helpers();
 function registerProjectCommands(program2) {
   const handleError = makeHandleError(program2);
-  program2.command("projects").description("Manage projects").option("--add", "Add a new project").option("--name <name>", "Project name").option("--path <path>", "Project path").option("--description <text>", "Project description").option("--limit <n>", "Max results (compact default: 20)", parseInt).option("--cursor <n>", "Cursor offset for the next page", parseInt).option("--offset <n>", "Offset for pagination", parseInt).action((opts) => {
+  program2.command("projects").description("Manage projects").option("--add", "Add a new project").option("--update <id>", "Update a project by its exact stable ID").option("--name <name>", "Project name").option("--path <path>", "Project path").option("--description <text>", "Project description").option("--memory-prefix <prefix>", "Project memory prefix").option("--expected-revision <revision>", "Exact updated_at revision required for compare-and-swap").option("--idempotency-key <key>", "Caller-owned key for one guarded mutation").option("--operation-id <id>", "Operation identifier (defaults to the idempotency key)").option("--step-id <id>", "Step identifier (defaults to mementos_project_update)").option("--dry-run", "Validate and preview the guarded update without writing").option("--rollback-receipt <id>", "Restore the exact before snapshot from an accepted update receipt").option("--limit <n>", "Max results (compact default: 20)", parseInt).option("--cursor <n>", "Cursor offset for the next page", parseInt).option("--offset <n>", "Offset for pagination", parseInt).action((opts) => {
     try {
       const globalOpts = program2.opts();
+      if (opts.add && opts.update) {
+        console.error(chalk23.red("--add and --update cannot be used together"));
+        process.exit(1);
+      }
       if (opts.add) {
         const name = opts.name;
         const path = opts.path;
@@ -62215,6 +63935,64 @@ function registerProjectCommands(program2) {
         }
         return;
       }
+      if (opts.update) {
+        const updates = {};
+        if (opts.name !== undefined)
+          updates.name = opts.name;
+        if (opts.path !== undefined)
+          updates.path = resolve16(opts.path);
+        if (opts.description !== undefined) {
+          updates.description = opts.description;
+        }
+        if (opts.memoryPrefix !== undefined) {
+          updates.memory_prefix = opts.memoryPrefix;
+        }
+        const rollbackReceipt = opts.rollbackReceipt;
+        if (Object.keys(updates).length === 0 && !rollbackReceipt) {
+          console.error(chalk23.red("At least one of --name, --path, --description, or --memory-prefix is required when updating"));
+          process.exit(1);
+        }
+        if (Object.keys(updates).length > 0 && rollbackReceipt) {
+          console.error(chalk23.red("Project fields and --rollback-receipt cannot be used together"));
+          process.exit(1);
+        }
+        if (opts.dryRun && rollbackReceipt) {
+          console.error(chalk23.red("Dry-run project rollback is not supported"));
+          process.exit(1);
+        }
+        const expectedRevision = opts.expectedRevision;
+        const idempotencyKey = opts.idempotencyKey;
+        if (!expectedRevision || !idempotencyKey) {
+          console.error(chalk23.red("--expected-revision and --idempotency-key are required for every project update"));
+          process.exit(1);
+        }
+        const common = {
+          authority_id: "mementos",
+          tenant_id: "default",
+          corpus_id: "default",
+          operation_id: opts.operationId ?? idempotencyKey,
+          step_id: opts.stepId ?? (rollbackReceipt ? "mementos_project_rollback" : "mementos_project_update"),
+          idempotency_key: idempotencyKey,
+          expected_revision: expectedRevision
+        };
+        const result = rollbackReceipt ? rollbackProjectUpdate(opts.update, {
+          ...common,
+          accepted_receipt_id: rollbackReceipt
+        }) : opts.dryRun ? previewProjectUpdate(opts.update, { ...common, updates }) : applyProjectUpdate(opts.update, { ...common, updates });
+        if (globalOpts.json) {
+          outputJson(result);
+        } else {
+          console.log(chalk23.green(result.dry_run ? "Project update preview:" : "Project updated:"));
+          console.log(`  ${chalk23.bold("ID:")}       ${result.project.id}`);
+          console.log(`  ${chalk23.bold("Name:")}     ${result.project.name}`);
+          console.log(`  ${chalk23.bold("Path:")}     ${result.project.path}`);
+          console.log(`  ${chalk23.bold("Revision:")} ${result.project.updated_at}`);
+          if (result.receipt) {
+            console.log(`  ${chalk23.bold("Receipt:")}  ${result.receipt.receipt_id}`);
+          }
+        }
+        return;
+      }
       const allProjects = listProjects();
       const limit = positiveIntOrDefault(opts.limit, DEFAULT_COMPACT_LIMIT);
       const offset = cursorOrOffset(opts.cursor, opts.offset) ?? 0;
@@ -63053,10 +64831,10 @@ init_memories();
 init_agents();
 init_projects();
 import chalk27 from "chalk";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir4 } from "os";
 import {
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   existsSync as existsSync7,
   accessSync,
   statSync as statSync3,
@@ -63244,9 +65022,9 @@ function registerDoctorCommand(program2) {
       checks.push({ name: "MCP server", status: "warn", detail: "could not check (is claude CLI installed?)" });
     }
     try {
-      const settingsFilePath = join7(homedir4(), ".claude", "settings.json");
+      const settingsFilePath = join8(homedir4(), ".claude", "settings.json");
       if (existsSync7(settingsFilePath)) {
-        const settings = JSON.parse(readFileSync5(settingsFilePath, "utf-8"));
+        const settings = JSON.parse(readFileSync6(settingsFilePath, "utf-8"));
         const hooksObj = settings["hooks"] || {};
         const stopHooks = hooksObj["Stop"] || [];
         const hasMementos = stopHooks.some((e) => e.hooks?.some((h) => h.command && h.command.includes("mementos")));
@@ -63262,7 +65040,7 @@ function registerDoctorCommand(program2) {
       checks.push({ name: "Stop hook", status: "warn", detail: "could not check stop hook" });
     }
     if (process.platform === "darwin") {
-      const plistFilePath = join7(homedir4(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
+      const plistFilePath = join8(homedir4(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
       checks.push({
         name: "Auto-start",
         status: existsSync7(plistFilePath) ? "ok" : "warn",
@@ -63345,9 +65123,9 @@ async function runCloudDoctor(globalOpts, checks) {
     checks.push({ name: "MCP server", status: "warn", detail: "could not check (is claude CLI installed?)" });
   }
   try {
-    const settingsFilePath = join7(homedir4(), ".claude", "settings.json");
+    const settingsFilePath = join8(homedir4(), ".claude", "settings.json");
     if (existsSync7(settingsFilePath)) {
-      const settings = JSON.parse(readFileSync5(settingsFilePath, "utf-8"));
+      const settings = JSON.parse(readFileSync6(settingsFilePath, "utf-8"));
       const hooksObj = settings["hooks"] || {};
       const stopHooks = hooksObj["Stop"] || [];
       const hasMementos = stopHooks.some((e) => e.hooks?.some((h) => h.command && h.command.includes("mementos")));
@@ -63363,7 +65141,7 @@ async function runCloudDoctor(globalOpts, checks) {
     checks.push({ name: "Stop hook", status: "warn", detail: "could not check stop hook" });
   }
   if (process.platform === "darwin") {
-    const plistFilePath = join7(homedir4(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
+    const plistFilePath = join8(homedir4(), "Library", "LaunchAgents", "com.hasna.mementos.plist");
     checks.push({
       name: "Auto-start",
       status: existsSync7(plistFilePath) ? "ok" : "warn",
@@ -64480,7 +66258,7 @@ function registerWatchCommand(program2) {
   program2.command("watch").description("Watch for new and changed memories in real-time").option("--scope <scope>", "Scope filter: global, shared, private, working").option("-c, --category <cat>", "Category filter: preference, fact, knowledge, history, procedural, resource").option("--agent <name>", "Agent filter").option("--project <path>", "Project filter").option("--interval <ms>", "Poll interval in milliseconds", parseInt).action((opts) => {
     try {
       const globalOpts = program2.opts();
-      const agentId = opts.agent || globalOpts.agent;
+      const agentId = resolveAgentFilter(opts.agent || globalOpts.agent);
       const projectPath = opts.project || globalOpts.project;
       let projectId;
       if (projectPath) {
@@ -65354,15 +67132,15 @@ function registerStorageCommands(program2) {
 // src/cli/commands/init.ts
 import chalk41 from "chalk";
 import {
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   writeFileSync as writeFileSync4,
   existsSync as existsSync9,
   copyFileSync as copyFileSync3,
   mkdirSync as mkdirSync6
 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname7, join as join10 } from "path";
 import { homedir as homedir5 } from "os";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function registerInitCommand(program2) {
   program2.command("init").description("One-command setup: register MCP, install stop hook, configure auto-start").action(async () => {
     const { platform: platform2 } = process;
@@ -65421,9 +67199,9 @@ function registerInitCommand(program2) {
     } else {
       console.log(chalk41.green("  \u2713 MCP server registered with Claude Code"));
     }
-    const hooksDir = join9(home, ".claude", "hooks");
-    const hookDest = join9(hooksDir, "mementos-stop-hook.ts");
-    const settingsPath = join9(home, ".claude", "settings.json");
+    const hooksDir = join10(home, ".claude", "hooks");
+    const hookDest = join10(hooksDir, "mementos-stop-hook.ts");
+    const settingsPath = join10(home, ".claude", "settings.json");
     const hookCommand = `bun ${hookDest}`;
     let hookAlreadyInstalled = false;
     let hookError = null;
@@ -65431,7 +67209,7 @@ function registerInitCommand(program2) {
       let settings = {};
       if (existsSync9(settingsPath)) {
         try {
-          settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+          settings = JSON.parse(readFileSync7(settingsPath, "utf-8"));
         } catch {
           settings = {};
         }
@@ -65446,11 +67224,11 @@ function registerInitCommand(program2) {
           mkdirSync6(hooksDir, { recursive: true });
         }
         if (!existsSync9(hookDest)) {
-          const packageDir = dirname6(dirname6(fileURLToPath3(import.meta.url)));
+          const packageDir = dirname7(dirname7(fileURLToPath4(import.meta.url)));
           const candidatePaths = [
-            join9(packageDir, "scripts", "hooks", "claude-stop-hook.ts"),
-            join9(packageDir, "..", "scripts", "hooks", "claude-stop-hook.ts"),
-            join9(home, ".bun", "install", "global", "node_modules", "@hasna", "mementos", "scripts", "hooks", "claude-stop-hook.ts")
+            join10(packageDir, "scripts", "hooks", "claude-stop-hook.ts"),
+            join10(packageDir, "..", "scripts", "hooks", "claude-stop-hook.ts"),
+            join10(home, ".bun", "install", "global", "node_modules", "@hasna", "mementos", "scripts", "hooks", "claude-stop-hook.ts")
           ];
           let hookSourceFound = false;
           for (const src of candidatePaths) {
@@ -65520,7 +67298,7 @@ main().catch(() => {});
     if (!isMac) {
       console.log(chalk41.dim(`  \xB7 Auto-start skipped (not macOS \u2014 platform: ${platform2})`));
     } else {
-      const plistPath = join9(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
+      const plistPath = join10(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
       const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -65548,7 +67326,7 @@ main().catch(() => {});
         if (existsSync9(plistPath)) {
           autoStartAlreadyInstalled = true;
         } else {
-          const launchAgentsDir = join9(home, "Library", "LaunchAgents");
+          const launchAgentsDir = join10(home, "Library", "LaunchAgents");
           if (!existsSync9(launchAgentsDir)) {
             mkdirSync6(launchAgentsDir, { recursive: true });
           }
@@ -65565,7 +67343,7 @@ main().catch(() => {});
         console.log(chalk41.green("  \u2713 Auto-start configured (starts on login)"));
       }
       if (!autoStartAlreadyInstalled && !autoStartError) {
-        const plistPath2 = join9(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
+        const plistPath2 = join10(home, "Library", "LaunchAgents", "com.hasna.mementos.plist");
         const loadResult = await run(["launchctl", "load", plistPath2]);
         if (!loadResult.ok) {
           console.log(chalk41.dim(`  \xB7 launchctl load: ${loadResult.output || "already loaded"}`));
@@ -66685,7 +68463,7 @@ import {
   readdirSync as readdirSync4
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import chalk43 from "chalk";
 
 // src/lib/gatherer.ts
@@ -66762,17 +68540,17 @@ var gatherTrainingData = async (options = {}) => {
 };
 
 // src/lib/model-config.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
-var CONFIG_DIR = join10(homedir6(), ".hasna", "mementos");
-var CONFIG_PATH = join10(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join11(homedir6(), ".hasna", "mementos");
+var CONFIG_PATH = join11(CONFIG_DIR, "config.json");
 function readConfig() {
   if (!existsSync10(CONFIG_PATH))
     return {};
   try {
-    const raw = readFileSync7(CONFIG_PATH, "utf-8");
+    const raw = readFileSync8(CONFIG_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -66827,12 +68605,12 @@ function makeBrainsCommand() {
         limit: opts.limit,
         since
       });
-      const outputDir = opts.output ?? join11(homedir7(), ".hasna", "mementos", "training");
+      const outputDir = opts.output ?? join12(homedir7(), ".hasna", "mementos", "training");
       if (!existsSync11(outputDir)) {
         mkdirSync8(outputDir, { recursive: true });
       }
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const outputPath = join11(outputDir, `mementos-training-${timestamp}.jsonl`);
+      const outputPath = join12(outputDir, `mementos-training-${timestamp}.jsonl`);
       const jsonl = result.examples.map((ex) => JSON.stringify(ex)).join(`
 `);
       writeFileSync6(outputPath, jsonl + `
@@ -66856,7 +68634,7 @@ function makeBrainsCommand() {
     try {
       let datasetPath = opts.dataset;
       if (!datasetPath) {
-        const trainingDir = join11(homedir7(), ".hasna", "mementos", "training");
+        const trainingDir = join12(homedir7(), ".hasna", "mementos", "training");
         if (!existsSync11(trainingDir)) {
           printError("No training data found. Run `mementos brains gather` first.");
           process.exit(1);
@@ -66867,7 +68645,7 @@ function makeBrainsCommand() {
           printError("No JSONL training files found. Run `mementos brains gather` first.");
           process.exit(1);
         }
-        datasetPath = join11(trainingDir, latestFile);
+        datasetPath = join12(trainingDir, latestFile);
       }
       if (!datasetPath || !existsSync11(datasetPath)) {
         printError(`Dataset file not found: ${datasetPath ?? "(unresolved)"}`);
@@ -66995,8 +68773,8 @@ function registerAllCommands(program2) {
 // src/cli/index.tsx
 function getPackageVersion2() {
   try {
-    const pkgPath = join12(dirname7(fileURLToPath4(import.meta.url)), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkgPath = join13(dirname8(fileURLToPath5(import.meta.url)), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";