@hasna/mementos 0.14.80 → 0.14.82

package/dist/server/index.js

@@ -52908,13 +52908,36 @@ function buildOpenApiDocument(version2) {
       required: true,
       schema: { type: "string" }
     }));
+    if (route.method === "GET" && route.path === "/api/projects/:id/resources") {
+      params.push({
+        name: "limit",
+        in: "query",
+        required: false,
+        schema: { type: "integer", minimum: 1, maximum: 1000, default: 100 }
+      }, {
+        name: "cursor",
+        in: "query",
+        required: false,
+        schema: { type: "string" }
+      }, {
+        name: "resource_kinds",
+        in: "query",
+        required: false,
+        description: "Comma-separated subset of project, knowledge, memory, session",
+        schema: { type: "string" }
+      });
+    }
+    const successSchema = route.method === "GET" && route.path === "/api/projects/:id/resources" ? { $ref: "#/components/schemas/MementosProjectResourcePage" } : route.method === "GET" && route.path === "/api/projects/:id/resources/:kind/:resource_id" ? { $ref: "#/components/schemas/MementosProjectResourceExactResult" } : undefined;
     paths[p] = paths[p] ?? {};
     paths[p][method] = {
       summary: `${route.method} ${p}`,
       operationId: `${method}_${p.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "")}`,
       ...params.length ? { parameters: params } : {},
       responses: {
-        "200": { description: "OK" },
+        "200": {
+          description: "OK",
+          ...successSchema ? { content: { "application/json": { schema: successSchema } } } : {}
+        },
         "401": { description: "Unauthorized" },
         "403": { description: "Forbidden" },
         "404": { description: "Not found" }
@@ -52933,6 +52956,124 @@ function buildOpenApiDocument(version2) {
       securitySchemes: {
         bearerAuth: { type: "http", scheme: "bearer" },
         apiKeyAuth: { type: "apiKey", in: "header", name: "x-api-key" }
+      },
+      schemas: {
+        MementosProjectResource: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "authority",
+            "source_package",
+            "project_id",
+            "resource_kind",
+            "stable_id",
+            "revision",
+            "digest",
+            "membership"
+          ],
+          properties: {
+            authority: { const: "mementos" },
+            source_package: { const: "@hasna/mementos" },
+            project_id: { type: "string" },
+            resource_kind: {
+              type: "string",
+              enum: ["project", "knowledge", "memory", "session"]
+            },
+            stable_id: { type: "string" },
+            revision: { type: "string" },
+            digest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+            membership: {
+              type: "string",
+              enum: ["project_aggregate", "explicit_project_id_or_focus"]
+            }
+          }
+        },
+        MementosProjectResourceAuthority: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "authority",
+            "authority_id",
+            "tenant_id",
+            "corpus_id",
+            "package_version"
+          ],
+          properties: {
+            authority: { const: "mementos" },
+            authority_id: { type: "string" },
+            tenant_id: { type: "string" },
+            corpus_id: { type: "string" },
+            package_version: { type: "string" }
+          }
+        },
+        MementosProjectResourcePage: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "schema",
+            "authority",
+            "project_id",
+            "project_revision",
+            "collection_revision",
+            "resource_kinds",
+            "resources",
+            "count",
+            "total",
+            "limit",
+            "cursor",
+            "next_cursor",
+            "has_more",
+            "complete",
+            "truncated"
+          ],
+          properties: {
+            schema: { const: "mementos.project-resources.v1" },
+            authority: { $ref: "#/components/schemas/MementosProjectResourceAuthority" },
+            project_id: { type: "string" },
+            project_revision: { type: "string" },
+            collection_revision: { type: "string", pattern: "^[0-9a-f]{64}$" },
+            resource_kinds: {
+              type: "array",
+              items: { type: "string", enum: ["project", "knowledge", "memory", "session"] }
+            },
+            resources: {
+              type: "array",
+              items: { $ref: "#/components/schemas/MementosProjectResource" }
+            },
+            count: { type: "integer", minimum: 0 },
+            total: { type: "integer", minimum: 0 },
+            limit: { type: "integer", minimum: 1, maximum: 1000 },
+            cursor: { type: ["string", "null"] },
+            next_cursor: { type: ["string", "null"] },
+            has_more: { type: "boolean" },
+            complete: { const: true },
+            truncated: { const: false }
+          }
+        },
+        MementosProjectResourceExactResult: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "schema",
+            "authority",
+            "project_id",
+            "project_revision",
+            "collection_revision",
+            "resource",
+            "complete",
+            "truncated"
+          ],
+          properties: {
+            schema: { const: "mementos.project-resource.v1" },
+            authority: { $ref: "#/components/schemas/MementosProjectResourceAuthority" },
+            project_id: { type: "string" },
+            project_revision: { type: "string" },
+            collection_revision: { type: "string", pattern: "^[0-9a-f]{64}$" },
+            resource: { $ref: "#/components/schemas/MementosProjectResource" },
+            complete: { const: true },
+            truncated: { const: false }
+          }
+        }
       }
     },
     security: [{ bearerAuth: [] }, { apiKeyAuth: [] }],
@@ -56419,6 +56560,97 @@ function getMementosPackageVersion() {
 // src/db/memory-project-link.ts
 init_schema();
 
+// src/project-registration/types.ts
+var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1";
+var MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
+var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
+var MEMENTOS_PROJECT_RESOURCE_ROUTE = "mementos.project-resources.v1";
+var MEMENTOS_PROJECT_RESOURCE_KINDS = [
+  "project",
+  "knowledge",
+  "memory",
+  "session"
+];
+
+class MementosProjectRegistrationError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MementosProjectRegistrationError";
+  }
+}
+
+// src/project-registration/identity.ts
+var MEMENTOS_PROJECT_AUTHORITY_ENV = {
+  authorityId: "MEMENTOS_PROJECT_AUTHORITY_ID",
+  tenantId: "MEMENTOS_PROJECT_TENANT_ID",
+  corpusId: "MEMENTOS_PROJECT_CORPUS_ID"
+};
+function configuredValue(override, envKey) {
+  return override?.trim() || process.env[envKey]?.trim() || null;
+}
+
+class MementosProjectAuthorityIdentityError extends Error {
+  missing_env;
+  code = "MEMENTOS_PROJECT_AUTHORITY_UNCONFIGURED";
+  constructor(missing_env) {
+    super("Mementos project authority identity is not configured; set " + missing_env.join(", "));
+    this.missing_env = missing_env;
+    this.name = "MementosProjectAuthorityIdentityError";
+  }
+}
+function resolveMementosProjectAuthorityIdentity(options = {}) {
+  const authorityId = configuredValue(options.authorityId, MEMENTOS_PROJECT_AUTHORITY_ENV.authorityId);
+  const tenantId = configuredValue(options.tenantId, MEMENTOS_PROJECT_AUTHORITY_ENV.tenantId);
+  const corpusId = configuredValue(options.corpusId, MEMENTOS_PROJECT_AUTHORITY_ENV.corpusId);
+  if (!authorityId || !tenantId || !corpusId) {
+    const missingEnv = [];
+    if (!authorityId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.authorityId);
+    if (!tenantId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.tenantId);
+    if (!corpusId)
+      missingEnv.push(MEMENTOS_PROJECT_AUTHORITY_ENV.corpusId);
+    throw new MementosProjectAuthorityIdentityError(missingEnv);
+  }
+  return {
+    authority_id: authorityId,
+    tenant_id: tenantId,
+    corpus_id: corpusId
+  };
+}
+function buildMementosProjectRegistrationCapability(options = {}) {
+  const identity = resolveMementosProjectAuthorityIdentity(options);
+  return {
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+    package_version: options.packageVersion ?? getMementosPackageVersion(),
+    ...identity,
+    supported_resources: ["project"],
+    conditional_create: true,
+    immutable_receipts: true,
+    exact_terminal_lookup: true,
+    exact_readback: true,
+    conditional_inverse: true,
+    ambiguous_outcome_reconciliation: true,
+    guarded_update: true,
+    guarded_update_route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    no_write_dry_run: true,
+    expected_revision_compare_and_swap: true,
+    caller_idempotency: true,
+    exact_inverse_rollback: true,
+    project_resource_enumeration: true,
+    project_resource_route: MEMENTOS_PROJECT_RESOURCE_ROUTE,
+    project_resource_kinds: ["project", "knowledge", "memory", "session"],
+    stable_keyset_pagination: true,
+    explicit_membership_only: true
+  };
+}
+
+// src/db/memory-project-link.ts
 class MemoryProjectLinkError extends Error {
   code;
   details;
@@ -56429,12 +56661,17 @@ class MemoryProjectLinkError extends Error {
     this.name = "MemoryProjectLinkError";
   }
 }
-var LINK_AUTHORITY = {
-  authority_id: "mementos",
-  tenant_id: "default",
-  corpus_id: "default"
-};
 var BOUNDED_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+function linkAuthority() {
+  try {
+    return resolveMementosProjectAuthorityIdentity();
+  } catch (error) {
+    if (error instanceof MementosProjectAuthorityIdentityError) {
+      throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH", error.message, { authority_code: error.code, missing_env: error.missing_env });
+    }
+    throw error;
+  }
+}
 function canonicalize(value) {
   if (Array.isArray(value))
     return value.map(canonicalize);
@@ -56542,7 +56779,8 @@ function receiptFromRow(row) {
   };
 }
 function assertIdentity(identity) {
-  if (identity.authority_id !== LINK_AUTHORITY.authority_id || identity.tenant_id !== LINK_AUTHORITY.tenant_id || identity.corpus_id !== LINK_AUTHORITY.corpus_id) {
+  const expectedIdentity = linkAuthority();
+  if (identity.authority_id !== expectedIdentity.authority_id || identity.tenant_id !== expectedIdentity.tenant_id || identity.corpus_id !== expectedIdentity.corpus_id) {
     throw new MemoryProjectLinkError("MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH", "memory project link does not match this authority, tenant, and corpus");
   }
 }
@@ -57019,7 +57257,7 @@ function rollbackMemoryProjectLink(memoryId, request, db) {
     };
   });
 }
-function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = LINK_AUTHORITY, db) {
+function getMemoryProjectLinkReceipt(memoryId, receiptId, identity = linkAuthority(), db) {
   assertIdentity(identity);
   assertBoundedIdentifier(memoryId, "memory_id");
   assertBoundedIdentifier(receiptId, "receipt_id");
@@ -57507,24 +57745,6 @@ addRoute("POST", "/api/locks/clean", () => {
 init_database();
 init_api_mode();
 import { createHash as createHash2 } from "crypto";
-
-// src/project-registration/types.ts
-var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1";
-var MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
-var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
-
-class MementosProjectRegistrationError extends Error {
-  code;
-  details;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "MementosProjectRegistrationError";
-  }
-}
-
-// src/db/projects.ts
 function parseProjectRow2(row) {
   return {
     id: row["id"],
@@ -57546,12 +57766,17 @@ class ProjectGuardedUpdateError extends Error {
     this.name = "ProjectGuardedUpdateError";
   }
 }
-var PROJECT_UPDATE_AUTHORITY = {
-  authority_id: "mementos",
-  tenant_id: "default",
-  corpus_id: "default"
-};
 var BOUNDED_IDENTIFIER2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+function projectUpdateAuthority() {
+  try {
+    return resolveMementosProjectAuthorityIdentity();
+  } catch (error) {
+    if (error instanceof MementosProjectAuthorityIdentityError) {
+      throw new ProjectGuardedUpdateError("PROJECT_UPDATE_AUTHORITY_MISMATCH", error.message, { authority_code: error.code, missing_env: error.missing_env });
+    }
+    throw error;
+  }
+}
 function canonicalizeProjectUpdateValue(value) {
   if (Array.isArray(value))
     return value.map(canonicalizeProjectUpdateValue);
@@ -57624,8 +57849,8 @@ function normalizeProjectUpdateInput(input) {
   }
   return normalized;
 }
-function assertProjectUpdateIdentity(identity) {
-  if (identity.authority_id !== PROJECT_UPDATE_AUTHORITY.authority_id || identity.tenant_id !== PROJECT_UPDATE_AUTHORITY.tenant_id || identity.corpus_id !== PROJECT_UPDATE_AUTHORITY.corpus_id) {
+function assertProjectUpdateIdentity(identity, expectedIdentity = projectUpdateAuthority()) {
+  if (identity.authority_id !== expectedIdentity.authority_id || identity.tenant_id !== expectedIdentity.tenant_id || identity.corpus_id !== expectedIdentity.corpus_id) {
     throw new ProjectGuardedUpdateError("PROJECT_UPDATE_AUTHORITY_MISMATCH", "guarded project update does not match this authority, tenant, and corpus");
   }
 }
@@ -57634,8 +57859,8 @@ function assertBoundedIdentifier2(value, field) {
     throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
   }
 }
-function assertProjectUpdateRequest(request) {
-  assertProjectUpdateIdentity(request);
+function assertProjectUpdateRequest(request, expectedIdentity = projectUpdateAuthority()) {
+  assertProjectUpdateIdentity(request, expectedIdentity);
   assertBoundedIdentifier2(request.operation_id, "operation_id");
   assertBoundedIdentifier2(request.step_id, "step_id");
   assertBoundedIdentifier2(request.idempotency_key, "idempotency_key");
@@ -57748,7 +57973,7 @@ function makeProjectUpdateReceipt(input) {
     target_id: input.target_id,
     expected_revision: input.request.expected_revision,
     result_revision: input.after_project.updated_at,
-    result_digest: digestProjectUpdateValue(input.after_project),
+    result_digest: input.result_digest ?? digestProjectUpdateValue(input.after_project),
     accepted_receipt_id: input.accepted_receipt_id ?? null,
     before_project: input.before_project,
     after_project: input.after_project,
@@ -57812,8 +58037,8 @@ function listProjects(db) {
   const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
   return rows.map(parseProjectRow2);
 }
-function previewProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function previewProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority()) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   const normalized = normalizeProjectUpdateInput(request.updates);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: true });
@@ -57835,8 +58060,8 @@ function previewProjectUpdate(id, request, db) {
     receipt: null
   };
 }
-function applyProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function applyProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority(), resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   const normalized = normalizeProjectUpdateInput(request.updates);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: false });
@@ -57897,14 +58122,15 @@ function applyProjectUpdate(id, request, db) {
       request_digest: requestDigest,
       target_id: id,
       before_project: before,
-      after_project: readback
+      after_project: readback,
+      result_digest: resultDigestForProject?.(readback)
     });
     insertProjectUpdateReceipt(d, receipt);
     return { dry_run: false, applied: true, project: readback, receipt };
   });
 }
-function rollbackProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function rollbackProjectUpdate(id, request, db, expectedIdentity = projectUpdateAuthority(), resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   assertBoundedIdentifier2(request.accepted_receipt_id, "accepted_receipt_id");
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-rollback`, request);
@@ -57970,14 +58196,15 @@ function rollbackProjectUpdate(id, request, db) {
       target_id: id,
       before_project: current,
       after_project: readback,
+      result_digest: resultDigestForProject?.(readback),
       accepted_receipt_id: accepted.receipt_id
     });
     insertProjectUpdateReceipt(d, receipt);
     return { dry_run: false, applied: true, project: readback, receipt };
   });
 }
-function getProjectUpdateReceipt(id, receiptId, identity = PROJECT_UPDATE_AUTHORITY, db) {
-  assertProjectUpdateIdentity(identity);
+function getProjectUpdateReceipt(id, receiptId, identity = projectUpdateAuthority(), db, expectedIdentity = projectUpdateAuthority()) {
+  assertProjectUpdateIdentity(identity, expectedIdentity);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/update-receipts/lookup`, { ...identity, receipt_id: receiptId });
     return data;
@@ -57990,91 +58217,6 @@ function getProjectUpdateReceipt(id, receiptId, identity = PROJECT_UPDATE_AUTHOR
   return receipt;
 }
 
-// src/server/routes/projects.ts
-init_router();
-addRoute("GET", "/api/projects", (_req, url) => {
-  const q = getSearchParams(url);
-  const projects = listProjects();
-  if (q["fields"]) {
-    const fields = q["fields"].split(",").map((f) => f.trim());
-    const filtered = projects.map((p) => Object.fromEntries(fields.map((f) => [f, p[f]]).filter(([, v]) => v !== undefined)));
-    return json({ projects: filtered, count: filtered.length });
-  }
-  return json({ projects, count: projects.length });
-});
-addRoute("POST", "/api/projects", async (req) => {
-  const body = await readJson(req);
-  if (!body || !body["name"] || !body["path"]) {
-    return errorResponse("Missing required fields: name, path", 400);
-  }
-  const project = registerProject(body["name"], body["path"], body["description"], body["memory_prefix"]);
-  return json(project, 201);
-});
-addRoute("GET", "/api/projects/:id", (_req, _url, params) => {
-  const project = getProject(params["id"]);
-  if (!project)
-    return errorResponse("Project not found", 404);
-  return json(project);
-});
-function guardedUpdateError(error) {
-  const status = error.code === "PROJECT_UPDATE_AUTHORITY_MISMATCH" ? 403 : error.code === "PROJECT_UPDATE_NOT_FOUND" || error.code === "PROJECT_UPDATE_RECEIPT_NOT_FOUND" ? 404 : error.code === "PROJECT_UPDATE_INVALID_INPUT" ? 400 : 409;
-  return errorResponse(error.message, status, { code: error.code, ...error.details });
-}
-addRoute("PATCH", "/api/projects/:id", () => errorResponse("Unguarded project updates are disabled; use POST /projects/:id/guarded-update", 428));
-addRoute("POST", "/api/projects/:id/guarded-update", async (req, _url, params) => {
-  const body = await readJson(req);
-  if (!body)
-    return errorResponse("Invalid JSON body", 400);
-  try {
-    const request = body;
-    return json(request.dry_run ? previewProjectUpdate(params["id"], request) : applyProjectUpdate(params["id"], request));
-  } catch (error) {
-    if (error instanceof ProjectGuardedUpdateError)
-      return guardedUpdateError(error);
-    throw error;
-  }
-});
-addRoute("POST", "/api/projects/:id/guarded-rollback", async (req, _url, params) => {
-  const body = await readJson(req);
-  if (!body)
-    return errorResponse("Invalid JSON body", 400);
-  try {
-    return json(rollbackProjectUpdate(params["id"], body));
-  } catch (error) {
-    if (error instanceof ProjectGuardedUpdateError)
-      return guardedUpdateError(error);
-    throw error;
-  }
-});
-addRoute("POST", "/api/projects/:id/update-receipts/lookup", async (req, _url, params) => {
-  const body = await readJson(req);
-  if (!body || typeof body["receipt_id"] !== "string") {
-    return errorResponse("receipt_id is required", 400);
-  }
-  try {
-    const identity = {
-      authority_id: String(body["authority_id"] ?? ""),
-      tenant_id: String(body["tenant_id"] ?? ""),
-      corpus_id: String(body["corpus_id"] ?? "")
-    };
-    return json(getProjectUpdateReceipt(params["id"], body["receipt_id"], identity));
-  } catch (error) {
-    if (error instanceof ProjectGuardedUpdateError)
-      return guardedUpdateError(error);
-    throw error;
-  }
-});
-addRoute("GET", "/api/projects/:id/agents", (_req, _url, params) => {
-  const project = getProject(params["id"]);
-  if (!project)
-    return errorResponse("Project not found", 404);
-  const agents = listAgentsByProject(project.id);
-  return json({ agents, count: agents.length });
-});
-
-// src/server/routes/project-registration.ts
-init_database();
-
 // src/project-registration/authority.ts
 import { createHash as createHash3 } from "crypto";
 import { resolve as resolve3 } from "path";
@@ -58205,9 +58347,9 @@ function assertWithinBounds(value, bounds, startedAt) {
   }
   return { response_bytes: bytes, elapsed_ms: elapsed };
 }
-function withResponseControl(receipt, bounds, startedAt) {
+function withBoundedResponseControl(payload, bounds, startedAt) {
   const result = {
-    receipt,
+    ...payload,
     response_control: {
       response_byte_limit: bounds.response_byte_limit,
       time_budget_ms: bounds.time_budget_ms,
@@ -58230,6 +58372,9 @@ function withResponseControl(receipt, bounds, startedAt) {
   result.response_control.elapsed_ms = measured.elapsed_ms;
   return result;
 }
+function withResponseControl(receipt, bounds, startedAt) {
+  return withBoundedResponseControl({ receipt }, bounds, startedAt);
+}
 function requireString(value, field, options = {}) {
   const min = options.min ?? 1;
   const max = options.max ?? 512;
@@ -58256,6 +58401,80 @@ function ownedPath(target) {
   }
   return path;
 }
+function guardedAuthorityIdentity(capability) {
+  return {
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id
+  };
+}
+function assertGuardedAuthorityRequest(targetId, request, capability) {
+  assertBounds(request);
+  requireString(targetId, "target_id", { min: 8, max: 128, pattern: OPERATION_PATTERN });
+  if (request.authority !== "mementos" || request.authority_route !== MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE || request.package_version !== capability.package_version || request.authority_id !== capability.authority_id || request.tenant_id !== capability.tenant_id || request.corpus_id !== capability.corpus_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "guarded project request does not match this authority capability identity");
+  }
+  return guardedAuthorityIdentity(capability);
+}
+function assertGuardedOperationFields(request) {
+  requireString(request.operation_id, "operation_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.step_id, "step_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.expected_revision, "expected_revision", { max: 128 });
+}
+function assertGuardedUpdateRequest(targetId, request, capability) {
+  const identity = assertGuardedAuthorityRequest(targetId, request, capability);
+  assertGuardedOperationFields(request);
+  if (!request.updates || typeof request.updates !== "object") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "guarded project updates must contain exactly one private path handle");
+  }
+  exactKeys(request.updates, ["path"], "updates");
+  return { identity, path: ownedPath(request.updates.path) };
+}
+function publicGuardedUpdateReceipt(receipt, capability) {
+  return {
+    receipt_id: receipt.receipt_id,
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    package_version: capability.package_version,
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    operation_id: receipt.operation_id,
+    step_id: receipt.step_id,
+    direction: receipt.direction,
+    idempotency_key: receipt.idempotency_key,
+    request_digest: receipt.request_digest,
+    outcome: "accepted",
+    target_id: receipt.target_id,
+    expected_revision: receipt.expected_revision,
+    result_revision: receipt.result_revision,
+    result_digest: receipt.result_digest,
+    accepted_receipt_id: receipt.accepted_receipt_id,
+    created_at: receipt.created_at
+  };
+}
+function guardedProjectError(cause) {
+  if (cause instanceof MementosProjectRegistrationError)
+    throw cause;
+  if (cause instanceof ProjectGuardedUpdateError) {
+    const code = cause.code === "PROJECT_UPDATE_INVALID_INPUT" ? "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT" : cause.code === "PROJECT_UPDATE_AUTHORITY_MISMATCH" ? "MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH" : cause.code === "PROJECT_UPDATE_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND" : cause.code === "PROJECT_UPDATE_RECEIPT_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND" : "MEMENTOS_PROJECT_REGISTRATION_CONFLICT";
+    throw new MementosProjectRegistrationError(code, "guarded project operation was rejected without exposing private project data", { project_update_code: cause.code });
+  }
+  throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation failed before a bounded public result was available");
+}
 function normalizedCallDigest(request) {
   return digestMementosProjectRegistrationValue({
     authority_route: request.authority_route,
@@ -58627,26 +58846,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
     this.db = db;
     this.now = options.now ?? (() => new Date().toISOString());
     this.faultInjector = options.faultInjector;
-    this.capabilityValue = {
-      authority: "mementos",
-      route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
-      package_version: options.packageVersion ?? getMementosPackageVersion(),
-      authority_id: options.authorityId ?? "mementos",
-      tenant_id: options.tenantId ?? "default",
-      corpus_id: options.corpusId ?? "default",
-      supported_resources: ["project"],
-      conditional_create: true,
-      immutable_receipts: true,
-      exact_terminal_lookup: true,
-      exact_readback: true,
-      conditional_inverse: true,
-      ambiguous_outcome_reconciliation: true,
-      guarded_update: true,
-      no_write_dry_run: true,
-      expected_revision_compare_and_swap: true,
-      caller_idempotency: true,
-      exact_inverse_rollback: true
-    };
+    this.capabilityValue = buildMementosProjectRegistrationCapability(options);
   }
   fault(point, request) {
     this.faultInjector?.(point, {
@@ -58703,6 +58903,90 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       supported_resources: ["project"]
     };
   }
+  boundedGuardedUpdateResult(targetId2, project, receipt, bounds, startedAt) {
+    if (!receipt || project.id !== targetId2 || receipt.target_id !== targetId2) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation did not return its exact immutable receipt");
+    }
+    if (project.updated_at !== receipt.result_revision) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project result revision did not match its immutable receipt");
+    }
+    const record = {
+      target_id: targetId2,
+      revision: receipt.result_revision,
+      digest: receipt.result_digest
+    };
+    return withBoundedResponseControl({
+      dry_run: false,
+      applied: true,
+      record,
+      receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+    }, bounds, startedAt);
+  }
+  async guardedUpdateProject(targetId2, request) {
+    const startedAt = Date.now();
+    const { identity, path } = assertGuardedUpdateRequest(targetId2, request, this.capabilityValue);
+    try {
+      const result = applyProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        updates: { path }
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async getGuardedProjectUpdateReceipt(targetId2, receiptId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    requireString(receiptId2, "receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const receipt = getProjectUpdateReceipt(targetId2, receiptId2, identity, this.db, identity);
+      return withBoundedResponseControl({
+        receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+      }, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async rollbackGuardedProjectUpdate(targetId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    assertGuardedOperationFields(request);
+    if (!request.accepted_receipt || typeof request.accepted_receipt !== "object") {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback requires the exact sanitized accepted receipt");
+    }
+    requireString(request.accepted_receipt.receipt_id, "accepted_receipt.receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const internalAccepted = getProjectUpdateReceipt(targetId2, request.accepted_receipt.receipt_id, identity, this.db, identity);
+      const accepted = publicGuardedUpdateReceipt(internalAccepted, this.capabilityValue);
+      if (accepted.direction !== "forward" || accepted.target_id !== targetId2 || request.expected_revision !== accepted.result_revision || canonicalMementosProjectRegistrationJson(request.accepted_receipt) !== canonicalMementosProjectRegistrationJson(accepted)) {
+        throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback receipt does not exactly match the accepted forward update");
+      }
+      const result = rollbackProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        accepted_receipt_id: accepted.receipt_id
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
   async create(request) {
     const startedAt = Date.now();
     const path = assertForwardRequest2(request, this.capabilityValue);
@@ -58799,9 +59083,9 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
     }
     requireString(request.target_id, "target_id", {
-      min: 51,
-      max: 51,
-      pattern: PROJECT_ID_PATTERN
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
     });
     const path = ownedPath(request.target);
     const project = getProjectByExactId3(this.db, request.target_id);
@@ -59059,6 +59343,31 @@ function fromWireReadRequest(body) {
     target: new WirePathHandle(canonicalPath)
   };
 }
+function fromWireGuardedUpdateRequest(body) {
+  const { target_id: targetId2, updates, ...request } = body;
+  if (typeof targetId2 !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target_id is required on the private guarded-update transport");
+  }
+  if (!updates || typeof updates !== "object" || Array.isArray(updates) || typeof updates["path"] !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "updates.path is required on the private guarded-update transport");
+  }
+  return {
+    targetId: targetId2,
+    request: {
+      ...request,
+      updates: {
+        path: new WirePathHandle(String(updates["path"]))
+      }
+    }
+  };
+}
+function exactWireIdentifier(body, field) {
+  const value = body[field];
+  if (typeof value !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} is required on the guarded-update transport`);
+  }
+  return value;
+}
 async function handleMementosProjectRegistrationHttpRequest(request, url, authority, basePath = "/v1/project-registration") {
   const path = url.pathname;
   if (path !== basePath && !path.startsWith(`${basePath}/`))
@@ -59093,6 +59402,21 @@ async function handleMementosProjectRegistrationHttpRequest(request, url, author
     if (action === "verify-inverse") {
       return json2({ verification: await authority.verifyInverse(fromWireRequest(body)) });
     }
+    if (action === "projects/guarded-update") {
+      const guarded = fromWireGuardedUpdateRequest(body);
+      return json2(await authority.guardedUpdateProject(guarded.targetId, guarded.request));
+    }
+    if (action === "projects/update-receipts/lookup") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const receiptId2 = exactWireIdentifier(body, "receipt_id");
+      const { target_id: _targetId, receipt_id: _receiptId, ...lookup } = body;
+      return json2(await authority.getGuardedProjectUpdateReceipt(targetId2, receiptId2, lookup));
+    }
+    if (action === "projects/guarded-rollback") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const { target_id: _targetId, ...rollback } = body;
+      return json2(await authority.rollbackGuardedProjectUpdate(targetId2, rollback));
+    }
     return json2({
       error: "unknown Mementos project-registration route",
       code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
@@ -59112,7 +59436,386 @@ async function handleMementosProjectRegistrationHttpRequest(request, url, author
     }, 500);
   }
 }
+// src/project-registration/project-resources.ts
+init_api_mode();
+init_database();
+init_memories();
+var DEFAULT_PAGE_LIMIT = 100;
+var MAX_PAGE_LIMIT = 1000;
+var CURSOR_SCHEMA = "mementos.project-resources.cursor.v1";
+
+class MementosProjectResourceError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MementosProjectResourceError";
+  }
+}
+function timestamp(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function normalizeSqlValue(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map(normalizeSqlValue);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalizeSqlValue(item)]));
+}
+function exactProject(db, projectId) {
+  const row = db.get("SELECT id, name, path, description, memory_prefix, created_at, updated_at FROM projects WHERE id = ? LIMIT 1", projectId);
+  if (!row) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_PROJECT_NOT_FOUND", `Mementos project not found: ${projectId}`, { project_id: projectId });
+  }
+  return row;
+}
+function resourceKey(resource) {
+  const rank = MEMENTOS_PROJECT_RESOURCE_KINDS.indexOf(resource.resource_kind);
+  return `${String(rank).padStart(2, "0")}:${resource.stable_id}`;
+}
+function projectResource(project) {
+  const normalized = normalizeSqlValue(project);
+  return {
+    authority: "mementos",
+    source_package: "@hasna/mementos",
+    project_id: project.id,
+    resource_kind: "project",
+    stable_id: project.id,
+    revision: timestamp(project.updated_at),
+    digest: digestMementosProjectRegistrationValue(normalized),
+    membership: "project_aggregate"
+  };
+}
+function memoryResources(db, projectId) {
+  const rows = db.all("SELECT * FROM memories WHERE project_id = ? ORDER BY id ASC", projectId);
+  return rows.map((row) => {
+    const memory = normalizeSqlValue(parseMemoryRow(row));
+    return {
+      authority: "mementos",
+      source_package: "@hasna/mementos",
+      project_id: projectId,
+      resource_kind: row["category"] === "knowledge" ? "knowledge" : "memory",
+      stable_id: String(row["id"]),
+      revision: timestamp(row["updated_at"]),
+      digest: digestMementosProjectRegistrationValue(memory),
+      membership: "explicit_project_id_or_focus"
+    };
+  });
+}
+function sessionResources(db, projectId) {
+  const rows = db.all("SELECT * FROM session_memory_jobs WHERE project_id = ? ORDER BY id ASC", projectId);
+  return rows.map((row) => {
+    const normalized = {
+      id: String(row["id"]),
+      session_id: String(row["session_id"]),
+      agent_id: row["agent_id"] === null ? null : String(row["agent_id"] ?? "") || null,
+      project_id: row["project_id"] === null ? null : String(row["project_id"] ?? "") || null,
+      source: String(row["source"]),
+      status: String(row["status"]),
+      transcript: String(row["transcript"]),
+      chunk_count: Number(row["chunk_count"]),
+      memories_extracted: Number(row["memories_extracted"]),
+      error: row["error"] === null ? null : String(row["error"] ?? "") || null,
+      metadata: typeof row["metadata"] === "string" ? JSON.parse(row["metadata"] || "{}") : normalizeSqlValue(row["metadata"] ?? {}),
+      created_at: timestamp(row["created_at"]),
+      started_at: row["started_at"] === null ? null : timestamp(row["started_at"]),
+      completed_at: row["completed_at"] === null ? null : timestamp(row["completed_at"])
+    };
+    return {
+      authority: "mementos",
+      source_package: "@hasna/mementos",
+      project_id: projectId,
+      resource_kind: "session",
+      stable_id: String(row["id"]),
+      revision: timestamp(row["completed_at"] ?? row["started_at"] ?? row["created_at"]),
+      digest: digestMementosProjectRegistrationValue(normalized),
+      membership: "explicit_project_id_or_focus"
+    };
+  });
+}
+function normalizeResourceKinds(value) {
+  if (!value)
+    return [...MEMENTOS_PROJECT_RESOURCE_KINDS];
+  if (value.length === 0) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "resource_kinds must contain at least one supported resource kind");
+  }
+  const requested = new Set(value);
+  for (const kind of requested) {
+    if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(kind)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `Unsupported Mementos project resource kind: ${kind}`);
+    }
+  }
+  return MEMENTOS_PROJECT_RESOURCE_KINDS.filter((kind) => requested.has(kind));
+}
+function normalizeLimit(value) {
+  const limit = value ?? DEFAULT_PAGE_LIMIT;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `limit must be an integer between 1 and ${MAX_PAGE_LIMIT}`);
+  }
+  return limit;
+}
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(raw) {
+  try {
+    const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+    if (parsed.schema !== CURSOR_SCHEMA || typeof parsed.project_id !== "string" || typeof parsed.collection_revision !== "string" || !Array.isArray(parsed.resource_kinds) || typeof parsed.after_key !== "string") {
+      throw new Error("invalid cursor shape");
+    }
+    return parsed;
+  } catch {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "cursor is not a valid Mementos project-resource cursor");
+  }
+}
+function localPopulation(projectId, db, resourceKinds) {
+  const project = exactProject(db, projectId);
+  const selected = new Set(resourceKinds);
+  const resources = [
+    ...selected.has("project") ? [projectResource(project)] : [],
+    ...memoryResources(db, projectId).filter((resource) => selected.has(resource.resource_kind)),
+    ...selected.has("session") ? sessionResources(db, projectId) : []
+  ].sort((left, right) => resourceKey(left).localeCompare(resourceKey(right)));
+  const collectionRevision = digestMementosProjectRegistrationValue({
+    schema: MEMENTOS_PROJECT_RESOURCE_ROUTE,
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    resource_kinds: resourceKinds,
+    resources: resources.map((resource) => ({
+      resource_kind: resource.resource_kind,
+      stable_id: resource.stable_id,
+      revision: resource.revision,
+      digest: resource.digest
+    }))
+  });
+  return { project, resources, collectionRevision };
+}
+function readMementosProjectResourcePage(projectId, options = {}, db, authorityOptions = {}) {
+  const resourceKinds = normalizeResourceKinds(options.resource_kinds);
+  const limit = normalizeLimit(options.limit);
+  if (!db && isApiMode()) {
+    const { data } = apiJson("GET", `/projects/${encodeURIComponent(projectId)}/resources${toQuery({
+      limit,
+      cursor: options.cursor ?? undefined,
+      resource_kinds: resourceKinds.join(",")
+    })}`);
+    return data;
+  }
+  const d = db ?? getDatabase();
+  const { project, resources, collectionRevision } = localPopulation(projectId, d, resourceKinds);
+  let start = 0;
+  if (options.cursor) {
+    const cursor = decodeCursor(options.cursor);
+    if (cursor.project_id !== projectId || JSON.stringify(cursor.resource_kinds) !== JSON.stringify(resourceKinds)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", "cursor does not belong to this project and resource-kind selection");
+    }
+    if (cursor.collection_revision !== collectionRevision) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_COLLECTION_CHANGED", "Mementos project resource collection changed; restart from the first page", {
+        cursor_collection_revision: cursor.collection_revision,
+        current_collection_revision: collectionRevision
+      });
+    }
+    const afterIndex = resources.findIndex((resource) => resourceKey(resource) === cursor.after_key);
+    if (afterIndex < 0) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_COLLECTION_CHANGED", "Mementos project resource cursor no longer names a member; restart from the first page");
+    }
+    start = afterIndex + 1;
+  }
+  const pageResources = resources.slice(start, start + limit);
+  const hasMore = start + pageResources.length < resources.length;
+  const nextCursor = hasMore && pageResources.length > 0 ? encodeCursor({
+    schema: CURSOR_SCHEMA,
+    project_id: projectId,
+    collection_revision: collectionRevision,
+    resource_kinds: resourceKinds,
+    after_key: resourceKey(pageResources[pageResources.length - 1])
+  }) : null;
+  const capability = buildMementosProjectRegistrationCapability(authorityOptions);
+  return {
+    schema: "mementos.project-resources.v1",
+    authority: {
+      authority: capability.authority,
+      authority_id: capability.authority_id,
+      tenant_id: capability.tenant_id,
+      corpus_id: capability.corpus_id,
+      package_version: capability.package_version
+    },
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    collection_revision: collectionRevision,
+    resource_kinds: resourceKinds,
+    resources: pageResources,
+    count: pageResources.length,
+    total: resources.length,
+    limit,
+    cursor: options.cursor ?? null,
+    next_cursor: nextCursor,
+    has_more: hasMore,
+    complete: true,
+    truncated: false
+  };
+}
+function getMementosProjectResourceExact(projectId, resourceKind, stableId, db, authorityOptions = {}) {
+  if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(resourceKind)) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `Unsupported Mementos project resource kind: ${resourceKind}`);
+  }
+  if (!db && isApiMode()) {
+    const { data } = apiJson("GET", `/projects/${encodeURIComponent(projectId)}/resources/${encodeURIComponent(resourceKind)}/${encodeURIComponent(stableId)}`);
+    return data;
+  }
+  const d = db ?? getDatabase();
+  const { project, resources, collectionRevision } = localPopulation(projectId, d, [
+    resourceKind
+  ]);
+  const resource = resources.find((candidate) => candidate.stable_id === stableId);
+  if (!resource) {
+    throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_NOT_FOUND", `Mementos ${resourceKind} resource not found in project ${projectId}: ${stableId}`, { project_id: projectId, resource_kind: resourceKind, stable_id: stableId });
+  }
+  const capability = buildMementosProjectRegistrationCapability(authorityOptions);
+  return {
+    schema: "mementos.project-resource.v1",
+    authority: {
+      authority: capability.authority,
+      authority_id: capability.authority_id,
+      tenant_id: capability.tenant_id,
+      corpus_id: capability.corpus_id,
+      package_version: capability.package_version
+    },
+    project_id: projectId,
+    project_revision: timestamp(project.updated_at),
+    collection_revision: collectionRevision,
+    resource,
+    complete: true,
+    truncated: false
+  };
+}
+// src/server/routes/projects.ts
+init_router();
+addRoute("GET", "/api/projects", (_req, url) => {
+  const q = getSearchParams(url);
+  const projects = listProjects();
+  if (q["fields"]) {
+    const fields = q["fields"].split(",").map((f) => f.trim());
+    const filtered = projects.map((p) => Object.fromEntries(fields.map((f) => [f, p[f]]).filter(([, v]) => v !== undefined)));
+    return json({ projects: filtered, count: filtered.length });
+  }
+  return json({ projects, count: projects.length });
+});
+addRoute("POST", "/api/projects", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"] || !body["path"]) {
+    return errorResponse("Missing required fields: name, path", 400);
+  }
+  const project = registerProject(body["name"], body["path"], body["description"], body["memory_prefix"]);
+  return json(project, 201);
+});
+addRoute("GET", "/api/projects/:id", (_req, _url, params) => {
+  const project = getProject(params["id"]);
+  if (!project)
+    return errorResponse("Project not found", 404);
+  return json(project);
+});
+function projectResourceError(error) {
+  const status = error.code === "MEMENTOS_PROJECT_RESOURCE_PROJECT_NOT_FOUND" || error.code === "MEMENTOS_PROJECT_RESOURCE_NOT_FOUND" ? 404 : error.code === "MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT" ? 400 : 409;
+  return errorResponse(error.message, status, { code: error.code, ...error.details });
+}
+function parseResourceKinds(raw) {
+  if (raw === undefined)
+    return;
+  const values = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  for (const value of values) {
+    if (!MEMENTOS_PROJECT_RESOURCE_KINDS.includes(value)) {
+      throw new MementosProjectResourceError("MEMENTOS_PROJECT_RESOURCE_INVALID_INPUT", `Unsupported Mementos project resource kind: ${value}`);
+    }
+  }
+  return values;
+}
+addRoute("GET", "/api/projects/:id/resources", (_req, url, params) => {
+  const q = getSearchParams(url);
+  try {
+    const parsedLimit = q["limit"] === undefined ? undefined : Number(q["limit"]);
+    return json(readMementosProjectResourcePage(params["id"], {
+      limit: parsedLimit,
+      cursor: q["cursor"],
+      resource_kinds: parseResourceKinds(q["resource_kinds"])
+    }));
+  } catch (error) {
+    if (error instanceof MementosProjectResourceError)
+      return projectResourceError(error);
+    throw error;
+  }
+});
+addRoute("GET", "/api/projects/:id/resources/:kind/:resource_id", (_req, _url, params) => {
+  try {
+    return json(getMementosProjectResourceExact(params["id"], params["kind"], params["resource_id"]));
+  } catch (error) {
+    if (error instanceof MementosProjectResourceError)
+      return projectResourceError(error);
+    throw error;
+  }
+});
+function guardedUpdateError(error) {
+  const status = error.code === "PROJECT_UPDATE_AUTHORITY_MISMATCH" ? 403 : error.code === "PROJECT_UPDATE_NOT_FOUND" || error.code === "PROJECT_UPDATE_RECEIPT_NOT_FOUND" ? 404 : error.code === "PROJECT_UPDATE_INVALID_INPUT" ? 400 : 409;
+  return errorResponse(error.message, status, { code: error.code, ...error.details });
+}
+addRoute("PATCH", "/api/projects/:id", () => errorResponse("Unguarded project updates are disabled; use POST /projects/:id/guarded-update", 428));
+addRoute("POST", "/api/projects/:id/guarded-update", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  try {
+    const request = body;
+    return json(request.dry_run ? previewProjectUpdate(params["id"], request) : applyProjectUpdate(params["id"], request));
+  } catch (error) {
+    if (error instanceof ProjectGuardedUpdateError)
+      return guardedUpdateError(error);
+    throw error;
+  }
+});
+addRoute("POST", "/api/projects/:id/guarded-rollback", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  try {
+    return json(rollbackProjectUpdate(params["id"], body));
+  } catch (error) {
+    if (error instanceof ProjectGuardedUpdateError)
+      return guardedUpdateError(error);
+    throw error;
+  }
+});
+addRoute("POST", "/api/projects/:id/update-receipts/lookup", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body || typeof body["receipt_id"] !== "string") {
+    return errorResponse("receipt_id is required", 400);
+  }
+  try {
+    const identity = {
+      authority_id: String(body["authority_id"] ?? ""),
+      tenant_id: String(body["tenant_id"] ?? ""),
+      corpus_id: String(body["corpus_id"] ?? "")
+    };
+    return json(getProjectUpdateReceipt(params["id"], body["receipt_id"], identity));
+  } catch (error) {
+    if (error instanceof ProjectGuardedUpdateError)
+      return guardedUpdateError(error);
+    throw error;
+  }
+});
+addRoute("GET", "/api/projects/:id/agents", (_req, _url, params) => {
+  const project = getProject(params["id"]);
+  if (!project)
+    return errorResponse("Project not found", 404);
+  const agents = listAgentsByProject(project.id);
+  return json({ agents, count: agents.length });
+});
+
 // src/server/routes/project-registration.ts
+init_database();
 init_router();
 var handle = async (request, url) => {
   const basePath = url.pathname.startsWith("/v1/") ? "/v1/project-registration" : "/api/project-registration";
@@ -59129,6 +59832,9 @@ addRoute("POST", "/api/project-registration/receipts/lookup", handle);
 addRoute("POST", "/api/project-registration/read-exact", handle);
 addRoute("POST", "/api/project-registration/compensate", handle);
 addRoute("POST", "/api/project-registration/verify-inverse", handle);
+addRoute("POST", "/api/project-registration/projects/guarded-update", handle);
+addRoute("POST", "/api/project-registration/projects/update-receipts/lookup", handle);
+addRoute("POST", "/api/project-registration/projects/guarded-rollback", handle);
 
 // src/server/routes/entities.ts
 init_entities();
@@ -60769,7 +61475,7 @@ function parseMemoryLink(row) {
 function createMemoryLink(input, db) {
   const d = db || getDatabase();
   const id = shortUuid();
-  const timestamp = now();
+  const timestamp2 = now();
   d.run(`INSERT OR IGNORE INTO memory_links (id, source_memory_id, target_memory_id, relation_type, run_id, metadata, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)`, [
     id,
@@ -60778,7 +61484,7 @@ function createMemoryLink(input, db) {
     input.relation_type,
     input.run_id ?? null,
     JSON.stringify(input.metadata ?? {}),
-    timestamp
+    timestamp2
   ]);
   const row = d.query(`SELECT * FROM memory_links
        WHERE source_memory_id = ? AND target_memory_id = ? AND relation_type = ? AND COALESCE(run_id, '') = ?