infinity-context 0.1.0__py3-none-any.whl

infinity_context_adapters/postgres/migrations/0001_core_facts.sql

@@ -0,0 +1,95 @@
+CREATE TABLE memory_spaces (
+  id VARCHAR(80) PRIMARY KEY,
+  slug VARCHAR(160) NOT NULL UNIQUE,
+  name VARCHAR(240) NOT NULL,
+  status VARCHAR(40) NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE TABLE memory_scopes (
+  id VARCHAR(80) PRIMARY KEY,
+  space_id VARCHAR(80) NOT NULL REFERENCES memory_spaces(id),
+  external_ref VARCHAR(200) NOT NULL,
+  name VARCHAR(240) NOT NULL,
+  status VARCHAR(40) NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  CONSTRAINT uq_memory_scope_external_ref UNIQUE (space_id, external_ref)
+);
+
+CREATE TABLE memory_facts (
+  id VARCHAR(80) PRIMARY KEY,
+  space_id VARCHAR(80) NOT NULL,
+  memory_scope_id VARCHAR(80) NOT NULL,
+  thread_id VARCHAR(80),
+  kind VARCHAR(80) NOT NULL,
+  text TEXT NOT NULL,
+  status VARCHAR(40) NOT NULL,
+  confidence VARCHAR(40) NOT NULL,
+  trust_level VARCHAR(40) NOT NULL,
+  classification VARCHAR(40) NOT NULL DEFAULT 'internal',
+  version INTEGER NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  CONSTRAINT ck_fact_version_positive CHECK (version > 0)
+);
+
+CREATE INDEX ix_memory_facts_scope_status
+  ON memory_facts(space_id, memory_scope_id, status, updated_at);
+
+CREATE TABLE memory_source_refs (
+  id SERIAL PRIMARY KEY,
+  fact_id VARCHAR(80) NOT NULL REFERENCES memory_facts(id),
+  fact_version INTEGER NOT NULL,
+  source_type VARCHAR(80) NOT NULL,
+  source_id VARCHAR(160) NOT NULL,
+  chunk_id VARCHAR(160),
+  char_start INTEGER,
+  char_end INTEGER,
+  quote_preview VARCHAR(240)
+);
+
+CREATE INDEX ix_memory_source_refs_fact
+  ON memory_source_refs(fact_id, fact_version);
+
+CREATE TABLE memory_fact_versions (
+  id SERIAL PRIMARY KEY,
+  fact_id VARCHAR(80) NOT NULL REFERENCES memory_facts(id),
+  version INTEGER NOT NULL,
+  text TEXT NOT NULL,
+  status VARCHAR(40) NOT NULL,
+  source_refs_json JSONB NOT NULL,
+  reason VARCHAR(240),
+  created_at TIMESTAMPTZ NOT NULL,
+  CONSTRAINT uq_fact_version UNIQUE (fact_id, version)
+);
+
+CREATE TABLE memory_outbox (
+  id SERIAL PRIMARY KEY,
+  event_type VARCHAR(120) NOT NULL,
+  aggregate_type VARCHAR(80) NOT NULL,
+  aggregate_id VARCHAR(80) NOT NULL,
+  aggregate_version INTEGER,
+  payload_json JSONB NOT NULL,
+  status VARCHAR(40) NOT NULL DEFAULT 'pending',
+  attempt_count INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at TIMESTAMPTZ NOT NULL,
+  last_safe_error VARCHAR(400),
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX ix_memory_outbox_status_next
+  ON memory_outbox(status, next_attempt_at);
+
+CREATE TABLE memory_idempotency_records (
+  id SERIAL PRIMARY KEY,
+  space_id VARCHAR(80) NOT NULL,
+  key VARCHAR(240) NOT NULL,
+  fingerprint VARCHAR(80) NOT NULL,
+  result_type VARCHAR(80) NOT NULL,
+  result_id VARCHAR(80) NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  CONSTRAINT uq_idempotency_space_key UNIQUE (space_id, key)
+);

infinity_context_adapters/postgres/migrations/0002_threads_documents_chunks.sql

@@ -0,0 +1,97 @@
+CREATE TABLE IF NOT EXISTS memory_threads (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    external_ref VARCHAR(240) NOT NULL,
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT uq_thread_external_ref UNIQUE (space_id, memory_scope_id, external_ref)
+);
+
+CREATE INDEX IF NOT EXISTS ix_memory_threads_scope_status
+    ON memory_threads (space_id, memory_scope_id, status);
+
+CREATE TABLE IF NOT EXISTS memory_episodes (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    thread_id VARCHAR(80) NOT NULL,
+    source_type VARCHAR(80) NOT NULL,
+    source_external_id VARCHAR(240) NOT NULL,
+    text TEXT NOT NULL,
+    speaker VARCHAR(40) NOT NULL,
+    trust_level VARCHAR(40) NOT NULL,
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    occurred_at TIMESTAMPTZ NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL,
+    metadata_json JSONB NOT NULL,
+    CONSTRAINT uq_episode_source UNIQUE (space_id, memory_scope_id, thread_id, source_external_id)
+);
+
+CREATE INDEX IF NOT EXISTS ix_memory_episodes_thread_status
+    ON memory_episodes (thread_id, status);
+
+CREATE TABLE IF NOT EXISTS memory_documents (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    thread_id VARCHAR(80),
+    title VARCHAR(300) NOT NULL,
+    source_type VARCHAR(80) NOT NULL,
+    source_external_id VARCHAR(240) NOT NULL,
+    content_hash VARCHAR(80) NOT NULL,
+    classification VARCHAR(40) NOT NULL DEFAULT 'unknown',
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_document_content_hash_memory_scope_wide
+    ON memory_documents (space_id, memory_scope_id, content_hash)
+    WHERE thread_id IS NULL AND status != 'deleted';
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_document_content_hash_thread
+    ON memory_documents (space_id, memory_scope_id, thread_id, content_hash)
+    WHERE thread_id IS NOT NULL AND status != 'deleted';
+
+CREATE INDEX IF NOT EXISTS ix_memory_documents_scope_status
+    ON memory_documents (space_id, memory_scope_id, status);
+
+CREATE TABLE IF NOT EXISTS memory_chunks (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    thread_id VARCHAR(80),
+    document_id VARCHAR(80),
+    episode_id VARCHAR(80),
+    source_type VARCHAR(80) NOT NULL,
+    source_external_id VARCHAR(240) NOT NULL,
+    source_hash VARCHAR(80) NOT NULL,
+    kind VARCHAR(80) NOT NULL,
+    text TEXT NOT NULL,
+    normalized_text TEXT NOT NULL,
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    sequence INTEGER NOT NULL,
+    char_start INTEGER NOT NULL,
+    char_end INTEGER NOT NULL,
+    token_estimate INTEGER NOT NULL,
+    classification VARCHAR(40) NOT NULL DEFAULT 'unknown',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    metadata_json JSONB NOT NULL,
+    CONSTRAINT uq_chunk_source_hash UNIQUE (space_id, memory_scope_id, source_hash),
+    CONSTRAINT ck_chunk_owner CHECK (
+        (document_id IS NOT NULL AND episode_id IS NULL)
+        OR (document_id IS NULL AND episode_id IS NOT NULL)
+    )
+);
+
+CREATE INDEX IF NOT EXISTS ix_memory_chunks_scope_status
+    ON memory_chunks (space_id, memory_scope_id, status);
+
+CREATE INDEX IF NOT EXISTS ix_memory_chunks_thread_status
+    ON memory_chunks (thread_id, status);
+
+CREATE INDEX IF NOT EXISTS ix_memory_chunks_document
+    ON memory_chunks (document_id, status, sequence);

infinity_context_adapters/postgres/migrations/0003_suggestions.sql

@@ -0,0 +1,24 @@
+CREATE TABLE IF NOT EXISTS memory_suggestions (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    candidate_text TEXT NOT NULL,
+    kind VARCHAR(80) NOT NULL,
+    status VARCHAR(40) NOT NULL,
+    source_refs_json JSONB NOT NULL,
+    confidence VARCHAR(40) NOT NULL,
+    trust_level VARCHAR(40) NOT NULL,
+    safe_reason VARCHAR(320) NOT NULL,
+    target_fact_id VARCHAR(80),
+    target_fact_version INTEGER,
+    review_reason VARCHAR(320),
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    reviewed_at TIMESTAMPTZ
+);
+
+CREATE INDEX IF NOT EXISTS ix_memory_suggestions_scope_status
+    ON memory_suggestions (space_id, memory_scope_id, status);
+
+CREATE INDEX IF NOT EXISTS ix_memory_suggestions_target
+    ON memory_suggestions (target_fact_id, status);

infinity_context_adapters/postgres/migrations/0004_service_tokens.sql

@@ -0,0 +1,16 @@
+CREATE TABLE memory_service_tokens (
+  id VARCHAR(80) PRIMARY KEY,
+  space_id VARCHAR(80),
+  memory_scope_ids_json JSONB,
+  description VARCHAR(240) NOT NULL,
+  token_hash VARCHAR(80) UNIQUE NOT NULL,
+  permissions_json JSONB,
+  status VARCHAR(40) NOT NULL DEFAULT 'active',
+  created_at TIMESTAMPTZ NOT NULL,
+  last_used_at TIMESTAMPTZ,
+  expires_at TIMESTAMPTZ,
+  revoked_at TIMESTAMPTZ
+);
+
+CREATE INDEX ix_memory_service_tokens_status
+  ON memory_service_tokens(status, created_at);

infinity_context_adapters/postgres/migrations/0005_data_classification_lite.sql

@@ -0,0 +1,8 @@
+ALTER TABLE memory_facts
+    ADD COLUMN IF NOT EXISTS classification VARCHAR(40) NOT NULL DEFAULT 'internal';
+
+ALTER TABLE memory_documents
+    ADD COLUMN IF NOT EXISTS classification VARCHAR(40) NOT NULL DEFAULT 'unknown';
+
+ALTER TABLE memory_chunks
+    ADD COLUMN IF NOT EXISTS classification VARCHAR(40) NOT NULL DEFAULT 'unknown';

infinity_context_adapters/postgres/migrations/0006_service_token_usage_metadata.sql

@@ -0,0 +1,5 @@
+ALTER TABLE memory_service_tokens
+    ADD COLUMN IF NOT EXISTS last_used_at TIMESTAMPTZ;
+
+ALTER TABLE memory_service_tokens
+    ADD COLUMN IF NOT EXISTS expires_at TIMESTAMPTZ;

infinity_context_adapters/postgres/migrations/0007_service_token_permissions.sql

@@ -0,0 +1,2 @@
+ALTER TABLE memory_service_tokens
+    ADD COLUMN IF NOT EXISTS permissions_json JSONB;

infinity_context_adapters/postgres/migrations/0008_service_token_memory_scope.sql

@@ -0,0 +1,2 @@
+ALTER TABLE memory_service_tokens
+    ADD COLUMN IF NOT EXISTS memory_scope_ids_json JSONB;

infinity_context_adapters/postgres/migrations/0009_outbox_lifecycle_hardening.sql

@@ -0,0 +1,15 @@
+ALTER TABLE memory_outbox
+    ADD COLUMN IF NOT EXISTS workload_class VARCHAR(80) NOT NULL DEFAULT 'projection';
+
+ALTER TABLE memory_outbox
+    ADD COLUMN IF NOT EXISTS fairness_key VARCHAR(160);
+
+UPDATE memory_outbox
+SET fairness_key = aggregate_type || ':' || aggregate_id
+WHERE fairness_key IS NULL;
+
+ALTER TABLE memory_outbox
+    ADD COLUMN IF NOT EXISTS last_safe_diagnostic_code VARCHAR(120);
+
+CREATE INDEX IF NOT EXISTS ix_memory_outbox_workload_fairness
+    ON memory_outbox(status, workload_class, fairness_key, next_attempt_at);

infinity_context_adapters/postgres/migrations/0010_fact_taxonomy.sql

@@ -0,0 +1,14 @@
+ALTER TABLE memory_facts
+  ADD COLUMN IF NOT EXISTS category VARCHAR(80);
+
+ALTER TABLE memory_facts
+  ADD COLUMN IF NOT EXISTS tags_json JSON NOT NULL DEFAULT '[]';
+
+ALTER TABLE memory_facts
+  ADD COLUMN IF NOT EXISTS ttl_policy VARCHAR(80);
+
+ALTER TABLE memory_facts
+  ADD COLUMN IF NOT EXISTS expires_at TIMESTAMPTZ;
+
+CREATE INDEX IF NOT EXISTS ix_memory_facts_taxonomy
+  ON memory_facts (space_id, memory_scope_id, category, status);

infinity_context_adapters/postgres/migrations/0011_asset_extractions.sql

@@ -0,0 +1,66 @@
+CREATE TABLE IF NOT EXISTS memory_asset_extraction_jobs (
+    id VARCHAR(80) PRIMARY KEY,
+    asset_id VARCHAR(80) NOT NULL,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    thread_id VARCHAR(80),
+    parser_profile VARCHAR(80) NOT NULL,
+    parser_config_hash VARCHAR(80) NOT NULL,
+    source_sha256_hex VARCHAR(80) NOT NULL,
+    parser_name VARCHAR(120),
+    parser_version VARCHAR(120),
+    model_version VARCHAR(120),
+    status VARCHAR(40) NOT NULL DEFAULT 'pending',
+    attempt_count INTEGER NOT NULL DEFAULT 0,
+    safe_error_code VARCHAR(120),
+    safe_error_message VARCHAR(500),
+    result_document_ids_json JSON NOT NULL DEFAULT '[]',
+    metadata_json JSON NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    started_at TIMESTAMPTZ,
+    finished_at TIMESTAMPTZ,
+    lease_owner VARCHAR(120),
+    lease_expires_at TIMESTAMPTZ,
+    heartbeat_at TIMESTAMPTZ,
+    retry_after_at TIMESTAMPTZ,
+    cancellation_requested_at TIMESTAMPTZ,
+    retry_disposition VARCHAR(40)
+);
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_jobs_asset_status
+ON memory_asset_extraction_jobs(asset_id, status, created_at);
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_jobs_scope_status
+ON memory_asset_extraction_jobs(space_id, memory_scope_id, status, updated_at);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_asset_extraction_jobs_active_profile
+ON memory_asset_extraction_jobs(
+    asset_id,
+    parser_profile,
+    parser_config_hash,
+    source_sha256_hex
+)
+WHERE status IN ('pending', 'running', 'succeeded');
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_jobs_running_lease
+ON memory_asset_extraction_jobs(status, lease_expires_at, heartbeat_at);
+
+CREATE TABLE IF NOT EXISTS memory_asset_extraction_artifacts (
+    id VARCHAR(80) PRIMARY KEY,
+    job_id VARCHAR(80) NOT NULL,
+    asset_id VARCHAR(80) NOT NULL,
+    artifact_type VARCHAR(80) NOT NULL,
+    storage_backend VARCHAR(80) NOT NULL,
+    storage_key VARCHAR(500) NOT NULL,
+    sha256_hex VARCHAR(80) NOT NULL,
+    byte_size INTEGER NOT NULL,
+    metadata_json JSON NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_artifacts_job
+ON memory_asset_extraction_artifacts(job_id, artifact_type);
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_artifacts_asset
+ON memory_asset_extraction_artifacts(asset_id, created_at);

infinity_context_adapters/postgres/migrations/0012_asset_extraction_execution_hardening.sql

@@ -0,0 +1,20 @@
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS lease_owner VARCHAR(120);
+
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS lease_expires_at TIMESTAMPTZ;
+
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS heartbeat_at TIMESTAMPTZ;
+
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS retry_after_at TIMESTAMPTZ;
+
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS cancellation_requested_at TIMESTAMPTZ;
+
+ALTER TABLE memory_asset_extraction_jobs
+ADD COLUMN IF NOT EXISTS retry_disposition VARCHAR(40);
+
+CREATE INDEX IF NOT EXISTS ix_asset_extraction_jobs_running_lease
+ON memory_asset_extraction_jobs(status, lease_expires_at, heartbeat_at);

infinity_context_adapters/postgres/migrations/0012_usage_governance.sql

@@ -0,0 +1,33 @@
+CREATE TABLE IF NOT EXISTS memory_usage_records (
+    id VARCHAR(80) PRIMARY KEY,
+    subject_type VARCHAR(40) NOT NULL,
+    subject_id VARCHAR(80) NOT NULL,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80),
+    resource VARCHAR(80) NOT NULL,
+    quantity INTEGER NOT NULL,
+    status VARCHAR(40) NOT NULL,
+    source_type VARCHAR(80) NOT NULL,
+    source_id VARCHAR(120) NOT NULL,
+    idempotency_key VARCHAR(240) NOT NULL,
+    window_start TIMESTAMPTZ NOT NULL,
+    window_end TIMESTAMPTZ NOT NULL,
+    metadata_json JSON NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_memory_usage_idempotency
+ON memory_usage_records(idempotency_key);
+
+CREATE INDEX IF NOT EXISTS ix_memory_usage_subject_window
+ON memory_usage_records(
+    subject_type,
+    subject_id,
+    resource,
+    status,
+    window_start,
+    window_end
+);
+
+CREATE INDEX IF NOT EXISTS ix_memory_usage_space_created
+ON memory_usage_records(space_id, created_at);

infinity_context_adapters/postgres/migrations/0013_context_link_suggestions.sql

@@ -0,0 +1,44 @@
+CREATE TABLE IF NOT EXISTS memory_context_link_suggestions (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    source_type VARCHAR(80) NOT NULL,
+    source_id VARCHAR(160) NOT NULL,
+    target_type VARCHAR(80) NOT NULL,
+    target_id VARCHAR(160) NOT NULL,
+    relation_type VARCHAR(80) NOT NULL,
+    confidence VARCHAR(40) NOT NULL DEFAULT 'medium',
+    reason VARCHAR(320) NOT NULL,
+    score DOUBLE PRECISION NOT NULL DEFAULT 0,
+    status VARCHAR(40) NOT NULL DEFAULT 'pending',
+    metadata_json JSON NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    reviewed_at TIMESTAMPTZ,
+    review_reason VARCHAR(320)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_context_link_suggestion_pending
+ON memory_context_link_suggestions(
+    space_id,
+    memory_scope_id,
+    source_type,
+    source_id,
+    target_type,
+    target_id,
+    relation_type
+)
+WHERE status = 'pending';
+
+CREATE INDEX IF NOT EXISTS ix_context_link_suggestions_source
+ON memory_context_link_suggestions(
+    space_id,
+    memory_scope_id,
+    source_type,
+    source_id,
+    status,
+    updated_at
+);
+
+CREATE INDEX IF NOT EXISTS ix_context_link_suggestions_status
+ON memory_context_link_suggestions(space_id, memory_scope_id, status, updated_at);

infinity_context_adapters/postgres/migrations/0014_memory_anchors.sql

@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS memory_anchors (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL,
+    memory_scope_id VARCHAR(80) NOT NULL,
+    kind VARCHAR(40) NOT NULL,
+    normalized_key VARCHAR(160) NOT NULL,
+    label VARCHAR(240) NOT NULL,
+    aliases_json JSON NOT NULL DEFAULT '[]',
+    description VARCHAR(500),
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    confidence VARCHAR(40) NOT NULL DEFAULT 'medium',
+    evidence_refs_json JSON NOT NULL DEFAULT '[]',
+    observed_at TIMESTAMPTZ,
+    valid_from TIMESTAMPTZ,
+    valid_to TIMESTAMPTZ,
+    metadata_json JSON NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_memory_anchor_active_key
+ON memory_anchors(space_id, memory_scope_id, kind, normalized_key)
+WHERE status = 'active';
+
+CREATE INDEX IF NOT EXISTS ix_memory_anchors_scope_kind
+ON memory_anchors(space_id, memory_scope_id, kind, status, updated_at);

infinity_context_adapters/postgres/migrations/0015_users_acl.sql

@@ -0,0 +1,36 @@
+CREATE TABLE IF NOT EXISTS memory_users (
+    id VARCHAR(80) PRIMARY KEY,
+    external_ref VARCHAR(200) NOT NULL,
+    display_name VARCHAR(240) NOT NULL,
+    email VARCHAR(320),
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    metadata_json JSON NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_memory_user_external_ref
+ON memory_users(external_ref);
+
+CREATE INDEX IF NOT EXISTS ix_memory_users_status
+ON memory_users(status, updated_at);
+
+CREATE TABLE IF NOT EXISTS memory_space_memberships (
+    id VARCHAR(80) PRIMARY KEY,
+    space_id VARCHAR(80) NOT NULL REFERENCES memory_spaces(id),
+    user_id VARCHAR(80) NOT NULL REFERENCES memory_users(id),
+    role VARCHAR(40) NOT NULL,
+    status VARCHAR(40) NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_memory_space_membership_active_user
+ON memory_space_memberships(space_id, user_id)
+WHERE status = 'active';
+
+CREATE INDEX IF NOT EXISTS ix_memory_space_memberships_space
+ON memory_space_memberships(space_id, status, updated_at);
+
+CREATE INDEX IF NOT EXISTS ix_memory_space_memberships_user
+ON memory_space_memberships(user_id, status, updated_at);

infinity_context_adapters/postgres/migrations/0016_managed_benchmark_runs.sql

@@ -0,0 +1,27 @@
+CREATE TABLE IF NOT EXISTS memory_comparison_benchmark_runs (
+    run_id_sha256 VARCHAR(64) PRIMARY KEY,
+    binding_commitment_sha256 VARCHAR(64) NOT NULL,
+    infinity_target_identity_sha256 VARCHAR(64) NOT NULL,
+    space_id VARCHAR(80) NOT NULL REFERENCES memory_spaces(id),
+    space_slug VARCHAR(160) NOT NULL,
+    idempotency_key_sha256 VARCHAR(64) NOT NULL,
+    registration_fingerprint_sha256 VARCHAR(64) NOT NULL,
+    state VARCHAR(40) NOT NULL,
+    cleanup_fingerprint_sha256 VARCHAR(64),
+    cleanup_receipt_json JSON,
+    created_at TIMESTAMPTZ NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT ck_memory_comparison_benchmark_run_state
+        CHECK (state IN ('active', 'cleanup_pending')),
+    CONSTRAINT ck_memory_comparison_benchmark_run_cleanup_state CHECK (
+        (state = 'active' AND cleanup_fingerprint_sha256 IS NULL
+            AND cleanup_receipt_json IS NULL)
+        OR
+        (state = 'cleanup_pending' AND cleanup_fingerprint_sha256 IS NOT NULL
+            AND cleanup_receipt_json IS NOT NULL)
+    ),
+    CONSTRAINT uq_memory_comparison_benchmark_run_space_id UNIQUE (space_id),
+    CONSTRAINT uq_memory_comparison_benchmark_run_space_slug UNIQUE (space_slug),
+    CONSTRAINT uq_memory_comparison_benchmark_run_idempotency
+        UNIQUE (idempotency_key_sha256)
+);

infinity_context_adapters/postgres/migrations/0017_managed_benchmark_writer_fence.sql

@@ -0,0 +1,104 @@
+CREATE OR REPLACE FUNCTION memory_comparison_enforce_benchmark_writer_fence()
+RETURNS TRIGGER
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    registry_state VARCHAR(40);
+    old_space_id VARCHAR(80);
+    new_space_id VARCHAR(80);
+BEGIN
+    IF TG_TABLE_NAME = 'memory_spaces' THEN
+        new_space_id := NEW.id;
+        IF TG_OP = 'UPDATE' THEN
+            old_space_id := OLD.id;
+        END IF;
+    ELSE
+        new_space_id := NEW.space_id;
+        IF TG_OP = 'UPDATE' THEN
+            old_space_id := OLD.space_id;
+        END IF;
+    END IF;
+
+    IF TG_OP = 'UPDATE' AND old_space_id IS DISTINCT FROM new_space_id THEN
+        IF EXISTS (
+            SELECT 1
+            FROM memory_comparison_benchmark_runs AS benchmark_run
+            WHERE benchmark_run.space_id IN (old_space_id, new_space_id)
+        ) THEN
+            RAISE EXCEPTION 'benchmark canonical space identity is immutable'
+                USING
+                    ERRCODE = '23514',
+                    CONSTRAINT = 'ck_memory_comparison_benchmark_run_writer_fence';
+        END IF;
+    END IF;
+
+    IF NEW.status IS DISTINCT FROM 'active' THEN
+        RETURN NEW;
+    END IF;
+
+    BEGIN
+        SELECT benchmark_run.state
+        INTO registry_state
+        FROM memory_comparison_benchmark_runs AS benchmark_run
+        WHERE benchmark_run.space_id = new_space_id
+        FOR SHARE NOWAIT;
+    EXCEPTION
+        WHEN lock_not_available THEN
+            RAISE EXCEPTION 'benchmark canonical writer fence rejected active data'
+                USING
+                    ERRCODE = '23514',
+                    CONSTRAINT = 'ck_memory_comparison_benchmark_run_writer_fence';
+    END;
+
+    IF registry_state = 'cleanup_pending' THEN
+        RAISE EXCEPTION 'benchmark canonical writer fence rejected active data'
+            USING
+                ERRCODE = '23514',
+                CONSTRAINT = 'ck_memory_comparison_benchmark_run_writer_fence';
+    END IF;
+
+    RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS trg_memory_spaces_benchmark_writer_fence ON memory_spaces;
+CREATE TRIGGER trg_memory_spaces_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF id, status ON memory_spaces
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_scopes_benchmark_writer_fence ON memory_scopes;
+CREATE TRIGGER trg_memory_scopes_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_scopes
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_threads_benchmark_writer_fence ON memory_threads;
+CREATE TRIGGER trg_memory_threads_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_threads
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_facts_benchmark_writer_fence ON memory_facts;
+CREATE TRIGGER trg_memory_facts_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_facts
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_episodes_benchmark_writer_fence ON memory_episodes;
+CREATE TRIGGER trg_memory_episodes_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_episodes
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_documents_benchmark_writer_fence ON memory_documents;
+CREATE TRIGGER trg_memory_documents_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_documents
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();
+
+DROP TRIGGER IF EXISTS trg_memory_chunks_benchmark_writer_fence ON memory_chunks;
+CREATE TRIGGER trg_memory_chunks_benchmark_writer_fence
+BEFORE INSERT OR UPDATE OF space_id, status ON memory_chunks
+FOR EACH ROW
+EXECUTE FUNCTION memory_comparison_enforce_benchmark_writer_fence();