diff --git a/CLAUDE.md b/CLAUDE.md
index 1393877..4d09128 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,6 +1,6 @@
 # ai-api Development Guidelines
 
-Auto-generated from all feature plans. Last updated: 2026-06-12
+Auto-generated from all feature plans. Last updated: 2026-06-13
 
 ## Active Technologies
 - Python 3.11+（同 Phase 1） (002-auth-membership)
@@ -68,6 +68,8 @@ Auto-generated from all feature plans. Last updated: 2026-06-12
 - PostgreSQL（生產）/ SQLite（dev、CI）；**不新增表/欄/migration**——沿用 0019 的 `call_records.{quantity,unit}` 與 `price_list.{price_unit,price_per_unit_usd}`，新單位 `image`/`query` 為字串值 (042-endpoint-registry)
 - Python 3.11+（後端為主）/ TypeScript strict + React 19（前端僅目錄顯示 realtime 類型 + 連線範例，極少量） + FastAPI（WebSocket — starlette 內建，**專案首次使用**）、SQLAlchemy 2.x async、Pydantic v2（皆既有）；**`websockets`（直連 Azure realtime WS 的 async client，提為直接依賴——已隨 uvicorn/litellm 在 image，現宣告為直接依賴）**；既有 `proxy/preflight.py`、計費（`services/pricing.py` 的 `calculate_unit_cost`）、audit。**realtime 不經 litellm**（其 realtime 是 Proxy form / client 直連，違原則；借其 `RealTimeStreaming` 結構自寫薄 relay）。 (043-realtime-transcription)
 - PostgreSQL（生產）/ SQLite（dev、CI）；**不新增表、不新增 migration**——沿用增量②（0019）的 `call_records.{quantity,unit}` 與 `price_list.{price_unit,price_per_unit_usd}`，新單位 `minute` 為字串值。 (043-realtime-transcription)
+- Python 3.11+（後端）/ TypeScript strict + React 19 + Vite 6（前端） + FastAPI、SQLAlchemy 2.x async、Alembic、Pydantic v2（後端）；TanStack Query、shadcn/ui（前端）——**皆既有，不新增套件** (046-cost-quota)
+- PostgreSQL（生產）/ SQLite（dev、CI）；**新 migration `0020`**——`allocations` 加一個 nullable 欄 `quota_cost_usd_per_month`（純加欄）。累計來源沿用既有 `call_records.cost_usd`（0019 已有）。 (046-cost-quota)
 
 - Python 3.11+ + LiteLLM（proxy core）、FastAPI（admin API）、 (001-gateway-core)
 
@@ -88,9 +90,9 @@ cd src [ONLY COMMANDS FOR ACTIVE TECHNOLOGIES][ONLY COMMANDS FOR ACTIVE TECHNOLO
 Python 3.11+: Follow standard conventions
 
 ## Recent Changes
+- 046-cost-quota: Added Python 3.11+（後端）/ TypeScript strict + React 19 + Vite 6（前端） + FastAPI、SQLAlchemy 2.x async、Alembic、Pydantic v2（後端）；TanStack Query、shadcn/ui（前端）——**皆既有，不新增套件**
 - 043-realtime-transcription: Added Python 3.11+（後端為主）/ TypeScript strict + React 19（前端僅目錄顯示 realtime 類型 + 連線範例，極少量） + FastAPI（WebSocket — starlette 內建，**專案首次使用**）、SQLAlchemy 2.x async、Pydantic v2（皆既有）；**`websockets`（直連 Azure realtime WS 的 async client，提為直接依賴——已隨 uvicorn/litellm 在 image，現宣告為直接依賴）**；既有 `proxy/preflight.py`、計費（`services/pricing.py` 的 `calculate_unit_cost`）、audit。**realtime 不經 litellm**（其 realtime 是 Proxy form / client 直連，違原則；借其 `RealTimeStreaming` 結構自寫薄 relay）。
 - 042-endpoint-registry: Added Python 3.11+（後端）/ TypeScript strict + React 19 + Vite 6（前端少量範例） + FastAPI（含 `UploadFile` multipart，既有）、SQLAlchemy 2.x async、Pydantic v2、`litellm`（`amoderation`/`asearch`/`aimage_edit` 既有函式）；TanStack Query、shadcn/ui（前端）——**皆既有，不新增套件**
-- 041-multi-endpoint-complete: Added Python 3.11+（後端）/ TypeScript strict + React 19 + Vite 6（前端） + FastAPI（含 `UploadFile` multipart）、SQLAlchemy 2.x async、Pydantic v2、`litellm`（`aimage_generation`/`arerank`/`aspeech`/`atranscription` library form）；TanStack Query、shadcn/ui（前端）——**皆既有，不新增套件**
 
 
 <!-- MANUAL ADDITIONS START -->
diff --git a/alembic/versions/0020_cost_quota.py b/alembic/versions/0020_cost_quota.py
new file mode 100644
index 0000000..d27920a
--- /dev/null
+++ b/alembic/versions/0020_cost_quota.py
@@ -0,0 +1,29 @@
+"""Phase 33 (046): cost-based monthly quota — per-allocation USD spend cap.
+
+Additive, nullable column (zero regression for token quota):
+  allocations: quota_cost_usd_per_month (NULL ⇒ no cost cap)
+Existing rows stay NULL and keep using quota_tokens_per_month unchanged.
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision: str = "0020_cost_quota"
+down_revision: str | Sequence[str] | None = "0019_billing_units"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "allocations",
+        sa.Column("quota_cost_usd_per_month", sa.Numeric(10, 6), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("allocations", "quota_cost_usd_per_month")
diff --git a/frontend/src/components/allocation-list.tsx b/frontend/src/components/allocation-list.tsx
index 23de14c..f02ab61 100644
--- a/frontend/src/components/allocation-list.tsx
+++ b/frontend/src/components/allocation-list.tsx
@@ -34,6 +34,8 @@ interface Allocation {
   revoked_at: string | null;
   token_prefix: string;
   quota_tokens_per_month?: number | null;
+  quota_cost_usd_per_month?: string | null;
+  cost_used_this_month?: string | null;
   price?: { input_per_1k: string; output_per_1k: string; cached_input_per_1k?: string } | null;
 }
 
@@ -225,6 +227,20 @@ export function AllocationList() {
                       <div>配額：無上限</div>
                     )
                   )}
+                  {a.status === "active" && a.quota_cost_usd_per_month != null && (() => {
+                    const used = Number(a.cost_used_this_month ?? 0);
+                    const cap = Number(a.quota_cost_usd_per_month);
+                    const near = cap > 0 && used / cap >= 0.8;
+                    return (
+                      <div className="space-y-1">
+                        <div className={near ? "text-destructive" : "text-foreground"}>
+                          本月花費 ${used.toFixed(2)} / 上限 ${cap.toFixed(2)}
+                          {near && "（接近上限）"}
+                        </div>
+                        <Progress value={cap > 0 ? Math.min(100, Math.round((used / cap) * 100)) : 0} />
+                      </div>
+                    );
+                  })()}
                   <div>
                     現價（每 1M）：
                     {a.price
diff --git a/frontend/src/routes/admin/allocations.tsx b/frontend/src/routes/admin/allocations.tsx
index 24165e0..c2364ec 100644
--- a/frontend/src/routes/admin/allocations.tsx
+++ b/frontend/src/routes/admin/allocations.tsx
@@ -49,6 +49,7 @@ interface AdminAllocation {
   display_name?: string | null;
   status: string;
   quota_tokens_per_month: number | null;
+  quota_cost_usd_per_month: string | null;
   is_service_allocation: boolean;
   quota_locked: boolean;
   token_prefix: string;
@@ -86,6 +87,7 @@ export function AdminAllocationsPage() {
   const [showRevoked, setShowRevoked] = React.useState(false);
   const [quotaTarget, setQuotaTarget] = React.useState<AdminAllocation | null>(null);
   const [quotaValue, setQuotaValue] = React.useState("");
+  const [costValue, setCostValue] = React.useState("");
 
   const allocsQuery = useQuery<AdminAllocation[], ApiError>({
     queryKey: ["admin", "allocations"],
@@ -257,6 +259,7 @@ export function AdminAllocationsPage() {
                         onClick={() => {
                           setQuotaTarget(a);
                           setQuotaValue(a.quota_tokens_per_month != null ? String(a.quota_tokens_per_month) : "");
+                          setCostValue(a.quota_cost_usd_per_month != null ? String(Number(a.quota_cost_usd_per_month)) : "");
                         }}
                       >
                         調整配額
@@ -403,8 +406,9 @@ export function AdminAllocationsPage() {
         <DialogContent>
           <DialogHeader>
             <DialogTitle>調整月度配額</DialogTitle>
-            <DialogDescription>留空＝無限額；否則填非負整數 tokens。</DialogDescription>
+            <DialogDescription>兩種上限可同時設、任一達到即擋；留空＝該項無上限。</DialogDescription>
           </DialogHeader>
+          <label className="text-sm font-medium">每月 token 上限</label>
           <Input
             type="number"
             min={0}
@@ -416,17 +420,41 @@ export function AdminAllocationsPage() {
           {quotaValue.trim() !== "" && !/^\d+$/.test(quotaValue.trim()) && (
             <p className="text-xs text-destructive">請填非負整數，或留空表示無限額。</p>
           )}
+          <label className="text-sm font-medium mt-2">每月花費上限（USD）</label>
+          <Input
+            type="number"
+            min={0}
+            step="0.01"
+            value={costValue}
+            placeholder="無上限"
+            aria-label="每月花費上限"
+            onChange={(e) => setCostValue(e.target.value)}
+          />
+          {costValue.trim() !== "" && !(Number(costValue) >= 0) && (
+            <p className="text-xs text-destructive">請填非負金額，或留空表示無上限。</p>
+          )}
+          <p className="text-xs text-muted-foreground">
+            花費上限以 USD 統一治理所有端點（token / 頁 / 張 / 秒 / 分…）；只治理「已定價」的用量。
+          </p>
           <DialogFooter>
             <Button variant="outline" onClick={() => setQuotaTarget(null)}>取消</Button>
             <Button
-              disabled={quotaValue.trim() !== "" && !/^\d+$/.test(quotaValue.trim())}
+              disabled={
+                (quotaValue.trim() !== "" && !/^\d+$/.test(quotaValue.trim())) ||
+                (costValue.trim() !== "" && !(Number(costValue) >= 0))
+              }
               onClick={() => {
                 if (!quotaTarget) return;
                 const v = quotaValue.trim();
+                const c = costValue.trim();
                 if (v !== "" && !/^\d+$/.test(v)) return;
+                if (c !== "" && !(Number(c) >= 0)) return;
                 patchMut.mutate({
                   id: quotaTarget.id,
-                  body: { quota_tokens_per_month: v === "" ? null : Number(v) },
+                  body: {
+                    quota_tokens_per_month: v === "" ? null : Number(v),
+                    quota_cost_usd_per_month: c === "" ? null : Number(c),
+                  },
                 });
                 setQuotaTarget(null);
               }}
diff --git a/specs/046-cost-quota/checklists/requirements.md b/specs/046-cost-quota/checklists/requirements.md
new file mode 100644
index 0000000..db5a8e4
--- /dev/null
+++ b/specs/046-cost-quota/checklists/requirements.md
@@ -0,0 +1,40 @@
+# Specification Quality Checklist: 成本制配額（跨端點統一額度上限）
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-06-13
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- 0 個 [NEEDS CLARIFICATION]——關鍵抉擇皆有合理預設且源自 knowie-next 已收斂的 brief 與既有專案 pattern：
+  - 「以花費（USD）為跨單位共同分母」源自 vision 階段 29 既定結論。
+  - 「花費上限不進自適應配額池」為明確排除，避免雙再分配邏輯互撞。
+  - 「未定價呼叫花費為 0、不被治理」延續「PriceList 是計費唯一真理」。
+  - 「realtime 連線中把關沿用既有撤回 re-check 協程」對應原則 3 + 階段 32 既有機制。
+- Key Entities 提到的「分配 / 用量紀錄」為**領域實體**（非技術框架），符合 spec 慣例。
+- 準備好進入 `/speckit-plan`。
diff --git a/specs/046-cost-quota/contracts/cost-quota.md b/specs/046-cost-quota/contracts/cost-quota.md
new file mode 100644
index 0000000..eb9b369
--- /dev/null
+++ b/specs/046-cost-quota/contracts/cost-quota.md
@@ -0,0 +1,69 @@
+# Contract: 成本制配額
+
+四個契約面。錯誤封包沿用既有 `{error:{code,message,request_id}}`。
+
+## 1. Admin 分配 create / update — 收選填花費上限
+
+**端點**：既有 `POST /admin/allocations`、`PATCH /admin/allocations/{id}`（或既有配額編輯端點）
+**新增欄位（請求）**：
+
+```jsonc
+{ "quota_cost_usd_per_month": 5.00 }   // 選填；null/省略 = 不設上限；< 0 → 422
+```
+
+- 接受 `null`（清除上限）、正數（設上限，含 0）、省略（不變）。
+- 變更留稽核（沿用既有 allocation 更新的 audit，記新值）。
+- **回應**：分配序列化多 `quota_cost_usd_per_month`。
+
+## 2. Proxy 同步端點 — 花費超額拒絕
+
+**端點**：所有計費端點（chat/responses + registry：embedding/ocr/image/rerank/audio/moderation/search/image_edit）共用 preflight。
+
+```
+preflight: 若 allocation.quota_cost_usd_per_month 非 null 且 current_month_cost ≥ cap
+  → 403 { "error": { "code": "cost_quota_exceeded",
+                     "message": "已達本月花費上限（$X / $Y）" } }
+  → 記一筆 CallRecord(outcome=rejected_cost_quota_exceeded, status=403, allocation 綁定)
+```
+
+- token 上限與花費上限**並列**：任一達到即擋（取較嚴者）。
+- 未設花費上限（null）→ 此檢查跳過，行為與現況一致。
+- 未定價呼叫（`cost_usd` NULL）不增加累計 → 不會因花費上限被擋。
+
+## 3. 用量顯示 — 本月花費 / 上限
+
+**端點**：`/me/usage`、`/me/allocations`、admin 用量每分配。
+**新增欄位（回應，每分配）**：
+
+```jsonc
+{
+  "cost_used_this_month": "4.90",          // Decimal 字串
+  "quota_cost_usd_per_month": "5.000000"   // 或 null
+}
+```
+
+## 4. Realtime 連線中花費把關
+
+**端點**：`/v1/realtime`（階段 32）
+**行為**：
+
+```
+連線建立：preflight 含 cost 檢查（同 §2，超額即 close 不開串流）
+連線中：旁路 watcher 每 N 秒：
+  committed = current_month_cost(allocation)        // 已落帳（不含本連線）
+  running   = session_running_cost(sess, price)     // 本連線進行中累計
+  若 committed + running ≥ cap → close(policy violation 1008, reason="本月花費上限")
+                                  + 已累計時長落帳（沿用「任何 close 路徑都落帳」）
+```
+
+- 容差：最多「上限 + 一個 re-check 週期」的小幅超出（與既有撤回延遲同語意）。
+
+## 契約測試（合併前必過）
+
+1. 分配設花費上限 $X，混合 chat（token）+ OCR/realtime（非 token）累計花費達 $X → 後續呼叫 403 `cost_quota_exceeded`，且落一筆 `rejected_cost_quota_exceeded`。
+2. 分配**未**設花費上限 → 大量非 token 呼叫不被擋（token 配額行為零回歸）。
+3. 分配同設 token+cost 上限 → 先達到者擋（兩種各驗一次）。
+4. 未定價模型呼叫 → 不增加累計、不被花費上限擋。
+5. realtime 連線中累計花費超額 → N 秒內 close（mock provider WS）+ 已累計時長落帳。
+6. 自適應配額池跑一輪 → 各分配 `quota_cost_usd_per_month` 不變（只 token 額度被再分配）。
+7. `current_month_cost` = 該分配本月成功呼叫 `cost_usd` 之 `Decimal` 總和（含非 token，未定價以 0 計）。
diff --git a/specs/046-cost-quota/data-model.md b/specs/046-cost-quota/data-model.md
new file mode 100644
index 0000000..82a53dc
--- /dev/null
+++ b/specs/046-cost-quota/data-model.md
@@ -0,0 +1,44 @@
+# Phase 1 Data Model: 成本制配額
+
+**核心結論：一個 additive migration（0020）、零新表。** 沿用既有 `call_records.cost_usd`（0019）作為累計來源；分配只加一個選填上限欄；新拒絕 outcome 走 VARCHAR enum 無 migration。
+
+## 1. Allocation（既有，加一欄）
+
+| 欄位 | 型別 | 說明 |
+|---|---|---|
+| `quota_cost_usd_per_month` | `Numeric(10,6)` **nullable** | 每月花費上限（USD）。NULL ⇒ 無花費上限（維持現況）。**migration 0020 純加欄。** |
+
+既有 `quota_tokens_per_month`（token 上限）、`quota_locked`、`is_service_allocation` 等**不變**。兩種上限可並存。
+
+**驗證規則**：`>= 0`（0＝立即擋；負值拒絕）。admin create/update 收選填值；空＝NULL（不設）。
+
+**與自適應池**：`quota_cost_usd_per_month` **不在** `quota_pool` 的讀寫範圍（池只動 `quota_tokens_per_month`）→ 不被再分配（SC-005）。
+
+## 2. CallRecord（既有，沿用 + 新 outcome 值）
+
+- 累計來源：`sum(cost_usd) where allocation_id=? and outcome=success and started_at>=月初(UTC)`。`cost_usd` NULL（未定價）→ `coalesce 0`，不計入。
+- `CallOutcome` 列舉新增 **`rejected_cost_quota_exceeded`**（`Enum(native_enum=False, length=32)` 存 VARCHAR → **無 migration**）。被花費上限擋的呼叫以此 outcome 落一筆（綁 allocation、status 403），與 `rejected_quota_exceeded`（token）可區分。
+
+## 3. 衍生計算（不落表）
+
+| 名稱 | 定義 | 用途 |
+|---|---|---|
+| `current_month_cost(allocation_id)` | `Σ cost_usd`（成功、本月、coalesce 0）→ `Decimal` | preflight 檢查 + 用量顯示 |
+| `is_over_cost_quota(allocation, spent)` | `cap is not None and spent >= cap` | preflight / watcher 共用判斷 |
+| `session_running_cost(sess, price)` | realtime 連線進行中累計 = `session_quantity(sess, price.unit) × price.per_unit` | 連線中把關（committed + 此值 ≥ cap） |
+
+## 4. 序列化新增欄（API 輸出）
+
+| 端點 | 新欄 |
+|---|---|
+| admin 分配（list/detail）+ create/update 輸入 | `quota_cost_usd_per_month`（選填） |
+| `/me/usage`、`/me/allocations`、admin 用量每分配 | `cost_used_this_month`（Decimal 字串）+ `quota_cost_usd_per_month` |
+
+## 5. 狀態/流程
+
+- **同步端點**：preflight 階段 `current_month_cost ≥ cap` → reject `cost_quota_exceeded`（403）+ 記一筆 `rejected_cost_quota_exceeded`。
+- **realtime**：建立時 preflight 含 cost 檢查；連線中 watcher 每 N 秒 `committed + running ≥ cap` → close（已累計時長落帳，沿用「任何 close 路徑都落帳」）。
+
+---
+
+**Migration 結論**：**`0020` 純加 `allocations.quota_cost_usd_per_month`（nullable）**。token 欄、`call_records` 皆不動（`cost_usd`/`unit`/`quantity` 0019 已就緒）；新 outcome 為 VARCHAR enum 值，非 schema 變更。
diff --git a/specs/046-cost-quota/plan.md b/specs/046-cost-quota/plan.md
new file mode 100644
index 0000000..73d061f
--- /dev/null
+++ b/specs/046-cost-quota/plan.md
@@ -0,0 +1,80 @@
+# Implementation Plan: 成本制配額（跨端點統一額度上限）
+
+**Branch**: `046-cost-quota` | **Date**: 2026-06-13 | **Spec**: [spec.md](./spec.md)
+**Input**: Feature specification from `/specs/046-cost-quota/spec.md`
+
+## Summary
+
+為每筆分配新增選填的「每月花費上限（USD）」，與既有「每月 token 上限」並列、任一超過即擋。**以花費（USD）為跨單位共同分母**，讓 token 與所有非 token 端點（OCR/圖片/語音/即時字幕/search/rerank）共用同一道月度上限——補上「非 token 用量繞過配額」的治理缺口（原則 1）。即時字幕長連線在**連線進行中**沿用既有撤回 watcher 週期核對累計花費、超額主動中止（原則 3）。花費上限為**獨立硬上限、不進自適應配額池**（階段 3c 只再分配 token 額度）。
+
+## Technical Context
+
+**Language/Version**: Python 3.11+（後端）/ TypeScript strict + React 19 + Vite 6（前端）
+**Primary Dependencies**: FastAPI、SQLAlchemy 2.x async、Alembic、Pydantic v2（後端）；TanStack Query、shadcn/ui（前端）——**皆既有，不新增套件**
+**Storage**: PostgreSQL（生產）/ SQLite（dev、CI）；**新 migration `0020`**——`allocations` 加一個 nullable 欄 `quota_cost_usd_per_month`（純加欄）。累計來源沿用既有 `call_records.cost_usd`（0019 已有）。
+**Testing**: pytest（contract / integration / unit）、vitest（前端）
+**Target Platform**: Linux server（K8s）/ 瀏覽器（SPA）
+**Project Type**: web（backend + frontend）
+**Performance Goals**: 配額前置檢查不顯著增加 proxy 延遲（多一個 `sum(cost_usd)` 聚合查詢，命中既有複合索引 `idx_callrecord_allocation_time (allocation_id, started_at)`）
+**Constraints**: 既有 token 配額路徑零回歸；花費以 `Decimal` 計（避免浮點誤差）；realtime 連線中把關容差 = 一個 re-check 週期
+**Scale/Scope**: 後端少量（quota 服務 + preflight + realtime watcher + admin/usage 序列化）+ 前端兩處顯示/編輯；單一新 migration、無新套件、無新表
+
+## Constitution Check
+
+> constitution 原則：I Test-First（非協商 TDD）、II 契約優先、III 整合測試覆蓋外部依賴且 CI 可重現、IV 可觀測性、V YAGNI。
+
+| 原則 | 評估 | 結論 |
+|---|---|---|
+| **I. Test-First** | 先寫失敗測試（contract：cost 超額被擋；integration：混合 token+非 token 累計、realtime 連線中超額；unit：`current_month_cost`、`is_over_cost_quota`）再實作 | ✅ 遵循 |
+| **II. 契約優先** | 先定契約再實作：① admin 分配 create/update 多收選填 `quota_cost_usd_per_month`；② proxy 新拒絕碼 `cost_quota_exceeded`（403）；③ `/me/usage`+admin usage 每分配多 `cost_used_this_month`+`quota_cost_usd_per_month`；④ realtime 連線中超額 close（policy violation + reason）。見 `contracts/cost-quota.md` | ✅ 遵循 |
+| **III. 整合測試覆蓋外部依賴 + CI 可重現** | cost 配額以真端點 contract 測（sqlite）；realtime 連線中把關沿用階段 32 的 **mock provider WS** in-loop 測（CI 可重現）；自適應池隔離以既有整合測試風格驗。**無新外部依賴** | ✅ 遵循 |
+| **IV. 可觀測性** | cost 超額拒絕走既有 `record_call`（新 outcome `rejected_cost_quota_exceeded`）+ 結構化日誌；realtime 連線中中止 log 原因 | ✅ 遵循 |
+| **V. YAGNI** | 只加一個 nullable 欄 + 既有 quota 檢查旁加一道；**重用** preflight 管線、realtime watcher、quota 服務、admin 配額 UI、用量顯示路徑；**刻意不**把 cost 納入自適應池（不為「未來可能」加再分配邏輯） | ✅ 遵循 |
+
+**Deviations**: 無。零新套件、零新表、零新抽象；單一 additive migration。
+
+## Project Structure
+
+### Documentation (this feature)
+
+```
+specs/046-cost-quota/
+├── spec.md              # 已完成
+├── plan.md              # 本檔
+├── research.md          # Phase 0（本次產出）
+├── data-model.md        # Phase 1（本次產出）
+├── quickstart.md        # Phase 1（本次產出）
+├── contracts/
+│   └── cost-quota.md    # Phase 1（本次產出）
+└── checklists/
+    └── requirements.md  # 已完成（16/16）
+```
+
+### Source Code (repository root)
+
+```
+src/ai_api/
+├── models/allocation.py         # + quota_cost_usd_per_month（nullable Numeric）
+├── models/call_record.py        # CallOutcome + rejected_cost_quota_exceeded（VARCHAR enum，無 migration）
+├── services/quota.py            # + current_month_cost() + is_over_cost_quota()
+├── proxy/preflight.py           # run_preflight 加一道 cost 檢查（與 token 並列）
+├── proxy/router.py              # _outcome_for_code 映 cost_quota_exceeded
+├── proxy/realtime.py            # 連線中 watcher 擴充：committed_month_cost + 本連線 running cost ≥ cap → close
+├── api/allocations.py + schemas.py  # admin create/update 收選填 quota_cost_usd_per_month
+├── api/me.py + api/usage.py     # 每分配序列化 cost_used_this_month + cost 上限
+alembic/versions/0020_cost_quota.py   # 純加欄
+frontend/src/
+├── 配額編輯 Dialog（admin）       # + 每月花費上限欄
+├── 分配卡 + usage 顯示            # 本月花費 / 上限
+tests/
+├── unit/test_quota.py           # current_month_cost / is_over_cost_quota
+├── contract/test_cost_quota.py  # 混合端點累計超額被擋、token 零回歸
+├── integration/test_realtime_relay.py  # + 連線中花費超額 close（mock provider WS）
+└── integration/test_quota_pool_*.py    # 自適應池不碰 cost 上限（既有風格）
+```
+
+**Structure Decision**: 沿用既有 web（backend `src/ai_api/` + frontend `frontend/src/`）單體結構。本功能是「核心治理層」增量——主要落在 `services/quota.py` + `proxy/preflight.py` + `proxy/realtime.py`，前端只在既有配額編輯與用量顯示處加欄。
+
+## Complexity Tracking
+
+> 無 Constitution 違反，無需填寫。
diff --git a/specs/046-cost-quota/quickstart.md b/specs/046-cost-quota/quickstart.md
new file mode 100644
index 0000000..0f4763f
--- /dev/null
+++ b/specs/046-cost-quota/quickstart.md
@@ -0,0 +1,29 @@
+# Quickstart: 成本制配額
+
+## 給管理員（怎麼用）
+
+1. 進**分配管理 → 某分配 → 配額**，在既有「每月 token 上限」旁設「**每月花費上限（USD）**」（例 `5`）。留空＝不設（維持現況）。
+2. 該分配當月**所有端點**的累計花費（chat token、OCR 頁、圖片張、即時字幕分鐘…，一律換算成 USD）達到 `5` 後，後續呼叫被擋、成員收到「已達本月花費上限」。
+3. 即時字幕長連線進行中若花費衝破上限，連線會在數秒內被主動中止（已用時長照常計費）。
+4. 成員在自己的「用量」頁可看到每個分配「本月已花 $X / 上限 $Y」，自己掌握、不會突然被擋還不知為何。
+
+**注意**：花費上限只治理**已定價**的用量。某模型若還沒設價（`未定價`），它的呼叫花費算 0、不計入上限——要納管請先到「價目」設好該模型的價。
+
+## 給維護者（驗收重點）
+
+- **混合端點累計**：對一個設了花費上限的分配，混送 chat（token）+ OCR/realtime（非 token），確認累計達上限後一律 403 `cost_quota_exceeded`（contract 測 1）。
+- **零回歸**：只設 token 上限（未設花費上限）的分配，行為與上線前完全一致（contract 測 2、SC-003）。
+- **realtime 連線中**：低上限 + 持續送音訊 → 連線於約定時間內被 close、已累計落帳（mock provider WS，contract 測 5）。
+- **自適應池隔離**：跑一輪 rebalance，確認 `quota_cost_usd_per_month` 不被改動（contract 測 6、SC-005）。
+- **部署**：有 migration → `--set migrationJob.enabled=true`；`kubectl exec <pod> -- python3 -m alembic current` 應顯 `0020`。
+
+## 驗收對照（spec Success Criteria）
+
+| SC | 驗證 |
+|---|---|
+| SC-001 混合端點達上限 100% 擋 | contract 測 1 |
+| SC-002 realtime 連線中超額約定時間內中止 | contract 測 5 |
+| SC-003 只設 token 上限零回歸 | contract 測 2 + 既有配額測試 git diff 為空 |
+| SC-004 成員/admin 看得到本月花費/上限 | 前端顯示 + 序列化測試 |
+| SC-005 自適應池不碰花費上限 | contract 測 6 |
+| SC-006 累計花費 = 成功呼叫 cost_usd 總和 | unit 測 `current_month_cost` |
diff --git a/specs/046-cost-quota/research.md b/specs/046-cost-quota/research.md
new file mode 100644
index 0000000..3a186d7
--- /dev/null
+++ b/specs/046-cost-quota/research.md
@@ -0,0 +1,96 @@
+# Phase 0 Research: 成本制配額
+
+spec 無 `[NEEDS CLARIFICATION]`；本檔釘死 5 個實作層設計問題到可實作程度。所有結論都對照既有程式實況（非臆測）。
+
+---
+
+## R1：本月累計花費的計算來源與效能
+
+**Decision**：新增 `current_month_cost(db, allocation_id) -> Decimal`，與既有 `current_month_usage`（token）**對稱**——`sum(call_records.cost_usd)`、`outcome == success`、`started_at >= 月初(UTC)`，`coalesce(…, 0)`。回 `Decimal`（不轉 float）。
+
+**Rationale**：
+- `call_records.cost_usd`（`Numeric(10,6)`，0019 既有）每筆呼叫都落（token 與非 token 一致）；以它加總＝以「花費」為跨單位共同分母（vision 階段 29 既定結論）。
+- 既有複合索引 `idx_callrecord_allocation_time (allocation_id, started_at)` 正好涵蓋此查詢的 where 條件 → 與既有 token 配額查詢同等效能，無新索引。
+- `Decimal` 全程：`cost_usd` 是 `Numeric`、上限欄也用 `Numeric`，比較不經 float（呼應「金額別用浮點」）。
+
+**Alternatives considered**：
+- 即時維護一個「本月累計」計數欄（避免每次聚合）→ 否決：YAGNI，多一個要同步的狀態 + 月初歸零的排程；既有 token 配額就是每次聚合、效能已驗可接受。
+- 以 `aggregate_usage` 既有彙總服務算 → 否決：那是面向報表的多維彙總，preflight 熱路徑要的是單分配單值，獨立小函式更直接（對稱 `current_month_usage`）。
+
+---
+
+## R2：preflight 整合 + 新拒絕語意
+
+**Decision**：在 `run_preflight` 既有 token 配額檢查**之後、同一段**加一道 cost 檢查：
+```
+if allocation.quota_cost_usd_per_month is not None:
+    spent = await current_month_cost(session, allocation.id)
+    if spent >= allocation.quota_cost_usd_per_month:
+        return PreflightRejection("cost_quota_exceeded", "...本月花費上限...", 403, allocation)
+```
+新增 `CallOutcome.rejected_cost_quota_exceeded`（`Enum(native_enum=False)` 存 VARCHAR → **無 migration**，沿用既有列舉擴充慣例）；`proxy/router.py` 的 `_outcome_for_code` 加 `"cost_quota_exceeded": rejected_cost_quota_exceeded`。
+
+**Rationale**：
+- token 與 cost 兩道並列、任一超過即擋（FR-004 取較嚴者）；放在同一前置點 → 兩端點（chat/responses）+ registry 引擎共用的 preflight 一次涵蓋所有同步端點。
+- 拒絕仍走既有 `record_call`（綁 allocation、可觀測）——沿用「拒絕路徑也要記、要綁 context」教訓。
+- 新 outcome 而非複用 `rejected_quota_exceeded`：用量視圖能分辨「token 超額」vs「花費超額」（admin 診斷需要），且 VARCHAR enum 加值零 migration。
+
+**Alternatives considered**：
+- 複用 `rejected_quota_exceeded` 一個碼 → 否決：兩種上限的處置與訊息不同，分開可診斷（呼應「新事件優先映既有語意」的反向權衡——此處語意確實不同，值得新值）。
+- 在每個端點各自檢查 → 否決：違反「單一前置管線」，必 drift。
+
+---
+
+## R3：realtime 連線中花費把關（連線中 cost re-check）
+
+**Decision**：擴充階段 32 既有的旁路 watcher。目前 `_revocation_watch` 每 N 秒呼叫 `check_active(allocation_id)`（查 active 狀態）。改為週期同時核對 **committed 月花費 + 本連線進行中累計**：
+```
+over_cost = (await current_month_cost(allocation_id)) + session_running_cost(sess, price) >= cap
+```
+- `committed`：已落帳的本月花費（不含本連線——本連線尚未 disconnect 落帳）。
+- `session_running_cost`：本連線目前累計 = `session_quantity(sess, price.unit) × price.per_unit`（沿用階段 32 既有 `session_quantity` + 落帳同一條 price lookup）。
+- 任一原因（非 active **或** over_cost）→ 翻 `close_reason`（cost 用既有 `revoked` 語意或新增 `cost_exceeded`）、停止 relay → 既有「任何 close 路徑都落帳」確保已累計時長落帳。
+- 連線建立時的 preflight 也已含 cost 檢查（R2）→ 一開始就超額的連線在建立時即被擋。
+
+**Rationale**：
+- 完全沿用既有 watcher 協程與週期/SLO（不另起機制，YAGNI + 原則 3「長連線不只建立時檢查一次」）。
+- 容差「上限 + 一個 tick」與既有撤回延遲同語意（spec edge case 已接受）。
+- running cost 用既有 `session_quantity`/price——零新計量邏輯。
+
+**Alternatives considered**：
+- 每筆 `input_audio_buffer.append` 都檢查花費 → 否決：耦合轉送熱路徑、頻率不可控（同階段 32 撤回的否決理由）。
+- 只在連線建立時檢查 → 否決：長連線正是缺口最嚴重處（FR-005、原則 3）。
+- cap 用 cost，但 watcher 要先把本連線「部分落帳」才能算 committed → 否決：複雜化落帳語意；改用「committed + in-flight running」兩段相加，落帳仍只在 disconnect 一次。
+
+---
+
+## R4：與自適應配額池（階段 3c）的隔離
+
+**Decision**：**什麼都不用做**——`services/quota_pool.py` 的 `compute_rebalance` / `apply_rebalance` 只讀寫 `quota_tokens_per_month`（已 inspect 確認：`apply_rebalance` 的 `.values(quota_tokens_per_month=...)`、conservation 也只加總 token 欄）。新欄 `quota_cost_usd_per_month` 不在其讀寫範圍內，**天然不被再分配**（SC-005 直接成立）。
+
+**Rationale**：花費上限與 token 池是兩個正交的治理軸（一個硬上限、一個守恆再分配）；不混疊符合「守住軸正交、別 overload」（原則 7）+ spec 明確排除。
+
+**Alternatives considered**：把「花費」也做成可再分配的池（Σcost=T）→ 否決：YAGNI（無此需求）+ 兩套再分配邏輯互撞（spec 風險已標）。以一支整合測試固化「池跑完 cost 上限不變」即可。
+
+---
+
+## R5：未定價呼叫的誠實處置
+
+**Decision**：未定價呼叫 `cost_usd` 為 NULL → `current_month_cost` 的 `coalesce(…,0)` 視為 0 → **不增加累計、不被花費上限擋**。不另做特別處理；在 admin 配額 UI/文件標明「花費上限只治理已定價用量」。
+
+**Rationale**：延續「PriceList 是計費唯一真理」——未定價是 admin 該補價的設定問題，不該由配額層假裝它花了錢或無限。誠實標記（FR-006）。
+
+**Alternatives considered**：未定價呼叫一律擋（保守）→ 否決：會把「admin 還沒設價」誤殺成「超額」，體感差且與計費語意不一致。把未定價當某固定估價擋 → 否決：憑空造價、不可稽核。
+
+---
+
+## 研究結論彙整（給 Phase 1 / tasks）
+
+| 問題 | 結論 | 落地 |
+|---|---|---|
+| 累計花費來源 | `sum(cost_usd)` 月初起、Decimal、命中既有索引 | `services/quota.py` `current_month_cost` |
+| preflight 整合 | token 後並列一道 cost 檢查、新 outcome（無 migration） | `proxy/preflight.py` + `router._outcome_for_code` + `CallOutcome` |
+| realtime 連線中把關 | 擴充既有 watcher：committed + in-flight running ≥ cap → close + 落帳 | `proxy/realtime.py` |
+| 自適應池隔離 | 無需改碼（池只動 token 欄）；測試固化 | `tests/integration/test_quota_pool_*` |
+| 未定價 | NULL→0→不治理，誠實標記 | UI 文案 + 文件 |
+| Migration | `0020` 純加 `allocations.quota_cost_usd_per_month`（nullable Numeric） | `alembic/versions/0020_cost_quota.py` |
diff --git a/specs/046-cost-quota/spec.md b/specs/046-cost-quota/spec.md
new file mode 100644
index 0000000..2243351
--- /dev/null
+++ b/specs/046-cost-quota/spec.md
@@ -0,0 +1,109 @@
+# Feature Specification: 成本制配額（跨端點統一額度上限）
+
+**Feature Branch**: `046-cost-quota`
+**Created**: 2026-06-13
+**Status**: Draft
+**Input**: User description: "成本制配額：每分配可設每月花費上限（USD），統一治理 token 與非 token（頁/張/秒/分/字元）端點用量；realtime 長連線連線中即時把關超額"
+
+## 背景與問題
+
+平台的月度配額目前只以 **token 數**計（`分配的每月 token 上限`）。但平台已開放多種**非 token 計量**的端點——OCR（按頁）、圖片（按張）、語音合成（按字元）、即時字幕（按秒/分鐘）、search/rerank（按查詢）。這些呼叫**完全不計入配額**，因此一個擁有非 token 分配（尤其是即時字幕長連線）的成員可以**無上限使用、永遠碰不到月配額**。
+
+這直接削弱了平台的核心承諾「**額度綁在分配、可調整、可收回**」（原則 1）：對非 token 端點，額度形同不存在。本功能補上這個治理缺口。
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - 管理員為分配設「每月花費上限」，超額即擋（Priority: P1）🎯 MVP
+
+管理員擔心某個分配（不論它用的是 chat、OCR、圖片還是即時字幕）把成本吃爆。管理員在分配管理介面為它設一個「每月花費上限（美元）」。當該分配當月**累計花費**達到上限後，後續任何呼叫——**不分端點、不分計量單位**——都被擋下並回一個可理解的「已達本月花費上限」訊息。
+
+**Why this priority**: 這是補上治理缺口的核心。沒有它，非 token 端點的用量無法被收斂，原則 1 對這些端點無法兌現。單獨交付即為可用 MVP（一個以花費為共同分母、覆蓋所有端點的上限）。
+
+**Independent Test**: 為一個分配設花費上限，混合送 token 呼叫（chat）與非 token 呼叫（OCR/圖片），累計花費達上限後，確認後續呼叫被拒；未設上限的分配行為不變。
+
+**Acceptance Scenarios**:
+
+1. **Given** 某分配設了每月花費上限 $5、本月已累計 $4.90，**When** 成員送一筆會花 $0.20 的呼叫，**Then** 該呼叫被拒、回「已達本月花費上限」，且這筆被拒呼叫被如實記錄（歸戶到該分配）。
+2. **Given** 某分配同時設了 token 上限與花費上限，**When** 任一上限被達到，**Then** 後續呼叫即被擋（兩道上限取較嚴者生效）。
+3. **Given** 某分配**未**設花費上限，**When** 成員大量使用非 token 端點，**Then** 行為與現況完全相同（不被花費上限影響）。
+4. **Given** 某分配的花費上限涵蓋當月所有端點，**When** 統計其當月累計花費，**Then** 該數字 = 該分配當月所有成功呼叫的花費總和（token 與非 token 一致以美元加總）。
+
+---
+
+### User Story 2 - 即時字幕長連線在連線進行中超額即被中止（Priority: P2）
+
+一個即時字幕連線可能持續很久、持續累積每分鐘費用。若只在「連線建立時」檢查一次上限，一條長連線可在連線後把花費衝破上限而不被攔。本故事要求：連線**進行中**也週期性核對累計花費，一旦超過上限，平台在約定時間內**主動中止**該連線（已累計的用量照常落帳）。
+
+**Why this priority**: 長連線是本缺口最嚴重的場景（也是最初發現缺口的場景）。對應原則 3「即時撤回」延伸到「連線中即時把關」——不靠連線自然結束。但需先有 P1 的花費上限機制，故列 P2。
+
+**Independent Test**: 建立一個即時字幕連線、設一個很低的花費上限，持續送音訊使累計花費超過上限，確認連線在約定時間內被主動關閉、且已累計時長落帳。
+
+**Acceptance Scenarios**:
+
+1. **Given** 一個進行中的即時字幕連線，其分配的本月累計花費（含本連線累計）超過花費上限，**When** 下一次週期性核對發生，**Then** 平台在約定時間內主動關閉連線，並回一個可理解的關閉原因。
+2. **Given** 連線因超額被中止，**When** 落帳，**Then** 已累計時長的費用仍被記錄、歸戶到該分配（不漏記）。
+
+---
+
+### User Story 3 - 成員與管理員都看得到「本月花費 / 上限」（Priority: P3）
+
+成員要能在自己的用量介面看到每個分配的「本月已花 / 上限」，自己掌握、避免突然被擋。管理員在分配管理也看得到並能設定/調整。
+
+**Why this priority**: 可見性讓上限可被理解與自助規劃（原則 6 可達性）。功能上依賴 P1 的資料，故列 P3。
+
+**Independent Test**: 為分配設花費上限後，成員在自己的用量頁、管理員在分配詳情，皆能看到「本月花費 / 上限」數字與接近上限的提示。
+
+**Acceptance Scenarios**:
+
+1. **Given** 某分配設了花費上限，**When** 成員開啟自己的用量介面，**Then** 看到該分配「本月已花 $X / 上限 $Y」。
+2. **Given** 管理員開啟分配詳情，**When** 檢視配額區，**Then** 看到並可編輯「每月花費上限」，且編輯會留下稽核紀錄。
+
+---
+
+### Edge Cases
+
+- **連線進行中才超額（realtime）**：核對是週期性的，故容許「上限 + 一個核對週期」的小幅超出；這個容差與既有撤回的延遲語意一致，視為可接受而非漏洞。
+- **未定價呼叫**：無法算出花費的呼叫，其花費視為 0、不增加累計，因此**不被花費上限擋下**。系統對此誠實——不假裝它花了錢，也不視為無限。管理員若要治理這類用量，需先為該模型補上價格。
+- **同時設 token 與花費兩種上限**：任一達到即擋（取較嚴者）。
+- **月度歸零**：花費累計以 UTC 月初為界，與既有 token 配額同語意。
+- **接近上限的單筆大額呼叫**：在呼叫前以「目前累計」判斷；單筆呼叫可能讓累計略微越過上限（事前無法精確預知該筆花費），與既有 token 配額的事前判斷語意一致。
+- **被自適應配額池影響？**：不會——花費上限是獨立硬上限，自適應池只再分配 token 額度（見 Assumptions）。
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: 管理員 MUST 能為任一分配設定選填的「每月花費上限（USD）」；不設＝該分配無花費上限（維持現況）。
+- **FR-002**: 系統 MUST 在每次呼叫前，以該分配「本月累計花費」對照其花費上限；達到或超過即拒絕後續呼叫，回一個可理解的「已達本月花費上限」錯誤，並如實記錄這筆被拒呼叫（歸戶該分配）。
+- **FR-003**: 花費上限 MUST 對**所有計費端點**生效（對話、embedding、OCR、圖片、語音、rerank、search、即時字幕…），不分計量單位——以**花費（USD）**為跨單位的共同分母。
+- **FR-004**: 既有「每月 token 上限」行為 MUST 零回歸；兩種上限可同時設定，任一超過即擋。
+- **FR-005**: 長連線端點（即時字幕）MUST 在連線進行中即時把關——累計花費超過上限時，於約定時間內主動中止連線；中止時已累計的用量仍落帳、歸戶分配。
+- **FR-006**: 未定價（無法計算花費）的呼叫 MUST NOT 被花費上限擋下（其花費為 0、不增加累計）；系統行為對此誠實。
+- **FR-007**: 成員 MUST 能看到自己每個分配的「本月花費 / 上限」；管理員 MUST 能在分配管理看到並設定/調整。
+- **FR-008**: 花費上限的設定/變更 MUST 留稽核（誰、何時、改成多少）。
+- **FR-009**: 自適應配額池（既有 token 額度再分配機制）MUST NOT 動到任何分配的花費上限——花費上限是不進池的獨立硬上限。
+
+### Key Entities *(include if feature involves data)*
+
+- **分配（Allocation）**：治理與歸戶的單位。本功能為其新增一個選填屬性「每月花費上限（USD）」。既有「每月 token 上限」「鎖定配額」等屬性不變。
+- **用量紀錄（CallRecord）**：每筆呼叫一列、已帶「花費」與「歸戶分配」。本功能以「某分配當月所有成功呼叫的花費總和」作為「本月累計花費」的來源——**不需新增資料表**，沿用既有計費紀錄。
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: 對設了花費上限的分配，混合 token 與非 token 呼叫使累計花費達上限後，後續呼叫 **100%** 被擋（含至少一個非 token 端點，如 OCR 或即時字幕）。
+- **SC-002**: 即時字幕連線在連線進行中累計花費超過上限時，於**約定時間內**（對齊既有撤回 SLO）被主動中止，且已累計時長照常落帳。
+- **SC-003**: 只設 token 上限（未設花費上限）的分配，行為與現況**完全一致**——既有配額相關測試零回歸。
+- **SC-004**: 管理員與成員皆能在介面看到任一受限分配的「本月花費 / 上限」數字。
+- **SC-005**: 自適應配額池執行一輪後，各分配的花費上限值**不被改動**（只 token 額度被再分配）。
+- **SC-006**: 「本月累計花費」的計算結果，等於該分配當月所有成功呼叫 `花費` 欄之總和（可由用量明細核對）。
+
+## Assumptions
+
+- **花費來源**：以既有計費機制（PriceList、point-in-time、append-only）算出的每筆呼叫花費為準；**未定價呼叫花費為 0**，故不增加累計、也不被花費上限治理（管理員需補價才能納管，延續「PriceList 是計費唯一真理」）。
+- **獨立硬上限**：花費上限**不進**自適應配額池（階段 3c 的 Σq=T 守恆只再分配 token 額度）；兩套機制不互相影響，避免雙再分配邏輯互撞。
+- **月度邊界**：花費累計以 UTC 月初歸零，沿用既有 token 配額同語意。
+- **連線中把關**：即時字幕的連線中超額核對，沿用階段 32 既有的「旁路週期 re-check」機制（與撤回同一個協程、同一個週期與 SLO），不另起新機制。
+- **不做每日上限**：本功能以 USD（月度）統一治理，**不**重做已 descope 的「每天 N 張/頁」per-unit 每日上限；若未來真需要日粒度再另議。
+- **既有設施重用**：分配配額編輯 UI、用量顯示路徑、稽核事件、preflight 前置管線、realtime relay 撤回協程皆已存在，本功能在其上增量。
diff --git a/specs/046-cost-quota/tasks.md b/specs/046-cost-quota/tasks.md
new file mode 100644
index 0000000..e5ffc62
--- /dev/null
+++ b/specs/046-cost-quota/tasks.md
@@ -0,0 +1,147 @@
+# Tasks: 成本制配額（跨端點統一額度上限）
+
+**Input**: Design documents from `specs/046-cost-quota/`
+**Prerequisites**: plan.md, spec.md, research.md, data-model.md, contracts/cost-quota.md, quickstart.md
+
+**Tests**: 包含（Constitution 原則 I Test-First 非協商）——契約/整合/單元測試先寫且先失敗，再實作。
+
+**Organization**: 按 user story（P1/P2/P3）分階段，每個 story 獨立可測。
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: 不同檔案、無未完成依賴，可並行
+- **[Story]**: US1 / US2 / US3（對映 spec 的 P1/P2/P3）
+
+---
+
+## Phase 1: Setup（資料與列舉基礎）
+
+- [X] T001 在 `src/ai_api/models/allocation.py` 加 `quota_cost_usd_per_month: Mapped[Decimal | None] = mapped_column(Numeric(10, 6), nullable=True)`（Phase 33；既有 token 欄不動）
+- [X] T002 新 migration `alembic/versions/0020_cost_quota.py`：`op.add_column("allocations", quota_cost_usd_per_month Numeric(10,6) nullable)`（純加欄，含 downgrade `drop_column`）；本機驗 `alembic upgrade head` + `downgrade`
+- [X] T003 [P] 在 `src/ai_api/models/call_record.py` 的 `CallOutcome` 加 `rejected_cost_quota_exceeded = "rejected_cost_quota_exceeded"`（`Enum(native_enum=False)` → 無 migration）
+
+**Checkpoint**: 分配可存花費上限、新拒絕 outcome 可用——Foundational 可開工
+
+---
+
+## Phase 2: Foundational（阻塞所有 user story）
+
+**⚠️ CRITICAL**: 本階段未完成前，US1–US3 無法開工（三者都要 `current_month_cost`）
+
+- [X] T004 [P] 單元測試（先失敗）：`tests/unit/test_quota.py` 加 `current_month_cost`（成功、本月、`coalesce(cost_usd,0)` 之 Decimal 總和；未定價以 0 計）與 `is_over_cost_quota`（cap None→False、`spent >= cap`→True）
+- [X] T005 在 `src/ai_api/services/quota.py` 實作 `current_month_cost(db, allocation_id) -> Decimal`（對稱 `current_month_usage`，`sum(CallRecord.cost_usd)`，命中既有索引）+ `is_over_cost_quota(allocation, spent)`
+
+**Checkpoint**: 花費累計與判斷可用——US1/US2/US3 皆可獨立進行
+
+---
+
+## Phase 3: User Story 1 - admin 設花費上限、超額即擋（Priority: P1）🎯 MVP
+
+**Goal**: 設了花費上限的分配，token 與非 token 累計花費達上限後，後續呼叫一律被擋；未設者零回歸。
+
+**Independent Test**: 為分配設上限，混送 chat + OCR 使累計達上限 → 後續 403 `cost_quota_exceeded`；未設上限者行為不變。
+
+### Tests for User Story 1 ⚠️（先寫、先失敗）
+
+- [X] T006 [P] [US1] 契約測試：設花費上限、混合 token+非 token 累計達上限 → 後續呼叫 403 `cost_quota_exceeded` 且落一筆 `rejected_cost_quota_exceeded`（`tests/contract/test_cost_quota.py`）
+- [X] T007 [P] [US1] 契約測試：未設花費上限 → 非 token 呼叫不被擋、token 配額行為零回歸（同檔）
+- [X] T008 [P] [US1] 契約測試：同設 token+花費兩種上限 → 先達到者擋（兩種各驗一次）（同檔）
+- [X] T009 [P] [US1] 契約測試：未定價模型呼叫 → 不增加累計、不被花費上限擋（同檔）
+
+### Implementation for User Story 1
+
+- [X] T010 [US1] `src/ai_api/proxy/preflight.py`：在既有 token 配額檢查後並列一道 cost 檢查（`quota_cost_usd_per_month` 非 None 且 `current_month_cost >= cap` → `PreflightRejection("cost_quota_exceeded", …, 403, allocation)`）
+- [X] T011 [US1] `src/ai_api/proxy/router.py` 的 `_outcome_for_code` 加 `"cost_quota_exceeded": CallOutcome.rejected_cost_quota_exceeded`（拒絕仍走既有 `record_call`、綁 allocation）
+- [X] T012 [US1] admin 分配 create/update 收選填 `quota_cost_usd_per_month`（`src/ai_api/api/allocations.py` + `src/ai_api/api/schemas.py`，`>= 0` 驗證、null 清除、變更留稽核）+ 分配序列化回傳此欄
+- [X] T013 [P] [US1] 前端：admin 配額編輯 Dialog 加「每月花費上限（USD）」欄（`frontend/src/` 既有配額編輯處），含一句「只治理已定價用量」說明
+
+**Checkpoint**: MVP 成立——admin 能設、所有同步端點受治理、未設者零回歸
+
+---
+
+## Phase 4: User Story 2 - 即時字幕連線中超額即被中止（Priority: P2）
+
+**Goal**: realtime 長連線進行中累計花費超過上限 → 約定時間內主動 close，已累計時長落帳。
+
+**Independent Test**: 低上限 + 持續送音訊使累計超額 → N 秒內被 close + 落帳（mock provider WS）。
+
+### Tests for User Story 2 ⚠️（先寫、先失敗）
+
+- [X] T014 [P] [US2] 整合測試：realtime 連線中累計花費超過上限 → N 秒內 close（policy violation）+ 已累計時長落帳（`tests/contract/test_realtime_transcription.py`，沿用既有 mock provider WS + 直接呼叫 `handle_realtime` + 注入 `check_active`/低 `revoke_interval`）
+
+### Implementation for User Story 2
+
+- [X] T015 [US2] `src/ai_api/proxy/realtime.py`：加 `session_running_cost(sess, price)`（= `session_quantity(sess, price.unit) × price.per_unit`）+ 擴充旁路 watcher——每 tick 核對 `current_month_cost(allocation) + running >= cap` → 翻 `close_reason`、停 relay
+- [X] T016 [US2] `src/ai_api/proxy/realtime.py`：cost 觸發的 close 走既有「任何 close 路徑都落帳」（必要時加 `close_reason="cost_exceeded"` 並映 close code/outcome；確認 `_bill_session` 不漏記）
+
+**Checkpoint**: US1 + US2——長連線也被花費上限即時把關
+
+---
+
+## Phase 5: User Story 3 - 成員/admin 看「本月花費 / 上限」（Priority: P3）
+
+**Goal**: 成員與 admin 都看得到每分配「本月已花 / 上限」。
+
+**Independent Test**: 設上限後，成員用量頁、admin 分配詳情皆顯示「本月花費 / 上限」。
+
+### Tests for User Story 3 ⚠️（先寫、先失敗）
+
+- [X] T017 [P] [US3] 序列化/契約測試：`/me/usage`（與 admin 用量）每分配回 `cost_used_this_month`（Decimal 字串）+ `quota_cost_usd_per_month`（`tests/contract/test_me_usage.py`）
+
+### Implementation for User Story 3
+
+- [X] T018 [US3] `src/ai_api/api/me.py` + `src/ai_api/api/usage.py`：每分配序列化加 `cost_used_this_month`（`current_month_cost`）+ `quota_cost_usd_per_month`（成員只看自己、嚴格隔離沿用既有）
+- [X] T019 [P] [US3] 前端：分配卡 + 用量頁顯示「本月花費 $X / 上限 $Y」+ 接近上限提示（`frontend/src/` 既有用量/分配顯示處）
+
+**Checkpoint**: 三個 user story 全部獨立可用
+
+---
+
+## Phase 6: Polish & Cross-Cutting
+
+- [X] T020 [P] 整合測試：自適應配額池跑一輪後，各分配 `quota_cost_usd_per_month` **不變**（只 token 額度被再分配）（`tests/integration/test_quota_pool_rebalance.py`，SC-005）
+- [X] T021 全綠關卡：`ruff check .` + mypy + 完整 `pytest tests/` 零回歸 + 前端 tsc/vitest/build；**既有配額 contract 測試 git diff 為空**（SC-003）
+- [ ] T022 部署後煙霧（quickstart.md）：有 migration → `--set migrationJob.enabled=true`；`kubectl exec <pod> -- python3 -m alembic current` 顯 `0020`；admin 設一個低上限對自己分配真打驗一次（同步端點 + realtime 連線中各一）
+
+---
+
+## Dependencies & Execution Order
+
+- **Setup（T001–T003）**：無依賴；T003 與 T001/T002 可並行（不同檔）
+- **Foundational（T004–T005）**：依賴 Setup；**BLOCKS 所有 user story**
+- **US1（P1）/ US2（P2）/ US3（P3）**：皆依賴 Foundational；三者彼此獨立可並行（US1 改 preflight、US2 改 realtime、US3 改 usage 序列化，不同檔）
+  - 建議順序 US1（MVP）→ US2 → US3，但無硬依賴
+- **Polish（T020–T022）**：依賴所需 user story 完成
+
+### Within Each User Story
+- 測試先寫且先失敗 → 實作 → 重構
+- 同 story 內：跨檔測試/前端標 [P]；改同一檔（preflight、realtime.py）的實作任務為順序
+
+### Parallel Opportunities
+- T001 / T003（Setup）可並行
+- 各 story 測試任務（T006–T009、T014、T017）標 [P] 可並行先寫
+- 前端任務（T013、T019）與後端不同檔，可並行
+- 三個 user story 因落在不同檔（preflight / realtime / usage），整體可並行推進
+
+---
+
+## Implementation Strategy
+
+### MVP First（User Story 1）
+1. Setup（T001–T003）→ 2. Foundational（T004–T005）→ 3. US1（T006–T013）→ **STOP & VALIDATE**（混合端點累計超額被擋、token 零回歸＝MVP）→ 視情況先上線。
+
+### Incremental Delivery
+1. Setup + Foundational → 花費累計可算
+2. US1 → 同步端點花費治理（MVP，可上線）
+3. US2 → 長連線連線中把關（realtime 治理完整）
+4. US3 → 成員/admin 可見性
+5. Polish（自適應池隔離測試 + 全綠 + 部署煙霧）
+
+### 零回歸鐵證
+- 既有配額相關 contract 測試**斷言不改全綠、git diff 為空**（SC-003）；只設 token 上限者行為 byte-identical。
+
+## Notes
+- [P] = 不同檔、無依賴；改 `preflight.py` / `realtime.py` 同檔的實作任務為順序。
+- 加欄位（`quota_cost_usd_per_month`）要追到所有 sink（preflight、admin API/UI、用量顯示、**自適應池要刻意排除**）——對照 `quota_tokens_per_month` 既有出現點（experience「加欄位追到所有 sink」）。
+- migration 後跑 Postgres 整合測試固化零回歸（experience「SQLite 寬鬆、Postgres 嚴格」）。
+- 改 `CallOutcome`（T003）後重跑完整 `pytest tests/`（experience「動列舉/對映後全套件重跑」）。
diff --git a/src/ai_api/api/allocations.py b/src/ai_api/api/allocations.py
index bec53dd..fd44d44 100644
--- a/src/ai_api/api/allocations.py
+++ b/src/ai_api/api/allocations.py
@@ -1,6 +1,7 @@
 """Allocation admin endpoints."""
 from __future__ import annotations
 
+from decimal import Decimal
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Query, status
@@ -13,7 +14,8 @@
     CreateAllocationRequest,
     CredentialOut,
 )
-from ai_api.models import AllocationStatus
+from ai_api.auth import audit
+from ai_api.models import ActorType, AllocationStatus, AuditEventType
 from ai_api.services.allocations import AllocationService
 
 router = APIRouter(dependencies=[Depends(require_admin_token)])
@@ -44,6 +46,7 @@ def _to_out(a: Any, display_name: str | None = None) -> AllocationOut:
         note=a.note,
         token_prefix=_repr_token_prefix(a),
         quota_tokens_per_month=a.quota_tokens_per_month,
+        quota_cost_usd_per_month=a.quota_cost_usd_per_month,
         is_service_allocation=a.is_service_allocation,
     )
 
@@ -64,6 +67,7 @@ async def create_allocation(
             subject=payload.subject,
             resource_model=payload.resource_model,
             note=payload.note,
+            quota_cost_usd_per_month=payload.quota_cost_usd_per_month,
         )
     except ValueError as exc:
         raise HTTPException(
@@ -202,11 +206,12 @@ async def patch_allocation(
 ) -> AllocationOut:
     """Update mutable allocation fields. Accepts:
     - quota_tokens_per_month (int | null) — null = unlimited
+    - quota_cost_usd_per_month (number | null) — null = no cost cap (Phase 33)
     - is_service_allocation (bool)
     - note (str)
     """
 
-    allowed = {"quota_tokens_per_month", "is_service_allocation", "note"}
+    allowed = {"quota_tokens_per_month", "quota_cost_usd_per_month", "is_service_allocation", "note"}
     unknown = set(payload.keys()) - allowed
     if unknown:
         raise HTTPException(
@@ -228,6 +233,30 @@ async def patch_allocation(
                 detail={"error": {"code": "bad_request", "message": "quota_tokens_per_month must be int >= 0 or null"}},
             )
         allocation.quota_tokens_per_month = v
+    if "quota_cost_usd_per_month" in payload:
+        cv = payload["quota_cost_usd_per_month"]
+        if cv is not None:
+            try:
+                cv = Decimal(str(cv))
+            except (ArithmeticError, ValueError, TypeError):
+                cv = Decimal(-1)
+            if cv < 0:
+                raise HTTPException(
+                    status_code=400,
+                    detail={"error": {"code": "bad_request",
+                                      "message": "quota_cost_usd_per_month must be a number >= 0 or null"}},
+                )
+        allocation.quota_cost_usd_per_month = cv
+        # FR-008: cost-cap changes are audited (the only quota change with an audit
+        # event; token-cap edits historically have none).
+        await audit.record(
+            session,
+            event_type=AuditEventType.allocation_cost_quota_updated,
+            actor_type=ActorType.admin,
+            target_type="allocation",
+            target_id=allocation.id,
+            details={"quota_cost_usd_per_month": str(cv) if cv is not None else None},
+        )
     if "is_service_allocation" in payload:
         allocation.is_service_allocation = bool(payload["is_service_allocation"])
     if "note" in payload:
diff --git a/src/ai_api/api/me.py b/src/ai_api/api/me.py
index 1f7a3ea..d803c2a 100644
--- a/src/ai_api/api/me.py
+++ b/src/ai_api/api/me.py
@@ -64,6 +64,7 @@ def _alloc_public(
     price: dict[str, str] | None = None,
     display_name: str | None = None,
     agent_compatible: bool = False,
+    cost_used_this_month: str | None = None,
 ) -> dict[str, Any]:
     return {
         "id": a.id,
@@ -74,6 +75,11 @@ def _alloc_public(
         "status": a.status,
         "origin": a.origin,
         "quota_tokens_per_month": a.quota_tokens_per_month,
+        # Phase 33 (046): monthly USD spend cap + this-month spend (Decimal as str).
+        "quota_cost_usd_per_month": (
+            str(a.quota_cost_usd_per_month) if a.quota_cost_usd_per_month is not None else None
+        ),
+        "cost_used_this_month": cost_used_this_month,
         "created_at": a.created_at.isoformat(),
         "revoked_at": a.revoked_at.isoformat() if a.revoked_at else None,
         "token_prefix": _repr_token_prefix(a),
@@ -98,8 +104,11 @@ async def list_my_allocations(
 
     from ai_api.models import ModelCatalog
     from ai_api.services import pricing, responses_support
+    from ai_api.services.quota import current_month_cost
 
     allocations = await AllocationService(db).list(member_id=member.id)
+    # Phase 33: this-month spend per allocation (cross-unit USD), for the cost cap line.
+    cost_used = {a.id: str(await current_month_cost(db, a.id)) for a in allocations}
     price_map = await pricing.current_price_map(db, datetime.now(UTC))
     # slug → (display_name, capabilities) from the catalog (orphan slugs absent).
     rows = await db.execute(
@@ -117,6 +126,7 @@ async def list_my_allocations(
             pricing.price_for_slug(price_map, _provider_of(a.resource_model), a.resource_model),
             name_map.get(a.resource_model),
             agent_map.get(a.resource_model, False),
+            cost_used_this_month=cost_used.get(a.id),
         )
         for a in allocations
     ]
diff --git a/src/ai_api/api/schemas.py b/src/ai_api/api/schemas.py
index d5c4076..cad63ba 100644
--- a/src/ai_api/api/schemas.py
+++ b/src/ai_api/api/schemas.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from datetime import datetime
+from decimal import Decimal
 from typing import Annotated
 
 from pydantic import (
@@ -31,6 +32,8 @@ class CreateAllocationRequest(BaseModel):
     subject: SubjectStr | None = None
     resource_model: ResourceModelStr
     note: str | None = Field(default=None, max_length=500)
+    # Phase 33 (046): optional monthly USD spend cap. None = no cost cap.
+    quota_cost_usd_per_month: Decimal | None = Field(default=None, ge=0)
 
     @model_validator(mode="after")
     def _require_either(self) -> CreateAllocationRequest:
@@ -55,6 +58,8 @@ class AllocationOut(BaseModel):
     token_prefix: str | None = None  # Phase 18: representative credential prefix
     # Phase 3a
     quota_tokens_per_month: int | None = None
+    # Phase 33 (046): monthly USD spend cap (None = no cost cap)
+    quota_cost_usd_per_month: Decimal | None = None
     is_service_allocation: bool = False
 
     @computed_field  # type: ignore[prop-decorator]
diff --git a/src/ai_api/models/allocation.py b/src/ai_api/models/allocation.py
index d2fad50..0666f6a 100644
--- a/src/ai_api/models/allocation.py
+++ b/src/ai_api/models/allocation.py
@@ -3,9 +3,10 @@
 
 import enum
 from datetime import datetime
+from decimal import Decimal
 from typing import TYPE_CHECKING
 
-from sqlalchemy import Boolean, DateTime, Enum, ForeignKey, Index, Integer, String, Text
+from sqlalchemy import Boolean, DateTime, Enum, ForeignKey, Index, Integer, Numeric, String, Text
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from ai_api.db import Base
@@ -47,6 +48,11 @@ class Allocation(Base):
     note: Mapped[str | None] = mapped_column(Text, nullable=True)
     # Phase 3a
     quota_tokens_per_month: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    # Phase 33 (046): per-allocation monthly SPEND cap (USD). NULL ⇒ no cost cap.
+    # Governs all endpoints via the cost (USD) common denominator — token + non-token
+    # (page/image/second/minute/character). Independent hard cap; NOT rebalanced by
+    # the adaptive quota pool (which only redistributes quota_tokens_per_month).
+    quota_cost_usd_per_month: Mapped[Decimal | None] = mapped_column(Numeric(10, 6), nullable=True)
     is_service_allocation: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     # Phase 3c
     quota_locked: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
diff --git a/src/ai_api/models/auth_audit.py b/src/ai_api/models/auth_audit.py
index c083d1c..590aa1c 100644
--- a/src/ai_api/models/auth_audit.py
+++ b/src/ai_api/models/auth_audit.py
@@ -58,6 +58,8 @@ class AuditEventType(enum.StrEnum):
     # Phase 019: allocation pause/resume (reversible, token-preserving)
     allocation_paused = "allocation_paused"
     allocation_resumed = "allocation_resumed"
+    # Phase 33 (046): cost-based monthly quota cap change
+    allocation_cost_quota_updated = "allocation_cost_quota_updated"
     # Phase 13: admin email notifications — event types that trigger admin emails
     responses_upstream_error_burst = "responses_upstream_error_burst"
     provider_credential_auth_failed = "provider_credential_auth_failed"
diff --git a/src/ai_api/models/call_record.py b/src/ai_api/models/call_record.py
index 5dadc76..4765c6c 100644
--- a/src/ai_api/models/call_record.py
+++ b/src/ai_api/models/call_record.py
@@ -30,6 +30,7 @@ class CallOutcome(enum.StrEnum):
     rejected_quarantined = "rejected_quarantined"
     rejected_paused = "rejected_paused"
     rejected_quota_exceeded = "rejected_quota_exceeded"
+    rejected_cost_quota_exceeded = "rejected_cost_quota_exceeded"
     rejected_model_forbidden = "rejected_model_forbidden"
     rejected_model_unsupported = "rejected_model_unsupported"
     rejected_response_forbidden = "rejected_response_forbidden"
diff --git a/src/ai_api/proxy/preflight.py b/src/ai_api/proxy/preflight.py
index 3c39909..c49f8b1 100644
--- a/src/ai_api/proxy/preflight.py
+++ b/src/ai_api/proxy/preflight.py
@@ -25,7 +25,12 @@
     ProviderUnavailableError,
     ResolvedCredential,
 )
-from ai_api.services.quota import current_month_usage, is_over_quota
+from ai_api.services.quota import (
+    current_month_cost,
+    current_month_usage,
+    is_over_cost_quota,
+    is_over_quota,
+)
 
 
 @dataclass
@@ -131,7 +136,7 @@ async def run_preflight(
             "allocation_paused", "allocation is paused", 403, allocation
         )
 
-    # Monthly quota.
+    # Monthly token quota.
     if allocation.quota_tokens_per_month is not None:
         usage = await current_month_usage(session, allocation.id)
         if is_over_quota(allocation, usage):
@@ -142,6 +147,19 @@ async def run_preflight(
                 allocation,
             )
 
+    # Monthly cost quota (Phase 33): cross-unit USD spend cap, governs every endpoint
+    # (token + non-token) via the cost common denominator. Independent of the token
+    # cap — either one trips. Unpriced calls accrue 0, so they aren't governed here.
+    if allocation.quota_cost_usd_per_month is not None:
+        spent = await current_month_cost(session, allocation.id)
+        if is_over_cost_quota(allocation, spent):
+            return PreflightRejection(
+                "cost_quota_exceeded",
+                f"monthly cost cap reached (${spent} / ${allocation.quota_cost_usd_per_month})",
+                403,
+                allocation,
+            )
+
     # Model binding.
     from fastapi import HTTPException
 
diff --git a/src/ai_api/proxy/realtime.py b/src/ai_api/proxy/realtime.py
index 459d68c..edc35f1 100644
--- a/src/ai_api/proxy/realtime.py
+++ b/src/ai_api/proxy/realtime.py
@@ -25,6 +25,7 @@
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from decimal import Decimal
 from typing import Any, Protocol
 
 from fastapi import APIRouter, WebSocket
@@ -90,8 +91,13 @@ class RealtimeSession:
     sample_rate: int = _DEFAULT_SAMPLE_RATE
     bytes_per_sample: int = _DEFAULT_BYTES_PER_SAMPLE
     channels: int = _DEFAULT_CHANNELS
-    # normal | client_abort | upstream_error | revoked
+    # normal | client_abort | upstream_error | revoked | cost_exceeded
     close_reason: str = "normal"
+    # Phase 33 (046): in-connection cost-cap watch. Captured at connect from the
+    # allocation + point-in-time price. cost_cap None ⇒ no cost watch.
+    cost_cap: Decimal | None = None
+    price_unit: str | None = None
+    price_per_unit: Decimal | None = None
 
 
 # --- Pure metering helpers (T014/T017) --------------------------------------
@@ -156,6 +162,15 @@ def session_quantity(sess: RealtimeSession, unit: str) -> int:
     )
 
 
+def session_running_cost(sess: RealtimeSession) -> Decimal:
+    """Phase 33: cost accrued by THIS connection so far (in-flight, not yet billed).
+    0 if unpriced. Used by the in-connection cost-cap watch: committed + running."""
+    if sess.price_per_unit is None:
+        return Decimal(0)
+    unit = sess.price_unit if sess.price_unit in ("second", "minute") else "second"
+    return Decimal(session_quantity(sess, unit)) * sess.price_per_unit
+
+
 def _apply_format(sess: RealtimeSession, ev: dict[str, Any]) -> None:
     """Read sample rate (and, if present, sample width/channels) from a
     `session.update` so metering uses the client's actual PCM geometry. Tolerant of
@@ -244,16 +259,40 @@ async def _upstream_to_client(client: ClientWS, upstream: UpstreamWS, sess: Real
 CheckActive = Callable[[str], Awaitable[bool]]
 
 
+async def _allocation_over_cost(sess: RealtimeSession) -> bool:
+    """Phase 33: committed month cost + this connection's in-flight cost ≥ cap.
+    cost_cap None ⇒ never over. Fail-open on a transient DB error."""
+    if sess.cost_cap is None:
+        return False
+    from ai_api.db import get_sessionmaker
+    from ai_api.services.quota import current_month_cost
+
+    try:
+        async with get_sessionmaker()() as s:
+            committed = await current_month_cost(s, sess.allocation_id)
+    except Exception:
+        logger.exception("realtime cost re-check query failed; leaving connection up")
+        return False
+    return (committed + session_running_cost(sess)) >= sess.cost_cap
+
+
+# over_cost(sess) -> bool
+OverCost = Callable[[RealtimeSession], Awaitable[bool]]
+
+
 async def _revocation_watch(
     sess: RealtimeSession,
     *,
     stop: asyncio.Event,
     check_active: CheckActive,
     interval: float,
+    over_cost: OverCost = _allocation_over_cost,
 ) -> None:
     """Side-channel: every `interval` seconds re-check the allocation; if it is no
-    longer active (revoked / paused / quarantined) flip close_reason and signal the
-    relay to stop (FR-005). Does not touch the relay hot path."""
+    longer active (revoked / paused / quarantined) → close_reason=revoked, or if the
+    monthly cost cap is exceeded (committed + in-flight) → close_reason=cost_exceeded;
+    either flips close_reason and signals the relay to stop (FR-005/Phase 33). Does not
+    touch the relay hot path."""
     while not stop.is_set():
         try:
             await asyncio.wait_for(stop.wait(), timeout=interval)
@@ -269,6 +308,10 @@ async def _revocation_watch(
             sess.close_reason = "revoked"
             stop.set()
             return
+        if await over_cost(sess):
+            sess.close_reason = "cost_exceeded"
+            stop.set()
+            return
 
 
 async def run_relay(
@@ -278,6 +321,7 @@ async def run_relay(
     *,
     check_active: CheckActive,
     interval: float = REVOKE_RECHECK_SECONDS,
+    over_cost: OverCost = _allocation_over_cost,
 ) -> None:
     """Run both forwarding coroutines + the revocation watcher until any one ends,
     then tear the others down. Returns once the connection is fully closed."""
@@ -292,7 +336,9 @@ async def _forward_then_stop(coro: Awaitable[None]) -> None:
     t_up = asyncio.create_task(_forward_then_stop(_client_to_upstream(client, upstream, sess)))
     t_down = asyncio.create_task(_forward_then_stop(_upstream_to_client(client, upstream, sess)))
     t_watch = asyncio.create_task(
-        _revocation_watch(sess, stop=stop, check_active=check_active, interval=interval)
+        _revocation_watch(
+            sess, stop=stop, check_active=check_active, interval=interval, over_cost=over_cost
+        )
     )
 
     await stop.wait()
@@ -310,6 +356,8 @@ async def _forward_then_stop(coro: Awaitable[None]) -> None:
 def _close_code_for(close_reason: str) -> tuple[int, str]:
     if close_reason == "revoked":
         return WS_POLICY_VIOLATION, "allocation revoked"
+    if close_reason == "cost_exceeded":
+        return WS_POLICY_VIOLATION, "monthly cost cap reached"
     if close_reason == "upstream_error":
         return WS_INTERNAL, "upstream connection closed"
     return WS_NORMAL, "connection closed"
@@ -376,7 +424,9 @@ async def _bill_session(sess: RealtimeSession) -> None:
                 unit=unit,
                 cost_usd=cost,
                 error_message=(
-                    "allocation revoked mid-connection" if sess.close_reason == "revoked" else None
+                    "allocation revoked mid-connection" if sess.close_reason == "revoked"
+                    else "monthly cost cap reached mid-connection" if sess.close_reason == "cost_exceeded"
+                    else None
                 ),
             )
             await s.commit()
@@ -417,6 +467,7 @@ async def handle_realtime(
     *,
     open_upstream: OpenUpstream,
     check_active: CheckActive = _allocation_is_active,
+    over_cost: OverCost = _allocation_over_cost,
     revoke_interval: float = REVOKE_RECHECK_SECONDS,
 ) -> None:
     """Drive one realtime connection end-to-end. Injectable `open_upstream` /
@@ -475,6 +526,16 @@ async def handle_realtime(
             return
         allocation_id = result.allocation.id
         subject = result.allocation.subject_snapshot
+        # Phase 33: capture the cost cap + point-in-time price for the in-connection
+        # cost watch (a connection already over cap is rejected by preflight above).
+        cost_cap = result.allocation.quota_cost_usd_per_month
+        from ai_api.services.pricing import lookup_price_for_call
+        _price = await lookup_price_for_call(
+            s, provider=result.provider,
+            model=result.upstream_model.split("/", 1)[-1], call_time=started_at,
+        )
+        price_unit = _price.price_unit if _price is not None else None
+        price_per_unit = _price.price_per_unit if _price is not None else None
 
     resolved = result.resolved
     sess = RealtimeSession(
@@ -485,6 +546,9 @@ async def handle_realtime(
         provider=result.provider,
         request_id=request_id,
         started_at=started_at,
+        cost_cap=cost_cap,
+        price_unit=price_unit,
+        price_per_unit=price_per_unit,
     )
     # Meter the first frame too (it may already be an append in some clients).
     _meter_client_event(sess, first_raw)
@@ -517,7 +581,8 @@ async def handle_realtime(
             sess.close_reason = "upstream_error"
         else:
             await run_relay(
-                client, upstream, sess, check_active=check_active, interval=revoke_interval
+                client, upstream, sess, check_active=check_active,
+                over_cost=over_cost, interval=revoke_interval
             )
     finally:
         await _safe_close_upstream(upstream)
diff --git a/src/ai_api/proxy/router.py b/src/ai_api/proxy/router.py
index 852e0b4..e92da08 100644
--- a/src/ai_api/proxy/router.py
+++ b/src/ai_api/proxy/router.py
@@ -43,6 +43,7 @@ def _outcome_for_code(code: str) -> CallOutcome:
         "allocation_quarantined": CallOutcome.rejected_quarantined,
         "allocation_paused": CallOutcome.rejected_paused,
         "quota_exceeded": CallOutcome.rejected_quota_exceeded,
+        "cost_quota_exceeded": CallOutcome.rejected_cost_quota_exceeded,
         "model_forbidden": CallOutcome.rejected_model_forbidden,
         "model_not_responses_capable": CallOutcome.rejected_model_unsupported,
         "response_forbidden": CallOutcome.rejected_response_forbidden,
diff --git a/src/ai_api/services/allocations.py b/src/ai_api/services/allocations.py
index d0e86be..c2835b0 100644
--- a/src/ai_api/services/allocations.py
+++ b/src/ai_api/services/allocations.py
@@ -4,6 +4,7 @@
 from collections.abc import Sequence
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from decimal import Decimal
 from typing import cast
 
 from sqlalchemy import select
@@ -58,6 +59,7 @@ async def create(
         created_by: str | None = None,
         subject: str | None = None,
         quota_tokens_per_month: int | None = None,
+        quota_cost_usd_per_month: Decimal | None = None,
         origin: AllocationOrigin = AllocationOrigin.admin,
     ) -> AllocationCreated:
         if not resource_model:
@@ -87,6 +89,7 @@ async def create(
             created_by=created_by or self.BOOTSTRAP_ADMIN,
             note=note,
             quota_tokens_per_month=quota_tokens_per_month,
+            quota_cost_usd_per_month=quota_cost_usd_per_month,
             origin=origin,
         )
         self._s.add(allocation)
diff --git a/src/ai_api/services/quota.py b/src/ai_api/services/quota.py
index da2106f..57cbbbb 100644
--- a/src/ai_api/services/quota.py
+++ b/src/ai_api/services/quota.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from datetime import UTC, datetime
+from decimal import Decimal
 
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -31,3 +32,27 @@ def is_over_quota(allocation: Allocation, current_usage: int) -> bool:
     if allocation.quota_tokens_per_month is None:
         return False
     return current_usage >= allocation.quota_tokens_per_month
+
+
+async def current_month_cost(db: AsyncSession, allocation_id: str) -> Decimal:
+    """Total successful `cost_usd` for this allocation since UTC month start (Phase 33).
+
+    Cross-unit common denominator: token + non-token (page/image/second/minute/char)
+    calls all carry cost_usd, so summing it governs every endpoint with one cap.
+    Unpriced calls have cost_usd NULL → coalesce(0) → they don't accrue and aren't
+    governed by the cost cap (honest; admin must price them to bring them in scope)."""
+    start = current_month_start_utc()
+    stmt = select(func.coalesce(func.sum(CallRecord.cost_usd), 0)).where(
+        CallRecord.allocation_id == allocation_id,
+        CallRecord.outcome == CallOutcome.success,
+        CallRecord.started_at >= start,
+    )
+    # str() guard: coerce exactly even if a backend hands back a float for the sum.
+    return Decimal(str((await db.execute(stmt)).scalar_one() or 0))
+
+
+def is_over_cost_quota(allocation: Allocation, current_cost: Decimal) -> bool:
+    """cost cap=None → unlimited; otherwise check >= cap (mirrors is_over_quota)."""
+    if allocation.quota_cost_usd_per_month is None:
+        return False
+    return current_cost >= allocation.quota_cost_usd_per_month
diff --git a/tests/contract/test_cost_quota.py b/tests/contract/test_cost_quota.py
new file mode 100644
index 0000000..d821e96
--- /dev/null
+++ b/tests/contract/test_cost_quota.py
@@ -0,0 +1,165 @@
+"""Phase 33 (046) US1: cost-based monthly quota — per-allocation USD spend cap.
+
+Cost quota is checked in preflight BEFORE credential resolution, so the *blocked*
+paths need no upstream mock. Cost accrual is seeded directly as CallRecords (a real
+priced call would just be a slower way to reach the same cost sum).
+"""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from decimal import Decimal
+
+import pytest
+from httpx import AsyncClient
+from sqlalchemy import select, update
+from ulid import ULID
+
+from ai_api.db import get_sessionmaker
+from ai_api.models import Allocation, CallOutcome, CallRecord
+
+MODEL = "azure/gpt-test"
+
+
+async def _alloc(client: AsyncClient, admin: dict, model: str = MODEL) -> dict:
+    r = await client.post("/admin/allocations", headers=admin,
+                          json={"subject": "alice@example.com", "resource_model": model})
+    assert r.status_code == 201, r.text
+    return r.json()
+
+
+async def _set_caps(alloc_id: str, *, cost: str | None = None, tokens: int | None = None) -> None:
+    sm = get_sessionmaker()
+    async with sm() as s:
+        vals: dict = {}
+        if cost is not None:
+            vals["quota_cost_usd_per_month"] = Decimal(cost)
+        if tokens is not None:
+            vals["quota_tokens_per_month"] = tokens
+        await s.execute(update(Allocation).where(Allocation.id == alloc_id).values(**vals))
+        await s.commit()
+
+
+async def _seed_call(alloc_id: str, *, cost: str | None, tokens: int | None = None,
+                     unit: str | None = None, quantity: int | None = None) -> None:
+    now = datetime.now(UTC)
+    sm = get_sessionmaker()
+    async with sm() as s:
+        s.add(CallRecord(
+            id=str(ULID()), request_id="seed", allocation_id=alloc_id, subject="alice@example.com",
+            model=MODEL, started_at=now, finished_at=now, status_code=200,
+            outcome=CallOutcome.success,
+            total_tokens=tokens, quantity=quantity, unit=unit,
+            cost_usd=Decimal(cost) if cost is not None else None,
+        ))
+        await s.commit()
+
+
+async def _chat(client: AsyncClient, token: str, model: str = MODEL):
+    return await client.post(
+        "/v1/chat/completions", headers={"Authorization": f"Bearer {token}"},
+        json={"model": model, "messages": [{"role": "user", "content": "hi"}]},
+    )
+
+
+async def _last(outcome: CallOutcome) -> CallRecord | None:
+    sm = get_sessionmaker()
+    async with sm() as s:
+        rows = (await s.execute(
+            select(CallRecord).where(CallRecord.outcome == outcome)
+            .order_by(CallRecord.started_at.desc())
+        )).scalars().all()
+        return rows[0] if rows else None
+
+
+# --- T006: cost cap blocks across token + non-token endpoints ----------------
+@pytest.mark.asyncio
+async def test_cost_cap_blocks_mixed_endpoints(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)
+    await _set_caps(alloc["id"], cost="1.00")
+    # token call $0.60 + OCR page call $0.40 →累計 $1.00 = cap
+    await _seed_call(alloc["id"], cost="0.60", tokens=300)
+    await _seed_call(alloc["id"], cost="0.40", unit="page", quantity=2)
+    r = await _chat(app_client, alloc["token"])
+    assert r.status_code == 403, r.text
+    assert r.json()["error"]["code"] == "cost_quota_exceeded"
+    rec = await _last(CallOutcome.rejected_cost_quota_exceeded)
+    assert rec is not None and rec.allocation_id == alloc["id"]
+
+
+# --- T007: no cost cap → cost gate doesn't fire; token path intact -----------
+@pytest.mark.asyncio
+async def test_no_cost_cap_gate_does_not_fire(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)  # no cost cap set
+    await _seed_call(alloc["id"], cost="999.00", unit="page", quantity=9)  # huge non-token spend
+    r = await _chat(app_client, alloc["token"])
+    # gate must NOT block on cost (it has no cost cap); it fails later (no upstream),
+    # but never with cost_quota_exceeded.
+    if r.status_code == 403:
+        assert r.json()["error"]["code"] != "cost_quota_exceeded"
+
+
+@pytest.mark.asyncio
+async def test_token_cap_still_blocks_zero_regression(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)
+    await _set_caps(alloc["id"], tokens=100)          # token cap, NO cost cap
+    await _seed_call(alloc["id"], cost=None, tokens=100)  # token usage at cap
+    r = await _chat(app_client, alloc["token"])
+    assert r.status_code == 403 and r.json()["error"]["code"] == "quota_exceeded"
+
+
+# --- T008: both caps → either one trips ------------------------------------
+@pytest.mark.asyncio
+async def test_both_caps_cost_trips(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)
+    await _set_caps(alloc["id"], cost="1.00", tokens=1_000_000)  # token slack, cost tight
+    await _seed_call(alloc["id"], cost="1.00", unit="minute", quantity=59)
+    r = await _chat(app_client, alloc["token"])
+    assert r.status_code == 403 and r.json()["error"]["code"] == "cost_quota_exceeded"
+
+
+@pytest.mark.asyncio
+async def test_both_caps_token_trips(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)
+    await _set_caps(alloc["id"], cost="100.00", tokens=10)  # cost slack, token tight
+    await _seed_call(alloc["id"], cost="0.01", tokens=10)
+    r = await _chat(app_client, alloc["token"])
+    assert r.status_code == 403 and r.json()["error"]["code"] == "quota_exceeded"
+
+
+# --- T009: unpriced calls don't accrue, don't block ------------------------
+@pytest.mark.asyncio
+async def test_unpriced_calls_not_counted(app_client: AsyncClient, admin_headers):
+    alloc = await _alloc(app_client, admin_headers)
+    await _set_caps(alloc["id"], cost="1.00")
+    # many unpriced (cost_usd NULL) calls → sum stays 0 → not blocked by cost cap
+    for _ in range(5):
+        await _seed_call(alloc["id"], cost=None, unit="page", quantity=10)
+    r = await _chat(app_client, alloc["token"])
+    if r.status_code == 403:
+        assert r.json()["error"]["code"] != "cost_quota_exceeded"
+
+
+# --- SC-006: current_month_cost = sum(cost_usd), unpriced as 0 -------------
+@pytest.mark.asyncio
+async def test_current_month_cost_sums_all_units(app_client: AsyncClient, admin_headers):
+    from ai_api.services.quota import current_month_cost
+
+    alloc = await _alloc(app_client, admin_headers)
+    await _seed_call(alloc["id"], cost="0.60", tokens=300)       # token
+    await _seed_call(alloc["id"], cost="0.40", unit="page", quantity=2)  # non-token
+    await _seed_call(alloc["id"], cost=None, unit="page", quantity=1)    # unpriced → 0
+    sm = get_sessionmaker()
+    async with sm() as s:
+        total = await current_month_cost(s, alloc["id"])
+    assert total == Decimal("1.00")
+
+
+# --- T012: admin API round-trips the cost cap ------------------------------
+@pytest.mark.asyncio
+async def test_admin_api_sets_and_returns_cost_cap(app_client: AsyncClient, admin_headers):
+    r = await app_client.post("/admin/allocations", headers=admin_headers, json={
+        "subject": "bob@example.com", "resource_model": MODEL,
+        "quota_cost_usd_per_month": "5.00",
+    })
+    assert r.status_code == 201, r.text
+    assert Decimal(r.json()["quota_cost_usd_per_month"]) == Decimal("5.00")
diff --git a/tests/contract/test_me_allocations.py b/tests/contract/test_me_allocations.py
index af8d680..5f3f03a 100644
--- a/tests/contract/test_me_allocations.py
+++ b/tests/contract/test_me_allocations.py
@@ -204,3 +204,35 @@ async def test_me_allocations_agent_compatible(
     assert by_model["azure/agent"]["agent_compatible"] is True
     assert by_model["azure/plain"]["agent_compatible"] is False
     assert by_model["azure/ghost"]["agent_compatible"] is False
+
+
+# --- Phase 33 (046) US3: /me/allocations exposes cost cap + this-month spend --
+@pytest.mark.asyncio
+async def test_me_allocations_exposes_cost_cap_and_used(app_client: AsyncClient, admin_headers):
+    from decimal import Decimal
+
+    from ulid import ULID
+
+    from ai_api.models import CallOutcome, CallRecord
+
+    me = await _login(app_client, admin_headers, email="costview@x.com")
+    r = await app_client.post("/admin/allocations", headers=admin_headers, json={
+        "member_id": me["id"], "resource_model": "azure/gpt-x",
+        "quota_cost_usd_per_month": "5.00",
+    })
+    assert r.status_code == 201, r.text
+    aid = r.json()["id"]
+    sm = get_sessionmaker()
+    async with sm() as s:
+        now = datetime.now(UTC)
+        s.add(CallRecord(
+            id=str(ULID()), request_id="x", allocation_id=aid, subject="costview@x.com",
+            model="azure/gpt-x", started_at=now, finished_at=now, status_code=200,
+            outcome=CallOutcome.success, cost_usd=Decimal("1.20"),
+        ))
+        await s.commit()
+    rows = (await app_client.get("/me/allocations")).json()
+    row = next(x for x in rows if x["id"] == aid)
+    assert row["quota_cost_usd_per_month"] is not None
+    assert Decimal(row["quota_cost_usd_per_month"]) == Decimal("5.00")
+    assert Decimal(row["cost_used_this_month"]) == Decimal("1.20")
diff --git a/tests/contract/test_realtime_transcription.py b/tests/contract/test_realtime_transcription.py
index 974a372..43974b9 100644
--- a/tests/contract/test_realtime_transcription.py
+++ b/tests/contract/test_realtime_transcription.py
@@ -338,3 +338,36 @@ async def failing_opener(**kwargs):
     # Connect failed before any audio relayed → 0 (unpriced → default unit second).
     rec = await _last(CallOutcome.upstream_error)
     assert rec is not None and rec.unit == "second" and rec.quantity == 0
+
+
+# --- Phase 33 (046) US2: in-connection cost-cap → close + bill --------------
+@pytest.mark.asyncio
+async def test_inflight_cost_cap_closes_and_bills(app_client: AsyncClient, admin_headers):
+    """A realtime connection whose accrued cost crosses the monthly cap is closed
+    mid-stream (policy violation) and the accrued time is still billed."""
+    await _seed_catalog(RT_MODEL)
+    await _seed_price("0.017")
+    alloc = await _alloc(app_client, admin_headers)
+    await _seed_provider(app_client, admin_headers)
+    client = FakeClientWS(_bearer(alloc["token"]),
+                          [_session_update(), _append(30.0)], hold_open=True)
+    upstream = FakeUpstreamWS(close_after=False)
+
+    ticks = {"n": 0}
+
+    async def over_cost_after_first_tick(sess) -> bool:
+        ticks["n"] += 1
+        return ticks["n"] >= 1  # first re-check already reports over the cost cap
+
+    await asyncio.wait_for(
+        handle_realtime(
+            client, open_upstream=fake_opener(upstream),
+            over_cost=over_cost_after_first_tick, revoke_interval=0.05,
+        ),
+        timeout=5,
+    )
+    assert client.closed is not None and client.closed[0] == 1008
+    assert client.closed[1] == "monthly cost cap reached"
+    rec = await _last(CallOutcome.success)
+    assert rec is not None and rec.unit == "minute" and rec.quantity == 1
+    assert rec.error_message == "monthly cost cap reached mid-connection"
diff --git a/tests/integration/test_credential_migration.py b/tests/integration/test_credential_migration.py
index 63b858d..83150b1 100644
--- a/tests/integration/test_credential_migration.py
+++ b/tests/integration/test_credential_migration.py
@@ -26,9 +26,6 @@
 from ai_api.config import get_settings
 from ai_api.db import get_sessionmaker
 from ai_api.models import (
-    Allocation,
-    AllocationOrigin,
-    AllocationStatus,
     Member,
     MemberProvider,
     MemberStatus,
@@ -64,39 +61,31 @@ async def wipe() -> None:
         await engine.dispose()
 
     async def seed_old() -> None:
-        # members/allocations are unchanged by 0015 → ORM is safe; the credential
-        # must be inserted raw because at 0014 the table still has the old columns.
+        # member/allocation/credential MUST be inserted raw: the ORM reflects the
+        # HEAD schema (which has columns added in later migrations, e.g. 0020
+        # allocations.quota_cost_usd_per_month) that don't exist at 0014. Raw SQL
+        # lists only the 0014-era columns. (experience: "ORM reflects head schema".)
         engine = create_async_engine(postgres_url)
         sm = async_sessionmaker(engine, expire_on_commit=False)
         now = datetime.now(UTC)
         async with sm() as s:
-            s.add(
-                Member(
-                    id=member_id,
-                    email="legacy@example.com",
-                    provider=MemberProvider.external,
-                    display_name="legacy",
-                    status=MemberStatus.active,
-                    password_hash=None,
-                    created_at=now,
-                    disabled_at=None,
-                    created_by="test",
-                )
+            await s.execute(
+                text(
+                    "INSERT INTO members "
+                    "(id, email, provider, display_name, status, created_at, created_by) "
+                    "VALUES (:id, :email, 'external', 'legacy', 'active', :now, 'test')"
+                ),
+                {"id": member_id, "email": "legacy@example.com", "now": now},
             )
-            s.add(
-                Allocation(
-                    id=alloc_id,
-                    member_id=member_id,
-                    subject_snapshot="legacy@example.com",
-                    resource_model="azure/gpt-test",
-                    status=AllocationStatus.active,
-                    created_at=now,
-                    revoked_at=None,
-                    created_by="test",
-                    note=None,
-                    quota_tokens_per_month=None,
-                    origin=AllocationOrigin.admin,
-                )
+            await s.execute(
+                text(
+                    "INSERT INTO allocations "
+                    "(id, member_id, subject_snapshot, resource_model, status, "
+                    " created_at, created_by, is_service_allocation, quota_locked, origin) "
+                    "VALUES (:id, :mid, :subj, :rm, 'active', :now, 'test', false, false, 'admin')"
+                ),
+                {"id": alloc_id, "mid": member_id, "subj": "legacy@example.com",
+                 "rm": "azure/gpt-test", "now": now},
             )
             await s.flush()
             await s.execute(
diff --git a/tests/integration/test_quota_pool_rebalance.py b/tests/integration/test_quota_pool_rebalance.py
index b3ab34b..5b24d0d 100644
--- a/tests/integration/test_quota_pool_rebalance.py
+++ b/tests/integration/test_quota_pool_rebalance.py
@@ -327,3 +327,36 @@ def _broken(*, T, floor, reserved_total, pool):
     after = await _quotas()
     assert after == before  # quota unchanged
     assert await _rebalance_log_count() == 0
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_cost_cap_untouched_by_rebalance(app_client, monkeypatch) -> None:
+    """Phase 33 (046) SC-005: the adaptive pool only redistributes TOKEN quota; a
+    cost cap is an independent hard cap and must not be rebalanced."""
+    from decimal import Decimal
+
+    from sqlalchemy import update as sa_update
+
+    monkeypatch.setenv("POOL_TOTAL_TOKENS_PER_MONTH", "1000")
+    monkeypatch.setenv("POOL_FLOOR_PER_ALLOCATION", "100")
+    get_settings.cache_clear()
+
+    a_id = await _seed_member_and_allocation(email="ca@x.com", usage=50)
+    await _seed_member_and_allocation(email="cb@x.com", usage=30)
+    sm = get_sessionmaker()
+    async with sm() as s:
+        await s.execute(sa_update(Allocation).where(Allocation.id == a_id)
+                        .values(quota_cost_usd_per_month=Decimal("7.50")))
+        await s.commit()
+    async with sm() as s:
+        await apply_rebalance(s, trigger="admin:test")
+        await s.commit()
+
+    quotas = await _quotas()
+    assert quotas[a_id] is not None and quotas[a_id] > 0  # token quota WAS rebalanced
+    async with sm() as s:
+        cap = (await s.execute(
+            select(Allocation.quota_cost_usd_per_month).where(Allocation.id == a_id)
+        )).scalar_one()
+    assert cap == Decimal("7.50")  # cost cap UNCHANGED
diff --git a/tests/unit/test_quota_check.py b/tests/unit/test_quota_check.py
index 2b49073..3779e84 100644
--- a/tests/unit/test_quota_check.py
+++ b/tests/unit/test_quota_check.py
@@ -3,8 +3,9 @@
 
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from decimal import Decimal
 
-from ai_api.services.quota import current_month_start_utc, is_over_quota
+from ai_api.services.quota import current_month_start_utc, is_over_cost_quota, is_over_quota
 
 
 def test_current_month_start_anchors_to_utc_first():
@@ -37,3 +38,30 @@ def test_quota_boundary_exact():
 
 def test_quota_boundary_over():
     assert is_over_quota(_Alloc(quota_tokens_per_month=100), 101) is True
+
+
+# --- Phase 33 (046): cost-based quota ---------------------------------------
+@dataclass
+class _CostAlloc:
+    quota_cost_usd_per_month: Decimal | None
+
+
+def test_cost_unlimited_never_over():
+    assert is_over_cost_quota(_CostAlloc(None), Decimal("999.99")) is False
+
+
+def test_cost_boundary_just_under():
+    assert is_over_cost_quota(_CostAlloc(Decimal("5")), Decimal("4.999999")) is False
+
+
+def test_cost_boundary_exact_is_over():
+    # spent == cap → over (>= rule, mirrors token quota)
+    assert is_over_cost_quota(_CostAlloc(Decimal("5")), Decimal("5")) is True
+
+
+def test_cost_boundary_over():
+    assert is_over_cost_quota(_CostAlloc(Decimal("5")), Decimal("5.20")) is True
+
+
+def test_cost_zero_cap_blocks_any_spend():
+    assert is_over_cost_quota(_CostAlloc(Decimal("0")), Decimal("0")) is True