现有数据库字典

2026-10-08 对 4489b400 的 schema.sql  静态核对，共 123 张表。这是字段词典，不是第二份建表脚本，也未验证正在运行的数据库与该基线完全一致。 所有现有字段按原 SQL 摘录约束，不在文档中补造已存在的外键。业务设计见数据库设计。

存量表数量不决定目标设计，不要求继续扩建所有领域；是否保留/合并/退役以当前页面、后台消费者和数据迁移证据决定。

字段表中保留类型、默认值和行内约束；表级键、CHECK、外键及索引在字段后列出。SQL 注释和模型/服务中的校验不等同于数据库约束。

identity_users

键与查询约束（现状）：

• CONSTRAINT identity_users_avatar_check CHECK ( (avatar_data IS NULL AND avatar_sha256 IS NULL) OR (avatar_data IS NOT NULL AND avatar_sha256 IS NOT NULL AND octet_length(avatar_data) BETWEEN 1 AND 262144 AND octet_length(avatar_sha256) = 32) )

identity_sessions

键与查询约束（现状）：

• CONSTRAINT identity_sessions_revocation CHECK ( (revoked_at IS NULL AND revoked_reason IS NULL) OR (revoked_at IS NOT NULL AND revoked_reason IS NOT NULL) )
• CREATE INDEX identity_sessions_user_id_idx ON identity_sessions(user_id);
• CREATE INDEX identity_sessions_active_expiry_idx ON identity_sessions(expires_at) WHERE revoked_at IS NULL;

monitor_topics

键与查询约束（现状）：

• CONSTRAINT monitor_topics_owner_id_key UNIQUE (owner_id, id)
• CREATE INDEX monitor_topics_owner_updated_idx ON monitor_topics (owner_id, updated_at);

monitor_topic_versions

键与查询约束（现状）：

• PRIMARY KEY (topic_id, version)
• CREATE INDEX monitor_topic_versions_created_by_idx ON monitor_topic_versions (created_by);

monitor_topic_status_events

键与查询约束（现状）：

• CONSTRAINT monitor_topic_status_events_owner_topic_sequence_key UNIQUE (owner_id, topic_id, event_sequence)
• CONSTRAINT monitor_topic_status_events_sequence_check CHECK (event_sequence >= 1)
• CONSTRAINT monitor_topic_status_events_rule_version_check CHECK (topic_rule_version >= 1)
• CONSTRAINT monitor_topic_status_events_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT monitor_topic_status_events_rule_version_fkey FOREIGN KEY (topic_id, topic_rule_version) REFERENCES monitor_topic_versions (topic_id, version) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED
• CONSTRAINT monitor_topic_status_events_status_reason_check CHECK ( (status = 'paused' AND reason IN ('created', 'cloned', 'paused', 'source_selection')) OR (status = 'active' AND reason = 'resumed') OR (status = 'archived' AND reason = 'archived') )
• CREATE INDEX monitor_topic_status_events_timeline_idx ON monitor_topic_status_events (owner_id, topic_id, occurred_at, event_sequence);

monitor_schedules

键与查询约束（现状）：

• CONSTRAINT monitor_schedules_owner_topic_source_capability_key PRIMARY KEY ( owner_id, topic_id, source_key, capability )
• CONSTRAINT monitor_schedules_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CREATE INDEX monitor_schedules_enabled_next_run_idx ON monitor_schedules (enabled, next_run_at);

followed_accounts

键与查询约束（现状）：

• CONSTRAINT followed_accounts_owner_source_identity_key UNIQUE (owner_id, source_key, external_id)
• CONSTRAINT followed_accounts_owner_id_key UNIQUE (owner_id, id)
• CREATE INDEX followed_accounts_owner_created_idx ON followed_accounts (owner_id, created_at, id);

followed_account_aliases

键与查询约束（现状）：

• PRIMARY KEY (owner_id, account_id, alias_value)
• CONSTRAINT followed_account_aliases_owner_account_fkey FOREIGN KEY (owner_id, account_id) REFERENCES followed_accounts (owner_id, id) ON DELETE CASCADE
• CREATE INDEX followed_account_aliases_owner_value_idx ON followed_account_aliases (owner_id, alias_value);

codex_reset_monitors

键与查询约束（现状）：

• CONSTRAINT codex_reset_monitors_owner_id_key UNIQUE(owner_id,id)
• CONSTRAINT codex_reset_monitors_owner_key UNIQUE(owner_id)
• CONSTRAINT codex_reset_monitors_versions_check CHECK(revision>=1 AND configuration_version>=1 AND projection_epoch>=1 AND scan_revision>=1)

codex_reset_monitor_versions

键与查询约束（现状）：

• PRIMARY KEY(owner_id,monitor_id,version)
• CONSTRAINT codex_reset_monitor_versions_monitor_fkey FOREIGN KEY(owner_id,monitor_id) REFERENCES codex_reset_monitors(owner_id,id) ON DELETE CASCADE
• CONSTRAINT codex_reset_monitor_versions_configuration_check CHECK(version>=1 AND jsonb_typeof(configuration)='object')

codex_reset_scan_gaps

键与查询约束（现状）：

• CONSTRAINT codex_reset_scan_gaps_version_fkey FOREIGN KEY(owner_id,monitor_id,configuration_version) REFERENCES codex_reset_monitor_versions(owner_id,monitor_id,version) ON DELETE CASCADE
• CONSTRAINT codex_reset_scan_gaps_state_check CHECK(state IN ('pending','held','complete'))
• CONSTRAINT codex_reset_scan_gaps_bounds_check CHECK(starts_at IS NULL AND ends_at IS NULL OR starts_at<ends_at)
• CREATE INDEX codex_reset_scan_gaps_monitor_idx ON codex_reset_scan_gaps(owner_id,monitor_id,state,created_at);

codex_reset_posts

键与查询约束（现状）：

• CONSTRAINT codex_reset_posts_owner_monitor_id_key UNIQUE(owner_id,monitor_id,id)
• CONSTRAINT codex_reset_posts_external_key UNIQUE(owner_id,monitor_id,external_id)
• CONSTRAINT codex_reset_posts_version_fkey FOREIGN KEY(owner_id,monitor_id,configuration_version) REFERENCES codex_reset_monitor_versions(owner_id,monitor_id,version)
• CONSTRAINT codex_reset_posts_input_check CHECK(octet_length(input_fingerprint)=32 AND review_version>=1 AND failure_count>=0)
• CONSTRAINT codex_reset_posts_source_check CHECK(external_id ~ '^[0-9]{1,19}$' AND jsonb_typeof(source_input)='object')
• CREATE INDEX codex_reset_posts_pending_idx ON codex_reset_posts(owner_id,monitor_id,published_at,external_id);

codex_reset_events

键与查询约束（现状）：

• PRIMARY KEY(owner_id,monitor_id,id)
• CONSTRAINT codex_reset_events_monitor_fkey FOREIGN KEY(owner_id,monitor_id) REFERENCES codex_reset_monitors(owner_id,id)
• CONSTRAINT codex_reset_events_state_check CHECK(kind IN ('direct_reset','reset_credit') AND status IN ('announced','confirmed'))
• CONSTRAINT codex_reset_events_revision_check CHECK(revision>=1 AND manual_version>=0)
• CONSTRAINT codex_reset_events_basis_check CHECK(confirmation_basis IS NULL OR confirmation_basis IN ('source_post','receipt_review'))
• CREATE INDEX codex_reset_events_timeline_idx ON codex_reset_events(owner_id,monitor_id,created_at);

codex_reset_event_posts

键与查询约束（现状）：

• PRIMARY KEY(owner_id,monitor_id,event_id,post_id)
• CONSTRAINT codex_reset_event_posts_event_fkey FOREIGN KEY(owner_id,monitor_id,event_id) REFERENCES codex_reset_events(owner_id,monitor_id,id)
• CONSTRAINT codex_reset_event_posts_post_fkey FOREIGN KEY(owner_id,monitor_id,post_id) REFERENCES codex_reset_posts(owner_id,monitor_id,id)
• CONSTRAINT codex_reset_event_posts_action_check CHECK(action IN ('announce','progress','confirm','amend','withdraw'))

codex_reset_reviews

键与查询约束（现状）：

• CONSTRAINT codex_reset_reviews_monitor_fkey FOREIGN KEY(owner_id,monitor_id) REFERENCES codex_reset_monitors(owner_id,id)
• CONSTRAINT codex_reset_reviews_operation_key UNIQUE(owner_id,monitor_id,operation_id)
• CONSTRAINT codex_reset_reviews_input_check CHECK(octet_length(input_fingerprint)=32 AND length(reason) BETWEEN 1 AND 1000)

source_connections

键与查询约束（现状）：

• CONSTRAINT source_connections_safety_stop_complete_check CHECK ( (safety_stop_reason IS NULL AND safety_trigger_job_id IS NULL AND safety_stopped_at IS NULL AND safety_stopped_version IS NULL) OR (source_key = 'bilibili' AND status = 'disabled' AND safety_stop_reason IS NOT NULL AND safety_trigger_job_id IS NOT NULL AND safety_stopped_at IS NOT NULL AND safety_stopped_version IS NOT NULL) )
• CONSTRAINT source_connections_owner_source_key UNIQUE (owner_id, source_key)
• CONSTRAINT source_connections_owner_id_key UNIQUE (owner_id, id)
• ALTER TABLE source_connections ADD CONSTRAINT source_connections_current_version_fkey FOREIGN KEY (owner_id, id, current_version) REFERENCES source_connection_versions (owner_id, connection_id, version) DEFERRABLE INITIALLY DEFERRED;

source_connection_versions

键与查询约束（现状）：

• PRIMARY KEY (connection_id, version)
• CONSTRAINT source_connection_versions_auth_secret_check CHECK ( (auth_kind = 'none' AND secret_ref IS NULL) OR ( auth_kind = 'server_credential' AND secret_ref IS NOT NULL AND secret_ref ~ '^[A-Za-z][A-Za-z0-9+.-]*:[A-Za-z0-9_./:-]+$' ) OR ( auth_kind = 'browser_state' AND secret_ref IS NOT NULL AND secret_ref = 'browser-state:' \|\| replace(owner_id::text, '-', '') \|\| '/' \|\| replace(connection_id::text, '-', '') \|\| '/' \|\| version::text ) )
• CONSTRAINT source_connection_versions_config_object_check CHECK ( jsonb_typeof(config) = 'object' )
• CONSTRAINT source_connection_versions_config_keys_check CHECK ( config - 'feed_url' - 'feed_url_template' - 'base_url' - 'engines' - 'allowed_hosts' - 'comment_scan' = '{}'::jsonb )
• CONSTRAINT source_connection_versions_comment_scan_keys_check CHECK ( NOT (config ? 'comment_scan') OR ( jsonb_typeof(config -> 'comment_scan') = 'object' AND (config -> 'comment_scan') - 'candidate_age_seconds' - 'refresh_interval_seconds' - 'max_posts_per_topic' - 'page_size' - 'max_pages' - 'max_requests' - 'max_seconds' - 'first_level_limit' - 'replies_per_thread_limit' = '{}'::jsonb ) )
• CONSTRAINT source_connection_versions_execution_policy_object_check CHECK ( execution_policy IS NULL OR jsonb_typeof(execution_policy) = 'object' )
• CONSTRAINT source_connection_versions_execution_policy_keys_check CHECK ( execution_policy IS NULL OR execution_policy - 'min_interval_seconds' - 'quiet_windows' - 'max_queries' - 'max_items_per_query' - 'max_requests' - 'max_seconds' - 'hard_timeout_seconds' - 'max_concurrency' - 'enabled' = '{}'::jsonb )
• CONSTRAINT source_connection_versions_owner_connection_version_key UNIQUE (owner_id, connection_id, version)
• CONSTRAINT source_connection_versions_owner_connection_fkey FOREIGN KEY (owner_id, connection_id) REFERENCES source_connections (owner_id, id) ON DELETE CASCADE
• CREATE INDEX source_connection_versions_created_by_idx ON source_connection_versions (created_by);

source_capability_evidence

键与查询约束（现状）：

• CONSTRAINT source_capability_evidence_owner_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT source_capability_evidence_connection_version_fkey FOREIGN KEY (owner_id, connection_id, connection_version) REFERENCES source_connection_versions (owner_id, connection_id, version) ON DELETE CASCADE
• CHECK ( (outcome = 'succeeded' AND stop_reason IS NULL) OR (outcome = 'failed' AND stop_reason IS NOT NULL) )
• CHECK (kind <> 'probe' OR resource_ref IS NULL)
• CHECK ( kind <> 'persisted_read' OR outcome <> 'succeeded' OR resource_ref IS NOT NULL )
• CREATE INDEX source_capability_evidence_latest_idx ON source_capability_evidence ( owner_id, connection_id, connection_version, capability, entry_point, observed_at );

editorial_source_profiles

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT editorial_profiles_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT editorial_profiles_source_key UNIQUE (owner_id, source_key)
• CONSTRAINT editorial_profiles_source_key_check CHECK (source_key ~ '^ed_[a-z_]+_[a-f0-9]{32}$')
• CONSTRAINT editorial_profiles_counters_check CHECK (current_version >= 1 AND revision >= 1 AND failure_count >= 0)
• CONSTRAINT editorial_profiles_health_check CHECK (health IN ('unknown','ok','degraded','failing'))
• CONSTRAINT editorial_profiles_cursor_check CHECK (jsonb_typeof(cursor) = 'object')
• CREATE INDEX editorial_profiles_due_idx ON editorial_source_profiles (enabled, next_fetch_at);
• ALTER TABLE editorial_source_profiles ADD CONSTRAINT editorial_profiles_current_version_fkey FOREIGN KEY (owner_id, id, current_version) REFERENCES editorial_source_profile_versions (owner_id, profile_id, version) DEFERRABLE INITIALLY DEFERRED;

editorial_source_profile_versions

键与查询约束（现状）：

• PRIMARY KEY (profile_id, version)
• CONSTRAINT editorial_versions_owner_key UNIQUE (owner_id, profile_id, version)
• CONSTRAINT editorial_versions_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT editorial_versions_profile_fkey FOREIGN KEY(owner_id, profile_id) REFERENCES editorial_source_profiles (owner_id, id) ON DELETE CASCADE
• CONSTRAINT editorial_versions_connection_fkey FOREIGN KEY(owner_id, connection_id, connection_version) REFERENCES source_connection_versions (owner_id, connection_id, version)
• CONSTRAINT editorial_versions_kind_check CHECK (kind IN ('rss','web_list','json_list','x_search','mp_account','external'))
• CONSTRAINT editorial_versions_participation_check CHECK (participation_mode IN ('editorial','hot_signal','isolated') AND tier IN ('T1','T1_5','T2','T3'))
• CONSTRAINT editorial_versions_numbers_check CHECK (octet_length(input_hash) = 32 AND version >= 1 AND policy_version >= 1 AND connection_version >= 1 AND interval_minutes BETWEEN 1 AND 360)
• CONSTRAINT editorial_versions_configuration_check CHECK (jsonb_typeof(configuration) = 'object')

source_access_policies

键与查询约束（现状）：

• CONSTRAINT source_access_policies_owner_source_capability_key UNIQUE (owner_id, source_key, capability)
• CONSTRAINT source_access_policies_owner_id_id_key UNIQUE (owner_id, id)
• CHECK (NOT enabled OR status = 'approved')
• CHECK ( status <> 'approved' OR ( access_basis IS NOT NULL AND terms_reference IS NOT NULL AND component_name IS NOT NULL AND component_version IS NOT NULL AND component_license IS NOT NULL AND reviewed_at IS NOT NULL AND field_purposes <> '{}'::jsonb ) )
• CHECK ( review_expires_at IS NULL OR (reviewed_at IS NOT NULL AND review_expires_at > reviewed_at) )

evidence_retention_policies

键与查询约束（现状）：

• CONSTRAINT evidence_retention_policies_owner_source_class_key UNIQUE (owner_id, source_policy_id, data_class)
• CONSTRAINT evidence_retention_policies_owner_id_id_key UNIQUE (owner_id, id)
• CONSTRAINT evidence_retention_policies_owner_source_policy_fkey FOREIGN KEY (owner_id, source_policy_id) REFERENCES source_access_policies (owner_id, id) ON DELETE CASCADE
• CHECK ( effective_days = CASE WHEN source_max_days IS NULL THEN requested_days ELSE LEAST(requested_days, source_max_days) END )

evidence_resources

键与查询约束（现状）：

• CONSTRAINT evidence_resources_owner_type_resource_key UNIQUE (owner_id, resource_type, resource_id)
• CONSTRAINT evidence_resources_owner_id_id_key UNIQUE (owner_id, id)
• CONSTRAINT evidence_resources_owner_source_policy_fkey FOREIGN KEY (owner_id, source_policy_id) REFERENCES source_access_policies (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT evidence_resources_owner_retention_policy_fkey FOREIGN KEY (owner_id, retention_policy_id) REFERENCES evidence_retention_policies (owner_id, id) ON DELETE RESTRICT
• CREATE INDEX evidence_resources_expiry_idx ON evidence_resources (expires_at);

evidence_deletions

键与查询约束（现状）：

• CONSTRAINT evidence_deletions_owner_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT evidence_deletions_owner_resource_key UNIQUE (owner_id, resource_record_id)
• CONSTRAINT evidence_deletions_owner_resource_fkey FOREIGN KEY (owner_id, resource_record_id) REFERENCES evidence_resources (owner_id, id) ON DELETE CASCADE
• CHECK ((status = 'completed') = (completed_at IS NOT NULL))
• CREATE INDEX evidence_deletions_status_due_idx ON evidence_deletions (status, cleanup_due_at);

evidence_cleanup_targets

键与查询约束（现状）：

• CONSTRAINT evidence_cleanup_targets_deletion_kind_reference_key UNIQUE (deletion_id, target_kind, target_reference)
• CHECK ( target_kind <> 'postgres_content_observation' OR target_reference ~* '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$' )
• CHECK ( (status = 'processing') = (lease_token IS NOT NULL AND lease_expires_at IS NOT NULL) )
• CHECK ((status = 'succeeded') = (completed_at IS NOT NULL))
• CREATE INDEX evidence_cleanup_targets_claim_idx ON evidence_cleanup_targets (status, next_attempt_at);

resource_budget_policies

键与查询约束（现状）：

• CONSTRAINT resource_budget_policies_owner_key UNIQUE (owner_id, budget_key)
• CONSTRAINT resource_budget_policies_owner_id_key UNIQUE (owner_id, id)
• CHECK ( (scope_kind = 'global' AND scope_reference IS NULL) OR ( scope_kind <> 'global' AND scope_reference ~ '^[a-z0-9][a-z0-9_.:-]{0,127}$' ) )
• CONSTRAINT resource_budget_policies_x_source_check CHECK (metric <> 'x_api_usd_micros' OR scope_kind <> 'source' OR scope_reference = 'x')
• CREATE UNIQUE INDEX resource_budget_policies_source_window_key ON resource_budget_policies (owner_id, scope_reference, metric, window_seconds, window_anchor_at) WHERE scope_kind = 'source';

resource_budget_windows

键与查询约束（现状）：

• CONSTRAINT resource_budget_windows_policy_start_key UNIQUE (owner_id, budget_policy_id, window_start)
• CONSTRAINT resource_budget_windows_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT resource_budget_windows_owner_policy_fkey FOREIGN KEY (owner_id, budget_policy_id) REFERENCES resource_budget_policies (owner_id, id) ON DELETE CASCADE
• CHECK (budget_mode = 'cumulative' OR used_units = 0)
• CREATE INDEX resource_budget_windows_lookup_idx ON resource_budget_windows (owner_id, budget_policy_id, window_end);

resource_budget_reservations

键与查询约束（现状）：

• CONSTRAINT resource_budget_reservations_owner_reservation_policy_key UNIQUE (owner_id, reservation_id, budget_policy_id)
• CONSTRAINT resource_budget_reservations_owner_policy_fkey FOREIGN KEY (owner_id, budget_policy_id) REFERENCES resource_budget_policies (owner_id, id) ON DELETE CASCADE
• CONSTRAINT resource_budget_reservations_owner_window_fkey FOREIGN KEY (owner_id, budget_window_id) REFERENCES resource_budget_windows (owner_id, id) ON DELETE CASCADE
• CHECK ( (status = 'reserved' AND actual_units IS NULL AND released_units IS NULL AND settled_at IS NULL) OR (status = 'settled' AND actual_units IS NOT NULL AND released_units IS NOT NULL AND settled_at IS NOT NULL) )
• CHECK ( actual_units IS NULL OR (actual_units >= 0 AND (actual_units <= requested_units OR metric IN ('provider_cny_micros', 'provider_usd_micros'))) )
• CHECK ( released_units IS NULL OR (released_units >= 0 AND released_units <= requested_units) )
• CHECK ( status = 'reserved' OR (budget_mode = 'cumulative' AND actual_units + released_units = GREATEST(requested_units, actual_units)) OR (budget_mode = 'concurrent' AND released_units = requested_units) )
• CREATE INDEX resource_budget_reservations_lookup_idx ON resource_budget_reservations (owner_id, reservation_id);

resource_component_policies

键与查询约束（现状）：

• CONSTRAINT resource_component_policies_owner_component_key UNIQUE (owner_id, component_key)
• CONSTRAINT resource_component_policies_owner_id_key UNIQUE (owner_id, id)
• CHECK (NOT enabled_for_core OR cost_class IN ('local', 'zero_price'))
• CONSTRAINT resource_component_policies_revision_pair_check CHECK ( (upstream_revision IS NULL AND patched_revision IS NULL) OR (upstream_revision IS NOT NULL AND patched_revision IS NOT NULL AND upstream_revision ~ '^[0-9a-f]{40}$' AND patched_revision ~ '^[0-9a-f]{40}$') )

resource_usage_attempts

键与查询约束（现状）：

• CONSTRAINT resource_usage_attempts_owner_attempt_key UNIQUE (owner_id, attempt_id)
• CONSTRAINT resource_usage_attempts_owner_policy_fkey FOREIGN KEY (owner_id, component_policy_id) REFERENCES resource_component_policies (owner_id, id) ON DELETE CASCADE
• CHECK ( (outcome = 'started' AND finished_at IS NULL) OR (outcome <> 'started' AND finished_at IS NOT NULL) )
• CHECK (finished_at IS NULL OR finished_at >= started_at)
• CREATE INDEX resource_usage_attempts_operation_idx ON resource_usage_attempts (owner_id, operation_id, started_at);

jobs

键与查询约束（现状）：

• CONSTRAINT jobs_owner_kind_operation_key UNIQUE (owner_id, kind, operation_id)
• CONSTRAINT jobs_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT jobs_mediacrawler_version_evidence_check CHECK ( (upstream_revision IS NULL AND patched_revision IS NULL AND adapter_version IS NULL) OR (upstream_revision IS NOT NULL AND patched_revision IS NOT NULL AND upstream_revision ~ '^[0-9a-f]{40}$' AND patched_revision ~ '^[0-9a-f]{40}$' AND adapter_version IS NOT NULL AND adapter_version <> '') )
• CHECK ( (source_key IS NULL AND source_capability IS NULL) OR ( source_key IS NOT NULL AND source_capability IS NOT NULL AND source_key ~ '^[a-z][a-z0-9_-]{0,63}$' AND source_capability IN ( 'search', 'author_posts', 'comments', 'replies', 'page_content', 'hotlist' ) ) )
• CHECK ( (lease_owner IS NULL AND lease_expires_at IS NULL) OR (lease_owner IS NOT NULL AND lease_expires_at IS NOT NULL) )
• CHECK (status = 'running' OR (lease_owner IS NULL AND lease_expires_at IS NULL))
• CHECK (progress_stage IS NULL OR progress_stage IN ('request', 'parse', 'save', 'analysis'))
• CHECK ( ( progress_stage IS NULL AND progress_updated_at IS NULL AND requests_sent = 0 AND items_saved = 0 ) OR (progress_stage IS NOT NULL AND progress_updated_at IS NOT NULL) )
• CHECK (progress_updated_at IS NULL OR progress_updated_at >= created_at)
• CONSTRAINT jobs_collection_cycle_check CHECK ( (collection_cycle_no = 0 AND collection_cycle_started_at IS NULL AND collection_cycle_requests_sent = 0) OR (collection_cycle_no >= 1 AND collection_cycle_started_at IS NOT NULL AND collection_cycle_requests_sent >= 0 AND collection_cycle_requests_sent <= requests_sent) )
• CHECK ( (cancel_requested_at IS NULL AND cancel_deadline_at IS NULL) OR ( cancel_requested_at IS NOT NULL AND status IN ('running', 'cancelled') AND (cancel_deadline_at IS NULL OR cancel_deadline_at >= cancel_requested_at) ) )
• CHECK ( completed_at IS NULL OR status IN ('succeeded', 'partially_succeeded', 'failed', 'cancelled') )
• CHECK ( (defer_reason IS NULL AND next_run_at IS NULL) OR ( status = 'queued' AND defer_reason IS NOT NULL AND next_run_at IS NOT NULL AND defer_reason ~ '^[a-z][a-z0-9_.:-]{0,127}$' ) )
• CHECK (next_run_at IS NULL OR next_run_at >= created_at)
• CHECK ( ( last_error_code IS NULL AND last_error_category IS NULL AND last_error_at IS NULL AND next_action IS NULL ) OR ( last_error_code ~ '^[a-z][a-z0-9_.:-]{0,127}$' AND last_error_category IN ( 'transient', 'rate_limited', 'authentication_required', 'permission_denied', 'invalid_response', 'parse_error', 'invalid_input', 'configuration_unavailable' ) AND last_error_at IS NOT NULL AND next_action IS NOT NULL ) )
• CREATE INDEX jobs_runnable_idx ON jobs (status, lease_expires_at);

editorial_source_runs

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT editorial_source_runs_operation_key UNIQUE (owner_id, profile_id, operation_id)
• CONSTRAINT editorial_source_runs_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT editorial_source_runs_version_fkey FOREIGN KEY(owner_id, profile_id, configuration_version) REFERENCES editorial_source_profile_versions (owner_id, profile_id, version)
• CONSTRAINT editorial_source_runs_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT editorial_source_runs_status_check CHECK (status IN ('running','staged','succeeded','partial','unknown','failed','blocked','cancelled'))
• CONSTRAINT editorial_source_runs_input_check CHECK (octet_length(input_hash) = 32 AND configuration_version >= 1 AND profile_revision >= 1)
• CONSTRAINT editorial_source_runs_counts_check CHECK (found >= 0 AND created >= 0 AND revised >= 0)
• CONSTRAINT editorial_source_runs_page_check CHECK (prepared_page IS NULL OR (jsonb_typeof(prepared_page) = 'object' AND octet_length(prepared_page::text) <= 8388608))
• CONSTRAINT editorial_source_runs_review_check CHECK (review_audit IS NULL OR jsonb_typeof(review_audit) = 'object')
• CREATE INDEX editorial_runs_profile_status_idx ON editorial_source_runs (owner_id, profile_id, status);

editorial_source_icons

键与查询约束（现状）：

• PRIMARY KEY (owner_id, profile_id)
• CONSTRAINT editorial_source_icons_version_fkey FOREIGN KEY (owner_id, profile_id, configuration_version) REFERENCES editorial_source_profile_versions (owner_id, profile_id, version)
• CONSTRAINT editorial_source_icons_job_fkey FOREIGN KEY (job_id) REFERENCES jobs (id)
• CONSTRAINT editorial_source_icons_version_check CHECK (configuration_version >= 1 AND profile_revision >= 1)
• CONSTRAINT editorial_source_icons_hash_check CHECK (octet_length(input_hash) = 32)
• CONSTRAINT editorial_source_icons_status_check CHECK (status IN ('ready','missing','blocked','unknown','running'))
• CONSTRAINT editorial_source_icons_media_check CHECK (jsonb_typeof(media_refs) = 'array' AND octet_length(media_refs::text) <= 65536)
• CONSTRAINT editorial_source_icons_ready_check CHECK (status <> 'ready' OR (source_url IS NOT NULL AND jsonb_array_length(media_refs) = 2))

provenance_manifests

键与查询约束（现状）：

• CONSTRAINT provenance_manifests_owner_id_id_key UNIQUE (owner_id, id)
• CONSTRAINT provenance_manifests_owner_job_result_key UNIQUE (owner_id, job_id, result_kind)
• CONSTRAINT provenance_manifests_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE CASCADE

provenance_manifest_inputs

键与查询约束（现状）：

• CONSTRAINT provenance_manifest_inputs_role_ordinal_key UNIQUE (manifest_id, role, ordinal)
• CONSTRAINT provenance_manifest_inputs_resource_snapshot_key UNIQUE (manifest_id, role, resource_record_id, snapshot_ref)
• CONSTRAINT provenance_manifest_inputs_owner_manifest_fkey FOREIGN KEY (owner_id, manifest_id) REFERENCES provenance_manifests (owner_id, id) ON DELETE CASCADE
• CONSTRAINT provenance_manifest_inputs_owner_resource_fkey FOREIGN KEY (owner_id, resource_record_id) REFERENCES evidence_resources (owner_id, id)
• CREATE INDEX provenance_manifest_inputs_manifest_idx ON provenance_manifest_inputs (manifest_id, role, ordinal);

coverage_windows

键与查询约束（现状）：

• CONSTRAINT coverage_windows_scope_range_key UNIQUE ( owner_id, source_key, capability, target_hash, sort_key, rule_version, starts_at, ends_at )
• CONSTRAINT coverage_windows_owner_job_fkey FOREIGN KEY (owner_id, last_job_id) REFERENCES jobs (owner_id, id) ON DELETE SET NULL (last_job_id)
• CONSTRAINT coverage_windows_range_check CHECK (starts_at < ends_at)
• CONSTRAINT coverage_windows_reason_check CHECK ( (status = 'partial' AND stop_reason ~ '^[a-z][a-z0-9_]{0,63}$') OR (status <> 'partial' AND stop_reason IS NULL) )

collection_due_windows

键与查询约束（现状）：

• CONSTRAINT collection_due_windows_owner_schedule_due_key UNIQUE (owner_id, schedule_key, due_at)
• CONSTRAINT collection_due_windows_owner_job_key UNIQUE (owner_id, job_id)
• CONSTRAINT collection_due_windows_owner_job_source_operation_key UNIQUE (owner_id, job_id, source_key, operation_id)
• CONSTRAINT collection_due_windows_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) DEFERRABLE INITIALLY DEFERRED
• CONSTRAINT collection_due_windows_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) DEFERRABLE INITIALLY DEFERRED
• CONSTRAINT collection_due_windows_range_check CHECK (window_start < window_end AND window_end <= due_at)
• CONSTRAINT collection_due_windows_admission_pair_check CHECK ( (admission_state = 'pending' AND reason IS NULL AND operation_id IS NULL AND job_id IS NULL) OR (admission_state = 'accepted' AND reason IS NULL AND operation_id IS NOT NULL AND job_id IS NOT NULL) OR (admission_state = 'skipped' AND reason IS NOT NULL AND reason IN ('quiet', 'disabled', 'rate_limited', 'budget') AND operation_id IS NULL AND job_id IS NULL) OR (admission_state = 'missed' AND reason IS NOT NULL AND reason = 'scheduler_interrupted' AND operation_id IS NULL AND job_id IS NULL) )
• CREATE INDEX collection_due_windows_owner_due_idx ON collection_due_windows (owner_id, due_at);

job_stage_attempts

键与查询约束（现状）：

• CONSTRAINT job_stage_attempts_job_stage_sequence_key UNIQUE (job_id, stage, attempt_sequence)
• CONSTRAINT job_stage_attempts_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE CASCADE
• CHECK ( (outcome = 'started' AND finished_at IS NULL) OR (outcome <> 'started' AND finished_at IS NOT NULL) )
• CHECK (finished_at IS NULL OR finished_at >= started_at)
• CREATE INDEX job_stage_attempts_owner_started_idx ON job_stage_attempts (owner_id, started_at);
• CREATE INDEX job_stage_attempts_job_stage_idx ON job_stage_attempts (job_id, stage, attempt_sequence);

outbox_messages

键与查询约束（现状）：

• CONSTRAINT outbox_messages_aggregate_dispatch_key UNIQUE (aggregate_id, dispatch_sequence)
• CHECK (published_at IS NULL OR published_at >= created_at)
• CREATE INDEX outbox_messages_unpublished_idx ON outbox_messages (available_at) WHERE published_at IS NULL;

job_attempts

键与查询约束（现状）：

• CONSTRAINT job_attempts_job_epoch_key UNIQUE (job_id, lease_epoch)
• CHECK (queued_at <= started_at)
• CHECK ( (finished_at IS NULL AND outcome IS NULL) OR (finished_at IS NOT NULL AND outcome IS NOT NULL) )
• CHECK (finished_at IS NULL OR finished_at >= started_at)
• CHECK ( outcome IS NULL OR outcome IN ('expired', 'succeeded', 'cancelled', 'delayed', 'failed') )

processed_messages

键与查询约束（现状）：

• CONSTRAINT processed_messages_topic_partition_offset_key UNIQUE (topic, partition, message_offset)

ai_calls

键与查询约束（现状）：

• CONSTRAINT ai_calls_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT ai_calls_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT ai_calls_routing_version_check CHECK (routing_version IS NULL OR routing_version >= 0)
• CONSTRAINT ai_calls_execution_epoch_check CHECK (execution_epoch IS NULL OR execution_epoch >= 1)
• CONSTRAINT ai_calls_routing_hash_check CHECK (routing_hash IS NULL OR octet_length(routing_hash) = 32)
• CONSTRAINT ai_calls_currency_check CHECK (currency IS NULL OR currency IN ('USD', 'CNY'))
• CONSTRAINT ai_calls_cost_check CHECK ( (cost_estimate_micros IS NULL OR cost_estimate_micros >= 0) AND (cost_actual_micros IS NULL OR cost_actual_micros >= 0) AND (cost_cap_micros IS NULL OR cost_cap_micros >= 0) )
• CONSTRAINT ai_calls_status_failure_check CHECK ( (status IN ('running', 'succeeded') AND failure_code IS NULL) OR (status IN ('unknown', 'failed') AND failure_code IS NOT NULL) )
• CREATE INDEX ai_calls_owner_created_idx ON ai_calls (owner_id, created_at);

codex_reset_recognitions

键与查询约束（现状）：

• CONSTRAINT codex_reset_recognitions_post_fkey FOREIGN KEY(owner_id,monitor_id,post_id) REFERENCES codex_reset_posts(owner_id,monitor_id,id)
• CONSTRAINT codex_reset_recognitions_ai_call_fkey FOREIGN KEY(owner_id,ai_call_id) REFERENCES ai_calls(owner_id,id)
• CONSTRAINT codex_reset_recognitions_status_check CHECK(status IN ('applied','held','stale','failed','running','unknown') AND octet_length(input_fingerprint)=32)
• CONSTRAINT codex_reset_recognitions_json_check CHECK(jsonb_typeof(recognition)='object' AND jsonb_typeof(held)='array' AND jsonb_typeof(notifications)='array')
• CREATE INDEX codex_reset_recognitions_post_idx ON codex_reset_recognitions(owner_id,monitor_id,post_id,created_at);

ai_capability_configurations

键与查询约束（现状）：

• PRIMARY KEY (owner_id, version)
• CONSTRAINT ai_capability_configurations_owner_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT ai_capability_configurations_version_check CHECK (version >= 1)
• CONSTRAINT ai_capability_configurations_hash_check CHECK (octet_length(input_hash) = 32)
• CONSTRAINT ai_capability_configurations_overrides_check CHECK ( jsonb_typeof(overrides) = 'object' AND octet_length(overrides::text) <= 4096 )

content_records

键与查询约束（现状）：

• CONSTRAINT content_records_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT content_records_owner_id_source_key UNIQUE (owner_id, id, source_key)
• CONSTRAINT content_records_source_identity_key UNIQUE NULLS NOT DISTINCT ( owner_id, source_key, object_type, native_scope, external_id )
• CREATE INDEX content_records_owner_id_idx ON content_records (owner_id, id);

content_native_identities

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT content_native_identities_native_key UNIQUE (owner_id, platform, object_type, namespace, native_id)
• CONSTRAINT content_native_identities_content_fkey FOREIGN KEY(owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_native_identities_namespace_check CHECK (platform = 'threads' AND object_type = 'post' AND namespace = 'threads_shortcode')
• CONSTRAINT content_native_identities_id_check CHECK (native_id ~ '^[A-Za-z0-9_-]{1,128}$')

content_discoveries

键与查询约束（现状）：

• CONSTRAINT content_discoveries_owner_content_job_key UNIQUE (owner_id, content_id, job_id)
• CONSTRAINT content_discoveries_owner_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_discoveries_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE RESTRICT
• CREATE INDEX content_discoveries_content_idx ON content_discoveries (owner_id, content_id);

hotlist_snapshots

键与查询约束（现状）：

• CONSTRAINT hotlist_snapshots_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT hotlist_snapshots_owner_job_key UNIQUE (owner_id, job_id)
• CONSTRAINT hotlist_snapshots_owner_source_operation_key UNIQUE (owner_id, source_key, operation_id)
• CONSTRAINT hotlist_snapshots_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT hotlist_snapshots_owner_due_identity_fkey FOREIGN KEY (owner_id, job_id, source_key, operation_id) REFERENCES collection_due_windows (owner_id, job_id, source_key, operation_id) ON DELETE RESTRICT
• CREATE INDEX hotlist_snapshots_latest_idx ON hotlist_snapshots (owner_id, source_key, observed_at DESC, id DESC);

hotlist_entries

键与查询约束（现状）：

• CONSTRAINT hotlist_entries_snapshot_rank_key PRIMARY KEY (snapshot_id, rank)
• CONSTRAINT hotlist_entries_owner_snapshot_fkey FOREIGN KEY (owner_id, snapshot_id) REFERENCES hotlist_snapshots (owner_id, id) ON DELETE CASCADE
• CONSTRAINT hotlist_entries_owner_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE SET NULL (content_id)

content_versions

键与查询约束（现状）：

• CONSTRAINT content_versions_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT content_versions_owner_content_id_key UNIQUE (owner_id, content_id, id)
• CONSTRAINT content_versions_owner_content_fingerprint_key UNIQUE (owner_id, content_id, fingerprint)
• CONSTRAINT content_versions_owner_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_versions_origin_ref_check CHECK ( (text_origin = 'source' AND text_origin_ref IS NULL) OR ( text_origin = 'machine_extracted' AND text_origin_ref IS NOT NULL AND text_origin_ref <> '' ) )
• CONSTRAINT content_versions_text_length_check CHECK ( (title IS NULL OR char_length(title) BETWEEN 1 AND 2000) AND (body IS NULL OR char_length(body) BETWEEN 1 AND 100000) )
• CONSTRAINT content_versions_scope_content_check CHECK ( ( text_scope = 'media_only' AND title IS NULL AND body IS NULL AND truncation_reason IS NULL AND text_origin = 'source' ) OR ( text_scope IN ('full', 'summary') AND (title IS NOT NULL OR body IS NOT NULL) AND truncation_reason IS NULL ) OR ( text_scope = 'truncated' AND (title IS NOT NULL OR body IS NOT NULL) AND truncation_reason IN ('source_limit', 'collector_limit') ) )
• CREATE INDEX content_versions_content_idx ON content_versions (owner_id, content_id, created_at, id);

content_version_relations

键与查询约束（现状）：

• CONSTRAINT content_version_relations_target_key UNIQUE NULLS NOT DISTINCT ( owner_id, content_version_id, relation_type, target_native_scope, target_external_id )
• CONSTRAINT content_version_relations_owner_version_fkey FOREIGN KEY (owner_id, content_version_id) REFERENCES content_versions (owner_id, id) ON DELETE CASCADE
• CREATE INDEX content_version_relations_version_idx ON content_version_relations ( owner_id, content_version_id, relation_type, id );

content_observations

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT content_observations_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT content_observations_owner_identity_version_key UNIQUE (owner_id, id, content_id, content_version_id)
• CONSTRAINT content_observations_source_context_key UNIQUE (owner_id, id, content_id, content_version_id, source_key)
• CONSTRAINT content_observations_input_basis_check CHECK (input_basis IS NULL OR input_basis IN ('source_v1', 'observations_v1'))
• CONSTRAINT content_observations_provenance_check CHECK ((input_basis IS NULL AND source_key IS NULL AND source_native_scope IS NULL AND source_external_id IS NULL AND source_identity_basis IS NULL AND editorial_profile_id IS NULL AND native_identity_proof IS NULL) OR (input_basis IS NOT NULL AND source_key IS NOT NULL AND source_external_id IS NOT NULL AND source_identity_basis IS NOT NULL AND source_key ~ '^[a-z][a-z0-9_-]{0,63}$' AND source_external_id <> '' AND source_identity_basis IN ('guid', 'url_fallback')))
• CONSTRAINT content_observations_proof_check CHECK (native_identity_proof IS NULL OR (jsonb_typeof(native_identity_proof) = 'object' AND octet_length(native_identity_proof::text) <= 8192))
• CONSTRAINT content_observations_owner_content_fkey FOREIGN KEY(owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_observations_owner_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT content_observations_owner_content_version_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE RESTRICT
• CONSTRAINT content_observations_owner_content_operation_key UNIQUE (owner_id, content_id, source_operation_id)
• CONSTRAINT content_observations_received_at_check CHECK (received_at >= observed_at)
• CONSTRAINT content_observations_canonical_url_check CHECK (canonical_url IS NULL OR canonical_url ~ '^https?://')
• CONSTRAINT content_observations_final_url_check CHECK (final_url IS NULL OR final_url ~ '^https?://')
• CONSTRAINT content_observations_author_check CHECK (author_external_id IS NULL OR author_external_id <> '')
• CONSTRAINT content_observations_author_name_check CHECK (author_name IS NULL OR author_name <> '')
• CONSTRAINT content_observations_published_precision_check CHECK ((published_at IS NULL AND published_at_fractional_digits IS NULL) OR (published_at IS NOT NULL AND published_at_fractional_digits BETWEEN 0 AND 6))
• CONSTRAINT content_observations_metrics_check CHECK ((like_count IS NULL OR like_count >= 0) AND (comment_count IS NULL OR comment_count >= 0) AND (repost_count IS NULL OR repost_count >= 0) AND (view_count IS NULL OR view_count >= 0) AND (play_count IS NULL OR play_count >= 0) AND (danmaku_count IS NULL OR danmaku_count >= 0))
• CREATE INDEX content_observations_latest_idx ON content_observations (owner_id, content_id, observed_at, received_at, id);

editorial_source_material_receipts

键与查询约束（现状）：

• PRIMARY KEY (owner_id, profile_id, identity_key)
• CONSTRAINT editorial_materials_profile_fkey FOREIGN KEY(owner_id, profile_id) REFERENCES editorial_source_profiles (owner_id, id) ON DELETE CASCADE
• CONSTRAINT editorial_materials_content_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id)
• CONSTRAINT editorial_materials_run_fkey FOREIGN KEY(owner_id, run_id) REFERENCES editorial_source_runs (owner_id, id)
• CONSTRAINT editorial_materials_observation_fkey FOREIGN KEY(owner_id, observation_id) REFERENCES content_observations (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT editorial_materials_numbers_check CHECK (octet_length(material_hash) = 32 AND body_retry_count BETWEEN 0 AND 3)
• CONSTRAINT editorial_materials_body_check CHECK (body_status IN ('ok','pending','none'))
• CONSTRAINT editorial_materials_metadata_check CHECK (jsonb_typeof(metadata) = 'object')

content_observation_inputs

键与查询约束（现状）：

• PRIMARY KEY (owner_id, output_observation_id, input_observation_id)
• CONSTRAINT content_observation_inputs_output_fkey FOREIGN KEY(owner_id, output_observation_id) REFERENCES content_observations (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_observation_inputs_input_fkey FOREIGN KEY(owner_id, input_observation_id) REFERENCES content_observations (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT content_observation_inputs_not_self_check CHECK (output_observation_id <> input_observation_id)

content_version_inputs

键与查询约束（现状）：

• PRIMARY KEY (owner_id, content_version_id, observation_id)
• CONSTRAINT content_version_inputs_version_fkey FOREIGN KEY (owner_id, content_version_id) REFERENCES content_versions (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_version_inputs_observation_fkey FOREIGN KEY (owner_id, observation_id) REFERENCES content_observations (owner_id, id) ON DELETE RESTRICT

content_topic_matches

键与查询约束（现状）：

• CONSTRAINT content_topic_matches_frozen_key UNIQUE (owner_id, topic_id, topic_rule_version, content_version_id, profile_id, profile_configuration_version)
• CONSTRAINT content_topic_matches_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_topic_matches_topic_rule_fkey FOREIGN KEY (topic_id, topic_rule_version) REFERENCES monitor_topic_versions (topic_id, version) ON DELETE CASCADE
• CONSTRAINT content_topic_matches_content_version_fkey FOREIGN KEY (owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE CASCADE
• CONSTRAINT content_topic_matches_observation_fkey FOREIGN KEY (owner_id, observation_id, content_id, content_version_id) REFERENCES content_observations (owner_id, id, content_id, content_version_id) ON DELETE CASCADE
• CONSTRAINT content_topic_matches_profile_version_fkey FOREIGN KEY (owner_id, profile_id, profile_configuration_version) REFERENCES editorial_source_profile_versions (owner_id, profile_id, version)
• CONSTRAINT content_topic_matches_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT content_topic_matches_connection_fkey FOREIGN KEY (owner_id, connection_id, connection_version) REFERENCES source_connection_versions (owner_id, connection_id, version)
• CONSTRAINT content_topic_matches_versions_check CHECK (topic_rule_version >= 1 AND profile_configuration_version >= 1 AND connection_version >= 1 AND policy_version >= 1)
• CONSTRAINT content_topic_matches_inputs_check CHECK (jsonb_typeof(input_observation_ids) = 'array' AND jsonb_array_length(input_observation_ids) BETWEEN 1 AND 32)
• CREATE INDEX content_topic_matches_topic_idx ON content_topic_matches (owner_id, topic_id, matched_at);

content_threads

键与查询约束（现状）：

• PRIMARY KEY (owner_id, content_id)
• CONSTRAINT content_threads_owner_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_threads_owner_post_fkey FOREIGN KEY (owner_id, post_content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_threads_owner_root_fkey FOREIGN KEY (owner_id, root_content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_threads_owner_parent_fkey FOREIGN KEY (owner_id, parent_content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_threads_owner_reply_target_fkey FOREIGN KEY (owner_id, reply_target_content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_threads_distinct_check CHECK ( content_id <> post_content_id AND (parent_content_id IS NULL OR parent_content_id <> content_id) AND (reply_target_content_id IS NULL OR reply_target_content_id <> content_id) AND ( (parent_content_id IS NULL AND root_content_id IS NOT NULL AND root_content_id = content_id AND reply_target_content_id IS NULL AND parent_relation_status = 'root') OR (parent_content_id IS NOT NULL AND (root_content_id IS NULL OR root_content_id <> content_id) AND parent_relation_status IN ('observed', 'unavailable', 'unresolved')) ) )
• CREATE INDEX content_threads_post_idx ON content_threads (owner_id, post_content_id, content_id);

content_visibility_observations

键与查询约束（现状）：

• CONSTRAINT content_visibility_observations_owner_content_operation_key UNIQUE (owner_id, content_id, source_operation_id)
• CONSTRAINT content_visibility_observations_owner_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_visibility_observations_owner_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT content_visibility_observations_status_basis_check CHECK ( (status = 'visible' AND basis = 'content_returned') OR ( status = 'deleted' AND basis IN ('source_tombstone', 'http_gone') ) OR ( status = 'restricted' AND basis IN ('access_denied', 'authentication_required') ) OR ( status = 'transient_failure' AND basis IN ('timeout', 'rate_limited', 'upstream_error') ) OR ( status = 'unknown' AND basis IN ('not_found', 'protocol_error') ) )
• CREATE INDEX content_visibility_observations_latest_idx ON content_visibility_observations ( owner_id, content_id, observed_at, received_at, id );

content_rendered_materials

键与查询约束（现状）：

• PRIMARY KEY (owner_id, content_version_id)
• CONSTRAINT content_rendered_materials_version_fkey FOREIGN KEY (owner_id, content_id, content_version_id) REFERENCES content_versions(owner_id, content_id, id) ON DELETE CASCADE
• CONSTRAINT content_rendered_materials_format_check CHECK (body_format IN ('text','html','markdown'))
• CONSTRAINT content_rendered_materials_body_check CHECK (char_length(body) <= 500000)
• CONSTRAINT content_rendered_materials_media_check CHECK (jsonb_typeof(media) = 'array' AND jsonb_array_length(media) <= 64 AND octet_length(media::text) <= 65536)
• CONSTRAINT content_rendered_materials_hash_check CHECK (octet_length(representation_hash) = 32 AND octet_length(input_hash) = 32)

analysis_prompt_activations

analysis_prompt_runtime_sessions

键与查询约束（现状）：

• CONSTRAINT analysis_prompt_runtime_sessions_last_seen_check CHECK (last_seen_at >= started_at)
• CONSTRAINT analysis_prompt_runtime_sessions_stopped_check CHECK (stopped_at IS NULL OR stopped_at >= last_seen_at)
• CREATE INDEX analysis_prompt_runtime_sessions_version_started_idx ON analysis_prompt_runtime_sessions (prompt_version, started_at);

content_annotations

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT content_annotations_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT content_annotations_owner_version_topic_rule_prompt_key UNIQUE (owner_id, content_version_id, topic_id, topic_rule_version, prompt_version, input_signature)
• CONSTRAINT content_annotations_owner_content_version_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE CASCADE
• CONSTRAINT content_annotations_owner_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT content_annotations_topic_rule_version_fkey FOREIGN KEY(topic_id, topic_rule_version) REFERENCES monitor_topic_versions (topic_id, version) ON DELETE CASCADE
• CONSTRAINT content_annotations_owner_ai_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT content_annotations_rule_version_check CHECK (topic_rule_version >= 1)
• CONSTRAINT content_annotations_prompt_version_check CHECK (prompt_version <> '')
• CONSTRAINT content_annotations_input_manifest_check CHECK ((input_manifest IS NULL AND input_signature = 'legacy') OR (input_manifest IS NOT NULL AND jsonb_typeof(input_manifest) = 'object' AND octet_length(input_manifest::text) <= 262144 AND input_signature ~ '^[0-9a-f]{64}$'))
• CONSTRAINT content_annotations_sentiment_check CHECK (sentiment IS NULL OR sentiment IN ('positive', 'neutral', 'negative'))
• CONSTRAINT content_annotations_viewpoints_check CHECK (jsonb_typeof(viewpoints) = 'array' AND jsonb_array_length(viewpoints) <= 5)
• CONSTRAINT content_annotations_diagnostic_history_check CHECK (jsonb_typeof(diagnostic_history) = 'array')
• CONSTRAINT content_annotations_status_check CHECK (status IN ('annotated', 'unanalyzed'))
• CONSTRAINT content_annotations_output_status_check CHECK ((status = 'annotated' AND result_state = 'valid' AND relevant IS NOT NULL AND relevance_reason IS NOT NULL AND btrim(relevance_reason) <> '' AND summary IS NOT NULL AND btrim(summary) <> '' AND ai_call_id IS NOT NULL AND error_code IS NULL AND ((relevant AND sentiment IS NOT NULL) OR (NOT relevant AND sentiment IS NULL))) OR (status = 'unanalyzed' AND result_state IN ('pending', 'failed', 'invalid') AND relevant IS NULL AND relevance_reason IS NULL AND sentiment IS NULL AND summary IS NULL AND viewpoints = '[]'::jsonb AND ((result_state = 'pending' AND ai_call_id IS NULL AND error_code IS NULL) OR (result_state IN ('failed', 'invalid') AND ai_call_id IS NOT NULL AND error_code IS NOT NULL AND btrim(error_code) <> ''))))
• CONSTRAINT content_annotations_updated_at_check CHECK (created_at <= updated_at)
• CONSTRAINT content_annotations_first_valid_at_check CHECK ((result_state = 'valid') = (first_valid_at IS NOT NULL))
• CREATE INDEX content_annotations_content_idx ON content_annotations (owner_id, content_id, created_at);
• CREATE INDEX content_annotations_topic_created_idx ON content_annotations (owner_id, topic_id, created_at);

editorial_sources

键与查询约束（现状）：

• PRIMARY KEY (owner_id, source_key)
• CONSTRAINT editorial_sources_revision_check CHECK (revision >= 1)

editorial_source_versions

键与查询约束（现状）：

• PRIMARY KEY (owner_id, source_key, revision)
• CONSTRAINT editorial_source_versions_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT editorial_source_versions_source_fkey FOREIGN KEY (owner_id, source_key) REFERENCES editorial_sources (owner_id, source_key) ON DELETE CASCADE
• CONSTRAINT editorial_source_versions_input_check CHECK (revision >= 1 AND octet_length(input_fingerprint) = 32)
• CONSTRAINT editorial_source_versions_configuration_check CHECK (jsonb_typeof(configuration) = 'object')

editorial_runs

键与查询约束（现状）：

• CONSTRAINT editorial_runs_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT editorial_runs_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT editorial_runs_content_version_fkey FOREIGN KEY (owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE CASCADE
• CONSTRAINT editorial_runs_source_version_fkey FOREIGN KEY (owner_id, source_key, source_revision) REFERENCES editorial_source_versions (owner_id, source_key, revision)
• CONSTRAINT editorial_runs_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT editorial_runs_status_check CHECK (status IN ('queued','running','complete','blocked','failed','unknown','stale'))
• CONSTRAINT editorial_runs_options_check CHECK (stages IN ('selection','all') AND manual_version >= 0)
• CONSTRAINT editorial_runs_input_check CHECK (octet_length(input_fingerprint) = 32 AND length(prompt_version) > 0)
• CONSTRAINT editorial_runs_result_check CHECK (result IS NULL OR jsonb_typeof(result) = 'object')
• CREATE INDEX editorial_runs_owner_content_created_idx ON editorial_runs (owner_id, content_id, created_at);

editorial_stages

键与查询约束（现状）：

• CONSTRAINT editorial_stages_run_key UNIQUE (owner_id, run_id, stage_key)
• CONSTRAINT editorial_stages_run_fkey FOREIGN KEY (owner_id, run_id) REFERENCES editorial_runs (owner_id, id) ON DELETE CASCADE
• CONSTRAINT editorial_stages_ai_call_fkey FOREIGN KEY (owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT editorial_stages_status_check CHECK (status IN ('running','succeeded','failed','unknown'))
• CONSTRAINT editorial_stages_input_check CHECK (octet_length(input_fingerprint) = 32)
• CONSTRAINT editorial_stages_output_check CHECK (output IS NULL OR jsonb_typeof(output) = 'object')
• CONSTRAINT editorial_stages_success_check CHECK (status <> 'succeeded' OR output IS NOT NULL)

editorial_overrides

键与查询约束（现状）：

• CONSTRAINT editorial_overrides_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT editorial_overrides_run_fkey FOREIGN KEY (owner_id, run_id) REFERENCES editorial_runs (owner_id, id)
• CONSTRAINT editorial_overrides_input_check CHECK (revision >= 1 AND octet_length(input_fingerprint) = 32)
• CONSTRAINT editorial_overrides_reason_check CHECK (length(reason) BETWEEN 1 AND 1000)

editorial_content_states

键与查询约束（现状）：

• PRIMARY KEY (owner_id, content_id)
• CONSTRAINT editorial_content_states_content_fkey FOREIGN KEY (owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT editorial_content_states_current_run_fkey FOREIGN KEY (owner_id, current_run_id) REFERENCES editorial_runs (owner_id, id)
• CONSTRAINT editorial_content_states_manual_check CHECK (manual_version >= 0)

analysis_selectbench_runs

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT analysis_selectbench_runs_scope_key UNIQUE (owner_id, id)
• CONSTRAINT analysis_selectbench_runs_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT analysis_selectbench_runs_input_check CHECK (octet_length(input_fingerprint)=32 AND octet_length(gold_fingerprint)=32 AND sample_size BETWEEN 1 AND 5000 AND jsonb_typeof(models)='array' AND jsonb_typeof(summary)='object')

analysis_selectbench_results

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT analysis_selectbench_results_run_fkey FOREIGN KEY(owner_id, run_id) REFERENCES analysis_selectbench_runs (owner_id, id) ON DELETE CASCADE
• CONSTRAINT analysis_selectbench_results_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT analysis_selectbench_results_case_key UNIQUE (owner_id, run_id, model, case_id)
• CONSTRAINT analysis_selectbench_results_decision_check CHECK (gold IN ('select','reject','either') AND (decision IS NULL OR decision IN ('select','reject')) AND (score IS NULL OR score BETWEEN 0 AND 100))

content_translation_runs

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT content_translation_runs_owner_key UNIQUE (owner_id, id)
• CONSTRAINT content_translation_runs_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT content_translation_runs_revision_key UNIQUE (owner_id, content_id, content_version_id, policy_revision, revision)
• CONSTRAINT content_translation_runs_content_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id)
• CONSTRAINT content_translation_runs_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT content_translation_runs_status_check CHECK (status IN ('queued','running','complete','partial','unknown','failed','stale'))
• CONSTRAINT content_translation_runs_version_check CHECK (source_format IN ('text','html','markdown') AND revision >= 1 AND policy_revision >= 1)
• CONSTRAINT content_translation_runs_input_check CHECK (length(input_fingerprint)=64 AND length(request_fingerprint)=64 AND jsonb_typeof(reference)='object')
• CONSTRAINT content_translation_runs_counts_check CHECK (translated_segments >= 0 AND translated_segments <= total_segments)
• CONSTRAINT content_translation_runs_result_check CHECK (status NOT IN ('complete','partial') OR body_html IS NOT NULL)

content_translation_batches

键与查询约束（现状）：

• PRIMARY KEY (run_id, ordinal)
• CONSTRAINT content_translation_batches_run_fkey FOREIGN KEY(owner_id, run_id) REFERENCES content_translation_runs (owner_id, id)
• CONSTRAINT content_translation_batches_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT content_translation_batches_status_check CHECK (status IN ('running','succeeded','unknown','failed') AND ordinal >= 0)
• CONSTRAINT content_translation_batches_answers_check CHECK (answers IS NULL OR jsonb_typeof(answers)='array')

events

键与查询约束（现状）：

• CONSTRAINT events_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT events_owner_topic_id_key UNIQUE (owner_id, topic_id, id)
• CONSTRAINT events_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT events_merged_into_fkey FOREIGN KEY (owner_id, topic_id, merged_into_id) REFERENCES events (owner_id, topic_id, id)
• CONSTRAINT events_merge_state_check CHECK ( (status = 'active' AND merged_into_id IS NULL) OR (status = 'merged' AND merged_into_id IS NOT NULL AND merged_into_id <> id) )
• CREATE INDEX events_owner_topic_seen_idx ON events (owner_id, topic_id, first_seen_at DESC, id);

event_members

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_members_input_manifest_check CHECK (input_manifest IS NULL OR jsonb_typeof(input_manifest)='object')
• CONSTRAINT event_members_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_members_content_version_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE RESTRICT
• CONSTRAINT event_members_observation_identity_fkey FOREIGN KEY(owner_id, observation_id, content_id, content_version_id) REFERENCES content_observations (owner_id, id, content_id, content_version_id) ON DELETE RESTRICT
• CONSTRAINT event_members_observation_source_check CHECK (observation_source_key IS NULL OR observation_source_key=source_key)
• CONSTRAINT event_members_observation_source_fkey FOREIGN KEY(owner_id, observation_id, content_id, content_version_id, observation_source_key) REFERENCES content_observations (owner_id, id, content_id, content_version_id, source_key) ON DELETE RESTRICT
• CONSTRAINT event_members_comment_fkey FOREIGN KEY(owner_id, representative_comment_id) REFERENCES content_records (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT event_members_comment_observation_fkey FOREIGN KEY(owner_id, representative_comment_observation_id) REFERENCES content_observations (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT event_members_revision_key UNIQUE (owner_id, topic_id, event_id, content_id, added_revision)
• CONSTRAINT event_members_scope_id_key UNIQUE (owner_id, topic_id, event_id, id)
• CONSTRAINT event_members_added_revision_check CHECK (added_revision >= 1)
• CONSTRAINT event_members_removed_revision_check CHECK (removed_revision IS NULL OR removed_revision > added_revision)
• CONSTRAINT event_members_origin_check CHECK (assignment_origin IN ('model', 'manual'))
• CONSTRAINT event_members_source_key_check CHECK (source_key ~ '^[a-z][a-z0-9_-]{0,63}$')
• CREATE INDEX event_members_event_current_idx ON event_members (owner_id, event_id) WHERE removed_revision IS NULL;
• CREATE UNIQUE INDEX event_members_one_current_assignment_idx ON event_members (owner_id, topic_id, content_id) WHERE removed_revision IS NULL;

event_candidates

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_candidates_fingerprint_key UNIQUE (owner_id, topic_id, input_fingerprint)
• CONSTRAINT event_candidates_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT event_candidates_owner_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_candidates_ai_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT event_candidates_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT event_candidates_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id)
• CONSTRAINT event_candidates_fingerprint_length_check CHECK (octet_length(input_fingerprint) = 32)
• CONSTRAINT event_candidates_members_check CHECK (jsonb_typeof(member_version_ids) = 'array' AND jsonb_array_length(member_version_ids) BETWEEN 1 AND 20)
• CONSTRAINT event_candidates_revisions_check CHECK (jsonb_typeof(expected_event_revisions) = 'object')
• CONSTRAINT event_candidates_input_manifest_check CHECK (input_manifest IS NULL OR jsonb_typeof(input_manifest) = 'object')
• CONSTRAINT event_candidates_window_check CHECK (window_end > window_start)
• CONSTRAINT event_candidates_prompt_check CHECK (prompt_version <> '')
• CONSTRAINT event_candidates_status_check CHECK (status IN ('pending', 'confirmed', 'rejected', 'failed'))
• CONSTRAINT event_candidates_updated_at_check CHECK (updated_at >= created_at)
• CONSTRAINT event_candidates_result_check CHECK ((status = 'pending' AND event_id IS NULL) OR (status = 'confirmed' AND event_id IS NOT NULL AND ai_call_id IS NOT NULL AND error_code IS NULL) OR (status = 'rejected' AND event_id IS NULL AND ai_call_id IS NOT NULL AND error_code IS NULL) OR (status = 'failed' AND event_id IS NULL AND error_code IS NOT NULL))
• CREATE INDEX event_candidates_pending_idx ON event_candidates (status, owner_id, topic_id, created_at);

event_facts

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_facts_scope_id_key UNIQUE (owner_id, topic_id, id)
• CONSTRAINT event_facts_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_facts_merged_into_fkey FOREIGN KEY(owner_id, topic_id, merged_into_id) REFERENCES event_facts (owner_id, topic_id, id)
• CONSTRAINT event_facts_revision_check CHECK (revision >= 1)
• CONSTRAINT event_facts_title_check CHECK (btrim(title) <> '')
• CONSTRAINT event_facts_summary_check CHECK (btrim(summary) <> '')
• CONSTRAINT event_facts_status_check CHECK (status IN ('confirmed','unreviewed','merged'))
• CONSTRAINT event_facts_merge_check CHECK ((status = 'merged' AND merged_into_id IS NOT NULL AND merged_into_id <> id) OR (status <> 'merged' AND merged_into_id IS NULL))
• CONSTRAINT event_facts_time_check CHECK (first_seen_basis IN ('published','discovered'))
• CONSTRAINT event_facts_frame_check CHECK (frame IS NULL OR jsonb_typeof(frame) = 'object')
• CONSTRAINT event_facts_updated_check CHECK (updated_at >= created_at)

event_fact_assignments

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_fact_assignments_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_fact_assignments_fact_fkey FOREIGN KEY(owner_id, topic_id, fact_id) REFERENCES event_facts (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_fact_assignments_root_fkey FOREIGN KEY(owner_id, topic_id, root_fact_id) REFERENCES event_facts (owner_id, topic_id, id)
• CONSTRAINT event_fact_assignments_revision_key UNIQUE (owner_id, event_id, fact_id, added_revision)
• CONSTRAINT event_fact_assignments_added_check CHECK (added_revision >= 1)
• CONSTRAINT event_fact_assignments_removed_check CHECK (removed_revision IS NULL OR removed_revision > added_revision)
• CONSTRAINT event_fact_assignments_relation_check CHECK (relation IN ('root','development','background','roundup','unreviewed'))
• CONSTRAINT event_fact_assignments_root_check CHECK ((relation IN ('development','background') AND root_fact_id IS NOT NULL AND root_fact_id <> fact_id) OR (relation IN ('root','roundup','unreviewed') AND root_fact_id IS NULL))
• CREATE UNIQUE INDEX event_fact_assignments_current_fact_idx ON event_fact_assignments (owner_id, topic_id, fact_id) WHERE removed_revision IS NULL;
• CREATE UNIQUE INDEX event_fact_assignments_current_root_idx ON event_fact_assignments (owner_id, event_id) WHERE removed_revision IS NULL AND relation IN ('root','roundup');

event_fact_members

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_fact_members_fact_fkey FOREIGN KEY(owner_id, topic_id, fact_id) REFERENCES event_facts (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_fact_members_member_fkey FOREIGN KEY(owner_id, topic_id, event_id, event_member_id) REFERENCES event_members (owner_id, topic_id, event_id, id) ON DELETE CASCADE
• CONSTRAINT event_fact_members_content_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE RESTRICT
• CONSTRAINT event_fact_members_history_key UNIQUE (owner_id, fact_id, event_member_id)
• CONSTRAINT event_fact_members_role_check CHECK (role IN ('primary','report','mention'))
• CONSTRAINT event_fact_members_origin_check CHECK (assignment_origin IN ('model','manual','legacy'))
• CONSTRAINT event_fact_members_added_check CHECK (added_revision >= 1)
• CONSTRAINT event_fact_members_removed_check CHECK (removed_revision IS NULL OR removed_revision > added_revision)
• CREATE UNIQUE INDEX event_fact_members_current_content_idx ON event_fact_members (owner_id, topic_id, content_id) WHERE removed_revision IS NULL;
• CREATE UNIQUE INDEX event_fact_members_current_primary_idx ON event_fact_members (owner_id, fact_id) WHERE removed_revision IS NULL AND role = 'primary';

event_grouping_overrides

键与查询约束（现状）：

• PRIMARY KEY (owner_id, topic_id, content_id)
• CONSTRAINT event_grouping_overrides_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_grouping_overrides_content_fkey FOREIGN KEY(owner_id, content_id) REFERENCES content_records (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_grouping_overrides_mode_check CHECK (mode IN ('standalone','manual','regroup_pending'))
• CONSTRAINT event_grouping_overrides_revision_check CHECK (revision >= 1)
• CONSTRAINT event_grouping_overrides_reason_check CHECK (btrim(reason) <> '')

event_revision_operations

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_revision_operations_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT event_revision_operations_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_revision_operations_hash_check CHECK (octet_length(input_fingerprint) = 32)
• CONSTRAINT event_revision_operations_kind_check CHECK (kind IN ('merge','split','move','detach','merge_facts','regroup','create_fact'))
• CONSTRAINT event_revision_operations_reason_check CHECK (btrim(reason) <> '')
• CONSTRAINT event_revision_operations_json_check CHECK (jsonb_typeof(before_state) = 'object' AND jsonb_typeof(after_state) = 'object' AND jsonb_typeof(result) = 'object')

event_derived_contents

键与查询约束（现状）：

• PRIMARY KEY (owner_id, event_id)
• CONSTRAINT event_derived_contents_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_derived_contents_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT event_derived_contents_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT event_derived_contents_revision_check CHECK (event_revision >= 1)
• CONSTRAINT event_derived_contents_hash_check CHECK (octet_length(input_fingerprint) = 32)
• CONSTRAINT event_derived_contents_status_check CHECK (status IN ('pending','valid','failed','stale'))
• CONSTRAINT event_derived_contents_text_check CHECK ((status = 'valid' AND title IS NOT NULL AND summary IS NOT NULL) OR (status <> 'valid' AND title IS NULL AND summary IS NULL AND latest_progress IS NULL))

event_grouping_assessments

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_grouping_assessments_candidate_fkey FOREIGN KEY(owner_id, candidate_id) REFERENCES event_candidates (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_grouping_assessments_topic_fkey FOREIGN KEY(owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_grouping_assessments_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT event_grouping_assessments_input_key UNIQUE (owner_id, candidate_id, input_fingerprint)
• CONSTRAINT event_grouping_assessments_hash_check CHECK (octet_length(input_fingerprint) = 32)
• CONSTRAINT event_grouping_assessments_status_check CHECK (status IN ('pending','valid','degraded','stale','failed'))
• CONSTRAINT event_grouping_assessments_json_check CHECK (jsonb_typeof(input_snapshot) = 'object' AND jsonb_typeof(decisions) = 'array')
• CONSTRAINT event_grouping_assessments_confidence_check CHECK (confidence IS NULL OR confidence BETWEEN 0 AND 1)

event_attention_sources

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_attention_sources_scope_id_key UNIQUE (owner_id, id)
• CONSTRAINT event_attention_sources_selector_key UNIQUE (owner_id, source_key, selector_kind, selector_ref)
• CONSTRAINT event_attention_sources_source_check CHECK (source_key ~ '^[a-z][a-z0-9_-]{0,63}$')
• CONSTRAINT event_attention_sources_selector_check CHECK (selector_kind IN ('source','author','native_scope','canonical_host'))
• CONSTRAINT event_attention_sources_identity_check CHECK (btrim(selector_ref) <> '' AND btrim(name) <> '')
• CONSTRAINT event_attention_sources_mode_check CHECK (mode IN ('editorial','signal','isolated'))
• CONSTRAINT event_attention_sources_revision_check CHECK (revision >= 1 AND interval_seconds >= 300)
• CONSTRAINT event_attention_sources_tier_check CHECK (tier IS NULL OR tier IN ('T1','T1_5','T2'))
• CONSTRAINT event_attention_sources_updated_check CHECK (updated_at >= created_at)

event_attention_signals

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_attention_signals_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_attention_signals_source_fkey FOREIGN KEY(owner_id, source_id) REFERENCES event_attention_sources (owner_id, id) ON DELETE CASCADE
• CONSTRAINT event_attention_signals_fact_fkey FOREIGN KEY(owner_id, topic_id, fact_id) REFERENCES event_facts (owner_id, topic_id, id)
• CONSTRAINT event_attention_signals_content_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE RESTRICT
• CONSTRAINT event_attention_signals_observation_fkey FOREIGN KEY(owner_id, observation_id) REFERENCES content_observations (owner_id, id) ON DELETE RESTRICT
• CONSTRAINT event_attention_signals_input_key UNIQUE (owner_id, topic_id, event_id, content_id, content_version_id, observation_id)
• CONSTRAINT event_attention_signals_kind_check CHECK (kind IN ('editorial','discussion','native'))
• CONSTRAINT event_attention_signals_time_check CHECK (time_basis IN ('published','discovered'))
• CONSTRAINT event_attention_signals_status_check CHECK (status IN ('active','withdrawn'))
• CREATE INDEX event_attention_signals_window_idx ON event_attention_signals (owner_id, event_id, source_time);

event_attention_snapshots

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_attention_snapshots_event_fkey FOREIGN KEY(owner_id, topic_id, event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_attention_snapshots_input_key UNIQUE (owner_id, event_id, event_revision, window_end, formula_version, input_fingerprint)
• CONSTRAINT event_attention_snapshots_revision_check CHECK (event_revision >= 1 AND octet_length(input_fingerprint) = 32)
• CONSTRAINT event_attention_snapshots_json_check CHECK (jsonb_typeof(input_manifest) = 'object' AND jsonb_typeof(result) = 'object')
• CREATE INDEX event_attention_snapshots_latest_idx ON event_attention_snapshots (owner_id, event_id, window_end, computed_at);

event_story_links

键与查询约束（现状）：

• PRIMARY KEY (owner_id, first_event_id, second_event_id)
• CONSTRAINT event_story_links_first_fkey FOREIGN KEY(owner_id, topic_id, first_event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_story_links_second_fkey FOREIGN KEY(owner_id, topic_id, second_event_id) REFERENCES events (owner_id, topic_id, id) ON DELETE CASCADE
• CONSTRAINT event_story_links_order_check CHECK (first_event_id < second_event_id)
• CONSTRAINT event_story_links_revision_check CHECK (first_revision >= 1 AND second_revision >= 1)
• CONSTRAINT event_story_links_evidence_check CHECK (jsonb_typeof(evidence)='array' AND jsonb_array_length(evidence) BETWEEN 2 AND 20)
• CREATE INDEX event_story_links_second_idx ON event_story_links (owner_id, topic_id, second_event_id);

event_content_embeddings

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT event_content_embeddings_scope_key UNIQUE (owner_id, id)
• CONSTRAINT event_content_embeddings_input_key UNIQUE (owner_id, content_version_id, model, requested_dimensions, input_fingerprint)
• CONSTRAINT event_content_embeddings_version_fkey FOREIGN KEY(owner_id, content_id, content_version_id) REFERENCES content_versions (owner_id, content_id, id) ON DELETE CASCADE
• CONSTRAINT event_content_embeddings_job_fkey FOREIGN KEY(owner_id, job_id) REFERENCES jobs (owner_id, id)
• CONSTRAINT event_content_embeddings_call_fkey FOREIGN KEY(owner_id, ai_call_id) REFERENCES ai_calls (owner_id, id)
• CONSTRAINT event_content_embeddings_input_check CHECK (requested_dimensions BETWEEN 0 AND 3072 AND octet_length(input_fingerprint)=32)
• CONSTRAINT event_content_embeddings_status_check CHECK (status IN ('pending','running','response_saved','valid','failed','unknown','stale'))
• CONSTRAINT event_content_embeddings_vector_check CHECK ((status IN ('valid','response_saved') AND dimensions BETWEEN 1 AND 3072 AND vector IS NOT NULL AND jsonb_typeof(vector)='array' AND jsonb_array_length(vector)=dimensions AND ai_call_id IS NOT NULL) OR (status NOT IN ('valid','response_saved') AND dimensions IS NULL AND vector IS NULL))

reports

键与查询约束（现状）：

• CONSTRAINT reports_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT reports_owner_topic_kind_window_version_key UNIQUE (owner_id, topic_id, kind, window_start, version)
• CONSTRAINT reports_owner_topic_fkey FOREIGN KEY (owner_id, topic_id) REFERENCES monitor_topics (owner_id, id) ON DELETE CASCADE
• CONSTRAINT reports_window_check CHECK (window_start < window_end)
• CONSTRAINT reports_cutoff_check CHECK (cutoff_at >= window_end)
• CONSTRAINT reports_created_cutoff_check CHECK (created_at >= cutoff_at)
• CREATE INDEX reports_owner_topic_window_idx ON reports (owner_id, topic_id, kind, window_start, status);

report_editions

键与查询约束（现状）：

• CONSTRAINT report_editions_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT report_editions_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT report_editions_revision_key UNIQUE (owner_id, kind, period_key, revision)
• CONSTRAINT report_editions_job_fkey FOREIGN KEY (owner_id, job_id) REFERENCES jobs(owner_id, id)
• CONSTRAINT report_editions_ai_call_fkey FOREIGN KEY (owner_id, ai_call_id) REFERENCES ai_calls(owner_id, id)
• CONSTRAINT report_editions_kind_revision_check CHECK (kind IN ('daily','weekly','monthly') AND revision >= 1)
• CONSTRAINT report_editions_status_check CHECK (status IN ('queued','running','complete','failed','unknown','stale'))
• CONSTRAINT report_editions_generator_check CHECK (generator IN ('template','model','manual'))
• CONSTRAINT report_editions_window_check CHECK (window_start < window_end AND cutoff_at >= window_end)
• CONSTRAINT report_editions_snapshot_check CHECK (jsonb_typeof(input_snapshot) = 'array')
• CONSTRAINT report_editions_content_check CHECK (content IS NULL OR jsonb_typeof(content) = 'object')
• CONSTRAINT report_editions_complete_check CHECK (status <> 'complete' OR (content IS NOT NULL AND body_markdown IS NOT NULL AND length(body_markdown) > 0))
• CONSTRAINT report_editions_fingerprint_check CHECK (length(input_fingerprint) = 64)
• CREATE INDEX report_editions_owner_period_idx ON report_editions(owner_id, kind, period_key, revision);

report_edition_schedules

键与查询约束（现状）：

• PRIMARY KEY (owner_id, kind)
• CONSTRAINT report_edition_schedules_kind_check CHECK (kind IN ('daily','weekly','monthly'))
• CONSTRAINT report_edition_schedules_key_check CHECK (length(first_period_key) BETWEEN 7 AND 10)

knowledge_exports

键与查询约束（现状）：

• PRIMARY KEY (owner_id, object_type, object_id)
• CONSTRAINT knowledge_exports_owner_relative_path_key UNIQUE (owner_id, relative_path)

notification_targets

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT notification_targets_owner_name_key UNIQUE (owner_id, name)
• CONSTRAINT notification_targets_owner_id_key UNIQUE (owner_id, id)
• CONSTRAINT notification_targets_channel_check CHECK (channel IN ('feishu', 'email'))
• CONSTRAINT notification_targets_recipients_check CHECK (jsonb_typeof(recipients) = 'array')
• CONSTRAINT notification_targets_secret_env_check CHECK (secret_env IS NULL OR secret_env ~ '^HOTKEY_[A-Z][A-Z0-9_]*$')
• CONSTRAINT notification_targets_updated_at_check CHECK (updated_at >= created_at)
• CONSTRAINT notification_targets_revision_check CHECK (revision >= 1)
• CONSTRAINT notification_targets_subscriptions_check CHECK (jsonb_typeof(subscriptions)='array' AND jsonb_array_length(subscriptions)<=5 AND subscriptions <@ '["report","edition","selected","codex_reset","alert"]'::jsonb)
• CONSTRAINT notification_targets_enabled_at_check CHECK (enabled_at IS NULL OR enabled_at >= created_at)

notification_deliveries

键与查询约束（现状）：

• PRIMARY KEY (id)
• CONSTRAINT notification_deliveries_owner_target_fkey FOREIGN KEY(owner_id, target_id) REFERENCES notification_targets (owner_id, id) ON DELETE CASCADE
• CONSTRAINT notification_deliveries_report_version_target_key UNIQUE (report_id, report_version, target_id)
• CONSTRAINT notification_deliveries_subject_target_key UNIQUE (owner_id, target_id, subject_kind, dedupe_key)
• CONSTRAINT notification_deliveries_subject_check CHECK (subject_kind IN ('report','edition','selected','codex_reset','alert') AND ((subject_kind='report' AND report_id IS NOT NULL AND subject_id IS NULL) OR (subject_kind<>'report' AND report_id IS NULL AND subject_id IS NOT NULL)))
• CONSTRAINT notification_deliveries_snapshot_check CHECK (revision>=1 AND target_revision>=1 AND (input_fingerprint IS NULL OR octet_length(input_fingerprint)=32) AND (subject_kind='report' OR (input_fingerprint IS NOT NULL AND dedupe_key IS NOT NULL)) AND (dedupe_key IS NULL OR length(dedupe_key) BETWEEN 1 AND 256) AND jsonb_typeof(frozen_payload)='object' AND jsonb_typeof(provider_receipt)='object')
• CONSTRAINT notification_deliveries_version_check CHECK (report_version >= 1)
• CONSTRAINT notification_deliveries_status_check CHECK (status IN ('pending', 'sending', 'succeeded', 'failed', 'unknown'))
• CONSTRAINT notification_deliveries_attempt_check CHECK (attempt_count BETWEEN 0 AND 3)
• CONSTRAINT notification_deliveries_updated_at_check CHECK (updated_at >= created_at)
• FOREIGN KEY(report_id) REFERENCES reports (id) ON DELETE CASCADE

publication_source_policies

键与查询约束（现状）：

• PRIMARY KEY (owner_id, source_key)
• CONSTRAINT publication_source_policies_revision_check CHECK (revision >= 1)

publication_policy_versions

键与查询约束（现状）：

• PRIMARY KEY (owner_id, source_key, revision)
• CONSTRAINT publication_policy_versions_policy_fk FOREIGN KEY (owner_id, source_key) REFERENCES publication_source_policies(owner_id, source_key)
• CONSTRAINT publication_policy_versions_operation_key UNIQUE (owner_id, operation_id)
• CONSTRAINT publication_policy_versions_revision_check CHECK (revision >= 1)

publication_records