@hasna/mementos 0.14.75 → 0.14.78

package/dist/index.js

@@ -1178,6 +1178,429 @@ var init_api_mode = __esm(() => {
   };
 });
 
+// src/project-registration/schema.ts
+function sqliteMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector),
+      UNIQUE(accepted_receipt_id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation BOOLEAN NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT UNIQUE,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TIMESTAMPTZ NOT NULL,
+      updated_at TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE OR REPLACE FUNCTION mementos_project_registration_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project registration receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_registration_receipts_immutable
+      ON mementos_project_registration_receipts;
+    CREATE TRIGGER mementos_project_registration_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_registration_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_registration_receipts_immutable();
+  `;
+}
+function sqliteMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json TEXT NOT NULL,
+      after_project_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json JSONB NOT NULL,
+      after_project_json JSONB NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE OR REPLACE FUNCTION mementos_project_update_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project update receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_update_receipts_immutable
+      ON mementos_project_update_receipts;
+    CREATE TRIGGER mementos_project_update_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_update_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_update_receipts_immutable();
+  `;
+}
+
+// src/memory-project-link/schema.ts
+function sqliteMementosMemoryProjectLinkSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_memory_project_link_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.memory-project-link.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN ('accepted', 'no_change')),
+      target_memory_id TEXT NOT NULL,
+      requested_project_id TEXT NOT NULL,
+      expected_memory_version INTEGER NOT NULL,
+      expected_memory_revision TEXT NOT NULL,
+      expected_project_revision TEXT,
+      result_memory_version INTEGER NOT NULL,
+      result_memory_revision TEXT NOT NULL,
+      result_memory_digest TEXT NOT NULL,
+      result_project_revision TEXT,
+      result_project_digest TEXT,
+      accepted_receipt_id TEXT,
+      before_link_json TEXT NOT NULL,
+      after_link_json TEXT NOT NULL,
+      before_project_revision TEXT,
+      before_project_digest TEXT,
+      after_project_revision TEXT,
+      after_project_digest TEXT,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_memory_project_link_receipts_target
+      ON mementos_memory_project_link_receipts(
+        authority_id, tenant_id, corpus_id, target_memory_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_memory_project_link_receipts_immutable_update
+    BEFORE UPDATE ON mementos_memory_project_link_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos memory project link receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_memory_project_link_receipts_immutable_delete
+    BEFORE DELETE ON mementos_memory_project_link_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos memory project link receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosMemoryProjectLinkSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_memory_project_link_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.memory-project-link.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN ('accepted', 'no_change')),
+      target_memory_id TEXT NOT NULL,
+      requested_project_id TEXT NOT NULL,
+      expected_memory_version INTEGER NOT NULL,
+      expected_memory_revision TEXT NOT NULL,
+      expected_project_revision TEXT,
+      result_memory_version INTEGER NOT NULL,
+      result_memory_revision TEXT NOT NULL,
+      result_memory_digest TEXT NOT NULL,
+      result_project_revision TEXT,
+      result_project_digest TEXT,
+      accepted_receipt_id TEXT,
+      before_link_json JSONB NOT NULL,
+      after_link_json JSONB NOT NULL,
+      before_project_revision TEXT,
+      before_project_digest TEXT,
+      after_project_revision TEXT,
+      after_project_digest TEXT,
+      created_at TIMESTAMPTZ NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_memory_project_link_receipts_target
+      ON mementos_memory_project_link_receipts(
+        authority_id, tenant_id, corpus_id, target_memory_id, created_at
+      );
+
+    CREATE OR REPLACE FUNCTION mementos_memory_project_link_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos memory project link receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_memory_project_link_receipts_immutable
+      ON mementos_memory_project_link_receipts;
+    CREATE TRIGGER mementos_memory_project_link_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_memory_project_link_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_memory_project_link_receipts_immutable();
+  `;
+}
+var MEMENTOS_MEMORY_PROJECT_LINK_ROUTE = "mementos.memory-project-link.v1", MEMORY_PROJECT_LINK_RECEIPT_COLUMNS;
+var init_schema = __esm(() => {
+  MEMORY_PROJECT_LINK_RECEIPT_COLUMNS = [
+    "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"
+  ];
+});
+
 // src/db/migrations.ts
 var MEMORY_VERSION_SNAPSHOT_TRIGGER = `
 CREATE TRIGGER IF NOT EXISTS memories_version_snapshot
@@ -1198,6 +1621,7 @@ BEGIN
 END;
 `, MIGRATIONS;
 var init_migrations = __esm(() => {
+  init_schema();
   MIGRATIONS = [
     `
   CREATE TABLE IF NOT EXISTS projects (
@@ -2131,6 +2555,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);
 `
   ];
 });
@@ -2501,8 +2937,8 @@ var init_util = __esm(() => {
 
 // node_modules/zod/v3/ZodError.js
 var ZodIssueCode, quotelessJson = (obj) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
+  const json2 = JSON.stringify(obj, null, 2);
+  return json2.replace(/"([^"]+)":/g, "$1:");
 }, ZodError;
 var init_ZodError = __esm(() => {
   init_util();
@@ -15694,24 +16130,24 @@ class JSONSchemaGenerator {
         const _json = result.schema;
         switch (def.type) {
           case "string": {
-            const json = _json;
-            json.type = "string";
+            const json2 = _json;
+            json2.type = "string";
             const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
             if (typeof minimum === "number")
-              json.minLength = minimum;
+              json2.minLength = minimum;
             if (typeof maximum === "number")
-              json.maxLength = maximum;
+              json2.maxLength = maximum;
             if (format) {
-              json.format = formatMap[format] ?? format;
-              if (json.format === "")
-                delete json.format;
+              json2.format = formatMap[format] ?? format;
+              if (json2.format === "")
+                delete json2.format;
             }
             if (contentEncoding)
-              json.contentEncoding = contentEncoding;
+              json2.contentEncoding = contentEncoding;
             if (patterns && patterns.size > 0) {
               const regexes = [...patterns];
               if (regexes.length === 1)
-                json.pattern = regexes[0].source;
+                json2.pattern = regexes[0].source;
               else if (regexes.length > 1) {
                 result.schema.allOf = [
                   ...regexes.map((regex) => ({
@@ -15724,41 +16160,41 @@ class JSONSchemaGenerator {
             break;
           }
           case "number": {
-            const json = _json;
+            const json2 = _json;
             const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
             if (typeof format === "string" && format.includes("int"))
-              json.type = "integer";
+              json2.type = "integer";
             else
-              json.type = "number";
+              json2.type = "number";
             if (typeof exclusiveMinimum === "number")
-              json.exclusiveMinimum = exclusiveMinimum;
+              json2.exclusiveMinimum = exclusiveMinimum;
             if (typeof minimum === "number") {
-              json.minimum = minimum;
+              json2.minimum = minimum;
               if (typeof exclusiveMinimum === "number") {
                 if (exclusiveMinimum >= minimum)
-                  delete json.minimum;
+                  delete json2.minimum;
                 else
-                  delete json.exclusiveMinimum;
+                  delete json2.exclusiveMinimum;
               }
             }
             if (typeof exclusiveMaximum === "number")
-              json.exclusiveMaximum = exclusiveMaximum;
+              json2.exclusiveMaximum = exclusiveMaximum;
             if (typeof maximum === "number") {
-              json.maximum = maximum;
+              json2.maximum = maximum;
               if (typeof exclusiveMaximum === "number") {
                 if (exclusiveMaximum <= maximum)
-                  delete json.maximum;
+                  delete json2.maximum;
                 else
-                  delete json.exclusiveMaximum;
+                  delete json2.exclusiveMaximum;
               }
             }
             if (typeof multipleOf === "number")
-              json.multipleOf = multipleOf;
+              json2.multipleOf = multipleOf;
             break;
           }
           case "boolean": {
-            const json = _json;
-            json.type = "boolean";
+            const json2 = _json;
+            json2.type = "boolean";
             break;
           }
           case "bigint": {
@@ -15806,23 +16242,23 @@ class JSONSchemaGenerator {
             break;
           }
           case "array": {
-            const json = _json;
+            const json2 = _json;
             const { minimum, maximum } = schema._zod.bag;
             if (typeof minimum === "number")
-              json.minItems = minimum;
+              json2.minItems = minimum;
             if (typeof maximum === "number")
-              json.maxItems = maximum;
-            json.type = "array";
-            json.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
+              json2.maxItems = maximum;
+            json2.type = "array";
+            json2.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
             break;
           }
           case "object": {
-            const json = _json;
-            json.type = "object";
-            json.properties = {};
+            const json2 = _json;
+            json2.type = "object";
+            json2.properties = {};
             const shape = def.shape;
             for (const key in shape) {
-              json.properties[key] = this.process(shape[key], {
+              json2.properties[key] = this.process(shape[key], {
                 ...params,
                 path: [...params.path, "properties", key]
               });
@@ -15837,15 +16273,15 @@ class JSONSchemaGenerator {
               }
             }));
             if (requiredKeys.size > 0) {
-              json.required = Array.from(requiredKeys);
+              json2.required = Array.from(requiredKeys);
             }
             if (def.catchall?._zod.def.type === "never") {
-              json.additionalProperties = false;
+              json2.additionalProperties = false;
             } else if (!def.catchall) {
               if (this.io === "output")
-                json.additionalProperties = false;
+                json2.additionalProperties = false;
             } else if (def.catchall) {
-              json.additionalProperties = this.process(def.catchall, {
+              json2.additionalProperties = this.process(def.catchall, {
                 ...params,
                 path: [...params.path, "additionalProperties"]
               });
@@ -15853,15 +16289,15 @@ class JSONSchemaGenerator {
             break;
           }
           case "union": {
-            const json = _json;
-            json.anyOf = def.options.map((x, i) => this.process(x, {
+            const json2 = _json;
+            json2.anyOf = def.options.map((x, i) => this.process(x, {
               ...params,
               path: [...params.path, "anyOf", i]
             }));
             break;
           }
           case "intersection": {
-            const json = _json;
+            const json2 = _json;
             const a = this.process(def.left, {
               ...params,
               path: [...params.path, "allOf", 0]
@@ -15875,17 +16311,17 @@ class JSONSchemaGenerator {
               ...isSimpleIntersection(a) ? a.allOf : [a],
               ...isSimpleIntersection(b) ? b.allOf : [b]
             ];
-            json.allOf = allOf;
+            json2.allOf = allOf;
             break;
           }
           case "tuple": {
-            const json = _json;
-            json.type = "array";
+            const json2 = _json;
+            json2.type = "array";
             const prefixItems = def.items.map((x, i) => this.process(x, { ...params, path: [...params.path, "prefixItems", i] }));
             if (this.target === "draft-2020-12") {
-              json.prefixItems = prefixItems;
+              json2.prefixItems = prefixItems;
             } else {
-              json.items = prefixItems;
+              json2.items = prefixItems;
             }
             if (def.rest) {
               const rest = this.process(def.rest, {
@@ -15893,29 +16329,29 @@ class JSONSchemaGenerator {
                 path: [...params.path, "items"]
               });
               if (this.target === "draft-2020-12") {
-                json.items = rest;
+                json2.items = rest;
               } else {
-                json.additionalItems = rest;
+                json2.additionalItems = rest;
               }
             }
             if (def.rest) {
-              json.items = this.process(def.rest, {
+              json2.items = this.process(def.rest, {
                 ...params,
                 path: [...params.path, "items"]
               });
             }
             const { minimum, maximum } = schema._zod.bag;
             if (typeof minimum === "number")
-              json.minItems = minimum;
+              json2.minItems = minimum;
             if (typeof maximum === "number")
-              json.maxItems = maximum;
+              json2.maxItems = maximum;
             break;
           }
           case "record": {
-            const json = _json;
-            json.type = "object";
-            json.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
-            json.additionalProperties = this.process(def.valueType, {
+            const json2 = _json;
+            json2.type = "object";
+            json2.propertyNames = this.process(def.keyType, { ...params, path: [...params.path, "propertyNames"] });
+            json2.additionalProperties = this.process(def.valueType, {
               ...params,
               path: [...params.path, "additionalProperties"]
             });
@@ -15934,17 +16370,17 @@ class JSONSchemaGenerator {
             break;
           }
           case "enum": {
-            const json = _json;
+            const json2 = _json;
             const values = getEnumValues(def.entries);
             if (values.every((v) => typeof v === "number"))
-              json.type = "number";
+              json2.type = "number";
             if (values.every((v) => typeof v === "string"))
-              json.type = "string";
-            json.enum = values;
+              json2.type = "string";
+            json2.enum = values;
             break;
           }
           case "literal": {
-            const json = _json;
+            const json2 = _json;
             const vals = [];
             for (const val of def.values) {
               if (val === undefined) {
@@ -15963,23 +16399,23 @@ class JSONSchemaGenerator {
             }
             if (vals.length === 0) {} else if (vals.length === 1) {
               const val = vals[0];
-              json.type = val === null ? "null" : typeof val;
-              json.const = val;
+              json2.type = val === null ? "null" : typeof val;
+              json2.const = val;
             } else {
               if (vals.every((v) => typeof v === "number"))
-                json.type = "number";
+                json2.type = "number";
               if (vals.every((v) => typeof v === "string"))
-                json.type = "string";
+                json2.type = "string";
               if (vals.every((v) => typeof v === "boolean"))
-                json.type = "string";
+                json2.type = "string";
               if (vals.every((v) => v === null))
-                json.type = "null";
-              json.enum = vals;
+                json2.type = "null";
+              json2.enum = vals;
             }
             break;
           }
           case "file": {
-            const json = _json;
+            const json2 = _json;
             const file = {
               type: "string",
               format: "binary",
@@ -15993,15 +16429,15 @@ class JSONSchemaGenerator {
             if (mime) {
               if (mime.length === 1) {
                 file.contentMediaType = mime[0];
-                Object.assign(json, file);
+                Object.assign(json2, file);
               } else {
-                json.anyOf = mime.map((m) => {
+                json2.anyOf = mime.map((m) => {
                   const mFile = { ...file, contentMediaType: m };
                   return mFile;
                 });
               }
             } else {
-              Object.assign(json, file);
+              Object.assign(json2, file);
             }
             break;
           }
@@ -16022,8 +16458,8 @@ class JSONSchemaGenerator {
             break;
           }
           case "success": {
-            const json = _json;
-            json.type = "boolean";
+            const json2 = _json;
+            json2.type = "boolean";
             break;
           }
           case "default": {
@@ -16058,12 +16494,12 @@ class JSONSchemaGenerator {
             break;
           }
           case "template_literal": {
-            const json = _json;
+            const json2 = _json;
             const pattern = schema._zod.pattern;
             if (!pattern)
               throw new Error("Pattern not found in template literal");
-            json.type = "string";
-            json.pattern = pattern.source;
+            json2.type = "string";
+            json2.pattern = pattern.source;
             break;
           }
           case "pipe": {
@@ -17156,7 +17592,7 @@ function _instanceof(cls, params = {
   inst._zod.bag.Class = cls;
   return inst;
 }
-function json(params) {
+function json2(params) {
   const jsonSchema = lazy(() => {
     return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
   });
@@ -17843,7 +18279,7 @@ __export(exports_external2, {
   ksuid: () => ksuid2,
   keyof: () => keyof,
   jwt: () => jwt,
-  json: () => json,
+  json: () => json2,
   iso: () => exports_iso,
   ipv6: () => ipv62,
   ipv4: () => ipv42,
@@ -19703,7 +20139,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve3(value) {
+async function resolve4(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -22525,11 +22961,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([
@@ -33199,24 +33635,24 @@ var require_oauth = __commonJS((exports, module) => {
     });
   }
   async function processTokenResponse(response) {
-    const json2 = await response.json();
+    const json3 = await response.json();
     if (!response.ok) {
-      const errorMsg = typeof json2 === "object" && json2 && "error" in json2 ? String(json2.error) : "Token refresh failed";
+      const errorMsg = typeof json3 === "object" && json3 && "error" in json3 ? String(json3.error) : "Token refresh failed";
       return [new Error(errorMsg)];
     }
-    if (typeof json2 !== "object" || json2 === null) {
+    if (typeof json3 !== "object" || json3 === null) {
       return [new Error("Invalid token response")];
     }
-    if (typeof json2.access_token !== "string") {
+    if (typeof json3.access_token !== "string") {
       return [new Error("Missing access_token in response")];
     }
-    if (json2.token_type !== "Bearer") {
+    if (json3.token_type !== "Bearer") {
       return [new Error("Invalid token_type in response")];
     }
-    if (typeof json2.expires_in !== "number") {
+    if (typeof json3.expires_in !== "number") {
       return [new Error("Missing expires_in in response")];
     }
-    return [null, json2];
+    return [null, json3];
   }
 });
 
@@ -33953,7 +34389,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(),
@@ -33971,7 +34407,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(),
@@ -34017,7 +34453,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(),
@@ -34039,7 +34475,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(),
@@ -34072,7 +34508,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,
@@ -34080,7 +34516,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({
@@ -34103,11 +34539,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({
@@ -34192,7 +34628,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,
@@ -34200,7 +34636,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 } : {}
@@ -34256,7 +34692,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,
@@ -34264,7 +34700,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,
@@ -34339,11 +34775,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,
@@ -34466,7 +34902,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,
@@ -34474,7 +34910,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,
@@ -44078,7 +44514,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 },
@@ -44139,7 +44575,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",
@@ -44316,7 +44752,7 @@ var import_api2, import_api3, __defProp2, __export2 = (target, all) => {
       return;
     }
   };
-}, json2 = ({
+}, json3 = ({
   name: name21,
   description
 } = {}) => {
@@ -47052,9 +47488,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)
@@ -47102,9 +47538,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)
@@ -48384,7 +48820,7 @@ var init_dist8 = __esm(() => {
   __export2(output_exports, {
     array: () => array2,
     choice: () => choice,
-    json: () => json2,
+    json: () => json3,
     object: () => object2,
     text: () => text
   });
@@ -50024,6 +50460,651 @@ function getMemoryVersions(memoryId, db) {
     return [];
   }
 }
+// src/db/memory-project-link.ts
+init_storage();
+init_api_mode();
+init_database();
+import { createHash } from "crypto";
+
+// src/lib/package-version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getMementosPackageVersion() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  for (const candidate of [
+    join4(here, "..", "..", "package.json"),
+    join4(here, "..", "package.json")
+  ]) {
+    try {
+      const parsed = JSON.parse(readFileSync2(candidate, "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.trim())
+        return parsed.version;
+    } catch {}
+  }
+  return "0.0.0";
+}
+
+// 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/memory-project-link/index.ts
+init_schema();
 // src/db/agents.ts
 init_database();
 init_api_mode();
@@ -50471,7 +51552,27 @@ function focusFilterSQL(agentId, projectId) {
 // 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_REGISTRATION_SCHEMA_VERSION = 1;
+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"],
@@ -50482,6 +51583,241 @@ function parseProjectRow(row) {
     updated_at: row["updated_at"]
   };
 }
+
+class ProjectCollisionError extends Error {
+  field;
+  value;
+  constructor(field, value) {
+    super(`Project ${field} already exists: ${value}`);
+    this.field = field;
+    this.value = value;
+    this.name = "ProjectCollisionError";
+  }
+}
+
+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", {
@@ -50501,7 +51837,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]);
@@ -50517,13 +51853,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) {
@@ -50533,7 +51869,1300 @@ 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/project-registration/authority.ts
+import { createHash as createHash3 } from "crypto";
+import { resolve as resolve2 } 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 !== resolve2(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);
+}
+var createLocalMementosProjectRegistrationAuthority = createMementosProjectRegistrationAuthority;
+// 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 json(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 readJson(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 json({ capability: await authority.capability() });
+    }
+    if (method !== "POST")
+      return json({ error: "method not allowed" }, 405);
+    const body = await readJson(request);
+    if (!body) {
+      return json({
+        error: "invalid JSON body",
+        code: "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT"
+      }, 400);
+    }
+    if (action === "create") {
+      return json({ receipt: await authority.create(fromWireRequest(body)) }, 201);
+    }
+    if (action === "receipts/lookup") {
+      return json(await authority.lookupReceipt(body));
+    }
+    if (action === "read-exact") {
+      return json({ record: await authority.readExact(fromWireReadRequest(body)) });
+    }
+    if (action === "compensate") {
+      return json({ receipt: await authority.compensate(fromWireRequest(body)) }, 201);
+    }
+    if (action === "verify-inverse") {
+      return json({ verification: await authority.verifyInverse(fromWireRequest(body)) });
+    }
+    return json({
+      error: "unknown Mementos project-registration route",
+      code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
+    }, 404);
+  } catch (cause) {
+    if (cause instanceof MementosProjectRegistrationError) {
+      return json({
+        error: cause.message,
+        code: cause.code,
+        details: cause.details,
+        authoritative: true
+      }, errorStatus(cause));
+    }
+    return json({
+      error: cause instanceof Error ? cause.message : "internal registration error",
+      code: "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE"
+    }, 500);
+  }
+}
+function extractPath(target) {
+  if (!target || typeof target.withOwnedPath !== "function") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target must be a package-owned path handle");
+  }
+  return target.withOwnedPath((absolutePath) => absolutePath);
+}
+function toWireRequest(request) {
+  const { target, ...serializable } = request;
+  return {
+    ...serializable,
+    canonical_path: extractPath(target)
+  };
+}
+
+class MementosProjectRegistrationHttpClient {
+  authority = "mementos";
+  baseUrl;
+  fetchImpl;
+  headers;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.headers = {
+      ...options.headers,
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+      "Content-Type": "application/json"
+    };
+  }
+  async request(action, init = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/project-registration${action}`, {
+      ...init,
+      headers: { ...this.headers, ...init.headers ?? {} }
+    });
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", `Mementos project registration HTTP ${response.status} returned non-JSON`);
+    }
+    if (!response.ok) {
+      throw new MementosProjectRegistrationError(typeof body["code"] === "string" ? body["code"] : "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", typeof body["error"] === "string" ? body["error"] : `Mementos project registration HTTP ${response.status}`, body["details"] && typeof body["details"] === "object" ? body["details"] : {});
+    }
+    return body;
+  }
+  async capability() {
+    const body = await this.request("/capability");
+    return body.capability;
+  }
+  async create(request) {
+    const body = await this.request("/create", { method: "POST", body: JSON.stringify(toWireRequest(request)) });
+    return body.receipt;
+  }
+  async readExact(request) {
+    const { target, ...serializable } = request;
+    const body = await this.request("/read-exact", {
+      method: "POST",
+      body: JSON.stringify({ ...serializable, canonical_path: extractPath(target) })
+    });
+    return body.record;
+  }
+  async lookupReceipt(request) {
+    return this.request("/receipts/lookup", { method: "POST", body: JSON.stringify(request) });
+  }
+  async compensate(request) {
+    const body = await this.request("/compensate", { method: "POST", body: JSON.stringify(toWireRequest(request)) });
+    return body.receipt;
+  }
+  async verifyInverse(request) {
+    const body = await this.request("/verify-inverse", {
+      method: "POST",
+      body: JSON.stringify(toWireRequest(request))
+    });
+    return body.verification;
+  }
+}
+function createMementosProjectRegistrationHttpClient(options) {
+  return new MementosProjectRegistrationHttpClient(options);
 }
 // src/db/machines.ts
 init_database();
@@ -50828,17 +53457,17 @@ function deleteEntity(id, db) {
   if (result.changes === 0)
     throw new EntityNotFoundError(id);
 }
-function mergeEntities(sourceId, targetId, db) {
+function mergeEntities(sourceId, targetId2, db) {
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", "/entities/merge", {
       source_id: sourceId,
-      target_id: targetId
+      target_id: targetId2
     });
     return data;
   }
   const d = db || getDatabase();
   const src = getEntity(sourceId, d).id;
-  const tgt = getEntity(targetId, d).id;
+  const tgt = getEntity(targetId2, d).id;
   d.run(`DELETE FROM relations
        WHERE source_entity_id = ?
          AND EXISTS (
@@ -51662,9 +54291,9 @@ function formatMementosProjectPanel(panel) {
 `);
 }
 // src/lib/config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, cpSync as cpSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, cpSync as cpSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+import { basename, dirname as dirname3, join as join5, resolve as resolve3 } from "path";
 function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
@@ -51727,11 +54356,11 @@ function isValidCategory(value) {
   return VALID_CATEGORIES.includes(value);
 }
 function loadConfig() {
-  const configPath = join4(homeDir(), ".hasna", "mementos", "config.json");
+  const configPath = join5(homeDir(), ".hasna", "mementos", "config.json");
   let fileConfig = {};
   if (existsSync3(configPath)) {
     try {
-      const raw = readFileSync2(configPath, "utf-8");
+      const raw = readFileSync3(configPath, "utf-8");
       fileConfig = JSON.parse(raw);
     } catch {}
   }
@@ -51755,13 +54384,13 @@ function loadConfig() {
 }
 function findFileWalkingUp(filename) {
   let dir = process.cwd();
-  const legacyHomeMementosDb = resolve2(homeDir(), ".mementos", "mementos.db");
+  const legacyHomeMementosDb = resolve3(homeDir(), ".mementos", "mementos.db");
   while (true) {
-    const candidate = join4(dir, filename);
-    if (existsSync3(candidate) && resolve2(candidate) !== legacyHomeMementosDb) {
+    const candidate = join5(dir, filename);
+    if (existsSync3(candidate) && resolve3(candidate) !== legacyHomeMementosDb) {
       return candidate;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) {
       return null;
     }
@@ -51771,10 +54400,10 @@ function findFileWalkingUp(filename) {
 function findGitRoot2() {
   let dir = process.cwd();
   while (true) {
-    if (existsSync3(join4(dir, ".git"))) {
+    if (existsSync3(join5(dir, ".git"))) {
       return dir;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) {
       return null;
     }
@@ -51782,17 +54411,17 @@ function findGitRoot2() {
   }
 }
 function profilesDir() {
-  return join4(homeDir(), ".hasna", "mementos", "profiles");
+  return join5(homeDir(), ".hasna", "mementos", "profiles");
 }
 function globalConfigPath() {
-  return join4(homeDir(), ".hasna", "mementos", "config.json");
+  return join5(homeDir(), ".hasna", "mementos", "config.json");
 }
 function readGlobalConfig() {
   const p = globalConfigPath();
   if (!existsSync3(p))
     return {};
   try {
-    return JSON.parse(readFileSync2(p, "utf-8"));
+    return JSON.parse(readFileSync3(p, "utf-8"));
   } catch {
     return {};
   }
@@ -51802,7 +54431,7 @@ function readGlobalConfigForWrite() {
   if (!existsSync3(p))
     return {};
   try {
-    const data = JSON.parse(readFileSync2(p, "utf-8"));
+    const data = JSON.parse(readFileSync3(p, "utf-8"));
     if (data === null || typeof data !== "object" || Array.isArray(data)) {
       throw new Error("expected a JSON object");
     }
@@ -51814,7 +54443,7 @@ function readGlobalConfigForWrite() {
 }
 function writeGlobalConfig(data) {
   const p = globalConfigPath();
-  ensureDir2(dirname2(p));
+  ensureDir2(dirname3(p));
   writeFileSync3(p, JSON.stringify(data, null, 2), "utf-8");
 }
 function getActiveProfile() {
@@ -51840,7 +54469,7 @@ function listProfiles() {
   return readdirSync(dir).filter((f) => f.endsWith(".db")).map((f) => basename(f, ".db")).sort();
 }
 function deleteProfile(name) {
-  const dbPath = join4(profilesDir(), `${name}.db`);
+  const dbPath = join5(profilesDir(), `${name}.db`);
   if (!existsSync3(dbPath))
     return false;
   unlinkSync2(dbPath);
@@ -51850,10 +54479,10 @@ function deleteProfile(name) {
 }
 function getDbPath2() {
   const _home = homeDir();
-  const _newDir = join4(_home, ".hasna", "mementos");
-  const _oldDir = join4(_home, ".mementos");
+  const _newDir = join5(_home, ".hasna", "mementos");
+  const _oldDir = join5(_home, ".mementos");
   if (!existsSync3(_newDir) && existsSync3(_oldDir)) {
-    mkdirSync3(join4(_home, ".hasna"), { recursive: true });
+    mkdirSync3(join5(_home, ".hasna"), { recursive: true });
     cpSync2(_oldDir, _newDir, { recursive: true });
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
@@ -51861,31 +54490,31 @@ function getDbPath2() {
     if (isInMemoryDb2(envDbPath)) {
       return envDbPath;
     }
-    const resolved = resolve2(envDbPath);
-    ensureDir2(dirname2(resolved));
+    const resolved = resolve3(envDbPath);
+    ensureDir2(dirname3(resolved));
     return resolved;
   }
   const profile = getActiveProfile();
   if (profile) {
-    const profilePath = join4(profilesDir(), `${profile}.db`);
-    ensureDir2(dirname2(profilePath));
+    const profilePath = join5(profilesDir(), `${profile}.db`);
+    ensureDir2(dirname3(profilePath));
     return profilePath;
   }
   const dbScope = process.env["MEMENTOS_DB_SCOPE"];
   if (dbScope === "project") {
     const gitRoot = findGitRoot2();
     if (gitRoot) {
-      const dbPath = join4(gitRoot, ".mementos", "mementos.db");
-      ensureDir2(dirname2(dbPath));
+      const dbPath = join5(gitRoot, ".mementos", "mementos.db");
+      ensureDir2(dirname3(dbPath));
       return dbPath;
     }
   }
-  const found = findFileWalkingUp(join4(".mementos", "mementos.db"));
+  const found = findFileWalkingUp(join5(".mementos", "mementos.db"));
   if (found) {
     return found;
   }
-  const fallback = join4(homeDir(), ".hasna", "mementos", "mementos.db");
-  ensureDir2(dirname2(fallback));
+  const fallback = join5(homeDir(), ".hasna", "mementos", "mementos.db");
+  ensureDir2(dirname3(fallback));
   return fallback;
 }
 function ensureDir2(dir) {
@@ -52270,18 +54899,18 @@ function runCleanup(config, db) {
   return { expired, evicted, archived, unused_archived, deprioritized };
 }
 // src/lib/sync.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function getAgentSyncDir(agentName) {
-  const dir = join5(homedir3(), ".hasna", "mementos", "agents", agentName);
+  const dir = join6(homedir3(), ".hasna", "mementos", "agents", agentName);
   if (!existsSync4(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
   return dir;
 }
 function setHighWaterMark(agentDir, timestamp) {
-  const markFile = join5(agentDir, ".highwatermark");
+  const markFile = join6(agentDir, ".highwatermark");
   writeFileSync4(markFile, timestamp, "utf-8");
 }
 function resolveConflict(local, remote, resolution) {
@@ -52302,7 +54931,7 @@ function pushMemories(agentName, agentId, projectId, db) {
     status: "active",
     limit: 1e4
   }, db);
-  const outFile = join5(agentDir, "memories.json");
+  const outFile = join6(agentDir, "memories.json");
   writeFileSync4(outFile, JSON.stringify(memories, null, 2), "utf-8");
   if (memories.length > 0) {
     const latest = memories.reduce((a, b) => new Date(a.updated_at).getTime() > new Date(b.updated_at).getTime() ? a : b);
@@ -52312,11 +54941,11 @@ function pushMemories(agentName, agentId, projectId, db) {
 }
 function pullMemories(agentName, conflictResolution = "prefer-newer", db) {
   const agentDir = getAgentSyncDir(agentName);
-  const inFile = join5(agentDir, "memories.json");
+  const inFile = join6(agentDir, "memories.json");
   if (!existsSync4(inFile)) {
     return { pulled: 0, conflicts: 0 };
   }
-  const raw = readFileSync3(inFile, "utf-8");
+  const raw = readFileSync4(inFile, "utf-8");
   let remoteMemories;
   try {
     remoteMemories = JSON.parse(raw);
@@ -54873,17 +57502,17 @@ var gatherTrainingData = async (options = {}) => {
   };
 };
 // src/lib/model-config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
-var CONFIG_DIR = join6(homedir4(), ".hasna", "mementos");
-var CONFIG_PATH = join6(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join7(homedir4(), ".hasna", "mementos");
+var CONFIG_PATH = join7(CONFIG_DIR, "config.json");
 function readConfig() {
   if (!existsSync5(CONFIG_PATH))
     return {};
   try {
-    const raw = readFileSync4(CONFIG_PATH, "utf-8");
+    const raw = readFileSync5(CONFIG_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -55337,6 +57966,9 @@ export {
   touchAgent,
   syncMemories,
   startTaskRunner,
+  sqliteMementosProjectRegistrationSchemaSql,
+  sqliteMementosProjectGuardedUpdateSchemaSql,
+  sqliteMementosMemoryProjectLinkSchemaSql,
   shortUuid,
   setPrimaryMachine,
   setFocus,
@@ -55347,6 +57979,8 @@ export {
   saveStorageConfig,
   runConsolidation,
   runCleanup,
+  rollbackProjectUpdate,
+  rollbackMemoryProjectLink,
   resolveProjectId,
   resolvePartialId,
   resetDatabase,
@@ -55365,11 +57999,17 @@ export {
   pullStorageChanges,
   providerRegistry,
   processConversationTurn,
+  previewProjectUpdate,
+  previewMemoryProjectLink,
+  postgresMementosProjectRegistrationSchemaSql,
+  postgresMementosProjectGuardedUpdateSchemaSql,
+  postgresMementosMemoryProjectLinkSchemaSql,
   parseRelationRow,
   parseEntityRow2 as parseEntityRow,
   now,
   mergeEntities,
   memoryLockId,
+  mementosProjectReferenceCounts,
   loadConfig,
   listTasks,
   listTaskComments,
@@ -55386,6 +58026,8 @@ export {
   linkEntityToMemory,
   incrementRecallCount,
   heuristicReflectionCritic,
+  hasMementosProjectReferences,
+  handleMementosProjectRegistrationHttpRequest,
   getTaskStats,
   getTaskRunnerStats,
   getTask,
@@ -55399,11 +58041,13 @@ export {
   getStorageConfig,
   getRelation,
   getRelatedEntities,
+  getProjectUpdateReceipt,
   getProject,
   getPrimaryMachineStartupWarning,
   getPrimaryMachineCandidate,
   getPrimaryMachine,
   getMemoryVersions,
+  getMemoryProjectLinkReceipt,
   getMemoryLinks,
   getMemoryByKey,
   getMemoryBacklinks,
@@ -55432,6 +58076,8 @@ export {
   focusFilterSQL,
   findPath,
   enforceQuotas,
+  digestMementosProjectRegistrationValue,
+  deriveMementosProjectRegistrationIdempotencyKey,
   deprioritizeStale,
   deleteTaskComment,
   deleteTask,
@@ -55446,7 +58092,10 @@ export {
   createRelation,
   createMemoryLink,
   createMemory,
+  createMementosProjectRegistrationHttpClient,
+  createMementosProjectRegistrationAuthority,
   createMementosProjectPanel,
+  createLocalMementosProjectRegistrationAuthority,
   createEntity,
   createAISDKReflectionCritic,
   containsSecrets,
@@ -55457,11 +58106,14 @@ export {
   cleanExpiredLocks,
   checkMemoryWriteLock,
   checkLock,
+  canonicalMementosProjectRegistrationJson,
   bulkLinkEntities,
   bulkDeleteMemories,
   buildFocusFilter,
   archiveUnused,
   archiveStale,
+  applyProjectUpdate,
+  applyMemoryProjectLink,
   agentHoldsLock,
   addTaskComment,
   acquireMemoryWriteLock,
@@ -55469,15 +58121,28 @@ export {
   VersionConflictError,
   SqliteAdapter,
   STORAGE_TABLES,
+  ProjectGuardedUpdateError,
+  ProjectCollisionError,
   PgAdapterAsync,
   PgAdapter,
+  PackageOwnedMementosProjectRegistrationAuthority,
+  MemoryProjectLinkError,
   MemoryNotFoundError,
   MemoryLockConflictError,
   MemoryInjector,
   MemoryExpiredError,
+  MementosProjectRegistrationHttpClient,
+  MementosProjectRegistrationError,
+  MEMORY_PROJECT_LINK_RECEIPT_COLUMNS,
   MEMENTOS_STORAGE_TABLES,
   MEMENTOS_STORAGE_FALLBACK_ENV,
   MEMENTOS_STORAGE_ENV,
+  MEMENTOS_PROJECT_REGISTRATION_SCHEMA_VERSION,
+  MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+  MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE,
+  MEMENTOS_PROJECT_REFERENCE_SURFACES,
+  MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+  MEMENTOS_MEMORY_PROJECT_LINK_ROUTE,
   InvalidScopeError,
   EntityNotFoundError,
   DuplicateMemoryError,