codexLB-up 1.25.0b10__py3-none-any.whl

app/db/alembic/versions/20260909_030000_dashboard_resilience_toggle_settings.py

@@ -0,0 +1,63 @@
+"""add dashboard-managed resilience toggle columns
+
+Three nullable ``dashboard_settings`` BOOLEAN columns named after the
+``Settings`` fields they take over: ``soft_drain_enabled``,
+``deterministic_failover_enabled`` and ``circuit_breaker_enabled``. NULL means
+"inherit": the deprecated ``CODEX_LB_*`` environment alias, then the code
+default, keep applying until an operator sets a value in the dashboard
+(configuration-tiers; slop-removal campaign 0908, C2-3).
+
+Revision ID: 20260909_030000_dashboard_resilience_toggle_settings
+Revises: 20260908_020000_merge_overflow_transport_heads
+Create Date: 2026-09-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_030000_dashboard_resilience_toggle_settings"
+down_revision = "20260908_020000_merge_overflow_transport_heads"
+branch_labels = None
+depends_on = None
+
+_SETTINGS_TABLE = "dashboard_settings"
+_COLUMN_NAMES = (
+    "soft_drain_enabled",
+    "deterministic_failover_enabled",
+    "circuit_breaker_enabled",
+)
+
+
+def _settings_columns() -> tuple[sa.Column, ...]:
+    # Fresh Column objects per call: a Column binds to the table it is added to.
+    return tuple(sa.Column(name, sa.Boolean(), nullable=True) for name in _COLUMN_NAMES)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    missing_columns = [column for column in _settings_columns() if column.name not in existing_columns]
+    if existing_columns and missing_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column in missing_columns:
+                batch_op.add_column(column)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    present_columns = [name for name in _COLUMN_NAMES if name in existing_columns]
+    if present_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column_name in present_columns:
+                batch_op.drop_column(column_name)

app/db/alembic/versions/20260909_040000_add_dashboard_user_invites.py

@@ -0,0 +1,54 @@
+"""Add dashboard_user_invites (one-time invitation links for pre-created accounts).
+
+Revision ID: 20260909_040000_add_dashboard_user_invites
+Revises: 20260909_030000_add_audit_actor_columns
+Create Date: 2026-09-09
+
+Only the token hash is stored. One live invite per user (``user_id`` unique);
+the row is removed with its user (``ON DELETE CASCADE``). ``created_by_user_id``
+is a snapshot without a foreign key so the invite survives the inviter's
+deletion. No data backfill: invites only exist from this release on.
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20260909_040000_add_dashboard_user_invites"
+down_revision = "20260909_030000_add_audit_actor_columns"
+branch_labels = None
+depends_on = None
+
+_TABLE = "dashboard_user_invites"
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if sa.inspect(bind).has_table(_TABLE):
+        return
+    op.create_table(
+        _TABLE,
+        sa.Column("id", sa.String(length=36), primary_key=True),
+        sa.Column(
+            "user_id",
+            sa.String(),
+            sa.ForeignKey("dashboard_users.id", ondelete="CASCADE"),
+            nullable=False,
+            unique=True,
+        ),
+        sa.Column("token_hash", sa.LargeBinary(), nullable=False, unique=True),
+        sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("consumed_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("revoked_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("created_by_user_id", sa.String(length=36), nullable=False),
+        sa.Column("sso_only", sa.Boolean(), server_default=sa.false(), nullable=False),
+        sa.Column("username_locked", sa.Boolean(), server_default=sa.false(), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if sa.inspect(bind).has_table(_TABLE):
+        op.drop_table(_TABLE)

app/db/alembic/versions/20260909_040000_dashboard_timeout_settings.py

@@ -0,0 +1,68 @@
+"""add dashboard columns for upstream timeouts and request budgets
+
+Seven nullable ``dashboard_settings`` columns named after the ``Settings``
+fields they override (slop-removal C2-1): ``upstream_connect_timeout_seconds``,
+``proxy_request_budget_seconds``, ``compact_request_budget_seconds``,
+``transcription_request_budget_seconds``, ``stream_idle_timeout_seconds``,
+``proxy_downstream_websocket_idle_timeout_seconds`` and
+``sse_keepalive_interval_seconds``. NULL means "inherit the environment value
+(or the code default)"; the environment is never copied into the column.
+
+Revision ID: 20260909_040000_dashboard_timeout_settings
+Revises: 20260909_030000_dashboard_resilience_toggle_settings
+Create Date: 2026-09-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_040000_dashboard_timeout_settings"
+down_revision = "20260909_030000_dashboard_resilience_toggle_settings"
+branch_labels = None
+depends_on = None
+
+_SETTINGS_TABLE = "dashboard_settings"
+_COLUMN_NAMES = (
+    "upstream_connect_timeout_seconds",
+    "proxy_request_budget_seconds",
+    "compact_request_budget_seconds",
+    "transcription_request_budget_seconds",
+    "stream_idle_timeout_seconds",
+    "proxy_downstream_websocket_idle_timeout_seconds",
+    "sse_keepalive_interval_seconds",
+)
+
+
+def _settings_columns() -> tuple[sa.Column, ...]:
+    # Fresh Column objects per call: a Column binds to the table it is added to.
+    return tuple(sa.Column(name, sa.Float(), nullable=True) for name in _COLUMN_NAMES)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    missing_columns = [column for column in _settings_columns() if column.name not in existing_columns]
+    if existing_columns and missing_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column in missing_columns:
+                batch_op.add_column(column)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    present_columns = [name for name in _COLUMN_NAMES if name in existing_columns]
+    if present_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column_name in present_columns:
+                batch_op.drop_column(column_name)

app/db/alembic/versions/20260909_050000_dashboard_routing_overload_settings.py

@@ -0,0 +1,65 @@
+"""dashboard-managed routing weights and overload isolation
+
+Revision ID: 20260909_050000_dashboard_routing_overload_settings
+Revises: 20260909_040000_dashboard_timeout_settings
+Create Date: 2026-09-09
+
+Adds the nullable ``dashboard_settings`` columns for the routing/overload
+tunables that were environment-only (C2-2 of the slop-removal campaign):
+``proxy_overload_isolation_seconds``, ``proxy_account_error_rate_weighting_enabled``,
+``proxy_account_inflight_penalty_pct``, ``proxy_account_lease_token_weight`` and
+``proxy_account_lease_ttl_seconds``. NULL inherits the process environment
+value (or the code default) at read time; the first-boot seed and this
+migration never copy the environment value into the row.
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_050000_dashboard_routing_overload_settings"
+down_revision = "20260909_040000_dashboard_timeout_settings"
+branch_labels = None
+depends_on = None
+
+_TABLE = "dashboard_settings"
+_COLUMNS: tuple[tuple[str, sa.types.TypeEngine], ...] = (
+    ("proxy_overload_isolation_seconds", sa.Integer()),
+    ("proxy_account_error_rate_weighting_enabled", sa.Boolean()),
+    ("proxy_account_inflight_penalty_pct", sa.Float()),
+    ("proxy_account_lease_token_weight", sa.Float()),
+    ("proxy_account_lease_ttl_seconds", sa.Float()),
+)
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing = _columns(bind, _TABLE)
+    if not existing:
+        return
+    missing = [(name, column_type) for name, column_type in _COLUMNS if name not in existing]
+    if not missing:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        for name, column_type in missing:
+            batch_op.add_column(sa.Column(name, column_type, nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    existing = _columns(bind, _TABLE)
+    present = [name for name, _ in _COLUMNS if name in existing]
+    if not present:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        for name in present:
+            batch_op.drop_column(name)

app/db/alembic/versions/20260909_060000_add_report_rollup.py

@@ -0,0 +1,74 @@
+"""Add permanent report history; background fold owns the paced backfill."""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_060000_add_report_rollup"
+down_revision = "20260909_050000_dashboard_routing_overload_settings"
+branch_labels = None
+depends_on = None
+
+_TABLE = "request_report_hourly_rollups"
+_STATE_TABLE = "account_usage_rollup_state"
+_WATERMARK_COLUMN = "reports_folded_through"
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+
+    if not sa.inspect(bind).has_table(_TABLE):
+        op.create_table(
+            _TABLE,
+            sa.Column("bucket_epoch", sa.BigInteger(), nullable=False),
+            sa.Column("account_id", sa.String(), nullable=False),
+            sa.Column("api_key_id", sa.String(), nullable=False),
+            sa.Column("model", sa.String(), nullable=False),
+            sa.Column("useragent_group", sa.String(), nullable=False),
+            sa.Column("conversation_id", sa.String(), nullable=False),
+            sa.Column("first_requested_at", sa.DateTime(), nullable=False),
+            sa.Column("request_count", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("error_count", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("cancelled_count", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("input_tokens", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("output_tokens", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("reasoning_tokens", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("reasoning_usage_known_requests", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("cached_input_tokens", sa.BigInteger(), server_default=sa.text("0"), nullable=False),
+            sa.Column("cost_usd", sa.Float(), server_default=sa.text("0"), nullable=False),
+            sa.PrimaryKeyConstraint(
+                "bucket_epoch", "account_id", "api_key_id", "model", "useragent_group", "conversation_id"
+            ),
+        )
+
+    state_columns = _columns(bind, _STATE_TABLE)
+    if state_columns and _WATERMARK_COLUMN not in state_columns:
+        with op.batch_alter_table(_STATE_TABLE) as batch_op:
+            batch_op.add_column(
+                sa.Column(
+                    _WATERMARK_COLUMN,
+                    sa.DateTime(),
+                    server_default=sa.text("'1970-01-01 00:00:00'"),
+                    nullable=False,
+                )
+            )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+
+    if _WATERMARK_COLUMN in _columns(bind, _STATE_TABLE):
+        with op.batch_alter_table(_STATE_TABLE) as batch_op:
+            batch_op.drop_column(_WATERMARK_COLUMN)
+
+    if sa.inspect(bind).has_table(_TABLE):
+        op.drop_table(_TABLE)

app/db/alembic/versions/20260909_070000_automation_run_claim_budget.py

@@ -0,0 +1,50 @@
+"""pin the automation stale-claim reclaim window to the budget captured at claim time
+
+Revision ID: 20260909_070000_automation_run_claim_budget
+Revises: 20260909_060000_add_report_rollup
+Create Date: 2026-09-09
+
+Adds the nullable ``automation_runs.claim_budget_seconds`` column. Every
+claim (fresh or stale reclaim) stores the compact request budget in effect
+at that moment, and the stale-claim reclaim window is derived from the
+stored value instead of the current dashboard budget, so lowering the
+budget in the dashboard no longer reclaims an in-flight run early. Rows
+claimed before this revision stay NULL and keep using the current budget.
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_070000_automation_run_claim_budget"
+down_revision = "20260909_060000_add_report_rollup"
+branch_labels = None
+depends_on = None
+
+_TABLE = "automation_runs"
+_COLUMN = "claim_budget_seconds"
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    existing = _columns(op.get_bind(), _TABLE)
+    if not existing or _COLUMN in existing:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        batch_op.add_column(sa.Column(_COLUMN, sa.Float(), nullable=True))
+
+
+def downgrade() -> None:
+    existing = _columns(op.get_bind(), _TABLE)
+    if _COLUMN not in existing:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        batch_op.drop_column(_COLUMN)

app/db/alembic/versions/20260909_080000_dashboard_stream_bridge_budgets.py

@@ -0,0 +1,62 @@
+"""add dashboard columns for the stream and session bridge request budgets
+
+Two nullable ``dashboard_settings`` columns named after the ``Settings``
+fields they override (slop-removal M1):
+``http_responses_stream_request_budget_seconds`` and
+``http_responses_session_bridge_request_budget_seconds``. NULL means "inherit
+the environment value (or the code default)"; the environment is never copied
+into the column.
+
+Revision ID: 20260909_080000_dashboard_stream_bridge_budgets
+Revises: 20260909_100000_dashboard_codex_prewarm
+Create Date: 2026-09-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_080000_dashboard_stream_bridge_budgets"
+down_revision = "20260909_100000_dashboard_codex_prewarm"
+branch_labels = None
+depends_on = None
+
+_SETTINGS_TABLE = "dashboard_settings"
+_COLUMN_NAMES = (
+    "http_responses_stream_request_budget_seconds",
+    "http_responses_session_bridge_request_budget_seconds",
+)
+
+
+def _settings_columns() -> tuple[sa.Column, ...]:
+    # Fresh Column objects per call: a Column binds to the table it is added to.
+    return tuple(sa.Column(name, sa.Float(), nullable=True) for name in _COLUMN_NAMES)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    missing_columns = [column for column in _settings_columns() if column.name not in existing_columns]
+    if existing_columns and missing_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column in missing_columns:
+                batch_op.add_column(column)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    present_columns = [name for name in _COLUMN_NAMES if name in existing_columns]
+    if present_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column_name in present_columns:
+                batch_op.drop_column(column_name)

app/db/alembic/versions/20260909_090000_dashboard_background_job_toggles.py

@@ -0,0 +1,63 @@
+"""add dashboard-managed background job toggle columns
+
+Three nullable ``dashboard_settings`` BOOLEAN columns named after the
+``Settings`` fields they take over: ``auth_guardian_enabled``,
+``automations_scheduler_enabled`` and ``rate_limit_reset_credits_refresh_enabled``.
+NULL means "inherit": the deprecated ``CODEX_LB_*`` environment alias, then the
+code default, keep applying until an operator sets a value in the dashboard
+(configuration-tiers; slop-removal campaign 0908, M2).
+
+Revision ID: 20260909_090000_dashboard_background_job_toggles
+Revises: 20260909_110000_model_context_window_overrides
+Create Date: 2026-09-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_090000_dashboard_background_job_toggles"
+down_revision = "20260909_110000_model_context_window_overrides"
+branch_labels = None
+depends_on = None
+
+_SETTINGS_TABLE = "dashboard_settings"
+_COLUMN_NAMES = (
+    "auth_guardian_enabled",
+    "automations_scheduler_enabled",
+    "rate_limit_reset_credits_refresh_enabled",
+)
+
+
+def _settings_columns() -> tuple[sa.Column, ...]:
+    # Fresh Column objects per call: a Column binds to the table it is added to.
+    return tuple(sa.Column(name, sa.Boolean(), nullable=True) for name in _COLUMN_NAMES)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    missing_columns = [column for column in _settings_columns() if column.name not in existing_columns]
+    if existing_columns and missing_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column in missing_columns:
+                batch_op.add_column(column)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    present_columns = [name for name in _COLUMN_NAMES if name in existing_columns]
+    if present_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            for column_name in present_columns:
+                batch_op.drop_column(column_name)

app/db/alembic/versions/20260909_100000_dashboard_codex_prewarm.py

@@ -0,0 +1,49 @@
+"""dashboard-managed Codex HTTP-bridge session prewarm
+
+Revision ID: 20260909_100000_dashboard_codex_prewarm
+Revises: 20260909_070000_automation_run_claim_budget
+Create Date: 2026-09-09
+
+Adds the nullable ``dashboard_settings.http_responses_session_bridge_codex_prewarm_enabled``
+column (M3 of the slop-removal campaign). NULL inherits the deprecated
+``CODEX_LB_HTTP_RESPONSES_SESSION_BRIDGE_CODEX_PREWARM_ENABLED`` environment
+alias (then the code default, off) at read time; the first-boot seed and this
+migration never copy the environment value into the row.
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_100000_dashboard_codex_prewarm"
+down_revision = "20260909_070000_automation_run_claim_budget"
+branch_labels = None
+depends_on = None
+
+_TABLE = "dashboard_settings"
+_COLUMN = "http_responses_session_bridge_codex_prewarm_enabled"
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    existing = _columns(op.get_bind(), _TABLE)
+    if not existing or _COLUMN in existing:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        batch_op.add_column(sa.Column(_COLUMN, sa.Boolean(), nullable=True))
+
+
+def downgrade() -> None:
+    existing = _columns(op.get_bind(), _TABLE)
+    if _COLUMN not in existing:
+        return
+    with op.batch_alter_table(_TABLE) as batch_op:
+        batch_op.drop_column(_COLUMN)

app/db/alembic/versions/20260909_110000_model_context_window_overrides.py

@@ -0,0 +1,45 @@
+"""dashboard-managed per-model context window overrides
+
+Revision ID: 20260909_110000_model_context_window_overrides
+Revises: 20260909_080000_dashboard_stream_bridge_budgets
+Create Date: 2026-09-09
+
+Adds the ``model_context_window_overrides`` table (M4 of the slop-removal
+campaign): one row per model slug whose reported context window an operator
+overrides from the dashboard. A row wins over the
+``CODEX_LB_MODEL_CONTEXT_WINDOW_OVERRIDES`` entry for the same slug; slugs
+without a row keep inheriting the environment entry (or have no override).
+The migration never copies the environment dict into rows.
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20260909_110000_model_context_window_overrides"
+down_revision = "20260909_080000_dashboard_stream_bridge_budgets"
+branch_labels = None
+depends_on = None
+
+_TABLE = "model_context_window_overrides"
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if sa.inspect(bind).has_table(_TABLE):
+        return
+    op.create_table(
+        _TABLE,
+        sa.Column("slug", sa.String(), nullable=False),
+        sa.Column("context_window", sa.Integer(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), server_default=sa.func.now(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), server_default=sa.func.now(), nullable=False),
+        sa.PrimaryKeyConstraint("slug"),
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if sa.inspect(bind).has_table(_TABLE):
+        op.drop_table(_TABLE)

app/db/alembic/versions/20260909_120000_dashboard_conversation_archive.py

@@ -0,0 +1,48 @@
+"""add dashboard-managed conversation archive toggle column
+
+One nullable ``dashboard_settings`` BOOLEAN column named after the ``Settings``
+field it takes over: ``conversation_archive_enabled``. NULL means "inherit":
+the deprecated ``CODEX_LB_CONVERSATION_ARCHIVE_ENABLED`` environment alias,
+then the code default (off), keep applying until an operator sets a value in
+the dashboard (configuration-tiers; slop-removal campaign 0908, M5).
+
+Revision ID: 20260909_120000_dashboard_conversation_archive
+Revises: 20260909_090000_dashboard_background_job_toggles
+Create Date: 2026-09-09
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260909_120000_dashboard_conversation_archive"
+down_revision = "20260909_090000_dashboard_background_job_toggles"
+branch_labels = None
+depends_on = None
+
+_SETTINGS_TABLE = "dashboard_settings"
+_COLUMN_NAME = "conversation_archive_enabled"
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    existing_columns = _column_names(bind, _SETTINGS_TABLE)
+    if existing_columns and _COLUMN_NAME not in existing_columns:
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            batch_op.add_column(sa.Column(_COLUMN_NAME, sa.Boolean(), nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if _COLUMN_NAME in _column_names(bind, _SETTINGS_TABLE):
+        with op.batch_alter_table(_SETTINGS_TABLE) as batch_op:
+            batch_op.drop_column(_COLUMN_NAME)