@hasna/mementos 0.14.75 → 0.14.79

package/dist/server/index.js

@@ -802,6 +802,201 @@ 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 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;
+  `;
+}
+
+// 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;
+  `;
+}
+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
@@ -822,6 +1017,7 @@ BEGIN
 END;
 `, MIGRATIONS;
 var init_migrations = __esm(() => {
+  init_schema();
   MIGRATIONS = [
     `
   CREATE TABLE IF NOT EXISTS projects (
@@ -1755,6 +1951,18 @@ UPDATE memory_audit_log SET new_value_hash = NULL
     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);
 `
   ];
 });
@@ -6192,8 +6400,8 @@ var init_util = __esm(() => {
 
 // node_modules/zod/v3/ZodError.js
 var ZodIssueCode, quotelessJson = (obj) => {
-  const json2 = JSON.stringify(obj, null, 2);
-  return json2.replace(/"([^"]+)":/g, "$1:");
+  const json3 = JSON.stringify(obj, null, 2);
+  return json3.replace(/"([^"]+)":/g, "$1:");
 }, ZodError;
 var init_ZodError = __esm(() => {
   init_util();
@@ -19385,24 +19593,24 @@ class JSONSchemaGenerator {
         const _json = result.schema;
         switch (def.type) {
           case "string": {
-            const json2 = _json;
-            json2.type = "string";
+            const json3 = _json;
+            json3.type = "string";
             const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
             if (typeof minimum === "number")
-              json2.minLength = minimum;
+              json3.minLength = minimum;
             if (typeof maximum === "number")
-              json2.maxLength = maximum;
+              json3.maxLength = maximum;
             if (format) {
-              json2.format = formatMap[format] ?? format;
-              if (json2.format === "")
-                delete json2.format;
+              json3.format = formatMap[format] ?? format;
+              if (json3.format === "")
+                delete json3.format;
             }
             if (contentEncoding)
-              json2.contentEncoding = contentEncoding;
+              json3.contentEncoding = contentEncoding;
             if (patterns && patterns.size > 0) {
               const regexes = [...patterns];
               if (regexes.length === 1)
-                json2.pattern = regexes[0].source;
+                json3.pattern = regexes[0].source;
               else if (regexes.length > 1) {
                 result.schema.allOf = [
                   ...regexes.map((regex) => ({
@@ -19415,41 +19623,41 @@ class JSONSchemaGenerator {
             break;
           }
           case "number": {
-            const json2 = _json;
+            const json3 = _json;
             const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
             if (typeof format === "string" && format.includes("int"))
-              json2.type = "integer";
+              json3.type = "integer";
             else
-              json2.type = "number";
+              json3.type = "number";
             if (typeof exclusiveMinimum === "number")
-              json2.exclusiveMinimum = exclusiveMinimum;
+              json3.exclusiveMinimum = exclusiveMinimum;
             if (typeof minimum === "number") {
-              json2.minimum = minimum;
+              json3.minimum = minimum;
               if (typeof exclusiveMinimum === "number") {
                 if (exclusiveMinimum >= minimum)
-                  delete json2.minimum;
+                  delete json3.minimum;
                 else
-                  delete json2.exclusiveMinimum;
+                  delete json3.exclusiveMinimum;
               }
             }
             if (typeof exclusiveMaximum === "number")
-              json2.exclusiveMaximum = exclusiveMaximum;
+              json3.exclusiveMaximum = exclusiveMaximum;
             if (typeof maximum === "number") {
-              json2.maximum = maximum;
+              json3.maximum = maximum;
               if (typeof exclusiveMaximum === "number") {
                 if (exclusiveMaximum <= maximum)
-                  delete json2.maximum;
+                  delete json3.maximum;
                 else
-                  delete json2.exclusiveMaximum;
+                  delete json3.exclusiveMaximum;
               }
             }
             if (typeof multipleOf === "number")
-              json2.multipleOf = multipleOf;
+              json3.multipleOf = multipleOf;
             break;
           }
           case "boolean": {
-            const json2 = _json;
-            json2.type = "boolean";
+            const json3 = _json;
+            json3.type = "boolean";
             break;
           }
           case "bigint": {
@@ -19497,23 +19705,23 @@ class JSONSchemaGenerator {
             break;
           }
           case "array": {
-            const json2 = _json;
+            const json3 = _json;
             const { minimum, maximum } = schema._zod.bag;
             if (typeof minimum === "number")
-              json2.minItems = minimum;
+              json3.minItems = minimum;
             if (typeof maximum === "number")
-              json2.maxItems = maximum;
-            json2.type = "array";
-            json2.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
+              json3.maxItems = maximum;
+            json3.type = "array";
+            json3.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
             break;
           }
           case "object": {
-            const json2 = _json;
-            json2.type = "object";
-            json2.properties = {};
+            const json3 = _json;
+            json3.type = "object";
+            json3.properties = {};
             const shape = def.shape;
             for (const key in shape) {
-              json2.properties[key] = this.process(shape[key], {
+              json3.properties[key] = this.process(shape[key], {
                 ...params,
                 path: [...params.path, "properties", key]
               });
@@ -19528,15 +19736,15 @@ class JSONSchemaGenerator {
               }
             }));
             if (requiredKeys.size > 0) {
-              json2.required = Array.from(requiredKeys);
+              json3.required = Array.from(requiredKeys);
             }
             if (def.catchall?._zod.def.type === "never") {
-              json2.additionalProperties = false;
+              json3.additionalProperties = false;
             } else if (!def.catchall) {
               if (this.io === "output")
-                json2.additionalProperties = false;
+                json3.additionalProperties = false;
             } else if (def.catchall) {
-              json2.additionalProperties = this.process(def.catchall, {
+              json3.additionalProperties = this.process(def.catchall, {
                 ...params,
                 path: [...params.path, "additionalProperties"]
               });
@@ -19544,15 +19752,15 @@ class JSONSchemaGenerator {
             break;
           }
           case "union": {
-            const json2 = _json;
-            json2.anyOf = def.options.map((x, i) => this.process(x, {
+            const json3 = _json;
+            json3.anyOf = def.options.map((x, i) => this.process(x, {
               ...params,
               path: [...params.path, "anyOf", i]
             }));
             break;
           }
           case "intersection": {
-            const json2 = _json;
+            const json3 = _json;
             const a = this.process(def.left, {
               ...params,
               path: [...params.path, "allOf", 0]
@@ -19566,17 +19774,17 @@ class JSONSchemaGenerator {
               ...isSimpleIntersection(a) ? a.allOf : [a],
               ...isSimpleIntersection(b) ? b.allOf : [b]
             ];
-            json2.allOf = allOf;
+            json3.allOf = allOf;
             break;
           }
           case "tuple": {
-            const json2 = _json;
-            json2.type = "array";
+            const json3 = _json;
+            json3.type = "array";
             const prefixItems = def.items.map((x, i) => this.process(x, { ...params, path: [...params.path, "prefixItems", i] }));
             if (this.target === "draft-2020-12") {
-              json2.prefixItems = prefixItems;
+              json3.prefixItems = prefixItems;
             } else {
-              json2.items = prefixItems;
+              json3.items = prefixItems;
             }
             if (def.rest) {
               const rest = this.process(def.rest, {
@@ -19584,29 +19792,29 @@ class JSONSchemaGenerator {
                 path: [...params.path, "items"]
               });
               if (this.target === "draft-2020-12") {
-                json2.items = rest;
+                json3.items = rest;
               } else {
-                json2.additionalItems = rest;
+                json3.additionalItems = rest;
               }
             }
             if (def.rest) {
-              json2.items = this.process(def.rest, {
+              json3.items = this.process(def.rest, {
                 ...params,
                 path: [...params.path, "items"]
               });
             }
             const { minimum, maximum } = schema._zod.bag;
             if (typeof minimum === "number")
-              json2.minItems = minimum;
+              json3.minItems = minimum;
             if (typeof maximum === "number")
-              json2.maxItems = maximum;
+              json3.maxItems = maximum;
             break;
           }
           case "record": {
-            const json2 = _json;
-            json2.type = "object";
-            json2.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
-            json2.additionalProperties = this.process(def.valueType, {
+            const json3 = _json;
+            json3.type = "object";
+            json3.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+            json3.additionalProperties = this.process(def.valueType, {
               ...params,
               path: [...params.path, "additionalProperties"]
             });
@@ -19625,17 +19833,17 @@ class JSONSchemaGenerator {
             break;
           }
           case "enum": {
-            const json2 = _json;
+            const json3 = _json;
             const values = getEnumValues(def.entries);
             if (values.every((v) => typeof v === "number"))
-              json2.type = "number";
+              json3.type = "number";
             if (values.every((v) => typeof v === "string"))
-              json2.type = "string";
-            json2.enum = values;
+              json3.type = "string";
+            json3.enum = values;
             break;
           }
           case "literal": {
-            const json2 = _json;
+            const json3 = _json;
             const vals = [];
             for (const val of def.values) {
               if (val === undefined) {
@@ -19654,23 +19862,23 @@ class JSONSchemaGenerator {
             }
             if (vals.length === 0) {} else if (vals.length === 1) {
               const val = vals[0];
-              json2.type = val === null ? "null" : typeof val;
-              json2.const = val;
+              json3.type = val === null ? "null" : typeof val;
+              json3.const = val;
             } else {
               if (vals.every((v) => typeof v === "number"))
-                json2.type = "number";
+                json3.type = "number";
               if (vals.every((v) => typeof v === "string"))
-                json2.type = "string";
+                json3.type = "string";
               if (vals.every((v) => typeof v === "boolean"))
-                json2.type = "string";
+                json3.type = "string";
               if (vals.every((v) => v === null))
-                json2.type = "null";
-              json2.enum = vals;
+                json3.type = "null";
+              json3.enum = vals;
             }
             break;
           }
           case "file": {
-            const json2 = _json;
+            const json3 = _json;
             const file = {
               type: "string",
               format: "binary",
@@ -19684,15 +19892,15 @@ class JSONSchemaGenerator {
             if (mime) {
               if (mime.length === 1) {
                 file.contentMediaType = mime[0];
-                Object.assign(json2, file);
+                Object.assign(json3, file);
               } else {
-                json2.anyOf = mime.map((m) => {
+                json3.anyOf = mime.map((m) => {
                   const mFile = { ...file, contentMediaType: m };
                   return mFile;
                 });
               }
             } else {
-              Object.assign(json2, file);
+              Object.assign(json3, file);
             }
             break;
           }
@@ -19713,8 +19921,8 @@ class JSONSchemaGenerator {
             break;
           }
           case "success": {
-            const json2 = _json;
-            json2.type = "boolean";
+            const json3 = _json;
+            json3.type = "boolean";
             break;
           }
           case "default": {
@@ -19749,12 +19957,12 @@ class JSONSchemaGenerator {
             break;
           }
           case "template_literal": {
-            const json2 = _json;
+            const json3 = _json;
             const pattern = schema._zod.pattern;
             if (!pattern)
               throw new Error("Pattern not found in template literal");
-            json2.type = "string";
-            json2.pattern = pattern.source;
+            json3.type = "string";
+            json3.pattern = pattern.source;
             break;
           }
           case "pipe": {
@@ -20847,7 +21055,7 @@ function _instanceof(cls, params = {
   inst._zod.bag.Class = cls;
   return inst;
 }
-function json2(params) {
+function json3(params) {
   const jsonSchema = lazy(() => {
     return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
   });
@@ -21534,7 +21742,7 @@ __export(exports_external2, {
   ksuid: () => ksuid2,
   keyof: () => keyof,
   jwt: () => jwt,
-  json: () => json2,
+  json: () => json3,
   iso: () => exports_iso,
   ipv6: () => ipv62,
   ipv4: () => ipv42,
@@ -23394,7 +23602,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve3(value) {
+async function resolve4(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -26216,11 +26424,11 @@ var VERSION2 = "3.0.82", anthropicErrorDataSchema, anthropicFailedResponseHandle
     betas,
     headers
   }) {
-    return combineHeaders(await resolve3(this.config.headers), headers, betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {});
+    return combineHeaders(await resolve4(this.config.headers), headers, betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {});
   }
   async getBetasFromHeaders(requestHeaders) {
     var _a16, _b16;
-    const configHeaders = await resolve3(this.config.headers);
+    const configHeaders = await resolve4(this.config.headers);
     const configBetaHeader = (_a16 = configHeaders["anthropic-beta"]) != null ? _a16 : "";
     const requestBetaHeader = (_b16 = requestHeaders == null ? undefined : requestHeaders["anthropic-beta"]) != null ? _b16 : "";
     return new Set([
@@ -36890,24 +37098,24 @@ var require_oauth = __commonJS((exports, module) => {
     });
   }
   async function processTokenResponse(response) {
-    const json3 = await response.json();
+    const json4 = await response.json();
     if (!response.ok) {
-      const errorMsg = typeof json3 === "object" && json3 && "error" in json3 ? String(json3.error) : "Token refresh failed";
+      const errorMsg = typeof json4 === "object" && json4 && "error" in json4 ? String(json4.error) : "Token refresh failed";
       return [new Error(errorMsg)];
     }
-    if (typeof json3 !== "object" || json3 === null) {
+    if (typeof json4 !== "object" || json4 === null) {
       return [new Error("Invalid token response")];
     }
-    if (typeof json3.access_token !== "string") {
+    if (typeof json4.access_token !== "string") {
       return [new Error("Missing access_token in response")];
     }
-    if (json3.token_type !== "Bearer") {
+    if (json4.token_type !== "Bearer") {
       return [new Error("Invalid token_type in response")];
     }
-    if (typeof json3.expires_in !== "number") {
+    if (typeof json4.expires_in !== "number") {
       return [new Error("Missing expires_in in response")];
     }
-    return [null, json3];
+    return [null, json4];
   }
 });
 
@@ -37644,7 +37852,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     try {
       const { value } = await getFromApi({
         url: `${this.config.baseURL}/config`,
-        headers: await resolve3(this.config.headers()),
+        headers: await resolve4(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayAvailableModelsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -37662,7 +37870,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       const baseUrl = new URL(this.config.baseURL);
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/credits`,
-        headers: await resolve3(this.config.headers()),
+        headers: await resolve4(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayCreditsResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -37708,7 +37916,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       }
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/report?${searchParams.toString()}`,
-        headers: await resolve3(this.config.headers()),
+        headers: await resolve4(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewaySpendReportResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -37730,7 +37938,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
       const baseUrl = new URL(this.config.baseURL);
       const { value } = await getFromApi({
         url: `${baseUrl.origin}/v1/generation?id=${encodeURIComponent(params.id)}`,
-        headers: await resolve3(this.config.headers()),
+        headers: await resolve4(this.config.headers()),
         successfulResponseHandler: createJsonResponseHandler(gatewayGenerationInfoResponseSchema),
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: exports_external2.any(),
@@ -37763,7 +37971,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
   async doGenerate(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -37771,7 +37979,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue: rawResponse
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve3(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, false), await resolve4(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createJsonResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -37794,11 +38002,11 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const { abortSignal } = options;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const { value: response, responseHeaders } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve3(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, options.headers, this.getModelConfigHeaders(this.modelId, true), await resolve4(this.config.o11yHeaders)),
         body: args,
         successfulResponseHandler: createEventSourceResponseHandler(exports_external2.any()),
         failedResponseHandler: createJsonErrorResponseHandler({
@@ -37883,7 +38091,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     providerOptions
   }) {
     var _a102;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -37891,7 +38099,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
         body: {
           values,
           ...providerOptions ? { providerOptions } : {}
@@ -37947,7 +38155,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal
   }) {
     var _a102, _b102, _c, _d;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -37955,7 +38163,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
         body: {
           prompt,
           n,
@@ -38030,11 +38238,11 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal
   }) {
     var _a102;
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const { responseHeaders, value: responseBody } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders), { accept: "text/event-stream" }),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders), { accept: "text/event-stream" }),
         body: {
           prompt,
           n,
@@ -38157,7 +38365,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
     abortSignal,
     providerOptions
   }) {
-    const resolvedHeaders = await resolve3(this.config.headers());
+    const resolvedHeaders = await resolve4(this.config.headers());
     try {
       const {
         responseHeaders,
@@ -38165,7 +38373,7 @@ var import_oidc, import_oidc2, marker17 = "vercel.ai.gateway.error", symbol18, _
         rawValue
       } = await postJsonToApi({
         url: this.getUrl(),
-        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve3(this.config.o11yHeaders)),
+        headers: combineHeaders(resolvedHeaders, headers != null ? headers : {}, this.getModelConfigHeaders(), await resolve4(this.config.o11yHeaders)),
         body: {
           documents,
           query,
@@ -47769,7 +47977,7 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
   const schema = asSchema(inputSchema);
   return {
     name: "object",
-    responseFormat: resolve3(schema.jsonSchema).then((jsonSchema2) => ({
+    responseFormat: resolve4(schema.jsonSchema).then((jsonSchema2) => ({
       type: "json",
       schema: jsonSchema2,
       ...name21 != null && { name: name21 },
@@ -47830,7 +48038,7 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
   const elementSchema = asSchema(inputElementSchema);
   return {
     name: "array",
-    responseFormat: resolve3(elementSchema.jsonSchema).then((jsonSchema2) => {
+    responseFormat: resolve4(elementSchema.jsonSchema).then((jsonSchema2) => {
       const { $schema, ...itemSchema } = jsonSchema2;
       return {
         type: "json",
@@ -48007,7 +48215,7 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
       return;
     }
   };
-}, json3 = ({
+}, json4 = ({
   name: name21,
   description
 } = {}) => {
@@ -50743,9 +50951,9 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
     ...options
   }) {
     var _a21, _b16, _c, _d, _e;
-    const resolvedBody = await resolve3(this.body);
-    const resolvedHeaders = await resolve3(this.headers);
-    const resolvedCredentials = await resolve3(this.credentials);
+    const resolvedBody = await resolve4(this.body);
+    const resolvedHeaders = await resolve4(this.headers);
+    const resolvedCredentials = await resolve4(this.credentials);
     const baseHeaders = {
       ...normalizeHeaders(resolvedHeaders),
       ...normalizeHeaders(options.headers)
@@ -50793,9 +51001,9 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
   }
   async reconnectToStream(options) {
     var _a21, _b16, _c, _d, _e;
-    const resolvedBody = await resolve3(this.body);
-    const resolvedHeaders = await resolve3(this.headers);
-    const resolvedCredentials = await resolve3(this.credentials);
+    const resolvedBody = await resolve4(this.body);
+    const resolvedHeaders = await resolve4(this.headers);
+    const resolvedCredentials = await resolve4(this.credentials);
     const baseHeaders = {
       ...normalizeHeaders(resolvedHeaders),
       ...normalizeHeaders(options.headers)
@@ -52075,7 +52283,7 @@ var init_dist8 = __esm(() => {
   __export2(output_exports, {
     array: () => array2,
     choice: () => choice,
-    json: () => json3,
+    json: () => json4,
     object: () => object2,
     text: () => text
   });
@@ -52738,7 +52946,7 @@ var init_openapi = __esm(() => {
 // src/server/index.ts
 import { existsSync as existsSync5 } from "fs";
 import { createRequire } from "module";
-import { join as join6, resolve as resolve4, sep } from "path";
+import { join as join7, resolve as resolve5, sep } from "path";
 
 // src/lib/config.ts
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, cpSync } from "fs";
@@ -54828,6 +55036,9 @@ addRoute("PATCH", "/api/memories/:id", async (req, _url, params) => {
   if (!body) {
     return errorResponse("Invalid JSON body", 400);
   }
+  if (Object.prototype.hasOwnProperty.call(body, "project_id")) {
+    return errorResponse("project_id changes require the guarded existing-memory project-link route", 428, { code: "MEMORY_PROJECT_LINK_GUARD_REQUIRED" });
+  }
   const patchViolation = validateMemoryEnums(body);
   if (patchViolation) {
     return errorResponse(formatEnumViolation(patchViolation), 400, {
@@ -55710,6 +55921,10 @@ addRoute("POST", "/api/memories/search", async (req) => {
     filter.category = body["category"];
   if (body["tags"])
     filter.tags = body["tags"];
+  if (body["agent_id"])
+    filter.agent_id = body["agent_id"];
+  if (body["project_id"])
+    filter.project_id = body["project_id"];
   if (body["session_id"])
     filter.session_id = body["session_id"];
   if (body["namespace"])
@@ -56175,6 +56390,701 @@ ${lines.join(`
   return json({ context, memories_count: lines.length });
 });
 
+// src/db/memory-project-link.ts
+init_storage();
+init_api_mode();
+init_database();
+init_memories();
+import { createHash } from "crypto";
+
+// src/lib/package-version.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function getMementosPackageVersion() {
+  const here = dirname4(fileURLToPath3(import.meta.url));
+  for (const candidate of [
+    join6(here, "..", "..", "package.json"),
+    join6(here, "..", "package.json")
+  ]) {
+    try {
+      const parsed = JSON.parse(readFileSync3(candidate, "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.trim())
+        return parsed.version;
+    } catch {}
+  }
+  return "0.0.0";
+}
+
+// src/db/memory-project-link.ts
+init_schema();
+
+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_IDENTIFIER = /^[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 createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+function timestampString(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function nullableTimestamp(value) {
+  return value === null || value === undefined ? null : timestampString(value);
+}
+function normalizeMemoryTimestamps(memory) {
+  return {
+    ...memory,
+    created_at: timestampString(memory.created_at),
+    updated_at: timestampString(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 parseProjectRow(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: timestampString(row["created_at"]),
+    updated_at: timestampString(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: timestampString(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: timestampString(row["expected_memory_revision"]),
+    expected_project_revision: nullableTimestamp(row["expected_project_revision"]),
+    result_memory_version: Number(row["result_memory_version"]),
+    result_memory_revision: timestampString(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: timestampString(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 assertBoundedIdentifier(value, field) {
+  if (!BOUNDED_IDENTIFIER.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);
+  assertBoundedIdentifier(request.operation_id, "operation_id");
+  assertBoundedIdentifier(request.step_id, "step_id");
+  assertBoundedIdentifier(request.idempotency_key, "idempotency_key");
+  assertBoundedIdentifier(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);
+  assertBoundedIdentifier(request.operation_id, "operation_id");
+  assertBoundedIdentifier(request.step_id, "step_id");
+  assertBoundedIdentifier(request.idempotency_key, "idempotency_key");
+  assertBoundedIdentifier(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 getProjectByExactId(id, db, lock = false) {
+  const row = db.query(`SELECT * FROM projects WHERE id = ? LIMIT 1${forUpdateSuffix(db, lock)}`).get(id);
+  return row ? parseProjectRow(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 = getProjectByExactId(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 ? getProjectByExactId(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);
+  assertBoundedIdentifier(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 = getProjectByExactId(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);
+  assertBoundedIdentifier(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);
+  assertBoundedIdentifier(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);
+  assertBoundedIdentifier(memoryId, "memory_id");
+  assertBoundedIdentifier(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/server/routes/memory-project-link.ts
+init_router();
+function linkError(error) {
+  const status = error.code === "MEMORY_PROJECT_LINK_AUTHORITY_MISMATCH" ? 403 : error.code === "MEMORY_PROJECT_LINK_MEMORY_NOT_FOUND" || error.code === "MEMORY_PROJECT_LINK_PROJECT_NOT_FOUND" || error.code === "MEMORY_PROJECT_LINK_RECEIPT_NOT_FOUND" ? 404 : error.code === "MEMORY_PROJECT_LINK_INVALID_INPUT" ? 400 : 409;
+  return errorResponse(error.message, status, { code: error.code, ...error.details });
+}
+addRoute("POST", "/api/memories/:id/guarded-project-link", 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 ? previewMemoryProjectLink(params["id"], request) : applyMemoryProjectLink(params["id"], request));
+  } catch (error) {
+    if (error instanceof MemoryProjectLinkError)
+      return linkError(error);
+    throw error;
+  }
+});
+addRoute("POST", "/api/memories/:id/guarded-project-link-rollback", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  try {
+    return json(rollbackMemoryProjectLink(params["id"], body));
+  } catch (error) {
+    if (error instanceof MemoryProjectLinkError)
+      return linkError(error);
+    throw error;
+  }
+});
+addRoute("POST", "/api/memories/:id/project-link-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(getMemoryProjectLinkReceipt(params["id"], body["receipt_id"], identity));
+  } catch (error) {
+    if (error instanceof MemoryProjectLinkError)
+      return linkError(error);
+    throw error;
+  }
+});
+
 // src/db/agents.ts
 init_types();
 init_database();
@@ -56596,7 +57506,26 @@ addRoute("POST", "/api/locks/clean", () => {
 // src/db/projects.ts
 init_database();
 init_api_mode();
-function parseProjectRow(row) {
+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"],
     name: row["name"],
@@ -56607,6 +57536,229 @@ function parseProjectRow(row) {
     updated_at: row["updated_at"]
   };
 }
+class ProjectGuardedUpdateError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ProjectGuardedUpdateError";
+  }
+}
+var PROJECT_UPDATE_AUTHORITY = {
+  authority_id: "mementos",
+  tenant_id: "default",
+  corpus_id: "default"
+};
+var BOUNDED_IDENTIFIER2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+function canonicalizeProjectUpdateValue(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalizeProjectUpdateValue);
+  if (!value || typeof value !== "object")
+    return value;
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      output[key] = canonicalizeProjectUpdateValue(item);
+  }
+  return output;
+}
+function canonicalProjectUpdateJson(value) {
+  return JSON.stringify(canonicalizeProjectUpdateValue(value));
+}
+function digestProjectUpdateValue(value) {
+  return createHash2("sha256").update(canonicalProjectUpdateJson(value)).digest("hex");
+}
+function timestampString2(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: timestampString2(row["expected_revision"]),
+    result_revision: timestampString2(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: timestampString2(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 assertBoundedIdentifier2(value, field) {
+  if (!BOUNDED_IDENTIFIER2.test(value)) {
+    throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
+  }
+}
+function assertProjectUpdateRequest(request) {
+  assertProjectUpdateIdentity(request);
+  assertBoundedIdentifier2(request.operation_id, "operation_id");
+  assertBoundedIdentifier2(request.step_id, "step_id");
+  assertBoundedIdentifier2(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 getProjectByExactId2(id, db) {
+  const row = db.query("SELECT * FROM projects WHERE id = ? LIMIT 1").get(id);
+  return row ? parseProjectRow2(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", {
@@ -56626,7 +57778,7 @@ function registerProject(name, path, description, memoryPrefix, db) {
       timestamp,
       existingId
     ]);
-    return parseProjectRow(existing);
+    return parseProjectRow2(existing);
   }
   const id = uuid();
   d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
@@ -56642,13 +57794,13 @@ function getProject(idOrPath, db) {
   const d = db || getDatabase();
   let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
   if (row)
-    return parseProjectRow(row);
+    return parseProjectRow2(row);
   row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
   if (row)
-    return parseProjectRow(row);
+    return parseProjectRow2(row);
   row = d.query("SELECT * FROM projects WHERE LOWER(name) = ?").get(idOrPath.toLowerCase());
   if (row)
-    return parseProjectRow(row);
+    return parseProjectRow2(row);
   return null;
 }
 function listProjects(db) {
@@ -56658,7 +57810,184 @@ function listProjects(db) {
   }
   const d = db || getDatabase();
   const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
-  return rows.map(parseProjectRow);
+  return rows.map(parseProjectRow2);
+}
+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 = getProjectByExactId2(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 = getProjectByExactId2(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 = getProjectByExactId2(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 = getProjectByExactId2(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);
+  assertBoundedIdentifier2(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 = getProjectByExactId2(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 = getProjectByExactId2(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 = getProjectByExactId2(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;
 }
 
 // src/server/routes/projects.ts
@@ -56687,6 +58016,54 @@ addRoute("GET", "/api/projects/:id", (_req, _url, params) => {
     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)
@@ -56695,6 +58072,1064 @@ addRoute("GET", "/api/projects/:id/agents", (_req, _url, params) => {
   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";
+
+// src/project-registration/project-references.ts
+var MEMENTOS_PROJECT_REFERENCE_SURFACES = [
+  { key: "memories", table: "memories", column: "project_id" },
+  { key: "sessions", table: "sessions", column: "project_id" },
+  { key: "entities", table: "entities", column: "project_id" },
+  { key: "agents", table: "agents", column: "active_project_id" },
+  { key: "tool_events", table: "tool_events", column: "project_id" },
+  { key: "tasks", table: "tasks", column: "project_id" },
+  {
+    key: "memory_consolidation_runs",
+    table: "memory_consolidation_runs",
+    column: "project_id"
+  },
+  {
+    key: "memory_reflection_runs",
+    table: "memory_reflection_runs",
+    column: "project_id"
+  },
+  { key: "memory_acl", table: "memory_acl", column: "project_id" },
+  { key: "search_history", table: "search_history", column: "project_id" },
+  {
+    key: "session_memory_jobs",
+    table: "session_memory_jobs",
+    column: "project_id"
+  },
+  { key: "synthesis_events", table: "synthesis_events", column: "project_id" },
+  { key: "synthesis_runs", table: "synthesis_runs", column: "project_id" },
+  { key: "webhook_hooks", table: "webhook_hooks", column: "project_id" }
+];
+function quotedIdentifier(value) {
+  if (!/^[a-z_][a-z0-9_]*$/.test(value)) {
+    throw new Error(`unsafe project-reference identifier: ${value}`);
+  }
+  return `"${value}"`;
+}
+function mementosProjectReferenceCounts(db, projectId) {
+  const projections = MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ key, table, column }) => `(SELECT COUNT(*) FROM ${quotedIdentifier(table)} ` + `WHERE ${quotedIdentifier(column)} = ?) AS ${quotedIdentifier(key)}`).join(`,
+`);
+  const row = db.get(`SELECT
+${projections}`, ...MEMENTOS_PROJECT_REFERENCE_SURFACES.map(() => projectId));
+  return Object.fromEntries(MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ key }) => [key, Number(row[key] ?? 0)]));
+}
+function hasMementosProjectReferences(counts) {
+  return MEMENTOS_PROJECT_REFERENCE_SURFACES.some(({ key }) => counts[key] > 0);
+}
+function deleteMementosProjectIfUnreferenced(db, projectId) {
+  const guards = MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ table, column }) => `NOT EXISTS (SELECT 1 FROM ${quotedIdentifier(table)} ` + `WHERE ${quotedIdentifier(column)} = ?)`).join(`
+      AND `);
+  const result = db.run(`DELETE FROM projects
+     WHERE id = ?
+       AND ${guards}`, projectId, ...MEMENTOS_PROJECT_REFERENCE_SURFACES.map(() => projectId));
+  return result.changes;
+}
+
+// src/project-registration/authority.ts
+var WORKSPACE_ID_PATTERN = /^wks_[A-Za-z0-9][A-Za-z0-9_-]{11,}$/;
+var OPERATION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+var STEP_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var IDEMPOTENCY_PATTERN = /^prk_[0-9a-f]{48}$/;
+var PROJECT_ID_PATTERN = /^mm_project_[0-9a-f]{40}$/;
+
+class WriteBoundaryError extends Error {
+  point;
+  cause;
+  constructor(point, cause) {
+    super(`Mementos project registration failed at ${point}`);
+    this.point = point;
+    this.cause = cause;
+  }
+}
+function canonicalMementosProjectRegistrationJson(value) {
+  return JSON.stringify(canonicalize2(value));
+}
+function canonicalize2(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize2);
+  if (!value || typeof value !== "object")
+    return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      out[key] = canonicalize2(item);
+  }
+  return out;
+}
+function digestMementosProjectRegistrationValue(value) {
+  return createHash3("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
+}
+function digestOwnedPath(path) {
+  return createHash3("sha256").update(path).digest("hex");
+}
+function deriveMementosProjectRegistrationIdempotencyKey(input) {
+  return `prk_${digestMementosProjectRegistrationValue({
+    route: MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE,
+    operation_id: input.operation_id,
+    step_id: input.step_id,
+    direction: input.direction,
+    target_selector: input.target_selector,
+    request_digest: input.request_digest,
+    precondition_digest: input.precondition_digest
+  }).slice(0, 48)}`;
+}
+function responseBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function assertBounds(bounds) {
+  if (!Number.isSafeInteger(bounds.response_byte_limit) || bounds.response_byte_limit <= 0) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "response_byte_limit must be a positive integer");
+  }
+  if (!Number.isSafeInteger(bounds.time_budget_ms) || bounds.time_budget_ms <= 0) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "time_budget_ms must be a positive integer");
+  }
+}
+function assertWithinBounds(value, bounds, startedAt) {
+  const bytes = responseBytes(value);
+  if (bytes > bounds.response_byte_limit) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RESPONSE_TOO_LARGE", `registration response requires ${bytes} bytes but the bound is ${bounds.response_byte_limit}`, { response_bytes: bytes, response_byte_limit: bounds.response_byte_limit });
+  }
+  const elapsed = Date.now() - startedAt;
+  if (elapsed > bounds.time_budget_ms) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_TIME_BUDGET_EXCEEDED", `registration call took ${elapsed}ms but the bound is ${bounds.time_budget_ms}ms`, { elapsed_ms: elapsed, time_budget_ms: bounds.time_budget_ms });
+  }
+  return { response_bytes: bytes, elapsed_ms: elapsed };
+}
+function withResponseControl(receipt, bounds, startedAt) {
+  const result = {
+    receipt,
+    response_control: {
+      response_byte_limit: bounds.response_byte_limit,
+      time_budget_ms: bounds.time_budget_ms,
+      response_bytes: 0,
+      elapsed_ms: 0,
+      complete: true,
+      truncated: false
+    }
+  };
+  for (let attempt = 0;attempt < 8; attempt += 1) {
+    const measured2 = assertWithinBounds(result, bounds, startedAt);
+    const stable = result.response_control.response_bytes === measured2.response_bytes && result.response_control.elapsed_ms === measured2.elapsed_ms;
+    result.response_control.response_bytes = measured2.response_bytes;
+    result.response_control.elapsed_ms = measured2.elapsed_ms;
+    if (stable)
+      break;
+  }
+  const measured = assertWithinBounds(result, bounds, startedAt);
+  result.response_control.response_bytes = measured.response_bytes;
+  result.response_control.elapsed_ms = measured.elapsed_ms;
+  return result;
+}
+function requireString(value, field, options = {}) {
+  const min = options.min ?? 1;
+  const max = options.max ?? 512;
+  if (typeof value !== "string" || value.length < min || value.length > max || /[\u0000-\u001f]/.test(value) || options.pattern && !options.pattern.test(value)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} is not a valid bounded registration identifier`);
+  }
+  return value;
+}
+function exactKeys(value, expected, field) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (actual.length !== wanted.length || actual.some((key, i) => key !== wanted[i])) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} must contain exactly: ${wanted.join(", ")}`);
+  }
+}
+function ownedPath(target) {
+  if (!target || typeof target.withOwnedPath !== "function") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target must be a package-owned path handle");
+  }
+  const path = target.withOwnedPath((value) => value);
+  requireString(path, "target path", { max: 4096 });
+  if (path !== resolve3(path)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target path must already be canonical and absolute");
+  }
+  return path;
+}
+function normalizedCallDigest(request) {
+  return digestMementosProjectRegistrationValue({
+    authority_route: request.authority_route,
+    package_version: request.package_version,
+    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,
+    resource_kind: request.resource_kind,
+    direction: request.direction,
+    target_selector: request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    project_id: request.project_id,
+    project_slug: request.project_slug,
+    project_name: request.project_name,
+    desired: request.desired,
+    accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
+  });
+}
+function publicReceipt(row) {
+  const { target_selector: _selector, normalized_call_digest: _digest, ...receipt } = row;
+  return receipt;
+}
+function timestampString3(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function receiptFromRow2(row) {
+  return {
+    ...row,
+    authority: "mementos",
+    resource_kind: "project",
+    created_by_operation: row["created_by_operation"] === true || Number(row["created_by_operation"]) === 1,
+    created_at: timestampString3(row["created_at"])
+  };
+}
+function bindingFromRow(row) {
+  return {
+    ...row,
+    created_at: timestampString3(row["created_at"]),
+    updated_at: timestampString3(row["updated_at"])
+  };
+}
+function getStoredReceipt(db, receiptId) {
+  const row = db.get("SELECT * FROM mementos_project_registration_receipts WHERE receipt_id = ? LIMIT 1", receiptId);
+  return row ? receiptFromRow2(row) : null;
+}
+function getAcceptedReceipt(db, request) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_receipts
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND operation_id = ? AND step_id = ? AND resource_kind = 'project'
+      AND direction = ? AND outcome = 'accepted'
+    ORDER BY created_at ASC, receipt_id ASC
+    LIMIT 1
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.operation_id, request.step_id, request.direction);
+  return row ? receiptFromRow2(row) : null;
+}
+function getReceiptForLookup(db, request) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_receipts
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND operation_id = ? AND step_id = ? AND resource_kind = 'project'
+      AND direction = ? AND idempotency_key = ? AND target_selector = ?
+    ORDER BY CASE outcome
+      WHEN 'terminal_nonacceptance' THEN 0
+      WHEN 'duplicate_of_accepted' THEN 1
+      ELSE 2
+    END, created_at DESC, receipt_id DESC
+    LIMIT 1
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.operation_id, request.step_id, request.direction, request.idempotency_key, request.target_selector);
+  return row ? receiptFromRow2(row) : null;
+}
+function getBinding(db, capability, targetSelector) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_bindings
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+    LIMIT 1
+  `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
+  return row ? bindingFromRow(row) : null;
+}
+function getProjectByExactId3(db, id) {
+  const row = db.get("SELECT * FROM projects WHERE id = ? LIMIT 1", id);
+  if (!row)
+    return null;
+  return {
+    id: String(row["id"]),
+    name: String(row["name"]),
+    path: String(row["path"]),
+    description: row["description"] === null ? null : String(row["description"]),
+    memory_prefix: row["memory_prefix"] === null ? null : String(row["memory_prefix"]),
+    created_at: timestampString3(row["created_at"]),
+    updated_at: timestampString3(row["updated_at"])
+  };
+}
+function getProjectByPath(db, path) {
+  const row = db.get("SELECT * FROM projects WHERE path = ? LIMIT 1", path);
+  return row ? getProjectByExactId3(db, String(row["id"])) : null;
+}
+function projectRecord(db, project, references = mementosProjectReferenceCounts(db, project.id)) {
+  return {
+    target_id: project.id,
+    revision: project.updated_at,
+    digest: digestMementosProjectRegistrationValue({
+      id: project.id,
+      name: project.name,
+      path: project.path,
+      description: project.description,
+      memory_prefix: project.memory_prefix,
+      created_at: project.created_at,
+      updated_at: project.updated_at,
+      references
+    })
+  };
+}
+function targetId(capability, selector) {
+  return `mm_project_${digestMementosProjectRegistrationValue({
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    selector
+  }).slice(0, 40)}`;
+}
+function receiptId(input) {
+  return `mmpr_${digestMementosProjectRegistrationValue(input).slice(0, 40)}`;
+}
+function makeReceipt2(request, capability, callDigest, now2, values) {
+  const withoutId = {
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+    package_version: capability.package_version,
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    resource_kind: "project",
+    direction: request.direction,
+    target_selector: values.target_selector ?? request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    normalized_call_digest: callDigest,
+    outcome: values.outcome,
+    reason: values.reason ?? null,
+    target_id: values.target_id ?? null,
+    result_revision: values.result_revision ?? null,
+    result_digest: values.result_digest ?? null,
+    duplicate_of_receipt_id: values.duplicate_of_receipt_id ?? null,
+    accepted_receipt_id: values.accepted_receipt_id ?? null,
+    created_by_operation: values.created_by_operation ?? false
+  };
+  return {
+    receipt_id: receiptId(withoutId),
+    ...withoutId,
+    created_at: now2
+  };
+}
+function insertReceipt2(db, receipt) {
+  db.run(`
+    INSERT INTO mementos_project_registration_receipts (
+      receipt_id, authority, route, package_version, authority_id, tenant_id,
+      corpus_id, operation_id, step_id, resource_kind, direction,
+      target_selector, idempotency_key, request_digest, precondition_digest,
+      normalized_call_digest, outcome, reason, target_id, result_revision,
+      result_digest, duplicate_of_receipt_id, accepted_receipt_id,
+      created_by_operation, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT DO NOTHING
+  `, 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.resource_kind, receipt.direction, receipt.target_selector, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.normalized_call_digest, receipt.outcome, receipt.reason, receipt.target_id, receipt.result_revision, receipt.result_digest, receipt.duplicate_of_receipt_id, receipt.accepted_receipt_id, receipt.created_by_operation, receipt.created_at);
+  const stored = getStoredReceipt(db, receipt.receipt_id);
+  const withoutCreatedAt = (value) => {
+    const { created_at: _createdAt, ...logical } = value;
+    return logical;
+  };
+  if (!stored || canonicalMementosProjectRegistrationJson(withoutCreatedAt(stored)) !== canonicalMementosProjectRegistrationJson(withoutCreatedAt(receipt))) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "immutable receipt id resolved to different content");
+  }
+  return stored;
+}
+function insertBinding(db, request, callDigest, now2) {
+  const result = db.run(`
+    INSERT INTO mementos_project_registration_bindings (
+      authority_id, tenant_id, corpus_id, resource_kind, target_selector,
+      operation_id, step_id, direction, idempotency_key, request_digest,
+      precondition_digest, normalized_call_digest, state, target_id,
+      accepted_receipt_id, result_revision, result_digest, removed_receipt_id,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, 'project', ?, ?, ?, 'forward', ?, ?, ?, ?, 'pending',
+      NULL, NULL, NULL, NULL, NULL, ?, ?)
+    ON CONFLICT DO NOTHING
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector, request.operation_id, request.step_id, request.idempotency_key, request.request_digest, request.precondition_digest, callDigest, now2, now2);
+  return result.changes === 1;
+}
+function lockBinding(db, capability, targetSelector) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET updated_at = updated_at
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+  `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
+  return result.changes === 1;
+}
+function setBindingAccepted(db, request, receipt, now2) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET state = 'accepted', target_id = ?, accepted_receipt_id = ?,
+      result_revision = ?, result_digest = ?, updated_at = ?
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ? AND state = 'pending'
+  `, receipt.target_id, receipt.receipt_id, receipt.result_revision, receipt.result_digest, now2, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector);
+  if (result.changes !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not pending at acceptance");
+  }
+}
+function setBindingRemoved(db, accepted, inverseReceiptId, now2) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET state = 'removed', removed_receipt_id = ?, updated_at = ?
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+      AND state = 'accepted' AND accepted_receipt_id = ?
+  `, inverseReceiptId, now2, accepted.authority_id, accepted.tenant_id, accepted.corpus_id, accepted.target_selector, accepted.receipt_id);
+  if (result.changes !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not accepted at inverse");
+  }
+}
+function capabilityMatches(request, capability) {
+  return request.authority_route === capability.route && request.package_version === capability.package_version && request.authority_id === capability.authority_id && request.tenant_id === capability.tenant_id && request.corpus_id === capability.corpus_id;
+}
+function assertCommonRequest(request, capability) {
+  assertBounds(request);
+  if (request.resource_kind !== "project") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
+  }
+  if (request.direction !== "forward" && request.direction !== "inverse") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "direction must be forward or inverse");
+  }
+  if (!capabilityMatches(request, capability)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "registration request does not match this authority capability identity");
+  }
+  requireString(request.operation_id, "operation_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.step_id, "step_id", { min: 3, max: 128, pattern: STEP_PATTERN });
+  requireString(request.target_selector, "target_selector", { max: 512 });
+  requireString(request.project_id, "project_id", {
+    min: 16,
+    max: 128,
+    pattern: WORKSPACE_ID_PATTERN
+  });
+  requireString(request.project_name, "project_name", { max: 256 });
+  requireString(request.project_slug, "project_slug", { max: 128 });
+  requireString(request.request_digest, "request_digest", {
+    min: 64,
+    max: 64,
+    pattern: SHA256_PATTERN
+  });
+  requireString(request.precondition_digest, "precondition_digest", {
+    min: 64,
+    max: 64,
+    pattern: SHA256_PATTERN
+  });
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 52,
+    max: 52,
+    pattern: IDEMPOTENCY_PATTERN
+  });
+  if (!request.desired || typeof request.desired !== "object" || Array.isArray(request.desired)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "desired must be a JSON object");
+  }
+  if (digestMementosProjectRegistrationValue(request.desired) !== request.request_digest) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "request_digest does not match the canonical desired payload");
+  }
+  const expectedKey = deriveMementosProjectRegistrationIdempotencyKey(request);
+  if (request.idempotency_key !== expectedKey) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "idempotency_key does not match the deterministic request", { expected: expectedKey });
+  }
+}
+function assertForwardRequest2(request, capability) {
+  assertCommonRequest(request, capability);
+  if (request.direction !== "forward" || request.accepted_receipt !== undefined) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional create requires a forward request without an accepted receipt");
+  }
+  exactKeys(request.desired, [
+    "name",
+    "source_project_id",
+    "source_project_slug",
+    "target_path_digest"
+  ], "forward desired");
+  if (request.target_selector !== request.project_id || request.desired["source_project_id"] !== request.project_id || request.desired["source_project_slug"] !== request.project_slug || request.desired["name"] !== request.project_name) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "forward project identity fields disagree");
+  }
+  const expectedPrecondition = digestMementosProjectRegistrationValue({
+    target_selector: request.target_selector,
+    expected: "absent"
+  });
+  if (request.precondition_digest !== expectedPrecondition) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "forward precondition must bind expected absence");
+  }
+  const path = ownedPath(request.target);
+  if (request.desired["target_path_digest"] !== digestOwnedPath(path)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "target path does not match the package-owned digest");
+  }
+  return path;
+}
+function sameReceipt(left, right) {
+  return canonicalMementosProjectRegistrationJson(publicReceipt(left)) === canonicalMementosProjectRegistrationJson(right);
+}
+function assertInverseRequest(request, capability) {
+  assertCommonRequest(request, capability);
+  if (request.direction !== "inverse" || !request.accepted_receipt) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional inverse requires the accepted forward receipt");
+  }
+  const accepted = request.accepted_receipt;
+  if (accepted.authority !== "mementos" || accepted.route !== capability.route || accepted.package_version !== capability.package_version || accepted.authority_id !== capability.authority_id || accepted.tenant_id !== capability.tenant_id || accepted.corpus_id !== capability.corpus_id || accepted.operation_id !== request.operation_id || accepted.step_id !== request.step_id || accepted.resource_kind !== "project" || accepted.direction !== "forward" || accepted.outcome !== "accepted" || !accepted.created_by_operation || !accepted.target_id || !accepted.result_revision || !accepted.result_digest || request.target_selector !== accepted.target_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "accepted receipt is not an exact attempt-created forward receipt");
+  }
+  exactKeys(request.desired, ["accepted_receipt_id", "target_id"], "inverse desired");
+  if (request.desired["accepted_receipt_id"] !== accepted.receipt_id || request.desired["target_id"] !== accepted.target_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "inverse desired payload does not bind the accepted receipt");
+  }
+  const expectedPrecondition = digestMementosProjectRegistrationValue({
+    expected_revision: accepted.result_revision,
+    expected_digest: accepted.result_digest
+  });
+  if (request.precondition_digest !== expectedPrecondition) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "inverse precondition does not bind the accepted object state");
+  }
+  return accepted;
+}
+function assertLookup(request, capability) {
+  assertBounds(request);
+  if (request.max_items !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "terminal receipt lookup requires max_items exactly 1");
+  }
+  if (request.authority !== "mementos" || request.resource_kind !== "project" || request.authority_route !== capability.route || request.package_version !== capability.package_version || request.authority_id !== capability.authority_id || request.tenant_id !== capability.tenant_id || request.corpus_id !== capability.corpus_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "receipt lookup does not match this authority capability identity");
+  }
+  requireString(request.operation_id, "operation_id", { pattern: OPERATION_PATTERN });
+  requireString(request.step_id, "step_id", { pattern: STEP_PATTERN });
+  requireString(request.target_selector, "target_selector");
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 52,
+    max: 52,
+    pattern: IDEMPOTENCY_PATTERN
+  });
+  if (request.target_id !== undefined) {
+    requireString(request.target_id, "target_id", {
+      min: 51,
+      max: 51,
+      pattern: PROJECT_ID_PATTERN
+    });
+  }
+}
+
+class PackageOwnedMementosProjectRegistrationAuthority {
+  db;
+  authority = "mementos";
+  capabilityValue;
+  now;
+  faultInjector;
+  constructor(db, options = {}) {
+    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
+    };
+  }
+  fault(point, request) {
+    this.faultInjector?.(point, {
+      operation_id: request.operation_id,
+      step_id: request.step_id,
+      resource_kind: "project",
+      direction: request.direction
+    });
+  }
+  writeBoundary(point, request) {
+    try {
+      this.fault(point, request);
+    } catch (cause) {
+      throw new WriteBoundaryError(point, cause);
+    }
+  }
+  terminal(request, callDigest, reason, values = {}) {
+    return insertReceipt2(this.db, makeReceipt2(request, this.capabilityValue, callDigest, this.now(), {
+      outcome: "terminal_nonacceptance",
+      reason,
+      target_id: values.target_id,
+      accepted_receipt_id: values.accepted_receipt_id,
+      target_selector: values.target_selector
+    }));
+  }
+  duplicateForwardOrTerminal(request, callDigest, path, accepted) {
+    if (accepted.normalized_call_digest !== callDigest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "accepted operation/step identity is bound to a different request");
+    }
+    const project = accepted.target_id ? getProjectByExactId3(this.db, accepted.target_id) : null;
+    if (!project || project.path !== path) {
+      return this.terminal(request, callDigest, "accepted_target_missing_or_replaced", {
+        target_id: accepted.target_id
+      });
+    }
+    const record = projectRecord(this.db, project);
+    if (record.revision !== accepted.result_revision || record.digest !== accepted.result_digest) {
+      return this.terminal(request, callDigest, "accepted_target_drifted", {
+        target_id: accepted.target_id
+      });
+    }
+    return insertReceipt2(this.db, makeReceipt2(request, this.capabilityValue, callDigest, this.now(), {
+      outcome: "duplicate_of_accepted",
+      target_id: accepted.target_id,
+      result_revision: accepted.result_revision,
+      result_digest: accepted.result_digest,
+      duplicate_of_receipt_id: accepted.receipt_id,
+      created_by_operation: false
+    }));
+  }
+  async capability() {
+    return {
+      ...this.capabilityValue,
+      supported_resources: ["project"]
+    };
+  }
+  async create(request) {
+    const startedAt = Date.now();
+    const path = assertForwardRequest2(request, this.capabilityValue);
+    const callDigest = normalizedCallDigest(request);
+    let stored;
+    try {
+      stored = this.db.transaction(() => {
+        const exact = getReceiptForLookup(this.db, {
+          ...request,
+          authority: "mementos",
+          max_items: 1
+        });
+        if (exact?.outcome === "terminal_nonacceptance")
+          return exact;
+        const accepted = getAcceptedReceipt(this.db, request);
+        if (accepted) {
+          return this.duplicateForwardOrTerminal(request, callDigest, path, accepted);
+        }
+        const existing = getProjectByPath(this.db, path) ?? getProjectByExactId3(this.db, targetId(this.capabilityValue, request.target_selector));
+        if (existing) {
+          return this.terminal(request, callDigest, "target_preexists", {
+            target_id: existing.id
+          });
+        }
+        const now2 = this.now();
+        const insertedBinding = insertBinding(this.db, request, callDigest, now2);
+        if (!lockBinding(this.db, this.capabilityValue, request.target_selector)) {
+          throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding disappeared before it could be locked");
+        }
+        const ownedBinding = getBinding(this.db, this.capabilityValue, request.target_selector);
+        if (!ownedBinding || ownedBinding.normalized_call_digest !== callDigest) {
+          return this.terminal(request, callDigest, "target_selector_preexists", {
+            target_id: ownedBinding?.target_id
+          });
+        }
+        const acceptedAfterBinding = getAcceptedReceipt(this.db, request);
+        if (acceptedAfterBinding) {
+          return this.duplicateForwardOrTerminal(request, callDigest, path, acceptedAfterBinding);
+        }
+        if (!insertedBinding || ownedBinding.state !== "pending") {
+          return this.terminal(request, callDigest, "target_selector_preexists", {
+            target_id: ownedBinding.target_id
+          });
+        }
+        const id = targetId(this.capabilityValue, request.target_selector);
+        this.writeBoundary("before_object_write", request);
+        try {
+          this.db.run(`
+            INSERT INTO projects (
+              id, name, path, description, memory_prefix, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+          `, id, request.project_name, path, null, request.project_slug, now2, now2);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_object_write", cause);
+        }
+        this.writeBoundary("after_object_write", request);
+        const project = getProjectByExactId3(this.db, id);
+        if (!project || project.path !== path) {
+          throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "project write did not read back by its full id");
+        }
+        const record = projectRecord(this.db, project);
+        const acceptedReceipt = makeReceipt2(request, this.capabilityValue, callDigest, now2, {
+          outcome: "accepted",
+          target_id: record.target_id,
+          result_revision: record.revision,
+          result_digest: record.digest,
+          created_by_operation: true
+        });
+        this.writeBoundary("before_receipt_write", request);
+        let inserted;
+        try {
+          inserted = insertReceipt2(this.db, acceptedReceipt);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_receipt_write", cause);
+        }
+        this.writeBoundary("after_receipt_write", request);
+        setBindingAccepted(this.db, request, inserted, now2);
+        return inserted;
+      });
+    } catch (error) {
+      if (!(error instanceof WriteBoundaryError))
+        throw error;
+      stored = this.db.transaction(() => this.terminal(request, callDigest, `write_failed:${error.point}`));
+    }
+    this.fault("after_commit", request);
+    const receipt = publicReceipt(stored);
+    assertWithinBounds(receipt, request, startedAt);
+    return receipt;
+  }
+  async readExact(request) {
+    const startedAt = Date.now();
+    assertBounds(request);
+    if (request.resource_kind !== "project") {
+      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
+    });
+    const path = ownedPath(request.target);
+    const project = getProjectByExactId3(this.db, request.target_id);
+    if (!project || project.path !== path) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "exact full-id project readback did not resolve the owned path");
+    }
+    const record = projectRecord(this.db, project);
+    assertWithinBounds(record, request, startedAt);
+    return record;
+  }
+  async lookupReceipt(request) {
+    const startedAt = Date.now();
+    assertLookup(request, this.capabilityValue);
+    const receipt = getReceiptForLookup(this.db, request);
+    if (!receipt || request.target_id !== undefined && receipt.target_id !== request.target_id) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "exact immutable terminal receipt was not found");
+    }
+    return withResponseControl(publicReceipt(receipt), request, startedAt);
+  }
+  async compensate(request) {
+    const startedAt = Date.now();
+    const acceptedPublic = assertInverseRequest(request, this.capabilityValue);
+    const callDigest = normalizedCallDigest(request);
+    const storedAccepted = getStoredReceipt(this.db, acceptedPublic.receipt_id);
+    if (!storedAccepted || !sameReceipt(storedAccepted, acceptedPublic)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND", "accepted forward receipt is not stored immutably in this authority");
+    }
+    const path = ownedPath(request.target);
+    let stored;
+    try {
+      stored = this.db.transaction(() => {
+        const exact = getReceiptForLookup(this.db, {
+          ...request,
+          authority: "mementos",
+          max_items: 1
+        });
+        if (exact?.outcome === "terminal_nonacceptance")
+          return exact;
+        if (!lockBinding(this.db, this.capabilityValue, storedAccepted.target_selector)) {
+          return this.terminal(request, callDigest, "accepted_binding_missing", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const binding = getBinding(this.db, this.capabilityValue, storedAccepted.target_selector);
+        if (!binding || binding.accepted_receipt_id !== storedAccepted.receipt_id) {
+          return this.terminal(request, callDigest, "accepted_binding_replaced", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const prior = getAcceptedReceipt(this.db, request);
+        if (prior) {
+          if (prior.normalized_call_digest !== callDigest || prior.accepted_receipt_id !== storedAccepted.receipt_id) {
+            throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "inverse operation/step identity is bound to a different request");
+          }
+          return insertReceipt2(this.db, makeReceipt2(request, this.capabilityValue, callDigest, this.now(), {
+            outcome: "duplicate_of_accepted",
+            target_id: prior.target_id,
+            result_revision: prior.result_revision,
+            result_digest: prior.result_digest,
+            duplicate_of_receipt_id: prior.receipt_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          }));
+        }
+        if (binding.state !== "accepted") {
+          return this.terminal(request, callDigest, "accepted_binding_not_active", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const project = getProjectByExactId3(this.db, storedAccepted.target_id);
+        if (!project) {
+          return this.terminal(request, callDigest, "target_missing", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        if (project.path !== path) {
+          return this.terminal(request, callDigest, "target_drifted", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const references = mementosProjectReferenceCounts(this.db, project.id);
+        if (hasMementosProjectReferences(references)) {
+          return this.terminal(request, callDigest, "target_has_dependents", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const current = projectRecord(this.db, project, references);
+        if (current.revision !== storedAccepted.result_revision || current.digest !== storedAccepted.result_digest) {
+          return this.terminal(request, callDigest, "target_drifted", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        this.writeBoundary("before_object_write", request);
+        let deleted;
+        try {
+          deleted = deleteMementosProjectIfUnreferenced(this.db, storedAccepted.target_id);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_object_write", cause);
+        }
+        if (deleted !== 1) {
+          const remaining = getProjectByExactId3(this.db, storedAccepted.target_id);
+          if (remaining && hasMementosProjectReferences(mementosProjectReferenceCounts(this.db, storedAccepted.target_id))) {
+            return this.terminal(request, callDigest, "target_has_dependents", {
+              target_id: storedAccepted.target_id,
+              accepted_receipt_id: storedAccepted.receipt_id
+            });
+          }
+          throw new WriteBoundaryError("before_object_write", new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "conditional inverse did not delete exactly one unreferenced project"));
+        }
+        this.writeBoundary("after_object_write", request);
+        const inverseRecord = {
+          target_id: storedAccepted.target_id,
+          revision: "absent",
+          digest: digestMementosProjectRegistrationValue({
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id,
+            absent: true
+          })
+        };
+        const inverseReceipt = makeReceipt2(request, this.capabilityValue, callDigest, this.now(), {
+          outcome: "accepted",
+          target_id: inverseRecord.target_id,
+          result_revision: inverseRecord.revision,
+          result_digest: inverseRecord.digest,
+          accepted_receipt_id: storedAccepted.receipt_id,
+          created_by_operation: false
+        });
+        this.writeBoundary("before_receipt_write", request);
+        let inserted;
+        try {
+          inserted = insertReceipt2(this.db, inverseReceipt);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_receipt_write", cause);
+        }
+        this.writeBoundary("after_receipt_write", request);
+        setBindingRemoved(this.db, storedAccepted, inserted.receipt_id, this.now());
+        return inserted;
+      });
+    } catch (error) {
+      if (!(error instanceof WriteBoundaryError))
+        throw error;
+      stored = this.db.transaction(() => this.terminal(request, callDigest, `write_failed:${error.point}`, {
+        target_id: storedAccepted.target_id,
+        accepted_receipt_id: storedAccepted.receipt_id
+      }));
+    }
+    this.fault("after_commit", request);
+    const receipt = publicReceipt(stored);
+    assertWithinBounds(receipt, request, startedAt);
+    return receipt;
+  }
+  async verifyInverse(request) {
+    const startedAt = Date.now();
+    const accepted = assertInverseRequest(request, this.capabilityValue);
+    const storedAccepted = getStoredReceipt(this.db, accepted.receipt_id);
+    if (!storedAccepted || !sameReceipt(storedAccepted, accepted)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND", "accepted forward receipt is not stored immutably in this authority");
+    }
+    const inverse = getAcceptedReceipt(this.db, request);
+    if (!inverse || inverse.outcome !== "accepted" || inverse.accepted_receipt_id !== accepted.receipt_id || inverse.result_revision !== "absent" || !inverse.result_digest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "accepted conditional inverse receipt was not found");
+    }
+    if (getProjectByExactId3(this.db, accepted.target_id)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "inverse verification found the accepted target still present");
+    }
+    const verification = {
+      target_id: accepted.target_id,
+      accepted_receipt_id: accepted.receipt_id,
+      absent: true,
+      digest: digestMementosProjectRegistrationValue({
+        target_id: accepted.target_id,
+        accepted_receipt_id: accepted.receipt_id,
+        absent: true
+      })
+    };
+    assertWithinBounds(verification, request, startedAt);
+    if (verification.digest !== inverse.result_digest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "inverse verification digest does not match its immutable receipt");
+    }
+    return verification;
+  }
+}
+function createMementosProjectRegistrationAuthority(db, options = {}) {
+  return new PackageOwnedMementosProjectRegistrationAuthority(db, options);
+}
+// src/project-registration/http.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+
+class WirePathHandle {
+  absolutePath;
+  constructor(absolutePath) {
+    this.absolutePath = absolutePath;
+  }
+  withOwnedPath(consumer) {
+    return consumer(this.absolutePath);
+  }
+}
+function json2(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function errorStatus(error) {
+  switch (error.code) {
+    case "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT":
+    case "MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS":
+    case "MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_EXACT_ID_REQUIRED":
+      return 400;
+    case "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND":
+    case "MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND":
+    case "MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND":
+      return 404;
+    case "MEMENTOS_PROJECT_REGISTRATION_RESPONSE_TOO_LARGE":
+      return 413;
+    case "MEMENTOS_PROJECT_REGISTRATION_TIME_BUDGET_EXCEEDED":
+      return 408;
+    case "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE":
+      return 503;
+    default:
+      return 409;
+  }
+}
+async function readJson2(request) {
+  try {
+    const value = await request.json();
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function fromWireRequest(body) {
+  const { canonical_path: canonicalPath, ...request } = body;
+  if (typeof canonicalPath !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "canonical_path is required on the private registration transport");
+  }
+  return {
+    ...request,
+    target: new WirePathHandle(canonicalPath)
+  };
+}
+function fromWireReadRequest(body) {
+  const { canonical_path: canonicalPath, ...request } = body;
+  if (typeof canonicalPath !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "canonical_path is required on the private exact-read transport");
+  }
+  return {
+    ...request,
+    target: new WirePathHandle(canonicalPath)
+  };
+}
+async function handleMementosProjectRegistrationHttpRequest(request, url, authority, basePath = "/v1/project-registration") {
+  const path = url.pathname;
+  if (path !== basePath && !path.startsWith(`${basePath}/`))
+    return null;
+  const action = path.slice(basePath.length).split("/").filter(Boolean).join("/");
+  const method = request.method.toUpperCase();
+  try {
+    if ((action === "" || action === "capability") && method === "GET") {
+      return json2({ capability: await authority.capability() });
+    }
+    if (method !== "POST")
+      return json2({ error: "method not allowed" }, 405);
+    const body = await readJson2(request);
+    if (!body) {
+      return json2({
+        error: "invalid JSON body",
+        code: "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT"
+      }, 400);
+    }
+    if (action === "create") {
+      return json2({ receipt: await authority.create(fromWireRequest(body)) }, 201);
+    }
+    if (action === "receipts/lookup") {
+      return json2(await authority.lookupReceipt(body));
+    }
+    if (action === "read-exact") {
+      return json2({ record: await authority.readExact(fromWireReadRequest(body)) });
+    }
+    if (action === "compensate") {
+      return json2({ receipt: await authority.compensate(fromWireRequest(body)) }, 201);
+    }
+    if (action === "verify-inverse") {
+      return json2({ verification: await authority.verifyInverse(fromWireRequest(body)) });
+    }
+    return json2({
+      error: "unknown Mementos project-registration route",
+      code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
+    }, 404);
+  } catch (cause) {
+    if (cause instanceof MementosProjectRegistrationError) {
+      return json2({
+        error: cause.message,
+        code: cause.code,
+        details: cause.details,
+        authoritative: true
+      }, errorStatus(cause));
+    }
+    return json2({
+      error: cause instanceof Error ? cause.message : "internal registration error",
+      code: "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE"
+    }, 500);
+  }
+}
+// src/server/routes/project-registration.ts
+init_router();
+var handle = async (request, url) => {
+  const basePath = url.pathname.startsWith("/v1/") ? "/v1/project-registration" : "/api/project-registration";
+  const response = await handleMementosProjectRegistrationHttpRequest(request, url, createMementosProjectRegistrationAuthority(getDatabase()), basePath);
+  return response ?? new Response(JSON.stringify({ error: "Not found" }), {
+    status: 404,
+    headers: { "Content-Type": "application/json" }
+  });
+};
+addRoute("GET", "/api/project-registration", handle);
+addRoute("GET", "/api/project-registration/capability", handle);
+addRoute("POST", "/api/project-registration/create", handle);
+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);
+
 // src/server/routes/entities.ts
 init_entities();
 init_relations();
@@ -57737,12 +60172,12 @@ function executeAddTag(proposal, d) {
   return { old_tags: rollback };
 }
 function executeMerge(proposal, d) {
-  const targetId = proposal.target_memory_id;
-  if (!targetId)
+  const targetId2 = proposal.target_memory_id;
+  if (!targetId2)
     throw new Error("merge proposal missing target_memory_id");
-  const target = getMemory(targetId, d);
+  const target = getMemory(targetId2, d);
   if (!target)
-    throw new Error(`Target memory ${targetId} not found`);
+    throw new Error(`Target memory ${targetId2} not found`);
   const rollback = {
     target_old_value: target.value,
     target_old_version: target.version,
@@ -57750,7 +60185,7 @@ function executeMerge(proposal, d) {
   };
   const sourceValues = [];
   for (const memId of proposal.memory_ids) {
-    if (memId === targetId)
+    if (memId === targetId2)
       continue;
     const mem = getMemory(memId, d);
     if (!mem)
@@ -57761,9 +60196,9 @@ function executeMerge(proposal, d) {
   const mergedValue = proposal.proposed_changes["merged_value"] ?? [target.value, ...sourceValues].join(`
 ---
 `);
-  d.run("UPDATE memories SET value = ?, version = version + 1, updated_at = ? WHERE id = ?", [mergedValue, now(), targetId]);
+  d.run("UPDATE memories SET value = ?, version = version + 1, updated_at = ? WHERE id = ?", [mergedValue, now(), targetId2]);
   for (const memId of proposal.memory_ids) {
-    if (memId === targetId)
+    if (memId === targetId2)
       continue;
     d.run("UPDATE memories SET status = 'archived', updated_at = ? WHERE id = ?", [now(), memId]);
   }
@@ -57853,9 +60288,9 @@ function rollbackProposal(proposal, d) {
         const targetOldValue = rb["target_old_value"];
         const targetOldVersion = rb["target_old_version"];
         const archivedMemories = rb["archived_memories"];
-        const targetId = proposal.target_memory_id;
-        if (targetId && targetOldValue !== undefined && targetOldVersion !== undefined) {
-          d.run("UPDATE memories SET value = ?, version = ?, updated_at = ? WHERE id = ?", [targetOldValue, targetOldVersion, now(), targetId]);
+        const targetId2 = proposal.target_memory_id;
+        if (targetId2 && targetOldValue !== undefined && targetOldVersion !== undefined) {
+          d.run("UPDATE memories SET value = ?, version = ?, updated_at = ? WHERE id = ?", [targetOldValue, targetOldVersion, now(), targetId2]);
         }
         if (archivedMemories) {
           for (const [memId, status] of Object.entries(archivedMemories)) {
@@ -59453,18 +61888,18 @@ function pkgVersion() {
 }
 async function findFreePort(start) {
   const net = await import("net");
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = net.createServer();
     server.unref();
     server.on("error", () => {
-      resolve5(findFreePort(start + 1));
+      resolve6(findFreePort(start + 1));
     });
     server.listen(start, () => {
       const address = server.address();
       if (address && typeof address === "object") {
-        server.close(() => resolve5(address.port));
+        server.close(() => resolve6(address.port));
       } else {
-        resolve5(start);
+        resolve6(start);
       }
     });
   });
@@ -59639,15 +62074,15 @@ function startServer(port) {
         const dashDir = resolveDashboardDir();
         if (existsSync5(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
           if (pathname !== "/") {
-            const resolvedDash = resolve4(dashDir) + sep;
-            const requestedPath = resolve4(join6(dashDir, pathname));
+            const resolvedDash = resolve5(dashDir) + sep;
+            const requestedPath = resolve5(join7(dashDir, pathname));
             if (requestedPath.startsWith(resolvedDash)) {
               const staticRes = serveStaticFile(requestedPath);
               if (staticRes)
                 return staticRes;
             }
           }
-          const indexRes = serveStaticFile(join6(dashDir, "index.html"));
+          const indexRes = serveStaticFile(join7(dashDir, "index.html"));
           if (indexRes)
             return indexRes;
         }