diff --git a/.github/scripts/release-docker-smoke.sh b/.github/scripts/release-docker-smoke.sh
index ab66a642..3c3475fd 100755
--- a/.github/scripts/release-docker-smoke.sh
+++ b/.github/scripts/release-docker-smoke.sh
@@ -4,6 +4,7 @@ umask 077
 
 release_version="${RELEASE_VERSION:-v2.0.0-local}"
 suffix="${RELEASE_SMOKE_SUFFIX:-local-$$}"
+source_image="${RELEASE_SMOKE_SOURCE_IMAGE:-}"
 case "${suffix}" in
   *[!A-Za-z0-9_-]*)
     printf 'RELEASE_SMOKE_SUFFIX contains unsupported characters\n' >&2
@@ -117,10 +118,16 @@ case "${docker_arch}" in
     ;;
 esac
 
-docker build \
-  --platform "${platform}" \
-  --build-arg "VERSION=${release_version}" \
-  -t "${image}" .
+if [[ -n "${source_image}" ]]; then
+  test "${source_image}" != "${image}"
+  docker pull --platform "${platform}" "${source_image}"
+  docker image tag "${source_image}" "${image}"
+else
+  docker build \
+    --platform "${platform}" \
+    --build-arg "VERSION=${release_version}" \
+    -t "${image}" .
+fi
 test "$(docker image inspect -f '{{.Config.User}}' "${image}")" = "10001:10001"
 
 docker volume create "${volume}" >/dev/null
@@ -326,7 +333,9 @@ node -e '
   const prices=JSON.parse(fs.readFileSync(process.argv[2],"utf8"));
   const usage=JSON.parse(fs.readFileSync(process.argv[3],"utf8"));
   if(!groups.data.some(item=>item.name==="Task13 Release Smoke Group")) process.exit(1);
-  if(!prices.data.some(item=>item.pattern==="task13-release-model"&&item.source==="user")) process.exit(1);
+  if(!prices.data.overrides.some(
+    item=>item.pattern==="task13-release-model"&&item.source==="user"
+  )) process.exit(1);
   if(usage.data.summary.request_count<1||usage.data.summary.total_tokens!==12) process.exit(1);
 ' \
   "${task_tmp}/groups-second.json" \
diff --git a/.github/scripts/release-image-digest.sh b/.github/scripts/release-image-digest.sh
new file mode 100755
index 00000000..18b84bd9
--- /dev/null
+++ b/.github/scripts/release-image-digest.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+image="${1:?image is required}"
+output=
+if output="$(
+  docker buildx imagetools inspect \
+    "${image}" \
+    --format '{{.Manifest.Digest}}' 2>&1
+)"; then
+  test -n "${output}"
+  printf '%s' "${output}"
+  exit 0
+fi
+
+if grep -Eqi 'manifest unknown|manifest_unknown' <<<"${output}" ||
+  {
+    grep -Fqi -- "${image}" <<<"${output}" &&
+      grep -Eqi 'not found|(^|[^0-9])404([^0-9]|$)' <<<"${output}"
+  }; then
+  printf 'absent'
+  exit 0
+fi
+
+printf '%s\n' "${output}" >&2
+exit 1
diff --git a/.github/scripts/release-native-smoke.ps1 b/.github/scripts/release-native-smoke.ps1
new file mode 100644
index 00000000..3e427f14
--- /dev/null
+++ b/.github/scripts/release-native-smoke.ps1
@@ -0,0 +1,226 @@
+$ErrorActionPreference = "Stop"
+
+$binary = $env:RELEASE_SMOKE_BINARY
+$checksumFile = $env:RELEASE_SMOKE_CHECKSUM_FILE
+$releaseVersion = $env:RELEASE_VERSION
+$port = if ($env:RELEASE_SMOKE_PORT) { $env:RELEASE_SMOKE_PORT } else { "39113" }
+foreach ($required in @($binary, $checksumFile, $releaseVersion)) {
+  if ([string]::IsNullOrWhiteSpace($required)) {
+    throw "RELEASE_SMOKE_BINARY, RELEASE_SMOKE_CHECKSUM_FILE, and RELEASE_VERSION are required"
+  }
+}
+
+Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class ReleaseNativeProcess
+{
+    private const uint CREATE_NEW_PROCESS_GROUP = 0x00000200;
+    private const uint CTRL_BREAK_EVENT = 1;
+    private const int ERROR_ACCESS_DENIED = 5;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct STARTUPINFO
+    {
+        public uint cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public uint dwX;
+        public uint dwY;
+        public uint dwXSize;
+        public uint dwYSize;
+        public uint dwXCountChars;
+        public uint dwYCountChars;
+        public uint dwFillAttribute;
+        public uint dwFlags;
+        public ushort wShowWindow;
+        public ushort cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct PROCESS_INFORMATION
+    {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public uint dwProcessId;
+        public uint dwThreadId;
+    }
+
+    [DllImport(
+        "kernel32.dll",
+        CharSet = CharSet.Unicode,
+        ExactSpelling = true,
+        SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CreateProcessW(
+        string applicationName,
+        StringBuilder commandLine,
+        IntPtr processAttributes,
+        IntPtr threadAttributes,
+        [MarshalAs(UnmanagedType.Bool)] bool inheritHandles,
+        uint creationFlags,
+        IntPtr environment,
+        string currentDirectory,
+        ref STARTUPINFO startupInfo,
+        out PROCESS_INFORMATION processInformation);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GenerateConsoleCtrlEvent(
+        uint ctrlEvent,
+        uint processGroupId);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern uint GetConsoleCP();
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool AllocConsole();
+
+    [DllImport("kernel32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CloseHandle(IntPtr handle);
+
+    private static void EnsureConsole()
+    {
+        if (GetConsoleCP() != 0 || AllocConsole())
+        {
+            return;
+        }
+        var error = Marshal.GetLastWin32Error();
+        if (error != ERROR_ACCESS_DENIED || GetConsoleCP() == 0)
+        {
+            throw new Win32Exception(error);
+        }
+    }
+
+    public static Process Start(string path)
+    {
+        EnsureConsole();
+        var startupInfo = new STARTUPINFO {
+            cb = (uint)Marshal.SizeOf<STARTUPINFO>()
+        };
+        var commandLine = new StringBuilder("\"" + path + "\"");
+        PROCESS_INFORMATION processInformation;
+        if (!CreateProcessW(
+            path,
+            commandLine,
+            IntPtr.Zero,
+            IntPtr.Zero,
+            false,
+            CREATE_NEW_PROCESS_GROUP,
+            IntPtr.Zero,
+            null,
+            ref startupInfo,
+            out processInformation))
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+        try
+        {
+            return Process.GetProcessById((int)processInformation.dwProcessId);
+        }
+        finally
+        {
+            CloseHandle(processInformation.hThread);
+            CloseHandle(processInformation.hProcess);
+        }
+    }
+
+    public static void SendCtrlBreak(int processGroupId)
+    {
+        if (!GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, (uint)processGroupId))
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+    }
+}
+'@
+
+$filename = [System.IO.Path]::GetFileName($binary)
+$checksumLine = Get-Content $checksumFile |
+  Where-Object { $_ -match "\s$([regex]::Escape($filename))$" }
+if (-not $checksumLine) { throw "missing checksum" }
+$expectedHash = ($checksumLine -split "\s+")[0].ToLowerInvariant()
+$beforeHash = (Get-FileHash -Algorithm SHA256 $binary).Hash.ToLowerInvariant()
+if ($beforeHash -ne $expectedHash) { throw "checksum mismatch before execution" }
+
+& $binary help | Out-Null
+if ($LASTEXITCODE -ne 0) { throw "help failed" }
+
+$dataDir = Join-Path $env:RUNNER_TEMP "gpt-load-native-smoke-$([guid]::NewGuid())"
+New-Item -ItemType Directory -Path $dataDir | Out-Null
+$env:DATA_DIR = $dataDir
+$env:PORT = $port
+$process = [ReleaseNativeProcess]::Start($binary)
+try {
+  $health = $null
+  for ($attempt = 0; $attempt -lt 80; $attempt++) {
+    try {
+      $health = Invoke-RestMethod "http://127.0.0.1:$port/health"
+      break
+    } catch {
+      Start-Sleep -Milliseconds 250
+    }
+  }
+  if ($null -eq $health) { throw "health check timed out" }
+  if ($health.version -ne $releaseVersion) { throw "version mismatch" }
+
+  $authFile = Join-Path $dataDir "auth.key"
+  $encryptionFile = Join-Path $dataDir "encryption.key"
+  $databaseFile = Join-Path $dataDir "gpt-load.db"
+  foreach ($file in @($authFile, $encryptionFile, $databaseFile)) {
+    if (-not (Test-Path $file)) { throw "missing generated asset: $file" }
+  }
+
+  $currentSid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+  foreach ($file in @($authFile, $encryptionFile)) {
+    $acl = Get-Acl $file
+    if (-not $acl.AreAccessRulesProtected) { throw "credential DACL inherits rules" }
+    $allowRules = @($acl.Access | Where-Object {
+      $_.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow
+    })
+    if ($allowRules.Count -eq 0) { throw "credential DACL has no allow rule" }
+    foreach ($rule in $allowRules) {
+      $sid = $rule.IdentityReference.Translate(
+        [System.Security.Principal.SecurityIdentifier]
+      )
+      if ($sid.Value -ne $currentSid.Value) {
+        throw "credential DACL allows another principal"
+      }
+    }
+  }
+
+  $authKey = (Get-Content $authFile -Raw).Trim()
+  Invoke-WebRequest "http://127.0.0.1:$port/" -UseBasicParsing | Out-Null
+  $headers = @{ Authorization = "Bearer $authKey" }
+  Invoke-RestMethod "http://127.0.0.1:$port/api/usage?range=24h" -Headers $headers | Out-Null
+  Invoke-RestMethod "http://127.0.0.1:$port/api/model-prices" -Headers $headers | Out-Null
+
+  [ReleaseNativeProcess]::SendCtrlBreak($process.Id)
+  if (-not $process.WaitForExit(15000)) {
+    throw "graceful shutdown timed out"
+  }
+  if ($process.ExitCode -ne 0) {
+    throw "graceful shutdown exited with code $($process.ExitCode)"
+  }
+
+  $afterHash = (Get-FileHash -Algorithm SHA256 $binary).Hash.ToLowerInvariant()
+  if ($afterHash -ne $expectedHash) { throw "checksum mismatch after execution" }
+} finally {
+  # Stop-Process is failure cleanup only; success is proven by CTRL_BREAK and exit code 0.
+  if (-not $process.HasExited) {
+    Stop-Process -Id $process.Id -ErrorAction SilentlyContinue
+    $process.WaitForExit(5000) | Out-Null
+  }
+  Remove-Item -Recurse -Force $dataDir -ErrorAction SilentlyContinue
+}
diff --git a/.github/scripts/release-native-smoke.sh b/.github/scripts/release-native-smoke.sh
new file mode 100755
index 00000000..7b47e302
--- /dev/null
+++ b/.github/scripts/release-native-smoke.sh
@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+set -euo pipefail
+umask 077
+
+binary="${RELEASE_SMOKE_BINARY:?RELEASE_SMOKE_BINARY is required}"
+checksum_file="${RELEASE_SMOKE_CHECKSUM_FILE:?RELEASE_SMOKE_CHECKSUM_FILE is required}"
+release_version="${RELEASE_VERSION:?RELEASE_VERSION is required}"
+port="${RELEASE_SMOKE_PORT:-39113}"
+filename="$(basename "${binary}")"
+
+expected_hash="$(awk -v name="${filename}" '$2 == name {print $1}' "${checksum_file}")"
+test -n "${expected_hash}"
+if command -v sha256sum >/dev/null 2>&1; then
+  before_hash="$(sha256sum "${binary}" | awk '{print $1}')"
+else
+  before_hash="$(shasum -a 256 "${binary}" | awk '{print $1}')"
+fi
+test "${before_hash}" = "${expected_hash}"
+
+chmod +x "${binary}"
+"${binary}" help >/dev/null
+
+data_dir="$(mktemp -d)"
+log_file="$(mktemp)"
+pid=
+cleanup() {
+  if [[ -n "${pid}" ]]; then
+    kill -TERM "${pid}" >/dev/null 2>&1 || true
+    wait "${pid}" >/dev/null 2>&1 || true
+  fi
+  rm -rf "${data_dir}" "${log_file}"
+}
+trap cleanup EXIT
+
+DATA_DIR="${data_dir}" \
+  PORT="${port}" \
+  "${binary}" >"${log_file}" 2>&1 &
+pid=$!
+for _ in $(seq 1 80); do
+  if curl -fsS "http://127.0.0.1:${port}/health" >"${data_dir}/health.json"; then
+    break
+  fi
+  sleep 0.25
+done
+
+test -s "${data_dir}/health.json"
+test -f "${data_dir}/auth.key"
+test -f "${data_dir}/encryption.key"
+test -f "${data_dir}/gpt-load.db"
+auth_key="$(cat "${data_dir}/auth.key")"
+test -n "${auth_key}"
+grep -F "\"version\":\"${release_version}\"" "${data_dir}/health.json"
+curl -fsS "http://127.0.0.1:${port}/" | grep -F '<div id="app"></div>' >/dev/null
+curl -fsS \
+  -H "Authorization: Bearer ${auth_key}" \
+  "http://127.0.0.1:${port}/api/usage?range=24h" >/dev/null
+curl -fsS \
+  -H "Authorization: Bearer ${auth_key}" \
+  "http://127.0.0.1:${port}/api/model-prices" >/dev/null
+
+kill -TERM "${pid}"
+wait "${pid}"
+pid=
+
+if command -v sha256sum >/dev/null 2>&1; then
+  after_hash="$(sha256sum "${binary}" | awk '{print $1}')"
+else
+  after_hash="$(shasum -a 256 "${binary}" | awk '{print $1}')"
+fi
+test "${after_hash}" = "${expected_hash}"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d82881ba..334e299b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -111,9 +111,7 @@ jobs:
         run: pnpm --dir web run test:e2e
 
       - name: Check repository invariants
-        run: |
-          git diff --check
-          cmp -s AGENTS.md CLAUDE.md
+        run: git diff --check
 
       - name: Upload verified web dist
         uses: actions/upload-artifact@v4
@@ -233,6 +231,9 @@ jobs:
             filename: gpt-load-windows-amd64.exe
     runs-on: ${{ matrix.runner }}
     steps:
+      - name: Checkout tag commit
+        uses: actions/checkout@v7
+
       - name: Download complete release assets
         uses: actions/download-artifact@v4
         with:
@@ -242,277 +243,22 @@ jobs:
       - name: Smoke POSIX native artifact
         if: runner.os != 'Windows'
         shell: bash
-        run: |
-          set -euo pipefail
-          binary="${GITHUB_WORKSPACE}/native-smoke/${{ matrix.filename }}"
-          checksum_file="${GITHUB_WORKSPACE}/native-smoke/SHA256SUMS"
-          expected_hash="$(awk -v name="${{ matrix.filename }}" '$2 == name {print $1}' "${checksum_file}")"
-          test -n "${expected_hash}"
-          if command -v sha256sum >/dev/null 2>&1; then
-            before_hash="$(sha256sum "${binary}" | awk '{print $1}')"
-          else
-            before_hash="$(shasum -a 256 "${binary}" | awk '{print $1}')"
-          fi
-          test "${before_hash}" = "${expected_hash}"
-          chmod +x "${binary}"
-          "${binary}" help >/dev/null
-
-          data_dir="$(mktemp -d)"
-          log_file="$(mktemp)"
-          cleanup() {
-            if [[ -n "${pid:-}" ]]; then
-              kill -TERM "${pid}" >/dev/null 2>&1 || true
-              wait "${pid}" >/dev/null 2>&1 || true
-            fi
-            rm -rf "${data_dir}" "${log_file}"
-          }
-          trap cleanup EXIT
-
-          DATA_DIR="${data_dir}" \
-            PORT=39113 \
-            "${binary}" >"${log_file}" 2>&1 &
-          pid=$!
-          for _ in $(seq 1 80); do
-            if curl -fsS http://127.0.0.1:39113/health >"${data_dir}/health.json"; then
-              break
-            fi
-            sleep 0.25
-          done
-          test -f "${data_dir}/auth.key"
-          test -f "${data_dir}/encryption.key"
-          test -f "${data_dir}/gpt-load.db"
-          auth_key="$(cat "${data_dir}/auth.key")"
-          test -n "${auth_key}"
-          grep -F "\"version\":\"${GITHUB_REF_NAME}\"" "${data_dir}/health.json"
-          curl -fsS http://127.0.0.1:39113/ | grep -F '<div id="app"></div>'
-          curl -fsS \
-            -H "Authorization: Bearer ${auth_key}" \
-            'http://127.0.0.1:39113/api/usage?range=24h' >/dev/null
-          curl -fsS \
-            -H "Authorization: Bearer ${auth_key}" \
-            http://127.0.0.1:39113/api/model-prices >/dev/null
-          kill -TERM "${pid}"
-          wait "${pid}"
-          pid=
-          if command -v sha256sum >/dev/null 2>&1; then
-            after_hash="$(sha256sum "${binary}" | awk '{print $1}')"
-          else
-            after_hash="$(shasum -a 256 "${binary}" | awk '{print $1}')"
-          fi
-          test "${after_hash}" = "${expected_hash}"
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+          RELEASE_SMOKE_BINARY: ${{ github.workspace }}/native-smoke/${{ matrix.filename }}
+          RELEASE_SMOKE_CHECKSUM_FILE: ${{ github.workspace }}/native-smoke/SHA256SUMS
+        run: .github/scripts/release-native-smoke.sh
 
       - name: Smoke Windows native artifact
         if: runner.os == 'Windows'
         shell: pwsh
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+          RELEASE_SMOKE_BINARY: ${{ github.workspace }}/native-smoke/${{ matrix.filename }}
+          RELEASE_SMOKE_CHECKSUM_FILE: ${{ github.workspace }}/native-smoke/SHA256SUMS
         run: |
-          $ErrorActionPreference = "Stop"
-          Add-Type -TypeDefinition @'
-          using System;
-          using System.ComponentModel;
-          using System.Diagnostics;
-          using System.Runtime.InteropServices;
-          using System.Text;
-
-          public static class ReleaseNativeProcess
-          {
-              private const uint CREATE_NEW_PROCESS_GROUP = 0x00000200;
-              private const uint CTRL_BREAK_EVENT = 1;
-              private const int ERROR_ACCESS_DENIED = 5;
-
-              [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-              private struct STARTUPINFO
-              {
-                  public uint cb;
-                  public string lpReserved;
-                  public string lpDesktop;
-                  public string lpTitle;
-                  public uint dwX;
-                  public uint dwY;
-                  public uint dwXSize;
-                  public uint dwYSize;
-                  public uint dwXCountChars;
-                  public uint dwYCountChars;
-                  public uint dwFillAttribute;
-                  public uint dwFlags;
-                  public ushort wShowWindow;
-                  public ushort cbReserved2;
-                  public IntPtr lpReserved2;
-                  public IntPtr hStdInput;
-                  public IntPtr hStdOutput;
-                  public IntPtr hStdError;
-              }
-
-              [StructLayout(LayoutKind.Sequential)]
-              private struct PROCESS_INFORMATION
-              {
-                  public IntPtr hProcess;
-                  public IntPtr hThread;
-                  public uint dwProcessId;
-                  public uint dwThreadId;
-              }
-
-              [DllImport(
-                  "kernel32.dll",
-                  CharSet = CharSet.Unicode,
-                  ExactSpelling = true,
-                  SetLastError = true)]
-              [return: MarshalAs(UnmanagedType.Bool)]
-              private static extern bool CreateProcessW(
-                  string applicationName,
-                  StringBuilder commandLine,
-                  IntPtr processAttributes,
-                  IntPtr threadAttributes,
-                  [MarshalAs(UnmanagedType.Bool)] bool inheritHandles,
-                  uint creationFlags,
-                  IntPtr environment,
-                  string currentDirectory,
-                  ref STARTUPINFO startupInfo,
-                  out PROCESS_INFORMATION processInformation);
-
-              [DllImport("kernel32.dll", SetLastError = true)]
-              [return: MarshalAs(UnmanagedType.Bool)]
-              private static extern bool GenerateConsoleCtrlEvent(
-                  uint ctrlEvent,
-                  uint processGroupId);
-
-              [DllImport("kernel32.dll", SetLastError = true)]
-              private static extern uint GetConsoleCP();
-
-              [DllImport("kernel32.dll", SetLastError = true)]
-              [return: MarshalAs(UnmanagedType.Bool)]
-              private static extern bool AllocConsole();
-
-              [DllImport("kernel32.dll")]
-              [return: MarshalAs(UnmanagedType.Bool)]
-              private static extern bool CloseHandle(IntPtr handle);
-
-              private static void EnsureConsole()
-              {
-                  if (GetConsoleCP() != 0 || AllocConsole())
-                  {
-                      return;
-                  }
-                  var error = Marshal.GetLastWin32Error();
-                  if (error != ERROR_ACCESS_DENIED || GetConsoleCP() == 0)
-                  {
-                      throw new Win32Exception(error);
-                  }
-              }
-
-              public static Process Start(string path)
-              {
-                  EnsureConsole();
-                  var startupInfo = new STARTUPINFO {
-                      cb = (uint)Marshal.SizeOf<STARTUPINFO>()
-                  };
-                  var commandLine = new StringBuilder("\"" + path + "\"");
-                  PROCESS_INFORMATION processInformation;
-                  if (!CreateProcessW(
-                      path,
-                      commandLine,
-                      IntPtr.Zero,
-                      IntPtr.Zero,
-                      false,
-                      CREATE_NEW_PROCESS_GROUP,
-                      IntPtr.Zero,
-                      null,
-                      ref startupInfo,
-                      out processInformation))
-                  {
-                      throw new Win32Exception(Marshal.GetLastWin32Error());
-                  }
-                  try
-                  {
-                      return Process.GetProcessById((int)processInformation.dwProcessId);
-                  }
-                  finally
-                  {
-                      CloseHandle(processInformation.hThread);
-                      CloseHandle(processInformation.hProcess);
-                  }
-              }
-
-              public static void SendCtrlBreak(int processGroupId)
-              {
-                  if (!GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, (uint)processGroupId))
-                  {
-                      throw new Win32Exception(Marshal.GetLastWin32Error());
-                  }
-              }
-          }
-          '@
-
-          $binary = Join-Path $env:GITHUB_WORKSPACE "native-smoke/${{ matrix.filename }}"
-          $checksumFile = Join-Path $env:GITHUB_WORKSPACE "native-smoke/SHA256SUMS"
-          $checksumLine = Get-Content $checksumFile |
-            Where-Object { $_ -match "\s${{ matrix.filename }}$" }
-          if (-not $checksumLine) { throw "missing checksum" }
-          $expectedHash = ($checksumLine -split "\s+")[0].ToLowerInvariant()
-          $beforeHash = (Get-FileHash -Algorithm SHA256 $binary).Hash.ToLowerInvariant()
-          if ($beforeHash -ne $expectedHash) { throw "checksum mismatch before execution" }
-          & $binary help | Out-Null
-          if ($LASTEXITCODE -ne 0) { throw "help failed" }
-
-          $dataDir = Join-Path $env:RUNNER_TEMP "gpt-load-native-smoke"
-          New-Item -ItemType Directory -Force -Path $dataDir | Out-Null
-          $env:DATA_DIR = $dataDir
-          $env:PORT = "39113"
-          $process = [ReleaseNativeProcess]::Start($binary)
-          try {
-            for ($attempt = 0; $attempt -lt 80; $attempt++) {
-              try {
-                $health = Invoke-RestMethod "http://127.0.0.1:39113/health"
-                break
-              } catch {
-                Start-Sleep -Milliseconds 250
-              }
-            }
-            if ($health.version -ne $env:GITHUB_REF_NAME) { throw "version mismatch" }
-            $authFile = Join-Path $dataDir "auth.key"
-            $encryptionFile = Join-Path $dataDir "encryption.key"
-            $databaseFile = Join-Path $dataDir "gpt-load.db"
-            foreach ($file in @($authFile, $encryptionFile, $databaseFile)) {
-              if (-not (Test-Path $file)) { throw "missing generated asset: $file" }
-            }
-            $currentSid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
-            foreach ($file in @($authFile, $encryptionFile)) {
-              $acl = Get-Acl $file
-              if (-not $acl.AreAccessRulesProtected) { throw "credential DACL inherits rules" }
-              $allowRules = @($acl.Access | Where-Object {
-                $_.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow
-              })
-              if ($allowRules.Count -eq 0) { throw "credential DACL has no allow rule" }
-              foreach ($rule in $allowRules) {
-                $sid = $rule.IdentityReference.Translate(
-                  [System.Security.Principal.SecurityIdentifier]
-                )
-                if ($sid.Value -ne $currentSid.Value) {
-                  throw "credential DACL allows another principal"
-                }
-              }
-            }
-            $authKey = (Get-Content $authFile -Raw).Trim()
-            Invoke-WebRequest "http://127.0.0.1:39113/" -UseBasicParsing | Out-Null
-            $headers = @{ Authorization = "Bearer $authKey" }
-            Invoke-RestMethod "http://127.0.0.1:39113/api/usage?range=24h" -Headers $headers | Out-Null
-            Invoke-RestMethod "http://127.0.0.1:39113/api/model-prices" -Headers $headers | Out-Null
-            [ReleaseNativeProcess]::SendCtrlBreak($process.Id)
-            if (-not $process.WaitForExit(15000)) {
-              throw "graceful shutdown timed out"
-            }
-            if ($process.ExitCode -ne 0) {
-              throw "graceful shutdown exited with code $($process.ExitCode)"
-            }
-            $afterHash = (Get-FileHash -Algorithm SHA256 $binary).Hash.ToLowerInvariant()
-            if ($afterHash -ne $expectedHash) { throw "checksum mismatch after execution" }
-          } finally {
-            # Stop-Process is failure cleanup only; success is proven by CTRL_BREAK and exit code 0.
-            if (-not $process.HasExited) {
-              Stop-Process -Id $process.Id -ErrorAction SilentlyContinue
-              $process.WaitForExit(5000) | Out-Null
-            }
-            Remove-Item -Recurse -Force $dataDir -ErrorAction SilentlyContinue
-          }
+          & .github/scripts/release-native-smoke.ps1
+          exit $LASTEXITCODE
 
   docker-smoke:
     needs:
@@ -531,6 +277,53 @@ jobs:
           RELEASE_SMOKE_SUFFIX: ${{ github.run_id }}
         run: .github/scripts/release-docker-smoke.sh
 
+  capture-channel-baseline:
+    needs:
+      - validate-tag
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      packages: read
+    outputs:
+      ghcr_latest_digest: ${{ steps.snapshot.outputs.ghcr_latest_digest }}
+      dockerhub_latest_digest: ${{ steps.snapshot.outputs.dockerhub_latest_digest }}
+    steps:
+      - name: Checkout tag commit
+        uses: actions/checkout@v7
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Log in to GHCR for baseline inspection
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Log in to Docker Hub for baseline inspection
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Capture latest digests before publication
+        id: snapshot
+        shell: bash
+        run: |
+          set -euo pipefail
+          ghcr_latest_digest="$(
+            .github/scripts/release-image-digest.sh ghcr.io/tbphp/gpt-load:latest
+          )"
+          dockerhub_latest_digest="$(
+            .github/scripts/release-image-digest.sh tbphp/gpt-load:latest
+          )"
+          printf 'ghcr_latest_digest=%s\n' \
+            "${ghcr_latest_digest}" >>"${GITHUB_OUTPUT}"
+          printf 'dockerhub_latest_digest=%s\n' \
+            "${dockerhub_latest_digest}" >>"${GITHUB_OUTPUT}"
+
   publish-github:
     needs:
       - validate-tag
@@ -600,6 +393,7 @@ jobs:
   publish-images:
     needs:
       - validate-tag
+      - capture-channel-baseline
       - verify-and-build-web
       - build-binaries
       - package-checksums
@@ -662,13 +456,70 @@ jobs:
           build-args: |
             VERSION=${{ github.ref_name }}
 
+  post-publish-native-smoke:
+    needs:
+      - publish-github
+      - publish-images
+    timeout-minutes: 15
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            filename: gpt-load-linux-amd64
+          - runner: ubuntu-24.04-arm
+            filename: gpt-load-linux-arm64
+          - runner: macos-15-intel
+            filename: gpt-load-macos-amd64
+          - runner: macos-15
+            filename: gpt-load-macos-arm64
+          - runner: windows-latest
+            filename: gpt-load-windows-amd64.exe
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Checkout tag commit
+        uses: actions/checkout@v7
+
+      - name: Download published GitHub Release assets
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          mkdir -p public-release
+          gh release download "${GITHUB_REF_NAME}" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --dir public-release
+
+      - name: Smoke published POSIX native artifact
+        if: runner.os != 'Windows'
+        shell: bash
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+          RELEASE_SMOKE_BINARY: ${{ github.workspace }}/public-release/${{ matrix.filename }}
+          RELEASE_SMOKE_CHECKSUM_FILE: ${{ github.workspace }}/public-release/SHA256SUMS
+        run: .github/scripts/release-native-smoke.sh
+
+      - name: Smoke published Windows native artifact
+        if: runner.os == 'Windows'
+        shell: pwsh
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+          RELEASE_SMOKE_BINARY: ${{ github.workspace }}/public-release/${{ matrix.filename }}
+          RELEASE_SMOKE_CHECKSUM_FILE: ${{ github.workspace }}/public-release/SHA256SUMS
+        run: .github/scripts/release-native-smoke.ps1
+
   post-publish-verify:
     needs:
       - validate-tag
+      - capture-channel-baseline
       - publish-github
       - publish-images
+      - post-publish-native-smoke
     runs-on: ubuntu-24.04
-    timeout-minutes: 10
+    timeout-minutes: 45
     permissions:
       contents: read
       packages: read
@@ -676,22 +527,40 @@ jobs:
       - name: Checkout tag commit
         uses: actions/checkout@v7
 
-      - name: Verify GitHub Release asset inventory
+      - name: Download and verify exact GitHub Release asset inventory
         env:
           GH_TOKEN: ${{ github.token }}
+        shell: bash
         run: |
-          gh release view "${GITHUB_REF_NAME}" \
-            --json assets \
-            --jq '.assets[].name' >/tmp/release-assets
-          for asset in \
-            gpt-load-linux-amd64 \
-            gpt-load-linux-arm64 \
-            gpt-load-macos-amd64 \
-            gpt-load-macos-arm64 \
-            gpt-load-windows-amd64.exe \
-            SHA256SUMS; do
-            grep -Fx "${asset}" /tmp/release-assets
-          done
+          set -euo pipefail
+          mkdir -p public-release
+          gh release download "${GITHUB_REF_NAME}" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --dir public-release
+
+          cat >/tmp/expected-release-assets <<'ASSETS'
+          SHA256SUMS
+          gpt-load-linux-amd64
+          gpt-load-linux-arm64
+          gpt-load-macos-amd64
+          gpt-load-macos-arm64
+          gpt-load-windows-amd64.exe
+          ASSETS
+          find public-release -mindepth 1 -maxdepth 1 -type f -exec basename {} \; |
+            sort >/tmp/actual-release-assets
+          asset_count="$(wc -l </tmp/actual-release-assets | tr -d ' ')"
+          test "${asset_count}" = "6"
+          cmp /tmp/expected-release-assets /tmp/actual-release-assets
+
+          cd public-release
+          test "$(wc -l <SHA256SUMS | tr -d ' ')" = "5"
+          awk '{print $2}' SHA256SUMS | sort >/tmp/checksummed-release-assets
+          tail -n +2 /tmp/expected-release-assets >/tmp/expected-checksummed-release-assets
+          cmp /tmp/expected-checksummed-release-assets /tmp/checksummed-release-assets
+          sha256sum --check SHA256SUMS
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
 
       - name: Log in to GHCR for manifest verification
         uses: docker/login-action@v4
@@ -700,6 +569,12 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Log in to Docker Hub for manifest verification
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
       - name: Verify published image manifests
         shell: bash
         run: |
@@ -717,9 +592,15 @@ jobs:
             test -n "${exact_digest}"
             if [[ "${repository}" == ghcr.io/* ]]; then
               ghcr_exact_digest="${exact_digest}"
+              latest_image="ghcr.io/tbphp/gpt-load:latest"
+              expected_latest_digest="${{ needs.capture-channel-baseline.outputs.ghcr_latest_digest }}"
             else
               dockerhub_exact_digest="${exact_digest}"
+              latest_image="tbphp/gpt-load:latest"
+              expected_latest_digest="${{ needs.capture-channel-baseline.outputs.dockerhub_latest_digest }}"
             fi
+            latest_digest="$(.github/scripts/release-image-digest.sh "${latest_image}")"
+            test "${latest_digest}" = "${expected_latest_digest}"
 
             if [[ "${{ needs.validate-tag.outputs.prerelease }}" == "false" ]]; then
               for alias in \
@@ -735,3 +616,19 @@ jobs:
             fi
           done
           test "${ghcr_exact_digest}" = "${dockerhub_exact_digest}"
+
+      - name: Run full runtime smoke for both published exact images
+        shell: bash
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+        run: |
+          set -euo pipefail
+          for source_and_suffix in \
+            "ghcr.io/tbphp/gpt-load:${{ needs.validate-tag.outputs.image_exact }}|ghcr" \
+            "tbphp/gpt-load:${{ needs.validate-tag.outputs.image_exact }}|dockerhub"; do
+            source_image="${source_and_suffix%%|*}"
+            smoke_suffix="${source_and_suffix##*|}"
+            RELEASE_SMOKE_SOURCE_IMAGE="${source_image}" \
+              RELEASE_SMOKE_SUFFIX="${GITHUB_RUN_ID}-${smoke_suffix}" \
+              .github/scripts/release-docker-smoke.sh
+          done
diff --git a/README.md b/README.md
index 8ada16ef..584b337c 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ cp .env.example .env
 docker compose config
 ```
 
-Continue only if the resolved configuration uses image `ghcr.io/tbphp/gpt-load:2`, sets `DATA_DIR=/app/data` and `DATABASE_DSN=/app/data/gpt-load.db`, and mounts a named volume at `/app/data`. If the checkout still resolves to `latest` or a host bind mount, the later T18 container closeout has not landed. Do not use that Compose file for a 2.0 production deployment, and do not substitute `latest`.
+Continue only if the resolved configuration uses image `ghcr.io/tbphp/gpt-load:2`, sets `DATA_DIR=/app/data` and `DATABASE_DSN=/app/data/gpt-load.db`, and mounts a named volume at `/app/data`. If it resolves to `latest` or a host bind mount, do not use that Compose file for a 2.0 production deployment, and do not substitute `latest`.
 
 After those preconditions are met:
 
diff --git a/README_CN.md b/README_CN.md
index 8f16a56a..c0e0c0b7 100644
--- a/README_CN.md
+++ b/README_CN.md
@@ -73,7 +73,7 @@ cp .env.example .env
 docker compose config
 ```
 
-只有当解析结果满足以下条件时，才继续：image 为 `ghcr.io/tbphp/gpt-load:2`，`DATA_DIR=/app/data`，`DATABASE_DSN=/app/data/gpt-load.db`，且 `/app/data` 使用 named volume。若当前 checkout 仍解析为 `latest` 或 host bind mount，表示后续 T18 容器收口尚未落地；不要把该 Compose 文件用于 2.0 生产部署，也不要自行改用 `latest`。
+只有当解析结果满足以下条件时，才继续：image 为 `ghcr.io/tbphp/gpt-load:2`，`DATA_DIR=/app/data`，`DATABASE_DSN=/app/data/gpt-load.db`，且 `/app/data` 使用 named volume。若解析结果仍是 `latest` 或 host bind mount，不要把该 Compose 文件用于 2.0 生产部署，也不要自行改用 `latest`。
 
 满足前置条件后：
 
diff --git a/README_JP.md b/README_JP.md
index aa74d307..e7724f54 100644
--- a/README_JP.md
+++ b/README_JP.md
@@ -73,7 +73,7 @@ cp .env.example .env
 docker compose config
 ```
 
-解決後の設定でimageが`ghcr.io/tbphp/gpt-load:2`、`DATA_DIR=/app/data`、`DATABASE_DSN=/app/data/gpt-load.db`となり、`/app/data`にnamed volumeがマウントされる場合だけ続行してください。現在のcheckoutがまだ`latest`またはhost bind mountに解決される場合、後続のT18コンテナ作業は未反映です。そのComposeファイルを2.0の本番デプロイに使用せず、`latest`で代用しないでください。
+解決後の設定でimageが`ghcr.io/tbphp/gpt-load:2`、`DATA_DIR=/app/data`、`DATABASE_DSN=/app/data/gpt-load.db`となり、`/app/data`にnamed volumeがマウントされる場合だけ続行してください。`latest`またはhost bind mountに解決される場合、そのComposeファイルを2.0の本番デプロイに使用せず、`latest`で代用しないでください。
 
 前提条件を満たした後：
 
diff --git a/docker-compose.yml b/docker-compose.yml
index b1d8e9ab..6f7ccfa5 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -10,6 +10,7 @@ services:
     env_file:
       - .env
     environment:
+      PORT: ${PORT:-3001}
       DATA_DIR: /app/data
       DATABASE_DSN: /app/data/gpt-load.db
     restart: always
diff --git a/internal/control/model_price.go b/internal/control/model_price.go
index 6bc17654..a0698124 100644
--- a/internal/control/model_price.go
+++ b/internal/control/model_price.go
@@ -69,32 +69,32 @@ func (s *Service) ResetModelPrice(ctx context.Context, pattern string) error {
 	})
 }
 
-func (s *Service) ListModelPrices(ctx context.Context) ([]modelPriceRuleResponse, error) {
+func (s *Service) ListModelPrices(ctx context.Context) (modelPriceListResponse, error) {
 	s.writeMu.RLock()
 	defer s.writeMu.RUnlock()
 
 	var rows []models.ModelPrice
 	if err := s.db.WithContext(ctx).Order("pattern ASC").Find(&rows).Error; err != nil {
-		return nil, app_errors.ParseDBError(err)
+		return modelPriceListResponse{}, app_errors.ParseDBError(err)
 	}
 
-	rules := pricing.BuiltinRules()
+	builtinRules := pricing.BuiltinRules()
+	sort.Slice(builtinRules, func(left, right int) bool {
+		return builtinRules[left].Pattern < builtinRules[right].Pattern
+	})
+	result := modelPriceListResponse{
+		PriceUnit: "usd_per_million_tokens",
+		Builtin:   make([]modelPriceRuleResponse, 0, len(builtinRules)),
+		Overrides: make([]modelPriceRuleResponse, 0, len(rows)),
+	}
+	for _, rule := range builtinRules {
+		result.Builtin = append(result.Builtin, newModelPriceRuleResponse(rule))
+	}
 	for _, row := range rows {
 		if row.Source != string(pricing.SourceUser) {
-			return nil, app_errors.ErrInternalServer
+			return modelPriceListResponse{}, app_errors.ErrInternalServer
 		}
-		rules = append(rules, modelPriceRule(row))
-	}
-	sort.Slice(rules, func(left, right int) bool {
-		if rules[left].Source != rules[right].Source {
-			return rules[left].Source < rules[right].Source
-		}
-		return rules[left].Pattern < rules[right].Pattern
-	})
-
-	result := make([]modelPriceRuleResponse, 0, len(rules))
-	for _, rule := range rules {
-		result = append(result, newModelPriceRuleResponse(rule))
+		result.Overrides = append(result.Overrides, newModelPriceRuleResponse(modelPriceRule(row)))
 	}
 	return result, nil
 }
diff --git a/internal/control/model_prices_api.go b/internal/control/model_prices_api.go
index 0eed5145..454beff7 100644
--- a/internal/control/model_prices_api.go
+++ b/internal/control/model_prices_api.go
@@ -30,6 +30,12 @@ type modelPriceRuleResponse struct {
 	UpdatedAt time.Time                `json:"updated_at"`
 }
 
+type modelPriceListResponse struct {
+	PriceUnit string                   `json:"price_unit"`
+	Builtin   []modelPriceRuleResponse `json:"builtin"`
+	Overrides []modelPriceRuleResponse `json:"overrides"`
+}
+
 type modelPriceUpsertRequest struct {
 	input ModelPriceInput
 }
diff --git a/internal/control/model_prices_api_test.go b/internal/control/model_prices_api_test.go
index 14edae00..ab14ad70 100644
--- a/internal/control/model_prices_api_test.go
+++ b/internal/control/model_prices_api_test.go
@@ -41,39 +41,45 @@ func TestModelPriceAPIListsStableBuiltinAndUserRules(t *testing.T) {
 	}
 	var envelope struct {
 		Code int `json:"code"`
-		Data []struct {
-			Pattern   string              `json:"pattern"`
-			Source    string              `json:"source"`
-			Prices    map[string]*float64 `json:"prices"`
-			SourceURL *string             `json:"source_url"`
-			UpdatedAt time.Time           `json:"updated_at"`
+		Data struct {
+			PriceUnit string                       `json:"price_unit"`
+			Builtin   []modelPriceListTestResponse `json:"builtin"`
+			Overrides []modelPriceListTestResponse `json:"overrides"`
 		} `json:"data"`
 	}
 	if err := json.Unmarshal(recorder.Body.Bytes(), &envelope); err != nil {
 		t.Fatalf("decode GET response: %v", err)
 	}
-	if envelope.Code != 0 || len(envelope.Data) < 3 {
+	if envelope.Code != 0 || envelope.Data.PriceUnit != "usd_per_million_tokens" ||
+		len(envelope.Data.Builtin) < 1 || len(envelope.Data.Overrides) != 2 {
 		t.Fatalf("GET envelope = %#v", envelope)
 	}
-	assertModelPriceResponseSorted(t, envelope.Data)
+	assertModelPriceResponseSorted(t, envelope.Data.Builtin)
+	assertModelPriceResponseSorted(t, envelope.Data.Overrides)
 
-	var builtin, userA, userZ *struct {
-		Pattern   string              `json:"pattern"`
-		Source    string              `json:"source"`
-		Prices    map[string]*float64 `json:"prices"`
-		SourceURL *string             `json:"source_url"`
-		UpdatedAt time.Time           `json:"updated_at"`
-	}
-	for index := range envelope.Data {
-		item := &envelope.Data[index]
+	var builtin, userA, userZ *modelPriceListTestResponse
+	for index := range envelope.Data.Builtin {
+		item := &envelope.Data.Builtin[index]
 		switch item.Pattern {
 		case "gpt-5.6":
 			builtin = item
+		default:
+			if item.Source != string(pricing.SourceBuiltin) {
+				t.Fatalf("builtin partition contains source %q", item.Source)
+			}
+		}
+	}
+	for index := range envelope.Data.Overrides {
+		item := &envelope.Data.Overrides[index]
+		switch item.Pattern {
 		case "a-user":
 			userA = item
 		case "z-user":
 			userZ = item
 		}
+		if item.Source != string(pricing.SourceUser) {
+			t.Fatalf("override partition contains source %q", item.Source)
+		}
 	}
 	if builtin == nil || builtin.Source != string(pricing.SourceBuiltin) || builtin.SourceURL == nil ||
 		*builtin.SourceURL != "https://developers.openai.com/api/docs/pricing" ||
@@ -254,26 +260,21 @@ func assertModelPriceAPIError(t *testing.T, recorder *httptest.ResponseRecorder,
 	}
 }
 
-func assertModelPriceResponseSorted(t *testing.T, rules []struct {
+type modelPriceListTestResponse struct {
 	Pattern   string              `json:"pattern"`
 	Source    string              `json:"source"`
 	Prices    map[string]*float64 `json:"prices"`
 	SourceURL *string             `json:"source_url"`
 	UpdatedAt time.Time           `json:"updated_at"`
-}) {
+}
+
+func assertModelPriceResponseSorted(t *testing.T, rules []modelPriceListTestResponse) {
 	t.Helper()
-	patterns := make(map[string][]string)
+	patterns := make([]string, 0, len(rules))
 	for _, rule := range rules {
-		patterns[rule.Source] = append(patterns[rule.Source], rule.Pattern)
+		patterns = append(patterns, rule.Pattern)
 	}
-	for source, values := range patterns {
-		if !sort.StringsAreSorted(values) {
-			t.Fatalf("%s patterns are not sorted: %#v", source, values)
-		}
-	}
-	for index := 1; index < len(rules); index++ {
-		if rules[index-1].Source > rules[index].Source {
-			t.Fatalf("sources are not stable: %#v then %#v", rules[index-1], rules[index])
-		}
+	if !sort.StringsAreSorted(patterns) {
+		t.Fatalf("patterns are not sorted: %#v", patterns)
 	}
 }
diff --git a/internal/control/request_logs.go b/internal/control/request_logs.go
index 0e6e920f..c0d844fc 100644
--- a/internal/control/request_logs.go
+++ b/internal/control/request_logs.go
@@ -416,15 +416,12 @@ type requestLogUsageCostResponse struct {
 }
 
 func mapRequestLogUsageCost(record requestlog.Record) (requestLogUsageCostResponse, error) {
-	switch record.UsageState {
-	case usage.StateComplete, usage.StatePartial, usage.StateMissing, usage.StateNotApplicable:
-	default:
-		return requestLogUsageCostResponse{}, fmt.Errorf("map request log usage state: invalid value")
-	}
-	switch record.CostState {
-	case pricing.CostStatePriced, pricing.CostStateUnpriced, pricing.CostStateNotApplicable:
-	default:
-		return requestLogUsageCostResponse{}, fmt.Errorf("map request log cost state: invalid value")
+	if err := requestlog.ValidateUsageCostState(
+		record.UsageState,
+		record.CostState,
+		record.EstimatedCostUSD,
+	); err != nil {
+		return requestLogUsageCostResponse{}, fmt.Errorf("map request log usage/cost: %w", err)
 	}
 	for _, value := range []int64{
 		record.UncachedInputTokens,
@@ -437,6 +434,9 @@ func mapRequestLogUsageCost(record requestlog.Record) (requestLogUsageCostRespon
 			return requestLogUsageCostResponse{}, fmt.Errorf("map request log usage tokens: unsafe value")
 		}
 	}
+	if uint64(record.GroupID) > uint64(maxSafeInteger) {
+		return requestLogUsageCostResponse{}, fmt.Errorf("map request log final Group ID: unsafe value")
+	}
 	cost, err := mapEstimatedCostUSD(record.EstimatedCostUSD)
 	if err != nil {
 		return requestLogUsageCostResponse{}, err
diff --git a/internal/control/request_logs_test.go b/internal/control/request_logs_test.go
index 7ac5262b..a67b4893 100644
--- a/internal/control/request_logs_test.go
+++ b/internal/control/request_logs_test.go
@@ -9,6 +9,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -293,6 +294,38 @@ func TestRequestLogUsageCostProjectionRejectsUnsafeValues(t *testing.T) {
 		{name: "unsafe token", mutate: func(record *requestlog.Record) { record.OutputTokens = maxSafeInteger + 1 }},
 		{name: "negative cost", mutate: func(record *requestlog.Record) { record.EstimatedCostUSD = -0.1 }},
 		{name: "infinite cost", mutate: func(record *requestlog.Record) { record.EstimatedCostUSD = math.Inf(1) }},
+		{
+			name: "missing usage cannot be priced",
+			mutate: func(record *requestlog.Record) {
+				record.UsageState = usage.StateMissing
+			},
+		},
+		{
+			name: "not applicable usage cannot be unpriced",
+			mutate: func(record *requestlog.Record) {
+				record.UsageState = usage.StateNotApplicable
+				record.CostState = pricing.CostStateUnpriced
+			},
+		},
+		{
+			name: "unpriced cost must be zero",
+			mutate: func(record *requestlog.Record) {
+				record.CostState = pricing.CostStateUnpriced
+				record.EstimatedCostUSD = 0.1
+			},
+		},
+	}
+	if strconv.IntSize == 64 {
+		tests = append(tests, struct {
+			name   string
+			mutate func(*requestlog.Record)
+		}{
+			name: "unsafe final Group ID",
+			mutate: func(record *requestlog.Record) {
+				unsafeGroupID := uint64(maxSafeInteger) + 1
+				record.GroupID = uint(unsafeGroupID)
+			},
+		})
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -305,6 +338,84 @@ func TestRequestLogUsageCostProjectionRejectsUnsafeValues(t *testing.T) {
 	}
 }
 
+func TestRequestLogUsageCostProjectionAcceptsMaximumSafeFinalGroupID(t *testing.T) {
+	if strconv.IntSize != 64 {
+		t.Skip("maximum JavaScript safe integer does not fit uint on this architecture")
+	}
+	safeGroupID := uint64(maxSafeInteger)
+	record := requestlog.Record{
+		GroupID: uint(safeGroupID), UsageState: usage.StateComplete,
+		CostState: pricing.CostStatePriced,
+	}
+	result, err := mapRequestLogListResponse(requestlog.Page{Items: []requestlog.Record{record}})
+	if err != nil {
+		t.Fatalf("mapRequestLogListResponse() error = %v", err)
+	}
+	if len(result.Items) != 1 || result.Items[0].GroupID == nil ||
+		uint64(*result.Items[0].GroupID) != safeGroupID {
+		t.Fatalf("projected final Group ID = %#v", result.Items)
+	}
+}
+
+func TestRequestLogEndpointFailsClosedOnCorruptReaderUsageCost(t *testing.T) {
+	tests := []struct {
+		name   string
+		mutate func(*requestlog.Record)
+	}{
+		{
+			name: "invalid state matrix",
+			mutate: func(record *requestlog.Record) {
+				record.UsageState = usage.StateMissing
+				record.CostState = pricing.CostStatePriced
+			},
+		},
+		{
+			name: "unpriced nonzero cost",
+			mutate: func(record *requestlog.Record) {
+				record.CostState = pricing.CostStateUnpriced
+				record.EstimatedCostUSD = 0.01
+			},
+		},
+	}
+	if strconv.IntSize == 64 {
+		tests = append(tests, struct {
+			name   string
+			mutate func(*requestlog.Record)
+		}{
+			name: "unsafe final Group ID",
+			mutate: func(record *requestlog.Record) {
+				unsafeGroupID := uint64(maxSafeInteger) + 1
+				record.GroupID = uint(unsafeGroupID)
+			},
+		})
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			record := requestlog.Record{
+				RequestID:   "00000000-0000-4000-8000-000000000605",
+				CompletedAt: time.Date(2026, time.July, 27, 0, 0, 0, 0, time.UTC),
+				UsageState:  usage.StateComplete,
+				CostState:   pricing.CostStatePriced,
+				Attempts:    []requestlog.Attempt{},
+			}
+			test.mutate(&record)
+			reader := &recordingRequestLogReader{
+				pages: []requestlog.Page{{Items: []requestlog.Record{record}}},
+			}
+			recorder := performRequestLogRequest(
+				newRequestLogTestEngine(t, reader),
+				"test-auth-key",
+				"",
+			)
+			if recorder.Code != http.StatusInternalServerError ||
+				!strings.Contains(recorder.Body.String(), "INTERNAL_SERVER_ERROR") ||
+				strings.Contains(strings.ToLower(recorder.Body.String()), "unsafe") {
+				t.Fatalf("corrupt response = %d %s", recorder.Code, recorder.Body.String())
+			}
+		})
+	}
+}
+
 func TestRequestLogEndpointRequiresManagementAuthentication(t *testing.T) {
 	reader := &recordingRequestLogReader{}
 	engine := newRequestLogTestEngine(t, reader)
diff --git a/internal/control/usage.go b/internal/control/usage.go
index 849101b4..0f5678c3 100644
--- a/internal/control/usage.go
+++ b/internal/control/usage.go
@@ -7,7 +7,10 @@ import (
 	"math"
 	"net/url"
 	"strconv"
+	"strings"
 	"time"
+	"unicode"
+	"unicode/utf8"
 
 	"github.com/gin-gonic/gin"
 
@@ -27,17 +30,6 @@ type UsageStatReader interface {
 	QueryUsage(context.Context, requestlog.UsageQuery) (requestlog.UsageReport, error)
 }
 
-type usageRangeResponse struct {
-	From        string                      `json:"from"`
-	To          string                      `json:"to"`
-	Granularity requestlog.UsageGranularity `json:"granularity"`
-}
-
-type usageFiltersResponse struct {
-	GroupID *uint  `json:"group_id"`
-	Model   string `json:"model"`
-}
-
 type usageAggregateResponse struct {
 	RequestCount         int64       `json:"request_count"`
 	SuccessCount         int64       `json:"success_count"`
@@ -66,15 +58,25 @@ type usageBreakdownResponse struct {
 	usageAggregateResponse
 }
 
+type usageCollectionHealthResponse struct {
+	Scope              string     `json:"scope"`
+	DroppedTotal       uint64     `json:"dropped_total"`
+	WriteFailureTotal  uint64     `json:"write_failure_total"`
+	LastWriteFailureAt *time.Time `json:"last_write_failure_at"`
+}
+
 type usageResponse struct {
-	ObservedAt         string                   `json:"observed_at"`
-	Range              usageRangeResponse       `json:"range"`
-	Filters            usageFiltersResponse     `json:"filters"`
-	Summary            usageAggregateResponse   `json:"summary"`
-	Series             []usageSeriesResponse    `json:"series"`
-	Breakdown          []usageBreakdownResponse `json:"breakdown"`
-	BreakdownTruncated bool                     `json:"breakdown_truncated"`
-	RequestLog         requestLogHealthResponse `json:"request_log"`
+	Range              string                        `json:"range"`
+	Granularity        requestlog.UsageGranularity   `json:"granularity"`
+	Timezone           string                        `json:"timezone"`
+	From               string                        `json:"from"`
+	To                 string                        `json:"to"`
+	ObservedAt         string                        `json:"observed_at"`
+	Summary            usageAggregateResponse        `json:"summary"`
+	Series             []usageSeriesResponse         `json:"series"`
+	Breakdown          []usageBreakdownResponse      `json:"breakdown"`
+	BreakdownTruncated bool                          `json:"breakdown_truncated"`
+	CollectionHealth   usageCollectionHealthResponse `json:"collection_health"`
 }
 
 func (service *Service) QueryUsage(
@@ -151,7 +153,7 @@ func parseUsageQuery(rawQuery string, observedAt time.Time) (requestlog.UsageQue
 		query.GroupID = &groupID
 	}
 	if value, ok := singleQueryValue(values, "model"); ok {
-		if value == "" {
+		if !validUsageModel(value) {
 			return requestlog.UsageQuery{}, app_errors.ErrValidation
 		}
 		query.Model = value
@@ -159,6 +161,19 @@ func parseUsageQuery(rawQuery string, observedAt time.Time) (requestlog.UsageQue
 	return query, nil
 }
 
+func validUsageModel(value string) bool {
+	if !utf8.ValidString(value) || len(value) < 1 || len(value) > 255 ||
+		strings.TrimSpace(value) != value {
+		return false
+	}
+	for _, character := range value {
+		if unicode.IsControl(character) {
+			return false
+		}
+	}
+	return true
+}
+
 func parseUsageGroupID(value string) (uint, *app_errors.APIError) {
 	parsed, err := strconv.ParseUint(value, 10, 64)
 	if err != nil {
@@ -182,22 +197,36 @@ func (service *Service) mapUsageResponse(
 	if err != nil {
 		return usageResponse{}, err
 	}
-	requestLog, err := mapRequestLogHealth(service.requestLogStats.Stats())
-	if err != nil {
-		return usageResponse{}, err
+	stats := service.requestLogStats.Stats()
+	if stats.DroppedTotal > uint64(maxSafeInteger) ||
+		stats.WriteFailureTotal > uint64(maxSafeInteger) {
+		return usageResponse{}, fmt.Errorf("map usage collection health: unsafe counter")
+	}
+	rangeValue := usageRange24Hours
+	switch query.Granularity {
+	case requestlog.UsageGranularityHour:
+	case requestlog.UsageGranularityDay:
+		rangeValue = usageRange30Days
+	default:
+		return usageResponse{}, fmt.Errorf("map usage response: invalid granularity")
 	}
 	result := usageResponse{
-		ObservedAt: observedAt.UTC().Format(time.RFC3339Nano),
-		Range: usageRangeResponse{
-			From: query.From.UTC().Format(time.RFC3339Nano), To: query.To.UTC().Format(time.RFC3339Nano),
-			Granularity: query.Granularity,
+		Range:       rangeValue,
+		Granularity: query.Granularity,
+		Timezone:    "UTC",
+		From:        query.From.UTC().Format(time.RFC3339Nano),
+		To:          query.To.UTC().Format(time.RFC3339Nano),
+		ObservedAt:  observedAt.UTC().Format(time.RFC3339Nano),
+		CollectionHealth: usageCollectionHealthResponse{
+			Scope:              "current_process",
+			DroppedTotal:       stats.DroppedTotal,
+			WriteFailureTotal:  stats.WriteFailureTotal,
+			LastWriteFailureAt: optionalUTC(stats.LastWriteFailureAt),
 		},
-		Filters:            usageFiltersResponse{GroupID: query.GroupID, Model: query.Model},
 		Summary:            summary,
 		Series:             make([]usageSeriesResponse, 0, len(report.Series)),
 		Breakdown:          make([]usageBreakdownResponse, 0, len(report.Breakdown)),
 		BreakdownTruncated: report.BreakdownTruncated,
-		RequestLog:         requestLog,
 	}
 	for _, point := range report.Series {
 		aggregate, err := mapUsageAggregate(point.UsageAggregate)
diff --git a/internal/control/usage_test.go b/internal/control/usage_test.go
index c4f4e355..9341138c 100644
--- a/internal/control/usage_test.go
+++ b/internal/control/usage_test.go
@@ -7,7 +7,7 @@ import (
 	"math"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
+	"net/url"
 	"strings"
 	"testing"
 	"time"
@@ -90,7 +90,11 @@ func TestUsageAPIDefaultsToFixedUTCAligned24HoursAndReturnsZeroArrays(t *testing
 	now := time.Date(2026, time.July, 27, 12, 34, 56, 789, time.FixedZone("UTC+8", 8*60*60))
 	reader := &recordingUsageStatReader{}
 	engine, fixture := newUsageTestEngine(t, now, reader)
-	fixture.requestLogStats.value.PersistedTotal = 8
+	fixture.requestLogStats.value.DroppedTotal = 2
+	fixture.requestLogStats.value.WriteFailureTotal = 1
+	fixture.requestLogStats.value.LastWriteFailureAt = time.Date(
+		2026, time.July, 27, 3, 0, 0, 0, time.UTC,
+	)
 
 	recorder := performUsageRequest(engine, "test-auth-key", "")
 	if recorder.Code != http.StatusOK {
@@ -109,23 +113,51 @@ func TestUsageAPIDefaultsToFixedUTCAligned24HoursAndReturnsZeroArrays(t *testing
 	var envelope struct {
 		Code int `json:"code"`
 		Data struct {
-			ObservedAt string            `json:"observed_at"`
-			Series     []json.RawMessage `json:"series"`
-			Breakdown  []json.RawMessage `json:"breakdown"`
-			RequestLog struct {
-				PersistedTotal uint64 `json:"persisted_total"`
-			} `json:"request_log"`
+			Range       string                      `json:"range"`
+			Granularity requestlog.UsageGranularity `json:"granularity"`
+			Timezone    string                      `json:"timezone"`
+			From        string                      `json:"from"`
+			To          string                      `json:"to"`
+			ObservedAt  string                      `json:"observed_at"`
+			Series      []json.RawMessage           `json:"series"`
+			Breakdown   []json.RawMessage           `json:"breakdown"`
+			Health      struct {
+				Scope              string     `json:"scope"`
+				DroppedTotal       uint64     `json:"dropped_total"`
+				WriteFailureTotal  uint64     `json:"write_failure_total"`
+				LastWriteFailureAt *time.Time `json:"last_write_failure_at"`
+			} `json:"collection_health"`
 		} `json:"data"`
 	}
 	if err := json.Unmarshal(recorder.Body.Bytes(), &envelope); err != nil {
 		t.Fatalf("decode response: %v", err)
 	}
-	if envelope.Code != 0 || envelope.Data.ObservedAt != "2026-07-27T04:34:56.000000789Z" ||
+	if envelope.Code != 0 || envelope.Data.Range != "24h" ||
+		envelope.Data.Granularity != requestlog.UsageGranularityHour ||
+		envelope.Data.Timezone != "UTC" ||
+		envelope.Data.From != "2026-07-26T05:00:00Z" ||
+		envelope.Data.To != "2026-07-27T05:00:00Z" ||
+		envelope.Data.ObservedAt != "2026-07-27T04:34:56.000000789Z" ||
 		envelope.Data.Series == nil || len(envelope.Data.Series) != 0 ||
 		envelope.Data.Breakdown == nil || len(envelope.Data.Breakdown) != 0 ||
-		envelope.Data.RequestLog.PersistedTotal != 8 {
+		envelope.Data.Health.Scope != "current_process" ||
+		envelope.Data.Health.DroppedTotal != 2 ||
+		envelope.Data.Health.WriteFailureTotal != 1 ||
+		envelope.Data.Health.LastWriteFailureAt == nil ||
+		envelope.Data.Health.LastWriteFailureAt.Format(time.RFC3339Nano) != "2026-07-27T03:00:00Z" {
 		t.Fatalf("default usage envelope = %#v", envelope)
 	}
+	var rawEnvelope struct {
+		Data map[string]json.RawMessage `json:"data"`
+	}
+	if err := json.Unmarshal(recorder.Body.Bytes(), &rawEnvelope); err != nil {
+		t.Fatalf("decode raw response: %v", err)
+	}
+	for _, forbidden := range []string{"filters", "request_log"} {
+		if _, exists := rawEnvelope.Data[forbidden]; exists {
+			t.Fatalf("usage response exposes forbidden %q field: %s", forbidden, recorder.Body.String())
+		}
+	}
 }
 
 func TestUsageAPISelectsThirtyUTCDaysAndAppliesFilters(t *testing.T) {
@@ -162,7 +194,12 @@ func TestUsageAPISelectsThirtyUTCDaysAndAppliesFilters(t *testing.T) {
 	}
 	var envelope struct {
 		Data struct {
-			Summary struct {
+			Range       string                      `json:"range"`
+			Granularity requestlog.UsageGranularity `json:"granularity"`
+			Timezone    string                      `json:"timezone"`
+			From        string                      `json:"from"`
+			To          string                      `json:"to"`
+			Summary     struct {
 				TotalTokens      int64       `json:"total_tokens"`
 				EstimatedCostUSD json.Number `json:"estimated_cost_usd"`
 			} `json:"summary"`
@@ -181,7 +218,13 @@ func TestUsageAPISelectsThirtyUTCDaysAndAppliesFilters(t *testing.T) {
 	if err := json.Unmarshal(recorder.Body.Bytes(), &envelope); err != nil {
 		t.Fatalf("decode response: %v", err)
 	}
-	if envelope.Data.Summary.TotalTokens != 5 || envelope.Data.Summary.EstimatedCostUSD.String() != "0" ||
+	if envelope.Data.Range != "30d" ||
+		envelope.Data.Granularity != requestlog.UsageGranularityDay ||
+		envelope.Data.Timezone != "UTC" ||
+		envelope.Data.From != "2026-06-28T00:00:00Z" ||
+		envelope.Data.To != "2026-07-28T00:00:00Z" ||
+		envelope.Data.Summary.TotalTokens != 5 ||
+		envelope.Data.Summary.EstimatedCostUSD.String() != "0" ||
 		len(envelope.Data.Series) != 1 || envelope.Data.Series[0].BucketStart != "2026-06-28T00:00:00Z" ||
 		envelope.Data.Series[0].TotalTokens != 5 || envelope.Data.Series[0].EstimatedCostUSD.String() != "1.12345678901" ||
 		len(envelope.Data.Breakdown) != 1 || envelope.Data.Breakdown[0].GroupID != 9 ||
@@ -190,6 +233,51 @@ func TestUsageAPISelectsThirtyUTCDaysAndAppliesFilters(t *testing.T) {
 	}
 }
 
+func TestUsageAPIValidatesModelAsUTF8BytesWithoutBoundaryWhitespaceOrControls(t *testing.T) {
+	reader := &recordingUsageStatReader{}
+	engine, _ := newUsageTestEngine(
+		t,
+		time.Date(2026, time.July, 27, 0, 0, 0, 0, time.UTC),
+		reader,
+	)
+	validModels := []string{
+		"a",
+		strings.Repeat("a", 252) + "猫",
+		"model variant",
+	}
+	for _, model := range validModels {
+		recorder := performUsageRequest(engine, "test-auth-key", "model="+url.QueryEscape(model))
+		if recorder.Code != http.StatusOK {
+			t.Fatalf("valid model %q response = %d %s", model, recorder.Code, recorder.Body.String())
+		}
+		if got := reader.queries[len(reader.queries)-1].Model; got != model {
+			t.Fatalf("reader model = %q, want %q", got, model)
+		}
+	}
+	validCalls := len(reader.queries)
+
+	invalidModels := []struct {
+		name  string
+		query string
+	}{
+		{name: "invalid UTF-8", query: "model=%FF"},
+		{name: "leading whitespace", query: "model=" + url.QueryEscape(" model")},
+		{name: "trailing whitespace", query: "model=" + url.QueryEscape("model\u3000")},
+		{name: "embedded control", query: "model=" + url.QueryEscape("model\x00id")},
+		{name: "DEL control", query: "model=" + url.QueryEscape("model\x7fid")},
+		{name: "256 UTF-8 bytes", query: "model=" + url.QueryEscape(strings.Repeat("a", 253)+"猫")},
+	}
+	for _, test := range invalidModels {
+		t.Run(test.name, func(t *testing.T) {
+			recorder := performUsageRequest(engine, "test-auth-key", test.query)
+			assertUsageErrorCode(t, recorder, "VALIDATION_FAILED")
+		})
+	}
+	if len(reader.queries) != validCalls {
+		t.Fatalf("reader calls = %d, want %d after invalid models", len(reader.queries), validCalls)
+	}
+}
+
 func TestUsageAPIRejectsStrictInvalidQueriesWithoutCallingReader(t *testing.T) {
 	reader := &recordingUsageStatReader{}
 	engine, _ := newUsageTestEngine(t, time.Date(2026, time.July, 27, 0, 0, 0, 0, time.UTC), reader)
@@ -241,29 +329,8 @@ func TestUsageAPIRejectsUnsafeProcessStatsWithoutLeakingCause(t *testing.T) {
 		name   string
 		mutate func(*requestlog.Stats)
 	}{
-		{name: "enqueued", mutate: func(stats *requestlog.Stats) { stats.EnqueuedTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "persisted", mutate: func(stats *requestlog.Stats) { stats.PersistedTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "dropped not running", mutate: func(stats *requestlog.Stats) { stats.DroppedNotRunningTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "dropped queue full", mutate: func(stats *requestlog.Stats) { stats.DroppedQueueFullTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "dropped stopping", mutate: func(stats *requestlog.Stats) { stats.DroppedStoppingTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "dropped persist failed", mutate: func(stats *requestlog.Stats) { stats.DroppedPersistFailedTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "dropped shutdown", mutate: func(stats *requestlog.Stats) { stats.DroppedShutdownTotal = uint64(maxSafeInteger) + 1 }},
 		{name: "dropped total", mutate: func(stats *requestlog.Stats) { stats.DroppedTotal = uint64(maxSafeInteger) + 1 }},
 		{name: "write failure", mutate: func(stats *requestlog.Stats) { stats.WriteFailureTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "retention delete failure", mutate: func(stats *requestlog.Stats) { stats.RetentionDeleteFailureTotal = uint64(maxSafeInteger) + 1 }},
-		{name: "negative queue depth", mutate: func(stats *requestlog.Stats) { stats.QueueDepth = -1 }},
-	}
-	if strconv.IntSize == 64 {
-		unsafeQueueCapacity := maxSafeInteger + 1
-		tests = append(tests, struct {
-			name   string
-			mutate func(*requestlog.Stats)
-		}{
-			name: "unsafe queue capacity",
-			mutate: func(stats *requestlog.Stats) {
-				stats.QueueCapacity = int(unsafeQueueCapacity)
-			},
-		})
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
diff --git a/internal/requestlog/query.go b/internal/requestlog/query.go
index d4026697..cd90cd26 100644
--- a/internal/requestlog/query.go
+++ b/internal/requestlog/query.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"math"
 
 	"gpt-load/internal/pricing"
 	"gpt-load/internal/protocol"
@@ -135,15 +134,12 @@ func decodeRequestLogRows(rows []models.RequestLog) ([]Record, error) {
 }
 
 func validateRequestLogUsageCost(row models.RequestLog) error {
-	switch usage.State(row.UsageState) {
-	case usage.StateComplete, usage.StatePartial, usage.StateMissing, usage.StateNotApplicable:
-	default:
-		return fmt.Errorf("decode request log usage state: invalid value")
-	}
-	switch pricing.CostState(row.CostState) {
-	case pricing.CostStatePriced, pricing.CostStateUnpriced, pricing.CostStateNotApplicable:
-	default:
-		return fmt.Errorf("decode request log cost state: invalid value")
+	if err := ValidateUsageCostState(
+		usage.State(row.UsageState),
+		pricing.CostState(row.CostState),
+		row.Cost,
+	); err != nil {
+		return fmt.Errorf("decode request log usage/cost: %w", err)
 	}
 	for _, value := range []int64{
 		row.InputTokens,
@@ -156,9 +152,6 @@ func validateRequestLogUsageCost(row models.RequestLog) error {
 			return fmt.Errorf("decode request log usage tokens: negative value")
 		}
 	}
-	if row.Cost < 0 || math.IsNaN(row.Cost) || math.IsInf(row.Cost, 0) {
-		return fmt.Errorf("decode request log cost: invalid value")
-	}
 	return nil
 }
 
diff --git a/internal/requestlog/query_test.go b/internal/requestlog/query_test.go
index c5d6dd79..e89d421a 100644
--- a/internal/requestlog/query_test.go
+++ b/internal/requestlog/query_test.go
@@ -81,6 +81,41 @@ func TestDecodeRequestLogRowsRejectsInvalidUsageCostValues(t *testing.T) {
 		{name: "negative cost", mutate: func(row *models.RequestLog) { row.Cost = -0.01 }},
 		{name: "infinite cost", mutate: func(row *models.RequestLog) { row.Cost = math.Inf(1) }},
 		{name: "not a number cost", mutate: func(row *models.RequestLog) { row.Cost = math.NaN() }},
+		{
+			name: "missing usage cannot be priced",
+			mutate: func(row *models.RequestLog) {
+				row.UsageState = string(usage.StateMissing)
+				row.CostState = string(pricing.CostStatePriced)
+			},
+		},
+		{
+			name: "not applicable usage cannot be unpriced",
+			mutate: func(row *models.RequestLog) {
+				row.UsageState = string(usage.StateNotApplicable)
+				row.CostState = string(pricing.CostStateUnpriced)
+			},
+		},
+		{
+			name: "complete usage cannot have not applicable cost",
+			mutate: func(row *models.RequestLog) {
+				row.CostState = string(pricing.CostStateNotApplicable)
+			},
+		},
+		{
+			name: "unpriced cost must be zero",
+			mutate: func(row *models.RequestLog) {
+				row.CostState = string(pricing.CostStateUnpriced)
+				row.Cost = 0.01
+			},
+		},
+		{
+			name: "not applicable cost must be zero",
+			mutate: func(row *models.RequestLog) {
+				row.UsageState = string(usage.StateNotApplicable)
+				row.CostState = string(pricing.CostStateNotApplicable)
+				row.Cost = 0.01
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -93,6 +128,48 @@ func TestDecodeRequestLogRowsRejectsInvalidUsageCostValues(t *testing.T) {
 	}
 }
 
+func TestDecodeRequestLogRowsAcceptsApprovedUsageCostMatrix(t *testing.T) {
+	tests := []struct {
+		name       string
+		usageState usage.State
+		costState  pricing.CostState
+		cost       float64
+	}{
+		{name: "complete priced", usageState: usage.StateComplete, costState: pricing.CostStatePriced, cost: 0.01},
+		{name: "complete unpriced", usageState: usage.StateComplete, costState: pricing.CostStateUnpriced},
+		{name: "partial priced", usageState: usage.StatePartial, costState: pricing.CostStatePriced, cost: 0.01},
+		{name: "partial unpriced", usageState: usage.StatePartial, costState: pricing.CostStateUnpriced},
+		{name: "missing unpriced", usageState: usage.StateMissing, costState: pricing.CostStateUnpriced},
+		{
+			name:       "not applicable",
+			usageState: usage.StateNotApplicable,
+			costState:  pricing.CostStateNotApplicable,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			row := models.RequestLog{
+				ID:         "00000000-0000-4000-8000-000000000604",
+				CreatedAt:  time.Date(2026, time.July, 27, 0, 0, 0, 0, time.UTC),
+				Protocol:   string(protocol.OpenAI),
+				Status:     string(telemetry.RequestStatusSuccess),
+				UsageState: string(test.usageState),
+				CostState:  string(test.costState),
+				Cost:       test.cost,
+				Attempts:   models.JSON(`[]`),
+			}
+			records, err := decodeRequestLogRows([]models.RequestLog{row})
+			if err != nil {
+				t.Fatalf("decodeRequestLogRows() error = %v", err)
+			}
+			if len(records) != 1 || records[0].UsageState != test.usageState ||
+				records[0].CostState != test.costState || records[0].EstimatedCostUSD != test.cost {
+				t.Fatalf("records = %#v", records)
+			}
+		})
+	}
+}
+
 func TestServiceListUsesStableKeysetCursor(t *testing.T) {
 	db := openRequestLogQueryDB(t)
 	service := newRequestLogTestService(db)
diff --git a/internal/requestlog/usage_cost.go b/internal/requestlog/usage_cost.go
new file mode 100644
index 00000000..40542226
--- /dev/null
+++ b/internal/requestlog/usage_cost.go
@@ -0,0 +1,36 @@
+package requestlog
+
+import (
+	"fmt"
+	"math"
+
+	"gpt-load/internal/pricing"
+	"gpt-load/internal/usage"
+)
+
+func ValidateUsageCostState(
+	usageState usage.State,
+	costState pricing.CostState,
+	cost float64,
+) error {
+	if cost < 0 || math.IsNaN(cost) || math.IsInf(cost, 0) {
+		return fmt.Errorf("invalid estimated cost")
+	}
+	validCombination := false
+	switch usageState {
+	case usage.StateComplete, usage.StatePartial:
+		validCombination = costState == pricing.CostStatePriced ||
+			costState == pricing.CostStateUnpriced
+	case usage.StateMissing:
+		validCombination = costState == pricing.CostStateUnpriced
+	case usage.StateNotApplicable:
+		validCombination = costState == pricing.CostStateNotApplicable
+	}
+	if !validCombination {
+		return fmt.Errorf("invalid usage and cost state combination")
+	}
+	if costState != pricing.CostStatePriced && cost != 0 {
+		return fmt.Errorf("unpriced or not-applicable cost must be zero")
+	}
+	return nil
+}
diff --git a/internal/webui/container_contract_test.go b/internal/webui/container_contract_test.go
index 371a5bf6..248a29c6 100644
--- a/internal/webui/container_contract_test.go
+++ b/internal/webui/container_contract_test.go
@@ -2,12 +2,67 @@ package webui
 
 import (
 	"encoding/json"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
 )
 
+func TestComposeShellPortOverridesDotEnvEverywhere(t *testing.T) {
+	projectDir := t.TempDir()
+	if err := os.WriteFile(
+		filepath.Join(projectDir, "docker-compose.yml"),
+		[]byte(readRepositoryFile(t, "docker-compose.yml")),
+		0o600,
+	); err != nil {
+		t.Fatalf("write temporary Compose file: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(projectDir, ".env"), []byte("PORT=3001\n"), 0o600); err != nil {
+		t.Fatalf("write temporary .env: %v", err)
+	}
+
+	command := exec.Command(
+		"docker", "compose", "config", "--no-env-resolution", "--format", "json",
+	)
+	command.Dir = projectDir
+	command.Env = append(os.Environ(), "PORT=41234")
+	output, err := command.CombinedOutput()
+	if err != nil {
+		t.Fatalf("docker compose config: %v\n%s", err, output)
+	}
+
+	var resolved struct {
+		Services map[string]struct {
+			Environment map[string]string `json:"environment"`
+			Healthcheck struct {
+				Test []string `json:"test"`
+			} `json:"healthcheck"`
+			Ports []struct {
+				Target    int    `json:"target"`
+				Published string `json:"published"`
+			} `json:"ports"`
+		} `json:"services"`
+	}
+	if err := json.Unmarshal(output, &resolved); err != nil {
+		t.Fatalf("decode docker compose config: %v\n%s", err, output)
+	}
+
+	service := resolved.Services["gpt-load"]
+	if service.Environment["PORT"] != "41234" {
+		t.Fatalf("resolved application PORT = %q, want shell override 41234", service.Environment["PORT"])
+	}
+	if len(service.Ports) != 1 ||
+		service.Ports[0].Target != 41234 ||
+		service.Ports[0].Published != "41234" {
+		t.Fatalf("resolved ports = %#v, want target/published 41234", service.Ports)
+	}
+	if len(service.Healthcheck.Test) != 2 ||
+		!strings.Contains(service.Healthcheck.Test[1], "localhost:41234/health") {
+		t.Fatalf("resolved healthcheck = %#v, want container PORT 41234", service.Healthcheck.Test)
+	}
+}
+
 func TestDockerfileFinalStageDeclaresNonRootPersistentRuntime(t *testing.T) {
 	content := readRepositoryFile(t, "Dockerfile")
 	finalStageIndex := strings.LastIndex(content, "\nFROM ")
diff --git a/internal/webui/workflow_test.go b/internal/webui/workflow_test.go
index 9f6a6601..e4ae7fd5 100644
--- a/internal/webui/workflow_test.go
+++ b/internal/webui/workflow_test.go
@@ -128,6 +128,19 @@ func TestReleaseWorkflowUsesTagOnlyTriggerAndStrictSemverGuard(t *testing.T) {
 	}
 }
 
+func TestReleaseWorkflowDoesNotRequireUntrackedAgentInstructionFiles(t *testing.T) {
+	content := readRepositoryFile(t, ".github/workflows/release.yml")
+	verifyJob := workflowJobBlock(t, content, "verify-and-build-web")
+	if !strings.Contains(verifyJob, "git diff --check") {
+		t.Fatal("release verification does not run git diff --check")
+	}
+	for _, untracked := range []string{"AGENTS.md", "CLAUDE.md"} {
+		if strings.Contains(verifyJob, untracked) {
+			t.Fatalf("release verification requires untracked %s", untracked)
+		}
+	}
+}
+
 func TestReleaseWorkflowBuildsOneWebDistAndFiveVersionedBinaries(t *testing.T) {
 	content := readRepositoryFile(t, ".github/workflows/release.yml")
 	if count := strings.Count(content, "uses: ./.github/actions/web-ci"); count != 1 {
@@ -252,6 +265,17 @@ func TestReleaseWorkflowIncludesCompleteS5NotesAndCSPWithinE2E(t *testing.T) {
 func TestReleaseWorkflowVerifiesDownloadedNativeChecksumsAndGeneratedKeys(t *testing.T) {
 	content := readRepositoryFile(t, ".github/workflows/release.yml")
 	nativeJob := workflowJobBlock(t, content, "native-artifact-smoke")
+	for _, scriptPath := range []string{
+		".github/scripts/release-native-smoke.sh",
+		".github/scripts/release-native-smoke.ps1",
+	} {
+		if !strings.Contains(nativeJob, scriptPath) {
+			t.Fatalf("native smoke does not invoke %s:\n%s", scriptPath, nativeJob)
+		}
+	}
+	nativeImplementation := nativeJob +
+		readRepositoryFile(t, ".github/scripts/release-native-smoke.sh") +
+		readRepositoryFile(t, ".github/scripts/release-native-smoke.ps1")
 	for _, required := range []string{
 		"name: release-assets",
 		"SHA256SUMS",
@@ -273,18 +297,18 @@ func TestReleaseWorkflowVerifiesDownloadedNativeChecksumsAndGeneratedKeys(t *tes
 		"$process.ExitCode -ne 0",
 		"if (-not $process.HasExited)",
 	} {
-		if !strings.Contains(nativeJob, required) {
-			t.Fatalf("native smoke does not contain %q:\n%s", required, nativeJob)
+		if !strings.Contains(nativeImplementation, required) {
+			t.Fatalf("native smoke does not contain %q", required)
 		}
 	}
-	if strings.Contains(nativeJob, "AUTH_KEY=release-native-smoke") ||
-		strings.Contains(nativeJob, `$env:AUTH_KEY = "release-native-smoke"`) {
+	if strings.Contains(nativeImplementation, "AUTH_KEY=release-native-smoke") ||
+		strings.Contains(nativeImplementation, `$env:AUTH_KEY = "release-native-smoke"`) {
 		t.Fatal("native smoke bypasses generated auth.key with an explicit AUTH_KEY")
 	}
-	if strings.Contains(nativeJob, "$process = Start-Process") {
+	if strings.Contains(nativeImplementation, "$process = Start-Process") {
 		t.Fatal("Windows native smoke uses Start-Process without a new console process group")
 	}
-	if strings.Contains(nativeJob, "CREATE_NEW_CONSOLE") {
+	if strings.Contains(nativeImplementation, "CREATE_NEW_CONSOLE") {
 		t.Fatal("Windows native smoke gives the child a separate console that cannot receive the targeted CTRL_BREAK")
 	}
 }
@@ -381,6 +405,163 @@ func TestReleaseWorkflowPostPublishVerifiesAliasesAndExactDigests(t *testing.T)
 	}
 }
 
+func TestReleaseWorkflowPostPublishDownloadsExactAssetsAndRunsFiveNativeSmokes(t *testing.T) {
+	content := readRepositoryFile(t, ".github/workflows/release.yml")
+	inventoryJob := workflowJobBlock(t, content, "post-publish-verify")
+	for _, required := range []string{
+		"gh release download",
+		"public-release",
+		"SHA256SUMS",
+		"sha256sum --check",
+		"asset_count",
+		`test "${asset_count}" = "6"`,
+	} {
+		if !strings.Contains(inventoryJob, required) {
+			t.Fatalf("post-publish asset inventory does not contain %q:\n%s", required, inventoryJob)
+		}
+	}
+
+	nativeJob := workflowJobBlock(t, content, "post-publish-native-smoke")
+	for _, required := range []string{
+		"publish-github",
+		"publish-images",
+		"ubuntu-24.04",
+		"ubuntu-24.04-arm",
+		"macos-15-intel",
+		"macos-15",
+		"windows-latest",
+		"gpt-load-linux-amd64",
+		"gpt-load-linux-arm64",
+		"gpt-load-macos-amd64",
+		"gpt-load-macos-arm64",
+		"gpt-load-windows-amd64.exe",
+		"gh release download",
+		".github/scripts/release-native-smoke.sh",
+		".github/scripts/release-native-smoke.ps1",
+	} {
+		if !strings.Contains(nativeJob, required) {
+			t.Fatalf("post-publish native smoke does not contain %q:\n%s", required, nativeJob)
+		}
+	}
+}
+
+func TestReleaseWorkflowRunsBothPublishedImagesAndPreservesLatest(t *testing.T) {
+	content := readRepositoryFile(t, ".github/workflows/release.yml")
+	snapshotJob := workflowJobBlock(t, content, "capture-channel-baseline")
+	for _, required := range []string{
+		"ghcr_latest_digest",
+		"dockerhub_latest_digest",
+		"ghcr.io/tbphp/gpt-load:latest",
+		"tbphp/gpt-load:latest",
+		".github/scripts/release-image-digest.sh",
+	} {
+		if !strings.Contains(snapshotJob, required) {
+			t.Fatalf("latest digest snapshot does not contain %q:\n%s", required, snapshotJob)
+		}
+	}
+
+	imagePublication := workflowJobBlock(t, content, "publish-images")
+	if !strings.Contains(imagePublication, "capture-channel-baseline") {
+		t.Fatal("image publication is not ordered after the latest digest snapshot")
+	}
+
+	postPublish := workflowJobBlock(t, content, "post-publish-verify")
+	for _, required := range []string{
+		"capture-channel-baseline",
+		"RELEASE_SMOKE_SOURCE_IMAGE",
+		`ghcr.io/tbphp/gpt-load:${{ needs.validate-tag.outputs.image_exact }}`,
+		`tbphp/gpt-load:${{ needs.validate-tag.outputs.image_exact }}`,
+		".github/scripts/release-docker-smoke.sh",
+		".github/scripts/release-image-digest.sh",
+		"ghcr_latest_digest",
+		"dockerhub_latest_digest",
+	} {
+		if !strings.Contains(postPublish, required) {
+			t.Fatalf("published image runtime verification does not contain %q:\n%s", required, postPublish)
+		}
+	}
+	for name, block := range map[string]string{
+		"capture-channel-baseline": snapshotJob,
+		"post-publish-verify":      postPublish,
+	} {
+		for _, required := range []string{
+			"Log in to Docker Hub",
+			"username: ${{ secrets.DOCKERHUB_USERNAME }}",
+			"password: ${{ secrets.DOCKERHUB_TOKEN }}",
+		} {
+			if !strings.Contains(block, required) {
+				t.Fatalf("%s does not contain authenticated Docker Hub read %q", name, required)
+			}
+		}
+	}
+}
+
+func TestReleaseImageDigestFailsClosedOnOperationalInspectionErrors(t *testing.T) {
+	for _, message := range []string{"rate limit exceeded", "docker: command not found"} {
+		t.Run(message, func(t *testing.T) {
+			script := filepath.Join("..", "..", ".github", "scripts", "release-image-digest.sh")
+			fakeBin := t.TempDir()
+			fakeDocker := filepath.Join(fakeBin, "docker")
+			if err := os.WriteFile(
+				fakeDocker,
+				[]byte("#!/usr/bin/env sh\nprintf '"+message+"\\n' >&2\nexit 1\n"),
+				0o700,
+			); err != nil {
+				t.Fatalf("write fake docker: %v", err)
+			}
+			command := exec.Command("bash", script, "example.test/gpt-load:latest")
+			command.Env = append(os.Environ(), "PATH="+fakeBin+":"+os.Getenv("PATH"))
+			output, err := command.CombinedOutput()
+			if err == nil {
+				t.Fatalf("operational inspect failure returned success: %s", output)
+			}
+			if !strings.Contains(string(output), message) {
+				t.Fatalf("operational inspect failure output = %q", output)
+			}
+		})
+	}
+}
+
+func TestReleaseImageDigestReturnsAbsentOnlyForMissingManifest(t *testing.T) {
+	script := filepath.Join("..", "..", ".github", "scripts", "release-image-digest.sh")
+	fakeBin := t.TempDir()
+	fakeDocker := filepath.Join(fakeBin, "docker")
+	if err := os.WriteFile(
+		fakeDocker,
+		[]byte("#!/usr/bin/env sh\nprintf 'manifest unknown\\n' >&2\nexit 1\n"),
+		0o700,
+	); err != nil {
+		t.Fatalf("write fake docker: %v", err)
+	}
+	command := exec.Command("bash", script, "example.test/gpt-load:latest")
+	command.Env = append(os.Environ(), "PATH="+fakeBin+":"+os.Getenv("PATH"))
+	output, err := command.CombinedOutput()
+	if err != nil {
+		t.Fatalf("missing manifest returned error: %v\n%s", err, output)
+	}
+	if strings.TrimSpace(string(output)) != "absent" {
+		t.Fatalf("missing manifest output = %q, want absent", output)
+	}
+}
+
+func TestReleaseDockerSmokeCanUsePublishedSourceWithoutDeletingIt(t *testing.T) {
+	script := readRepositoryFile(t, ".github/scripts/release-docker-smoke.sh")
+	for _, required := range []string{
+		"RELEASE_SMOKE_SOURCE_IMAGE",
+		`docker pull --platform "${platform}" "${source_image}"`,
+		`docker image tag "${source_image}" "${image}"`,
+		`docker image rm "${image}"`,
+		"prices.data.overrides.some",
+	} {
+		if !strings.Contains(script, required) {
+			t.Fatalf("release Docker smoke source-image mode does not contain %q", required)
+		}
+	}
+	if strings.Contains(script, `docker image rm "${source_image}"`) {
+		t.Fatal("release Docker smoke deletes the externally owned source image")
+	}
+}
+
 func TestReleaseWorkflowRemovesObsoletePublishers(t *testing.T) {
 	for _, name := range []string{
 		".github/workflows/docker-build.yml",
@@ -394,6 +575,15 @@ func TestReleaseWorkflowRemovesObsoletePublishers(t *testing.T) {
 	}
 }
 
+func TestReadmesDoNotExposeInternalReleaseTaskNames(t *testing.T) {
+	for _, name := range []string{"README.md", "README_CN.md", "README_JP.md"} {
+		content := readRepositoryFile(t, name)
+		if strings.Contains(content, "T18") {
+			t.Fatalf("%s exposes the completed internal T18 task name", name)
+		}
+	}
+}
+
 func TestDockerfileCopiesWebInstallPolicyBeforeInstalling(t *testing.T) {
 	content := readRepositoryFile(t, "Dockerfile")
 	copyInputs := "COPY web/package.json web/pnpm-lock.yaml web/pnpm-workspace.yaml ./web/"
diff --git a/web/e2e/business-flows.spec.ts b/web/e2e/business-flows.spec.ts
index 50ddc64b..13d5625c 100644
--- a/web/e2e/business-flows.spec.ts
+++ b/web/e2e/business-flows.spec.ts
@@ -132,10 +132,23 @@ test('critical management journey works through the embedded binary', async ({ p
     const addDrawer = page.getByRole('dialog', { name: 'Add model price override' })
     await addDrawer.getByLabel('Model pattern').fill('*')
     await addDrawer.getByLabel('Uncached input').fill('1')
-    await expect(addDrawer.getByRole('button', { name: 'Save override' })).toBeDisabled()
-    await addDrawer.getByLabel('I understand that * shadows every built-in price rule.').check()
+    await expect(addDrawer).toContainText('* shadows every built-in price rule')
+    await expect(addDrawer.getByRole('button', { name: 'Save override' })).toBeEnabled()
     await addDrawer.getByRole('button', { name: 'Save override' }).click()
 
+    const globalPriceDialog = page.getByRole('dialog', {
+      name: 'Create a global user price override?',
+    })
+    await expect(globalPriceDialog).toContainText(
+      'takes precedence over every built-in exact and prefix rule',
+    )
+    await expect(globalPriceDialog).toContainText('Unset price slots do not fall back')
+    await expect(globalPriceDialog).toContainText('future completed or Emit requests')
+    await expect(globalPriceDialog).toContainText(
+      'Reset restores the remaining user and built-in rules',
+    )
+    await globalPriceDialog.getByRole('button', { name: 'Create global override' }).click()
+
     const overrideRow = page.locator('[data-test="override-price-row-0"]')
     await expect(overrideRow).toContainText('*')
     await expect(overrideRow).toContainText('$1')
@@ -145,8 +158,8 @@ test('critical management journey works through the embedded binary', async ({ p
     const editDrawer = page.getByRole('dialog', { name: 'Edit model price override' })
     await expect(editDrawer.getByLabel('Model pattern')).toHaveAttribute('readonly', '')
     await editDrawer.getByLabel('Output').fill('2')
-    await editDrawer.getByLabel('I understand that * shadows every built-in price rule.').check()
     await editDrawer.getByRole('button', { name: 'Save override' }).click()
+    await globalPriceDialog.getByRole('button', { name: 'Create global override' }).click()
     await expect(editPrice).toBeFocused()
     await expect(page.locator('[data-test="override-price-row-0"]')).toContainText('$2')
 
@@ -222,8 +235,7 @@ test('critical management journey works through the embedded binary', async ({ p
     await expect(page.locator('[data-test="usage-quality-missing"]')).toContainText('1')
     await expect(page.locator('[data-test="usage-quality-partial"]')).toContainText('1')
     await expect(page.locator('[data-test="usage-quality-unpriced"]')).toContainText('3')
-    await expect(page.locator('[data-test="usage-kpi-cost"]')).toContainText('Unknown')
-    await expect(page.locator('[data-test="usage-kpi-cost"]')).not.toContainText('$0')
+    await expect(page.locator('[data-test="usage-kpi-cost"]')).toContainText('$0.00 + unknown')
     await expect(page.locator('[data-test="usage-kpi-cost"]')).not.toContainText('Free')
     await expect(page.locator('[data-test="usage-scope"]')).toContainText('current process')
     await expect(page.locator('[data-test="usage-prices-link"]')).toHaveAttribute(
@@ -251,7 +263,7 @@ test('critical management journey works through the embedded binary', async ({ p
     await expect(page.locator('[data-test="home-usage-requests"]')).toContainText(
       String(expectedUsageRequests),
     )
-    await expect(page.locator('[data-test="home-usage-cost"]')).toContainText('Unknown')
+    await expect(page.locator('[data-test="home-usage-cost"]')).toContainText('$0.00 + unknown')
     await expect(page.locator('[data-test="home-usage-tokens"]')).toContainText('Unknown')
     await expect(page.locator('[data-test="home-usage-tokens"]')).not.toContainText('0')
     await expect(page.locator('[data-test="home-usage-quality-missing"]')).toContainText(
diff --git a/web/src/api/control/model-prices.test.ts b/web/src/api/control/model-prices.test.ts
index 13a60e9c..8fa18ac8 100644
--- a/web/src/api/control/model-prices.test.ts
+++ b/web/src/api/control/model-prices.test.ts
@@ -42,36 +42,122 @@ const userRule = {
 describe('ModelPrice control API', () => {
   it('projects valid builtin and user rules while preserving explicit null and zero prices', async () => {
     const signal = new AbortController().signal
-    const request = vi.fn().mockResolvedValue([builtinRule, userRule])
-
-    await expect(
-      getModelPrices({ request: request as ApiClient['request'] }, signal),
-    ).resolves.toEqual({
+    const response = {
       price_unit: 'usd_per_million_tokens',
       builtin: [builtinRule],
       overrides: [userRule],
-    })
+    } as const
+    const request = vi.fn().mockResolvedValue(response)
+
+    await expect(
+      getModelPrices({ request: request as ApiClient['request'] }, signal),
+    ).resolves.toEqual(response)
     expect(request).toHaveBeenCalledWith('/api/model-prices', { method: 'GET', signal })
   })
 
   it.each([
-    ['non-array response', {}],
-    ['malformed rule', [{}]],
-    ['unknown source', [{ ...builtinRule, source: 'remote' }]],
-    ['malformed timestamp', [{ ...builtinRule, updated_at: 'tomorrow' }]],
+    ['legacy flat response', [builtinRule, userRule]],
+    [
+      'wrong price unit',
+      {
+        price_unit: 'usd_per_token',
+        builtin: [builtinRule],
+        overrides: [userRule],
+      },
+    ],
+    ['missing builtin partition', { price_unit: 'usd_per_million_tokens', overrides: [userRule] }],
+    [
+      'malformed rule',
+      { price_unit: 'usd_per_million_tokens', builtin: [{}], overrides: [userRule] },
+    ],
+    [
+      'unknown source',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, source: 'remote' }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'user source in builtin partition',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [userRule],
+        overrides: [],
+      },
+    ],
+    [
+      'builtin source in override partition',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [],
+        overrides: [builtinRule],
+      },
+    ],
+    [
+      'malformed timestamp',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, updated_at: 'tomorrow' }],
+        overrides: [userRule],
+      },
+    ],
     [
       'normalized invalid calendar timestamp',
-      [{ ...builtinRule, updated_at: '2026-02-30T00:00:00Z' }],
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, updated_at: '2026-02-30T00:00:00Z' }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'invalid RFC3339 offset',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, updated_at: '2026-07-27T12:30:00+24:00' }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'missing five-price key',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, prices: { ...prices, output: undefined } }],
+        overrides: [userRule],
+      },
     ],
-    ['invalid RFC3339 offset', [{ ...builtinRule, updated_at: '2026-07-27T12:30:00+24:00' }]],
-    ['missing five-price key', [{ ...builtinRule, prices: { ...prices, output: undefined } }]],
     [
       'non-finite price',
-      [{ ...builtinRule, prices: { ...prices, output: Number.POSITIVE_INFINITY } }],
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, prices: { ...prices, output: Number.POSITIVE_INFINITY } }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'negative price',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, prices: { ...prices, output: -0.01 } }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'builtin without source URL',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [{ ...builtinRule, source_url: null }],
+        overrides: [userRule],
+      },
+    ],
+    [
+      'user with source URL',
+      {
+        price_unit: 'usd_per_million_tokens',
+        builtin: [builtinRule],
+        overrides: [{ ...userRule, source_url: 'https://example.test/pricing' }],
+      },
     ],
-    ['negative price', [{ ...builtinRule, prices: { ...prices, output: -0.01 } }]],
-    ['builtin without source URL', [{ ...builtinRule, source_url: null }]],
-    ['user with source URL', [{ ...userRule, source_url: 'https://example.test/pricing' }]],
   ])('rejects %s', (_name, value) => {
     expect(() => projectModelPrices(value)).toThrow(InvalidResponseError)
   })
diff --git a/web/src/api/control/model-prices.ts b/web/src/api/control/model-prices.ts
index ca6e7d25..b54ebede 100644
--- a/web/src/api/control/model-prices.ts
+++ b/web/src/api/control/model-prices.ts
@@ -110,16 +110,21 @@ function projectBuiltinSourceURL(value: unknown): string {
 }
 
 export function projectModelPrices(value: unknown): ModelPriceReportDto {
-  if (!Array.isArray(value)) throw new InvalidResponseError()
-  const builtin: ModelPriceRuleDto[] = []
-  const overrides: ModelPriceRuleDto[] = []
-  for (const item of value) {
-    const rule = projectRule(item)
-    if (rule.source === 'builtin') {
-      builtin.push(rule)
-    } else {
-      overrides.push(rule)
-    }
+  if (
+    !isRecord(value) ||
+    value.price_unit !== 'usd_per_million_tokens' ||
+    !Array.isArray(value.builtin) ||
+    !Array.isArray(value.overrides)
+  ) {
+    throw new InvalidResponseError()
+  }
+  const builtin = value.builtin.map(projectRule)
+  const overrides = value.overrides.map(projectRule)
+  if (
+    builtin.some((rule) => rule.source !== 'builtin') ||
+    overrides.some((rule) => rule.source !== 'user')
+  ) {
+    throw new InvalidResponseError()
   }
   return { price_unit: 'usd_per_million_tokens', builtin, overrides }
 }
diff --git a/web/src/api/control/usage.test.ts b/web/src/api/control/usage.test.ts
index 98ea9b37..7502b1aa 100644
--- a/web/src/api/control/usage.test.ts
+++ b/web/src/api/control/usage.test.ts
@@ -19,31 +19,20 @@ const aggregate = {
   unpriced_request_count: 3,
 } as const
 
-const requestLog = {
-  enqueued_total: 12,
-  persisted_total: 10,
-  dropped_not_running_total: 1,
-  dropped_queue_full_total: 0,
-  dropped_stopping_total: 0,
-  dropped_persist_failed_total: 1,
-  dropped_shutdown_total: 0,
+const collectionHealth = {
+  scope: 'current_process',
   dropped_total: 2,
   write_failure_total: 1,
-  retention_delete_failure_total: 0,
-  queue_depth: 2,
-  queue_capacity: 256,
   last_write_failure_at: null,
-  last_retention_failure_at: '2026-07-27T10:00:00Z',
 } as const
 
 const report = {
+  range: '24h',
+  granularity: 'hour',
+  timezone: 'UTC',
+  from: '2026-07-26T13:00:00Z',
+  to: '2026-07-27T13:00:00Z',
   observed_at: '2026-07-27T12:21:48Z',
-  range: {
-    from: '2026-07-26T13:00:00Z',
-    to: '2026-07-27T13:00:00Z',
-    granularity: 'hour',
-  },
-  filters: { group_id: 7, model: 'gpt-5.6' },
   summary: aggregate,
   series: [
     {
@@ -54,7 +43,7 @@ const report = {
   ],
   breakdown: [{ group_id: 7, model: 'gpt-5.6', ...aggregate }],
   breakdown_truncated: false,
-  request_log: requestLog,
+  collection_health: collectionHealth,
 } as const
 
 describe('Usage control API', () => {
@@ -104,11 +93,10 @@ describe('Usage control API', () => {
   it('accepts an exact UTC day bucket inside the aligned 30-day window', () => {
     const dailyReport = {
       ...report,
-      range: {
-        from: '2026-06-28T00:00:00Z',
-        to: '2026-07-28T00:00:00Z',
-        granularity: 'day' as const,
-      },
+      range: '30d' as const,
+      granularity: 'day' as const,
+      from: '2026-06-28T00:00:00Z',
+      to: '2026-07-28T00:00:00Z',
       series: [
         {
           ...report.series[0],
@@ -135,11 +123,11 @@ describe('Usage control API', () => {
       { ...report, summary: { ...aggregate, estimated_cost_usd: Number.POSITIVE_INFINITY } },
     ],
     ['bad observed timestamp', { ...report, observed_at: 'tomorrow' }],
-    [
-      'bad range timestamp',
-      { ...report, range: { ...report.range, from: '2026-02-30T00:00:00Z' } },
-    ],
-    ['unknown granularity', { ...report, range: { ...report.range, granularity: 'week' } }],
+    ['bad range timestamp', { ...report, from: '2026-02-30T00:00:00Z' }],
+    ['unknown range', { ...report, range: '7d' }],
+    ['unknown granularity', { ...report, granularity: 'week' }],
+    ['wrong timezone', { ...report, timezone: 'Asia/Shanghai' }],
+    ['range/granularity mismatch', { ...report, range: '30d' }],
     [
       'out-of-order buckets',
       {
@@ -158,11 +146,8 @@ describe('Usage control API', () => {
       'rolling response window without UTC-aligned boundaries',
       {
         ...report,
-        range: {
-          ...report.range,
-          from: '2026-07-26T12:21:48Z',
-          to: '2026-07-27T12:21:48Z',
-        },
+        from: '2026-07-26T12:21:48Z',
+        to: '2026-07-27T12:21:48Z',
         series: [],
       },
     ],
@@ -170,10 +155,7 @@ describe('Usage control API', () => {
       'aligned response window with the wrong bucket count',
       {
         ...report,
-        range: {
-          ...report.range,
-          from: '2026-07-26T14:00:00Z',
-        },
+        from: '2026-07-26T14:00:00Z',
         series: [],
       },
     ],
@@ -234,11 +216,10 @@ describe('Usage control API', () => {
       {
         ...report,
         observed_at: '2026-07-27T12:21:48Z',
-        range: {
-          from: '2026-06-28T00:00:00Z',
-          to: '2026-07-28T00:00:00Z',
-          granularity: 'day',
-        },
+        range: '30d',
+        granularity: 'day',
+        from: '2026-06-28T00:00:00Z',
+        to: '2026-07-28T00:00:00Z',
         series: [
           {
             ...report.series[0],
@@ -249,12 +230,39 @@ describe('Usage control API', () => {
       },
     ],
     [
-      'breakdown outside filtered source scope',
-      { ...report, breakdown: [{ ...report.breakdown[0], group_id: 8 }] },
+      'unsafe breakdown Group',
+      {
+        ...report,
+        breakdown: [{ ...report.breakdown[0], group_id: Number.MAX_SAFE_INTEGER + 1 }],
+      },
     ],
     [
-      'malformed request-log counter',
-      { ...report, request_log: { ...requestLog, queue_depth: -1 } },
+      'malformed collection-health scope',
+      { ...report, collection_health: { ...collectionHealth, scope: 'all_time' } },
+    ],
+    [
+      'malformed collection-health counter',
+      { ...report, collection_health: { ...collectionHealth, dropped_total: -1 } },
+    ],
+    [
+      'malformed collection-health timestamp',
+      {
+        ...report,
+        collection_health: { ...collectionHealth, last_write_failure_at: 'tomorrow' },
+      },
+    ],
+    [
+      'legacy private response shape',
+      {
+        observed_at: report.observed_at,
+        range: { from: report.from, to: report.to, granularity: report.granularity },
+        filters: { group_id: 7, model: 'gpt-5.6' },
+        summary: aggregate,
+        series: report.series,
+        breakdown: report.breakdown,
+        breakdown_truncated: false,
+        request_log: {},
+      },
     ],
   ])('rejects %s', (_name, value) => {
     expect(() => projectUsageReport(value)).toThrow(InvalidResponseError)
diff --git a/web/src/api/control/usage.ts b/web/src/api/control/usage.ts
index 5bd6ad85..15af78ca 100644
--- a/web/src/api/control/usage.ts
+++ b/web/src/api/control/usage.ts
@@ -1,8 +1,6 @@
 import type { ApiClient } from '@/api/client'
 import { InvalidResponseError } from '@/api/errors'
 
-import type { RequestLogHealthDto } from './types'
-
 export interface UsageFilters {
   range: '24h' | '30d'
   group_id?: number
@@ -26,14 +24,22 @@ export interface UsageAggregateDto {
 }
 
 export interface UsageReportDto {
+  range: '24h' | '30d'
+  granularity: 'hour' | 'day'
+  timezone: 'UTC'
+  from: string
+  to: string
   observed_at: string
-  range: { from: string; to: string; granularity: 'hour' | 'day' }
-  filters: { group_id: number | null; model: string }
   summary: UsageAggregateDto
   series: Array<UsageAggregateDto & { bucket_start: string; bucket_end: string }>
   breakdown: Array<UsageAggregateDto & { group_id: number; model: string }>
   breakdown_truncated: boolean
-  request_log: RequestLogHealthDto
+  collection_health: {
+    scope: 'current_process'
+    dropped_total: number
+    write_failure_total: number
+    last_write_failure_at: string | null
+  }
 }
 
 const aggregateKeys = [
@@ -51,21 +57,6 @@ const aggregateKeys = [
   'unpriced_request_count',
 ] as const
 
-const requestLogCountKeys = [
-  'enqueued_total',
-  'persisted_total',
-  'dropped_not_running_total',
-  'dropped_queue_full_total',
-  'dropped_stopping_total',
-  'dropped_persist_failed_total',
-  'dropped_shutdown_total',
-  'dropped_total',
-  'write_failure_total',
-  'retention_delete_failure_total',
-  'queue_depth',
-  'queue_capacity',
-] as const
-
 const hourMs = 60 * 60 * 1000
 const dayMs = 24 * hourMs
 
@@ -149,33 +140,45 @@ function projectAggregate(value: unknown): UsageAggregateDto {
   return value as unknown as UsageAggregateDto
 }
 
-function projectRequestLog(value: unknown): RequestLogHealthDto {
-  if (!isRecord(value)) throw new InvalidResponseError()
-  for (const key of requestLogCountKeys) {
-    if (!isSafeNonNegativeInteger(value[key])) throw new InvalidResponseError()
+function projectCollectionHealth(value: unknown): UsageReportDto['collection_health'] {
+  if (
+    !isRecord(value) ||
+    value.scope !== 'current_process' ||
+    !isSafeNonNegativeInteger(value.dropped_total) ||
+    !isSafeNonNegativeInteger(value.write_failure_total) ||
+    (value.last_write_failure_at !== null && !isRFC3339Timestamp(value.last_write_failure_at))
+  ) {
+    throw new InvalidResponseError()
   }
-  for (const key of ['last_write_failure_at', 'last_retention_failure_at'] as const) {
-    if (value[key] !== null && !isRFC3339Timestamp(value[key])) throw new InvalidResponseError()
+  return {
+    scope: 'current_process',
+    dropped_total: value.dropped_total,
+    write_failure_total: value.write_failure_total,
+    last_write_failure_at: value.last_write_failure_at,
   }
-  return value as unknown as RequestLogHealthDto
 }
 
 export function projectUsageReport(value: unknown): UsageReportDto {
-  if (!isRecord(value) || !isRecord(value.range) || !isRecord(value.filters)) {
+  if (
+    !isRecord(value) ||
+    (value.range !== '24h' && value.range !== '30d') ||
+    (value.granularity !== 'hour' && value.granularity !== 'day') ||
+    value.timezone !== 'UTC' ||
+    (value.range === '24h' && value.granularity !== 'hour') ||
+    (value.range === '30d' && value.granularity !== 'day')
+  ) {
     throw new InvalidResponseError()
   }
   const observedAt = timestamp(value.observed_at)
-  const rangeFrom = timestamp(value.range.from)
-  const rangeTo = timestamp(value.range.to)
-  const granularity = value.range.granularity
-  if (granularity !== 'hour' && granularity !== 'day') {
-    throw new InvalidResponseError()
-  }
+  const rangeFrom = timestamp(value.from)
+  const rangeTo = timestamp(value.to)
+  const range = value.range
+  const granularity = value.granularity
   const observedAtMs = timestampMs(observedAt)
   const rangeFromMs = timestampMs(rangeFrom)
   const rangeToMs = timestampMs(rangeTo)
   const bucketDurationMs = granularity === 'hour' ? hourMs : dayMs
-  const bucketCount = granularity === 'hour' ? 24 : 30
+  const bucketCount = range === '24h' ? 24 : 30
   if (
     !isUTCAligned(rangeFromMs, granularity) ||
     !isUTCAligned(rangeToMs, granularity) ||
@@ -185,11 +188,7 @@ export function projectUsageReport(value: unknown): UsageReportDto {
   ) {
     throw new InvalidResponseError()
   }
-  const filters = value.filters
   if (
-    (filters.group_id !== null && !isSafeNonNegativeInteger(filters.group_id)) ||
-    (filters.group_id !== null && filters.group_id === 0) ||
-    typeof filters.model !== 'string' ||
     !Array.isArray(value.series) ||
     !Array.isArray(value.breakdown) ||
     typeof value.breakdown_truncated !== 'boolean'
@@ -227,23 +226,20 @@ export function projectUsageReport(value: unknown): UsageReportDto {
     ) {
       throw new InvalidResponseError()
     }
-    if (
-      (filters.group_id !== null && item.group_id !== filters.group_id) ||
-      (filters.model !== '' && item.model !== filters.model)
-    ) {
-      throw new InvalidResponseError()
-    }
     return { ...projectAggregate(item), group_id: item.group_id, model: item.model }
   })
   return {
+    range,
+    granularity,
+    timezone: 'UTC',
+    from: rangeFrom,
+    to: rangeTo,
     observed_at: observedAt,
-    range: { from: rangeFrom, to: rangeTo, granularity },
-    filters: { group_id: filters.group_id, model: filters.model },
     summary: projectAggregate(value.summary),
     series,
     breakdown,
     breakdown_truncated: value.breakdown_truncated,
-    request_log: projectRequestLog(value.request_log),
+    collection_health: projectCollectionHealth(value.collection_health),
   }
 }
 
diff --git a/web/src/features/home/HomeView.test.ts b/web/src/features/home/HomeView.test.ts
index 4656d427..0da3bfbe 100644
--- a/web/src/features/home/HomeView.test.ts
+++ b/web/src/features/home/HomeView.test.ts
@@ -62,12 +62,11 @@ const healthFixture: RuntimeHealthDto = {
 
 const usageFixture: UsageReportDto = {
   observed_at: '2026-07-25T10:00:01Z',
-  range: {
-    from: '2026-07-24T11:00:00Z',
-    to: '2026-07-25T11:00:00Z',
-    granularity: 'hour',
-  },
-  filters: { group_id: null, model: '' },
+  range: '24h',
+  granularity: 'hour',
+  timezone: 'UTC',
+  from: '2026-07-24T11:00:00Z',
+  to: '2026-07-25T11:00:00Z',
   summary: {
     request_count: 4,
     success_count: 3,
@@ -86,7 +85,12 @@ const usageFixture: UsageReportDto = {
   series: [],
   breakdown: [],
   breakdown_truncated: false,
-  request_log: healthFixture.request_log,
+  collection_health: {
+    scope: 'current_process',
+    dropped_total: healthFixture.request_log.dropped_total,
+    write_failure_total: healthFixture.request_log.write_failure_total,
+    last_write_failure_at: healthFixture.request_log.last_write_failure_at,
+  },
 }
 
 async function mountHome(api: FakeApi, origin?: string, queryClient?: QueryClient) {
diff --git a/web/src/features/home/UsageSummaryCard.test.ts b/web/src/features/home/UsageSummaryCard.test.ts
index af5f8c11..3ae95ec8 100644
--- a/web/src/features/home/UsageSummaryCard.test.ts
+++ b/web/src/features/home/UsageSummaryCard.test.ts
@@ -26,32 +26,21 @@ const aggregate: UsageAggregateDto = {
 
 function usageReport(overrides: Partial<UsageReportDto> = {}): UsageReportDto {
   return {
+    range: '24h',
+    granularity: 'hour',
+    timezone: 'UTC',
+    from: '2026-07-26T05:00:00Z',
+    to: '2026-07-27T05:00:00Z',
     observed_at: '2026-07-27T04:00:01Z',
-    range: {
-      from: '2026-07-26T05:00:00Z',
-      to: '2026-07-27T05:00:00Z',
-      granularity: 'hour',
-    },
-    filters: { group_id: null, model: '' },
     summary: { ...aggregate },
     series: [],
     breakdown: [],
     breakdown_truncated: false,
-    request_log: {
-      enqueued_total: 20,
-      persisted_total: 18,
-      dropped_not_running_total: 0,
-      dropped_queue_full_total: 1,
-      dropped_stopping_total: 0,
-      dropped_persist_failed_total: 1,
-      dropped_shutdown_total: 0,
+    collection_health: {
+      scope: 'current_process',
       dropped_total: 2,
       write_failure_total: 1,
-      retention_delete_failure_total: 0,
-      queue_depth: 0,
-      queue_capacity: 100,
       last_write_failure_at: '2026-07-27T03:00:00Z',
-      last_retention_failure_at: null,
     },
     ...overrides,
   }
@@ -132,10 +121,11 @@ describe('UsageSummaryCard', () => {
         partial_count: 0,
         unpriced_request_count: 0,
       },
-      request_log: {
-        ...usageReport().request_log,
+      collection_health: {
+        ...usageReport().collection_health,
         dropped_total: 0,
         write_failure_total: 0,
+        last_write_failure_at: null,
       },
     })
     const { wrapper } = await mountSummary(new UsageApi(report))
@@ -160,10 +150,11 @@ describe('UsageSummaryCard', () => {
         partial_count: 0,
         unpriced_request_count: 0,
       },
-      request_log: {
-        ...usageReport().request_log,
+      collection_health: {
+        ...usageReport().collection_health,
         dropped_total: 0,
         write_failure_total: 0,
+        last_write_failure_at: null,
       },
     })
     const { wrapper } = await mountSummary(new UsageApi(report))
@@ -204,8 +195,9 @@ describe('UsageSummaryCard', () => {
     })
     const { wrapper } = await mountSummary(new UsageApi(report))
 
-    expect(wrapper.get('[data-test="home-usage-cost"]').text()).toContain('Unknown')
-    expect(wrapper.get('[data-test="home-usage-cost"]').text()).not.toMatch(/\$0|Free/)
+    expect(wrapper.get('[data-test="home-usage-cost"]').text()).toContain('$0.00')
+    expect(wrapper.get('[data-test="home-usage-cost"]').text()).toContain('unknown')
+    expect(wrapper.get('[data-test="home-usage-cost"]').text()).not.toContain('Free')
     expect(wrapper.get('[data-test="home-usage-quality-missing"]').text()).toBe('Usage missing 2')
     expect(wrapper.get('[data-test="home-usage-quality-partial"]').text()).toBe('Usage partial 3')
     expect(wrapper.get('[data-test="home-usage-quality-unpriced"]').text()).toBe('Cost unpriced 4')
@@ -223,6 +215,21 @@ describe('UsageSummaryCard', () => {
     )
   })
 
+  it('keeps a positive sub-cent estimated cost visible', async () => {
+    const report = usageReport({
+      summary: {
+        ...aggregate,
+        estimated_cost_usd: 0.00000049,
+        unpriced_request_count: 0,
+      },
+    })
+    const { wrapper } = await mountSummary(new UsageApi(report))
+
+    const displayedCost = wrapper.get('[data-test="home-usage-cost"] strong').text()
+    expect(displayedCost).toBe('$0.00000049')
+    expect(displayedCost).not.toBe('$0.00')
+  })
+
   it('shows a safe initial error without exposing the transport error', async () => {
     const { wrapper } = await mountSummary(
       new UsageApi(Promise.reject(new Error('usage-secret-canary'))),
diff --git a/web/src/features/home/UsageSummaryCard.vue b/web/src/features/home/UsageSummaryCard.vue
index 8495e078..c16a93d4 100644
--- a/web/src/features/home/UsageSummaryCard.vue
+++ b/web/src/features/home/UsageSummaryCard.vue
@@ -12,6 +12,7 @@ import InlineFeedback from '@/components/ui/InlineFeedback.vue'
 import QueryFeedback from '@/components/ui/QueryFeedback.vue'
 import StatusBadge from '@/components/ui/StatusBadge.vue'
 import SurfaceCard from '@/components/ui/SurfaceCard.vue'
+import { formatEstimatedUSD } from '@/features/usage/estimated-cost'
 
 const filters = { range: '24h' } as const
 const client = useApiClient()
@@ -24,8 +25,8 @@ const report = computed(() => usageQuery.data.value)
 const hasPipelineWarning = computed(() =>
   Boolean(
     report.value &&
-    (report.value.request_log.dropped_total > 0 ||
-      report.value.request_log.write_failure_total > 0),
+    (report.value.collection_health.dropped_total > 0 ||
+      report.value.collection_health.write_failure_total > 0),
   ),
 )
 const observedAt = computed(() => {
@@ -56,22 +57,11 @@ function formatReportedTokens(aggregate: UsageAggregateDto): string {
 
 function formatEstimatedCost(aggregate: UsageAggregateDto): string {
   if (aggregate.unpriced_request_count > 0) {
-    if (aggregate.estimated_cost_usd === 0) return t('home.usage.cost.unknown')
     return t('home.usage.cost.knownPlusUnknown', {
-      cost: new Intl.NumberFormat(locale.value, {
-        style: 'currency',
-        currency: 'USD',
-        minimumFractionDigits: 6,
-        maximumFractionDigits: 6,
-      }).format(aggregate.estimated_cost_usd),
+      cost: formatEstimatedUSD(aggregate.estimated_cost_usd, locale.value),
     })
   }
-  return new Intl.NumberFormat(locale.value, {
-    style: 'currency',
-    currency: 'USD',
-    minimumFractionDigits: 6,
-    maximumFractionDigits: 6,
-  }).format(aggregate.estimated_cost_usd)
+  return formatEstimatedUSD(aggregate.estimated_cost_usd, locale.value)
 }
 </script>
 
@@ -175,8 +165,8 @@ function formatEstimatedCost(aggregate: UsageAggregateDto): string {
           <TriangleAlert :size="16" aria-hidden="true" />
           {{
             t('home.usage.pipelineWarning', {
-              dropped: formatCount(report.request_log.dropped_total),
-              failures: formatCount(report.request_log.write_failure_total),
+              dropped: formatCount(report.collection_health.dropped_total),
+              failures: formatCount(report.collection_health.write_failure_total),
             })
           }}
         </InlineFeedback>
diff --git a/web/src/features/model-prices/ModelPriceDrawer.test.ts b/web/src/features/model-prices/ModelPriceDrawer.test.ts
index 7a2318a1..a7aa3d33 100644
--- a/web/src/features/model-prices/ModelPriceDrawer.test.ts
+++ b/web/src/features/model-prices/ModelPriceDrawer.test.ts
@@ -114,7 +114,7 @@ describe('ModelPriceDrawer', () => {
     wrapper.unmount()
   })
 
-  it('requires an explicit hard confirmation before saving a bare global star', async () => {
+  it('requires an explicit dialog confirmation before saving a bare global star', async () => {
     const request = vi.fn().mockResolvedValue(undefined) as ApiClient['request']
     const { wrapper } = await mountDrawer(request)
 
@@ -124,51 +124,60 @@ describe('ModelPriceDrawer', () => {
       'All user rules take precedence over built-in rules',
     )
     expect(document.body.textContent).toContain('* shadows every built-in price rule')
-    expect(document.body.textContent).toContain(
-      'I understand that * shadows every built-in price rule',
-    )
-    expect(element<HTMLButtonElement>('[data-test="model-price-save"]').disabled).toBe(true)
-
-    const confirmation = element<HTMLInputElement>('[data-test="model-price-global-confirm"]')
-    confirmation.checked = true
-    confirmation.dispatchEvent(new Event('change', { bubbles: true }))
+    expect(document.querySelector('[data-test="model-price-global-confirm"]')).toBeNull()
+    const save = element<HTMLButtonElement>('[data-test="model-price-save"]')
+    expect(save.disabled).toBe(false)
+    save.click()
     await flushPromises()
-    expect(element<HTMLButtonElement>('[data-test="model-price-save"]').disabled).toBe(false)
-    element<HTMLButtonElement>('[data-test="model-price-save"]').click()
+    expect(request).not.toHaveBeenCalled()
+
+    const dialogBody = element<HTMLElement>('[data-test="model-price-global-dialog"]')
+    const dialog = dialogBody.closest<HTMLElement>('[role="dialog"]')
+    if (!dialog) throw new Error('missing global price confirmation dialog')
+    expect(dialog.textContent).toContain('Create a global user price override?')
+    expect(dialog.textContent).toContain(
+      'takes precedence over every built-in exact and prefix rule',
+    )
+    expect(dialog.textContent).toContain('Unset price slots do not fall back')
+    expect(dialog.textContent).toContain('future completed or Emit requests')
+    expect(dialog.textContent).toContain('Reset restores the remaining user and built-in rules')
+    expect(dialog.contains(document.activeElement)).toBe(true)
+
+    element<HTMLButtonElement>('[data-test="model-price-global-save-confirm"]').click()
     await flushPromises()
     expect(request).toHaveBeenCalledTimes(1)
     wrapper.unmount()
   })
 
   it.each([
-    [
-      'zh-CN',
-      '所有用户规则都优先于内置规则',
-      '* 会遮蔽全部内置价格规则',
-      '我理解 * 会遮蔽全部内置价格规则',
-    ],
+    ['zh-CN', '所有用户规则都优先于内置规则', '* 会遮蔽全部内置价格规则', '创建全局用户价格覆盖？'],
     [
       'en-US',
       'All user rules take precedence over built-in rules',
       '* shadows every built-in price rule',
-      'I understand that * shadows every built-in price rule',
+      'Create a global user price override?',
     ],
     [
       'ja-JP',
       'すべてのユーザールールは組み込みルールより優先されます',
       '* はすべての組み込み価格ルールを覆い隠します',
-      '* がすべての組み込み価格ルールを覆い隠すことを理解しました',
+      'グローバルユーザー価格オーバーライドを作成しますか？',
     ],
   ] as const)(
-    'makes user precedence and complete builtin shadowing explicit in %s',
-    async (locale, precedence, shadowing, confirmation) => {
+    'makes user precedence and complete builtin shadowing explicit before the dialog in %s',
+    async (locale, precedence, shadowing, dialogTitle) => {
       const { wrapper } = await mountDrawer(vi.fn() as ApiClient['request'], null, locale)
 
       await setInput('[data-test="model-price-pattern"]', '*')
       await setInput('[data-test="model-price-output"]', '8')
       expect(document.body.textContent).toContain(precedence)
       expect(document.body.textContent).toContain(shadowing)
-      expect(document.body.textContent).toContain(confirmation)
+      element<HTMLButtonElement>('[data-test="model-price-save"]').click()
+      await flushPromises()
+      expect(
+        element<HTMLElement>('[data-test="model-price-global-dialog"]').closest('[role="dialog"]')
+          ?.textContent,
+      ).toContain(dialogTitle)
 
       wrapper.unmount()
     },
diff --git a/web/src/features/model-prices/ModelPriceDrawer.vue b/web/src/features/model-prices/ModelPriceDrawer.vue
index 866f42c8..85efcab9 100644
--- a/web/src/features/model-prices/ModelPriceDrawer.vue
+++ b/web/src/features/model-prices/ModelPriceDrawer.vue
@@ -9,6 +9,7 @@ import { putModelPrice, type ModelPriceRuleDto } from '@/api/control/model-price
 import { RequestCancelledError } from '@/api/errors'
 import { controlQueryKeys } from '@/app/query-keys'
 import AppButton from '@/components/ui/AppButton.vue'
+import AppDialog from '@/components/ui/AppDialog.vue'
 import AppDrawer from '@/components/ui/AppDrawer.vue'
 import FormField from '@/components/ui/FormField.vue'
 import InlineFeedback from '@/components/ui/InlineFeedback.vue'
@@ -33,7 +34,7 @@ const { t } = useI18n()
 const patternInput = ref<HTMLInputElement>()
 const draft = ref<ModelPriceDraft>(createModelPriceDraft())
 const initialDraft = ref<ModelPriceDraft>(createModelPriceDraft())
-const globalConfirmed = ref(false)
+const globalConfirmOpen = ref(false)
 const pending = ref(false)
 const failed = ref(false)
 let controller: AbortController | undefined
@@ -46,9 +47,7 @@ const dirty = computed(
     props.rule?.source !== 'user' ||
     JSON.stringify(draft.value) !== JSON.stringify(initialDraft.value),
 )
-const valid = computed(
-  () => requestBody.value !== null && dirty.value && (!isGlobal.value || globalConfirmed.value),
-)
+const valid = computed(() => requestBody.value !== null && dirty.value)
 const title = computed(() => {
   if (props.rule?.source === 'builtin') return t('modelPrices.drawer.builtinTitle')
   if (props.rule?.source === 'user') return t('modelPrices.drawer.editTitle')
@@ -80,7 +79,7 @@ async function resetForOpen(): Promise<void> {
   const nextDraft = createModelPriceDraft(props.rule)
   draft.value = nextDraft
   initialDraft.value = { ...nextDraft }
-  globalConfirmed.value = false
+  globalConfirmOpen.value = false
   failed.value = false
   await nextTick()
   await nextTick()
@@ -91,7 +90,7 @@ function setOpen(open: boolean): void {
   if (!open) {
     clearRequest()
     failed.value = false
-    globalConfirmed.value = false
+    globalConfirmOpen.value = false
   }
   emit('update:open', open)
 }
@@ -107,10 +106,24 @@ watch(
 watch(
   () => draft.value.pattern,
   (pattern) => {
-    if (pattern !== '*') globalConfirmed.value = false
+    if (pattern !== '*') globalConfirmOpen.value = false
   },
 )
 
+function requestSave(): void {
+  if (!valid.value || pending.value) return
+  if (isGlobal.value) {
+    globalConfirmOpen.value = true
+    return
+  }
+  void save()
+}
+
+function setGlobalConfirmOpen(open: boolean): void {
+  if (!open && pending.value) clearRequest()
+  globalConfirmOpen.value = open
+}
+
 async function save(): Promise<void> {
   const body = requestBody.value
   if (pending.value || body === null || !valid.value) return
@@ -124,6 +137,7 @@ async function save(): Promise<void> {
     if (controller !== activeController || !props.open) return
     await queryClient.invalidateQueries({ queryKey: controlQueryKeys.modelPrices() })
     if (controller !== activeController || !props.open) return
+    globalConfirmOpen.value = false
     setOpen(false)
   } catch (error: unknown) {
     if (
@@ -155,7 +169,7 @@ onBeforeUnmount(clearRequest)
   >
     <template #trigger><slot name="trigger" /></template>
 
-    <form class="model-price-drawer" @submit.prevent="save">
+    <form class="model-price-drawer" @submit.prevent="requestSave">
       <InlineFeedback v-if="failed" tone="danger">
         {{ t('modelPrices.drawer.saveFailed') }}
       </InlineFeedback>
@@ -225,15 +239,6 @@ onBeforeUnmount(clearRequest)
       <InlineFeedback v-if="isGlobal" tone="warning">
         {{ t('modelPrices.drawer.globalWarning') }}
       </InlineFeedback>
-      <label v-if="isGlobal" class="model-price-drawer__global-confirm">
-        <input
-          v-model="globalConfirmed"
-          data-test="model-price-global-confirm"
-          type="checkbox"
-          :disabled="pending"
-        />
-        <span>{{ t('modelPrices.drawer.globalConfirm') }}</span>
-      </label>
 
       <div class="model-price-drawer__actions">
         <AppButton variant="secondary" :disabled="pending" @click="setOpen(false)">
@@ -245,6 +250,39 @@ onBeforeUnmount(clearRequest)
       </div>
     </form>
   </AppDrawer>
+
+  <AppDialog
+    :open="globalConfirmOpen"
+    :title="t('modelPrices.drawer.globalDialog.title')"
+    :description="t('modelPrices.drawer.globalDialog.description')"
+    :close-label="t('modelPrices.drawer.globalDialog.close')"
+    @update:open="setGlobalConfirmOpen"
+  >
+    <div class="model-price-drawer__global-dialog" data-test="model-price-global-dialog">
+      <ul>
+        <li>{{ t('modelPrices.drawer.globalDialog.precedence') }}</li>
+        <li>{{ t('modelPrices.drawer.globalDialog.noFallback') }}</li>
+        <li>{{ t('modelPrices.drawer.globalDialog.futureOnly') }}</li>
+        <li>{{ t('modelPrices.drawer.globalDialog.reset') }}</li>
+      </ul>
+      <InlineFeedback v-if="failed" tone="danger">
+        {{ t('modelPrices.drawer.saveFailed') }}
+      </InlineFeedback>
+      <div class="model-price-drawer__actions">
+        <AppButton variant="secondary" :disabled="pending" @click="setGlobalConfirmOpen(false)">
+          {{ t('common.cancel') }}
+        </AppButton>
+        <AppButton
+          data-test="model-price-global-save-confirm"
+          :busy="pending"
+          :disabled="pending"
+          @click="save"
+        >
+          <Save :size="16" aria-hidden="true" />{{ t('modelPrices.drawer.globalDialog.confirm') }}
+        </AppButton>
+      </div>
+    </div>
+  </AppDialog>
 </template>
 
 <style scoped>
@@ -287,17 +325,15 @@ onBeforeUnmount(clearRequest)
 .model-price-drawer__group-error {
   color: var(--color-danger) !important;
 }
-.model-price-drawer__global-confirm {
-  display: flex;
-  min-height: 44px;
-  align-items: center;
-  gap: var(--space-2);
-  font-weight: 650;
-  cursor: pointer;
+.model-price-drawer__global-dialog {
+  display: grid;
+  gap: var(--space-4);
 }
-.model-price-drawer__global-confirm input {
-  width: 20px;
-  height: 20px;
+.model-price-drawer__global-dialog ul {
+  display: grid;
+  gap: var(--space-2);
+  margin: 0;
+  padding-left: var(--space-5);
 }
 .model-price-drawer__actions {
   display: flex;
diff --git a/web/src/features/model-prices/ModelPricesView.test.ts b/web/src/features/model-prices/ModelPricesView.test.ts
index 84ad8984..9df39225 100644
--- a/web/src/features/model-prices/ModelPricesView.test.ts
+++ b/web/src/features/model-prices/ModelPricesView.test.ts
@@ -45,6 +45,17 @@ const globalOverride: ModelPriceRuleDto = {
   pattern: '*',
 }
 
+function priceReport(
+  builtinRules: ModelPriceRuleDto[] = [builtin],
+  overrides: ModelPriceRuleDto[] = [override],
+) {
+  return {
+    price_unit: 'usd_per_million_tokens' as const,
+    builtin: builtinRules,
+    overrides,
+  }
+}
+
 function queryClient() {
   return new QueryClient({ defaultOptions: { queries: { retry: false } } })
 }
@@ -70,7 +81,7 @@ describe('ModelPricesView', () => {
     )
 
     const request = vi.fn(async (path: string, options?: ApiRequestOptions) => {
-      if (path === '/api/model-prices' && options?.method === 'GET') return [builtin, override]
+      if (path === '/api/model-prices' && options?.method === 'GET') return priceReport()
       throw new Error(`unexpected ${path}`)
     }) as ApiClient['request']
     const { wrapper } = await mountView(request)
@@ -79,19 +90,35 @@ describe('ModelPricesView', () => {
     expect(wrapper.findAll('table')).toHaveLength(2)
     expect(wrapper.get('[data-test="builtin-price-row-0"]').text()).toContain('Built-in')
     expect(wrapper.get('[data-test="override-price-row-0"]').text()).toContain('Override')
-    expect(wrapper.get('[data-test="builtin-0-cache_read"]').text()).toBe('$0')
+    expect(wrapper.get('[data-test="builtin-0-cache_read"]').text()).toContain('$0')
+    expect(wrapper.get('[data-test="builtin-0-cache_read"]').text()).toContain('Explicitly free')
     expect(wrapper.get('[data-test="builtin-0-cache_write_5m"]').text()).toBe('Not configured')
     expect(wrapper.get('[data-test="override-0-uncached_input"]').text()).toBe('Not configured')
+    expect(wrapper.get('[data-test="builtin-0-output"]').text()).toBe('$30 / 1M')
+    expect(wrapper.get('[data-test="override-0-output"]').text()).toBe('$8 / 1M')
+    expect(wrapper.get('[data-test="override-source-0"]').text()).toContain('Override')
+    expect(wrapper.get('time[datetime="2026-07-26T00:00:00Z"]')).toBeDefined()
+    expect(wrapper.get('time[datetime="2026-07-27T00:00:00Z"]')).toBeDefined()
     const source = wrapper.get<HTMLAnchorElement>('[data-test="builtin-source-0"]')
     expect(source.attributes('href')).toBe(builtin.source_url)
     expect(source.attributes('target')).toBe('_blank')
     expect(source.attributes('rel')).toContain('noopener')
     expect(wrapper.text()).toContain('Historical usage and cost are not recalculated')
+    expect(wrapper.text()).toContain('upstream model ID')
+    expect(wrapper.text()).toContain('same model ID shares one global price')
+    expect(wrapper.text()).toContain(
+      'User overrides take precedence over every built-in exact and prefix rule',
+    )
+    expect(wrapper.text()).toContain('replaces the whole five-slot rule')
+    const orderedSections = wrapper
+      .findAll('[data-test="model-price-rule-section"]')
+      .map((section) => section.attributes('data-source'))
+    expect(orderedSections).toEqual(['user', 'builtin'])
     wrapper.unmount()
   })
 
   it('opens add, builtin-prefill, and user-edit drawers from their visible actions', async () => {
-    const request = vi.fn().mockResolvedValue([builtin, override]) as ApiClient['request']
+    const request = vi.fn().mockResolvedValue(priceReport()) as ApiClient['request']
     const { wrapper } = await mountView(request)
 
     await wrapper.get('[data-test="model-price-add"]').trigger('click')
@@ -121,6 +148,16 @@ describe('ModelPricesView', () => {
     wrapper.unmount()
   })
 
+  it('marks a bare star row as a global user override', async () => {
+    const request = vi.fn().mockResolvedValue(priceReport([builtin], [globalOverride]))
+    const { wrapper } = await mountView(request as ApiClient['request'])
+
+    const warning = wrapper.get('[data-test="model-price-global-row-warning"]')
+    expect(warning.text()).toContain('Global user override')
+    expect(warning.find('svg').exists()).toBe(true)
+    wrapper.unmount()
+  })
+
   it('distinguishes loading, initial error, and a genuinely empty price table', async () => {
     let resolveRequest!: (value: unknown) => void
     const pending = vi.fn(
@@ -131,7 +168,7 @@ describe('ModelPricesView', () => {
     ) as ApiClient['request']
     const pendingMount = await mountView(pending)
     expect(pendingMount.wrapper.text()).toContain('Loading model prices')
-    resolveRequest([])
+    resolveRequest(priceReport([], []))
     await flushPromises()
     expect(pendingMount.wrapper.text()).toContain('No built-in model prices')
     expect(pendingMount.wrapper.text()).toContain('No overrides configured')
@@ -148,7 +185,7 @@ describe('ModelPricesView', () => {
     let calls = 0
     const request = vi.fn(async () => {
       calls += 1
-      if (calls === 1) return [builtin, override]
+      if (calls === 1) return priceReport()
       throw new Error('STALE_PRICE_CANARY')
     }) as ApiClient['request']
     const { queryClient: client, wrapper } = await mountView(request)
@@ -165,7 +202,7 @@ describe('ModelPricesView', () => {
   it('deletes only the selected exact override when broader user prefix and global rules remain', async () => {
     const request = vi.fn(async (path: string, options?: ApiRequestOptions) => {
       if (path === '/api/model-prices' && options?.method === 'GET') {
-        return [builtin, exactOverride, override, globalOverride]
+        return priceReport([builtin], [exactOverride, override, globalOverride])
       }
       if (path === '/api/model-prices?pattern=vendor-model' && options?.method === 'DELETE') {
         return undefined
diff --git a/web/src/features/model-prices/ModelPricesView.vue b/web/src/features/model-prices/ModelPricesView.vue
index 19da9a3b..c409b521 100644
--- a/web/src/features/model-prices/ModelPricesView.vue
+++ b/web/src/features/model-prices/ModelPricesView.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ArrowLeft, ExternalLink, Pencil, Plus, Tags } from 'lucide-vue-next'
+import { ArrowLeft, ExternalLink, Pencil, Plus, Tags, TriangleAlert } from 'lucide-vue-next'
 import { useQuery } from '@tanstack/vue-query'
 import { nextTick, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
@@ -54,7 +54,9 @@ async function setDrawerOpen(open: boolean): Promise<void> {
 }
 
 function formatPrice(value: number | null): string {
-  return value === null ? t('modelPrices.notConfigured') : `$${value}`
+  if (value === null) return t('modelPrices.notConfigured')
+  if (value === 0) return t('modelPrices.explicitlyFree')
+  return t('modelPrices.configuredPrice', { price: value })
 }
 
 function kindLabel(pattern: string): string {
@@ -93,6 +95,9 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
       <div>
         <strong>{{ t('modelPrices.priceUnit') }}</strong>
         <p>{{ t('modelPrices.historyNote') }}</p>
+        <p>{{ t('modelPrices.modelIdentityNote') }}</p>
+        <p>{{ t('modelPrices.precedenceNote') }}</p>
+        <p>{{ t('modelPrices.wholeRuleNote') }}</p>
       </div>
     </SurfaceCard>
 
@@ -117,7 +122,102 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
         @retry="pricesQuery.refetch()"
       />
 
-      <section class="model-prices__section" aria-labelledby="builtin-prices-title">
+      <section
+        class="model-prices__section"
+        data-test="model-price-rule-section"
+        data-source="user"
+        aria-labelledby="override-prices-title"
+      >
+        <div class="model-prices__section-heading">
+          <div>
+            <h2 id="override-prices-title">{{ t('modelPrices.overrides.title') }}</h2>
+            <p>{{ t('modelPrices.overrides.description') }}</p>
+          </div>
+          <StatusBadge>{{ t('modelPrices.source.user') }}</StatusBadge>
+        </div>
+        <EmptyState
+          v-if="pricesQuery.data.value.overrides.length === 0"
+          :title="t('modelPrices.overrides.empty')"
+          :description="t('modelPrices.overrides.emptyDescription')"
+        />
+        <DataTable v-else :caption="t('modelPrices.overrides.caption')" dense>
+          <thead>
+            <tr>
+              <th scope="col">{{ t('modelPrices.table.pattern') }}</th>
+              <th scope="col">{{ t('modelPrices.table.kind') }}</th>
+              <th scope="col">{{ t('modelPrices.fields.uncached_input') }}</th>
+              <th scope="col">{{ t('modelPrices.fields.cache_read') }}</th>
+              <th scope="col">{{ t('modelPrices.fields.cache_write_5m') }}</th>
+              <th scope="col">{{ t('modelPrices.fields.cache_write_1h') }}</th>
+              <th scope="col">{{ t('modelPrices.fields.output') }}</th>
+              <th scope="col">{{ t('modelPrices.table.source') }}</th>
+              <th scope="col">{{ t('modelPrices.table.updatedAt') }}</th>
+              <th scope="col">{{ t('modelPrices.table.actions') }}</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="(rule, index) in pricesQuery.data.value.overrides"
+              :key="rule.pattern"
+              :data-test="`override-price-row-${index}`"
+            >
+              <td>
+                <code>{{ rule.pattern }}</code>
+                <span
+                  v-if="rule.pattern === '*'"
+                  class="model-prices__global-warning"
+                  data-test="model-price-global-row-warning"
+                >
+                  <TriangleAlert :size="14" aria-hidden="true" />
+                  {{ t('modelPrices.globalUserOverride') }}
+                </span>
+              </td>
+              <td>
+                <StatusBadge>{{ kindLabel(rule.pattern) }}</StatusBadge>
+                <span class="model-prices__source-label">{{ t('modelPrices.source.user') }}</span>
+              </td>
+              <td :data-test="`override-${index}-uncached_input`">
+                {{ value(rule, 'uncached_input') }}
+              </td>
+              <td :data-test="`override-${index}-cache_read`">
+                {{ value(rule, 'cache_read') }}
+              </td>
+              <td :data-test="`override-${index}-cache_write_5m`">
+                {{ value(rule, 'cache_write_5m') }}
+              </td>
+              <td :data-test="`override-${index}-cache_write_1h`">
+                {{ value(rule, 'cache_write_1h') }}
+              </td>
+              <td :data-test="`override-${index}-output`">{{ value(rule, 'output') }}</td>
+              <td :data-test="`override-source-${index}`">
+                {{ t('modelPrices.source.user') }}
+              </td>
+              <td>
+                <time :datetime="rule.updated_at">{{ rule.updated_at }}</time>
+              </td>
+              <td>
+                <div class="model-prices__row-actions">
+                  <AppButton
+                    :data-test="`override-price-edit-${index}`"
+                    variant="ghost"
+                    @click="editRule(rule, $event)"
+                  >
+                    <Pencil :size="15" aria-hidden="true" />{{ t('modelPrices.overrides.edit') }}
+                  </AppButton>
+                  <ModelPriceResetDialog :rule="rule" />
+                </div>
+              </td>
+            </tr>
+          </tbody>
+        </DataTable>
+      </section>
+
+      <section
+        class="model-prices__section"
+        data-test="model-price-rule-section"
+        data-source="builtin"
+        aria-labelledby="builtin-prices-title"
+      >
         <div class="model-prices__section-heading">
           <div>
             <h2 id="builtin-prices-title">{{ t('modelPrices.builtin.title') }}</h2>
@@ -141,6 +241,7 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
               <th scope="col">{{ t('modelPrices.fields.cache_write_1h') }}</th>
               <th scope="col">{{ t('modelPrices.fields.output') }}</th>
               <th scope="col">{{ t('modelPrices.table.source') }}</th>
+              <th scope="col">{{ t('modelPrices.table.updatedAt') }}</th>
               <th scope="col">{{ t('modelPrices.table.actions') }}</th>
             </tr>
           </thead>
@@ -184,6 +285,9 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
                   <ExternalLink :size="14" aria-hidden="true" />
                 </a>
               </td>
+              <td>
+                <time :datetime="rule.updated_at">{{ rule.updated_at }}</time>
+              </td>
               <td>
                 <AppButton
                   :data-test="`builtin-price-edit-${index}`"
@@ -199,75 +303,6 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
           </tbody>
         </DataTable>
       </section>
-
-      <section class="model-prices__section" aria-labelledby="override-prices-title">
-        <div class="model-prices__section-heading">
-          <div>
-            <h2 id="override-prices-title">{{ t('modelPrices.overrides.title') }}</h2>
-            <p>{{ t('modelPrices.overrides.description') }}</p>
-          </div>
-          <StatusBadge>{{ t('modelPrices.source.user') }}</StatusBadge>
-        </div>
-        <EmptyState
-          v-if="pricesQuery.data.value.overrides.length === 0"
-          :title="t('modelPrices.overrides.empty')"
-          :description="t('modelPrices.overrides.emptyDescription')"
-        />
-        <DataTable v-else :caption="t('modelPrices.overrides.caption')" dense>
-          <thead>
-            <tr>
-              <th scope="col">{{ t('modelPrices.table.pattern') }}</th>
-              <th scope="col">{{ t('modelPrices.table.kind') }}</th>
-              <th scope="col">{{ t('modelPrices.fields.uncached_input') }}</th>
-              <th scope="col">{{ t('modelPrices.fields.cache_read') }}</th>
-              <th scope="col">{{ t('modelPrices.fields.cache_write_5m') }}</th>
-              <th scope="col">{{ t('modelPrices.fields.cache_write_1h') }}</th>
-              <th scope="col">{{ t('modelPrices.fields.output') }}</th>
-              <th scope="col">{{ t('modelPrices.table.actions') }}</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr
-              v-for="(rule, index) in pricesQuery.data.value.overrides"
-              :key="rule.pattern"
-              :data-test="`override-price-row-${index}`"
-            >
-              <td>
-                <code>{{ rule.pattern }}</code>
-              </td>
-              <td>
-                <StatusBadge>{{ kindLabel(rule.pattern) }}</StatusBadge>
-                <span class="model-prices__source-label">{{ t('modelPrices.source.user') }}</span>
-              </td>
-              <td :data-test="`override-${index}-uncached_input`">
-                {{ value(rule, 'uncached_input') }}
-              </td>
-              <td :data-test="`override-${index}-cache_read`">
-                {{ value(rule, 'cache_read') }}
-              </td>
-              <td :data-test="`override-${index}-cache_write_5m`">
-                {{ value(rule, 'cache_write_5m') }}
-              </td>
-              <td :data-test="`override-${index}-cache_write_1h`">
-                {{ value(rule, 'cache_write_1h') }}
-              </td>
-              <td :data-test="`override-${index}-output`">{{ value(rule, 'output') }}</td>
-              <td>
-                <div class="model-prices__row-actions">
-                  <AppButton
-                    :data-test="`override-price-edit-${index}`"
-                    variant="ghost"
-                    @click="editRule(rule, $event)"
-                  >
-                    <Pencil :size="15" aria-hidden="true" />{{ t('modelPrices.overrides.edit') }}
-                  </AppButton>
-                  <ModelPriceResetDialog :rule="rule" />
-                </div>
-              </td>
-            </tr>
-          </tbody>
-        </DataTable>
-      </section>
     </template>
   </section>
 </template>
@@ -306,6 +341,9 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
   margin: 0;
   color: var(--color-text-muted);
 }
+.model-prices__notice p + p {
+  margin-top: var(--space-1);
+}
 .model-prices__section {
   display: grid;
   min-width: 0;
@@ -342,6 +380,16 @@ function value(rule: ModelPriceRuleDto, field: ModelPriceField): string {
   color: var(--color-text-muted);
   font-size: 0.75rem;
 }
+.model-prices__global-warning {
+  display: flex;
+  align-items: center;
+  gap: var(--space-1);
+  margin-top: var(--space-1);
+  color: var(--color-warning);
+  font-size: 0.75rem;
+  font-weight: 650;
+  white-space: normal;
+}
 .model-prices__row-actions {
   gap: var(--space-2);
   white-space: nowrap;
diff --git a/web/src/features/monitor/LogDetailDrawer.test.ts b/web/src/features/monitor/LogDetailDrawer.test.ts
index 47463b39..c6928177 100644
--- a/web/src/features/monitor/LogDetailDrawer.test.ts
+++ b/web/src/features/monitor/LogDetailDrawer.test.ts
@@ -317,8 +317,14 @@ describe('LogDetailDrawer', () => {
     await mountDrawer(logFixture({ cost_state: 'priced', estimated_cost_usd: 0 }))
 
     const cost = bodyElement('[data-test="log-estimated-cost"]').textContent ?? ''
-    expect(cost).toContain('$0.000000')
+    expect(cost).toContain('$0.00')
     expect(cost).not.toContain('Unknown')
     expect(cost).not.toContain('Free')
   })
+
+  it('shows the lower-bound marker for a positive estimated cost below display precision', async () => {
+    await mountDrawer(logFixture({ cost_state: 'priced', estimated_cost_usd: 0.000000001 }))
+
+    expect(bodyElement('[data-test="log-estimated-cost"]').textContent).toContain('<$0.00000001')
+  })
 })
diff --git a/web/src/features/monitor/LogDetailDrawer.vue b/web/src/features/monitor/LogDetailDrawer.vue
index 8c665daa..b9f7fea9 100644
--- a/web/src/features/monitor/LogDetailDrawer.vue
+++ b/web/src/features/monitor/LogDetailDrawer.vue
@@ -12,6 +12,7 @@ import AppDrawer from '@/components/ui/AppDrawer.vue'
 import CopyButton from '@/components/ui/CopyButton.vue'
 import InlineFeedback from '@/components/ui/InlineFeedback.vue'
 import StatusBadge from '@/components/ui/StatusBadge.vue'
+import { formatEstimatedUSD } from '@/features/usage/estimated-cost'
 
 const props = defineProps<{
   open: boolean
@@ -142,12 +143,7 @@ function tokenValue(log: RequestLogItemDto, value: number): string {
 function estimatedCost(log: RequestLogItemDto): string {
   if (log.cost_state === 'not_applicable') return t('monitor.logs.drawer.usage.notApplicable')
   if (log.cost_state === 'unpriced') return t('monitor.logs.drawer.usage.unknown')
-  return new Intl.NumberFormat(locale.value, {
-    style: 'currency',
-    currency: 'USD',
-    minimumFractionDigits: 6,
-    maximumFractionDigits: 6,
-  }).format(log.estimated_cost_usd)
+  return formatEstimatedUSD(log.estimated_cost_usd, locale.value)
 }
 </script>
 
diff --git a/web/src/features/monitor/UsageSparkline.test.ts b/web/src/features/monitor/UsageSparkline.test.ts
index 022e19dc..739e88f7 100644
--- a/web/src/features/monitor/UsageSparkline.test.ts
+++ b/web/src/features/monitor/UsageSparkline.test.ts
@@ -21,7 +21,7 @@ function point(bucketStart: string, requestCount: number) {
 
 function mountSparkline(
   series: Array<{ bucket_start: string; bucket_end: string; request_count: number }>,
-  inputRange: UsageReportDto['range'] = range,
+  inputRange: Pick<UsageReportDto, 'from' | 'to' | 'granularity'> = range,
 ) {
   return mount(UsageSparkline, {
     props: {
diff --git a/web/src/features/monitor/UsageSparkline.vue b/web/src/features/monitor/UsageSparkline.vue
index e725adad..1678ec86 100644
--- a/web/src/features/monitor/UsageSparkline.vue
+++ b/web/src/features/monitor/UsageSparkline.vue
@@ -7,6 +7,7 @@ type UsageSeriesPoint = Pick<
   UsageReportDto['series'][number],
   'bucket_start' | 'bucket_end' | 'request_count'
 >
+type UsageWindow = Pick<UsageReportDto, 'from' | 'to' | 'granularity'>
 
 interface SparklinePoint {
   x: number
@@ -15,7 +16,7 @@ interface SparklinePoint {
 }
 
 const props = defineProps<{
-  range: UsageReportDto['range']
+  range: UsageWindow
   series: UsageSeriesPoint[]
   title: string
   description: string
diff --git a/web/src/features/monitor/UsageTab.test.ts b/web/src/features/monitor/UsageTab.test.ts
index 1649007a..d41c06e4 100644
--- a/web/src/features/monitor/UsageTab.test.ts
+++ b/web/src/features/monitor/UsageTab.test.ts
@@ -27,13 +27,12 @@ const aggregate: UsageAggregateDto = {
 
 function usageReport(overrides: Partial<UsageReportDto> = {}): UsageReportDto {
   return {
+    range: '24h',
+    granularity: 'hour',
+    timezone: 'UTC',
+    from: '2026-07-26T05:00:00Z',
+    to: '2026-07-27T05:00:00Z',
     observed_at: '2026-07-27T04:00:01Z',
-    range: {
-      from: '2026-07-26T05:00:00Z',
-      to: '2026-07-27T05:00:00Z',
-      granularity: 'hour',
-    },
-    filters: { group_id: null, model: '' },
     summary: { ...aggregate },
     series: [
       {
@@ -44,21 +43,11 @@ function usageReport(overrides: Partial<UsageReportDto> = {}): UsageReportDto {
     ],
     breakdown: [{ ...aggregate, group_id: 7, model: 'gpt-upstream' }],
     breakdown_truncated: false,
-    request_log: {
-      enqueued_total: 20,
-      persisted_total: 18,
-      dropped_not_running_total: 0,
-      dropped_queue_full_total: 1,
-      dropped_stopping_total: 0,
-      dropped_persist_failed_total: 1,
-      dropped_shutdown_total: 0,
+    collection_health: {
+      scope: 'current_process',
       dropped_total: 2,
       write_failure_total: 1,
-      retention_delete_failure_total: 0,
-      queue_depth: 0,
-      queue_capacity: 100,
       last_write_failure_at: '2026-07-27T03:00:00Z',
-      last_retention_failure_at: null,
     },
     ...overrides,
   }
@@ -214,20 +203,140 @@ describe('UsageTab', () => {
     expect(wrapper.text()).not.toContain('groups-secret')
   })
 
-  it('uses backend total_tokens and presents separate quality counts with overlap and process scope', async () => {
+  it('uses backend totals and presents success/failure plus five token categories', async () => {
     const { wrapper } = await mountUsage(new UsageApi())
 
     expect(wrapper.get('[data-test="usage-kpi-total-tokens"]').text()).toContain('177')
+    expect(wrapper.get('[data-test="usage-kpi-outcomes"]').text()).toContain('9')
+    expect(wrapper.get('[data-test="usage-kpi-outcomes"]').text()).toContain('3')
+    expect(wrapper.get('[data-test="usage-kpi-outcomes"]').text()).not.toContain('%')
+    const tokenDefinition = wrapper.get('[data-test="usage-summary-token-definition"]').text()
+    for (const value of ['100', '20', '3', '4', '50']) {
+      expect(tokenDefinition).toContain(value)
+    }
+  })
+
+  it('separates durable-window quality from current-process health with fixed scope semantics', async () => {
+    const { wrapper } = await mountUsage(new UsageApi())
+
+    expect(wrapper.get('[data-test="usage-window-quality"]').text()).toContain('selected window')
     expect(wrapper.get('[data-test="usage-quality-missing"]').text()).toContain('2')
     expect(wrapper.get('[data-test="usage-quality-partial"]').text()).toContain('3')
     expect(wrapper.get('[data-test="usage-quality-unpriced"]').text()).toContain('4')
     expect(wrapper.get('[data-test="usage-quality-overlap"]').text()).toContain('may overlap')
-    expect(wrapper.get('[data-test="usage-scope"]').text()).toContain('current process')
-    expect(wrapper.get('[data-test="usage-quality-dropped"]').text()).toContain('2')
-    expect(wrapper.get('[data-test="usage-quality-write-failures"]').text()).toContain('1')
+    const processHealth = wrapper.get('[data-test="usage-process-health"]')
+    expect(processHealth.text()).toContain('current process')
+    expect(processHealth.text()).toContain('reset when the process restarts')
+    expect(processHealth.text()).toContain('2026-07-27T03:00:00Z')
+    expect(processHealth.get('[data-test="usage-quality-dropped"]').text()).toContain('2')
+    expect(processHealth.get('[data-test="usage-quality-write-failures"]').text()).toContain('1')
+    expect(wrapper.text().indexOf('Current process collection health')).toBeLessThan(
+      wrapper.text().indexOf('Persisted request trend'),
+    )
+    expect(processHealth.get('[data-test="usage-process-dropped-warning"]').text()).toContain(
+      'covers only requests persisted successfully',
+    )
+    expect(processHealth.get('[data-test="usage-process-write-failure-warning"]').text()).toContain(
+      'persistence batch failed',
+    )
   })
 
-  it('explains excluded tokens and links unpriced requests to model prices without calling unknown cost free', async () => {
+  it('always shows overlap and uses neutral process status when current counters are zero', async () => {
+    const report = usageReport({
+      summary: {
+        ...aggregate,
+        usage_missing_count: 0,
+        partial_count: 0,
+        unpriced_request_count: 0,
+      },
+      collection_health: {
+        scope: 'current_process',
+        dropped_total: 0,
+        write_failure_total: 0,
+        last_write_failure_at: null,
+      },
+    })
+    const { wrapper } = await mountUsage(new UsageApi([report]))
+
+    expect(wrapper.get('[data-test="usage-quality-overlap"]').text()).toContain('may overlap')
+    expect(
+      wrapper.get('[data-test="usage-quality-dropped"]').find('[class*="status-badge"]').classes(),
+    ).toContain('status-badge--neutral')
+    expect(
+      wrapper
+        .get('[data-test="usage-quality-write-failures"]')
+        .find('[class*="status-badge"]')
+        .classes(),
+    ).toContain('status-badge--neutral')
+    expect(wrapper.get('[data-test="usage-process-health"]').text()).toContain(
+      'has not reported dropped telemetry or write failures',
+    )
+  })
+
+  it('explains dropped and write-failure process counters independently', async () => {
+    const dropped = await mountUsage(
+      new UsageApi([
+        usageReport({
+          collection_health: {
+            scope: 'current_process',
+            dropped_total: 2,
+            write_failure_total: 0,
+            last_write_failure_at: null,
+          },
+        }),
+      ]),
+    )
+    expect(dropped.wrapper.find('[data-test="usage-process-dropped-warning"]').exists()).toBe(true)
+    expect(dropped.wrapper.find('[data-test="usage-process-write-failure-warning"]').exists()).toBe(
+      false,
+    )
+    dropped.wrapper.unmount()
+
+    const writeFailure = await mountUsage(
+      new UsageApi([
+        usageReport({
+          collection_health: {
+            scope: 'current_process',
+            dropped_total: 0,
+            write_failure_total: 1,
+            last_write_failure_at: '2026-07-27T03:00:00Z',
+          },
+        }),
+      ]),
+    )
+    expect(writeFailure.wrapper.find('[data-test="usage-process-dropped-warning"]').exists()).toBe(
+      false,
+    )
+    expect(
+      writeFailure.wrapper.find('[data-test="usage-process-write-failure-warning"]').exists(),
+    ).toBe(true)
+  })
+
+  it('keeps current-process health visible when the durable window is empty', async () => {
+    const report = usageReport({
+      summary: {
+        ...aggregate,
+        request_count: 0,
+        success_count: 0,
+        failure_count: 0,
+        total_tokens: 0,
+        estimated_cost_usd: 0,
+        usage_missing_count: 0,
+        partial_count: 0,
+        unpriced_request_count: 0,
+      },
+      series: [],
+      breakdown: [],
+    })
+    const { wrapper } = await mountUsage(new UsageApi([report]))
+
+    expect(wrapper.get('[data-test="usage-empty"]').text()).toContain('No persisted usage matches')
+    expect(wrapper.get('[data-test="usage-process-health"]').text()).toContain('Dropped')
+    expect(wrapper.get('[data-test="usage-process-health"]').text()).toContain('2')
+    expect(wrapper.find('[data-test="usage-kpi-total-tokens"]').exists()).toBe(false)
+  })
+
+  it('conditionally explains partial and unpriced exclusions and preserves known zero cost', async () => {
     const report = usageReport({
       summary: { ...aggregate, estimated_cost_usd: 0, unpriced_request_count: 4 },
       series: [
@@ -262,10 +371,44 @@ describe('UsageTab', () => {
       '[data-test="usage-series-cost-0"]',
       '[data-test="usage-breakdown-cost-0"]',
     ]) {
-      expect(wrapper.get(selector).text()).toContain('Unknown')
-      expect(wrapper.get(selector).text()).not.toContain('$0')
+      expect(wrapper.get(selector).text()).toContain('$0.00')
+      expect(wrapper.get(selector).text()).toContain('unknown')
       expect(wrapper.get(selector).text()).not.toContain('Free')
     }
+    expect(wrapper.get('[data-test="usage-unpriced-explanation"]').text()).toContain(
+      'unsupported billing detail or diagnostics',
+    )
+    expect(wrapper.get('[data-test="usage-unpriced-explanation"]').text()).toContain(
+      'tokens are excluded',
+    )
+    expect(wrapper.get('[data-test="usage-partial-explanation"]').text()).toContain(
+      'usage-only final chunk',
+    )
+
+    const complete = await mountUsage(
+      new UsageApi([
+        usageReport({
+          summary: {
+            ...aggregate,
+            partial_count: 0,
+            unpriced_request_count: 0,
+          },
+        }),
+      ]),
+    )
+    expect(complete.wrapper.find('[data-test="usage-unpriced-explanation"]').exists()).toBe(false)
+    expect(complete.wrapper.find('[data-test="usage-partial-explanation"]').exists()).toBe(false)
+  })
+
+  it('refreshes without changing the applied URL filters', async () => {
+    const api = new UsageApi([usageReport(), usageReport()])
+    const { router, wrapper } = await mountUsage(api)
+
+    await wrapper.get('[data-test="usage-refresh"]').trigger('click')
+    await flushPromises()
+
+    expect(api.requests.filter(({ path }) => path.startsWith('/api/usage?'))).toHaveLength(2)
+    expect(router.currentRoute.value.fullPath).toBe('/monitor?tab=usage&range=24h')
   })
 
   it.each([
@@ -283,9 +426,33 @@ describe('UsageTab', () => {
     expect(wrapper.get('[data-test="usage-series-table"]').text()).toContain('2026-07-27T02:00:00Z')
     expect(wrapper.get('[data-test="usage-breakdown-table"]').text()).toContain('gpt-upstream')
     expect(wrapper.get('[data-test="usage-breakdown-table"]').text()).toContain('Upstream model')
+    for (const heading of [
+      'Uncached input',
+      'Cache read',
+      'Cache write (5m)',
+      'Cache write (1h)',
+      'Output',
+    ]) {
+      expect(wrapper.get('[data-test="usage-breakdown-table"]').text()).toContain(heading)
+    }
     expect(wrapper.get('[data-test="usage-breakdown-truncated"]').text()).toContain('top 100')
   })
 
+  it('labels deleted or unknown Groups in filters and breakdown rows', async () => {
+    const report = usageReport({
+      breakdown: [{ ...aggregate, group_id: 99, model: 'orphan-model' }],
+    })
+    const { wrapper } = await mountUsage(
+      new UsageApi([report], [group(7, 'Primary')]),
+      '/monitor?tab=usage&range=24h&group_id=99',
+    )
+
+    expect(wrapper.get('[data-test="usage-group"]').text()).toContain('#99 · Deleted or unknown')
+    expect(wrapper.get('[data-test="usage-breakdown-table"]').text()).toContain(
+      '#99 · Deleted or unknown',
+    )
+  })
+
   it('renders loading, no-data, terminal error, and stale-data states without leaking errors', async () => {
     const pending = deferred<UsageReportDto>()
     const loading = await mountApp(UsageTab, {
@@ -347,4 +514,25 @@ describe('UsageTab', () => {
     expect(stale.wrapper.get('[data-test="usage-kpi-total-tokens"]').text()).toContain('177')
     expect(stale.wrapper.text()).not.toContain('stale-secret-canary')
   })
+
+  it.each([
+    [0, '$0.00'],
+    [0.01, '$0.01'],
+    [0.00000001, '$0.00000001'],
+    [0.000000001, '<$0.00000001'],
+  ])(
+    'formats estimated USD %s without rounding a positive value to zero',
+    async (cost, expected) => {
+      const report = usageReport({
+        summary: {
+          ...aggregate,
+          estimated_cost_usd: cost,
+          unpriced_request_count: 0,
+        },
+      })
+      const { wrapper } = await mountUsage(new UsageApi([report]))
+
+      expect(wrapper.get('[data-test="usage-kpi-cost"]').text()).toContain(expected)
+    },
+  )
 })
diff --git a/web/src/features/monitor/UsageTab.vue b/web/src/features/monitor/UsageTab.vue
index d2f94bc1..f056a06c 100644
--- a/web/src/features/monitor/UsageTab.vue
+++ b/web/src/features/monitor/UsageTab.vue
@@ -1,6 +1,13 @@
 <script setup lang="ts">
 import { useQuery } from '@tanstack/vue-query'
-import { Activity, CircleDollarSign, Database, Gauge, TriangleAlert } from 'lucide-vue-next'
+import {
+  Activity,
+  CircleDollarSign,
+  Database,
+  Gauge,
+  RefreshCw,
+  TriangleAlert,
+} from 'lucide-vue-next'
 import { computed, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useRoute, useRouter } from 'vue-router'
@@ -17,6 +24,7 @@ import InlineFeedback from '@/components/ui/InlineFeedback.vue'
 import QueryFeedback from '@/components/ui/QueryFeedback.vue'
 import StatusBadge from '@/components/ui/StatusBadge.vue'
 import SurfaceCard from '@/components/ui/SurfaceCard.vue'
+import { formatEstimatedUSD } from '@/features/usage/estimated-cost'
 
 import {
   applyUsageFilterDraft,
@@ -48,15 +56,6 @@ const usageQuery = useQuery({
 })
 const report = computed(() => usageQuery.data.value)
 const hasData = computed(() => (report.value?.summary.request_count ?? 0) > 0)
-const hasQualityOverlap = computed(() => {
-  const summary = report.value?.summary
-  if (!summary) return false
-  return (
-    [summary.usage_missing_count, summary.partial_count, summary.unpriced_request_count].filter(
-      (count) => count > 0,
-    ).length > 1
-  )
-})
 
 watch([() => appliedFilters.value.group_id, () => appliedFilters.value.model], () => {
   draft.value = createUsageFilterDraft(appliedFilters.value)
@@ -69,22 +68,17 @@ function formatCount(value: number): string {
 
 function formatEstimatedCost(aggregate: UsageAggregateDto): string {
   if (aggregate.unpriced_request_count > 0) {
-    if (aggregate.estimated_cost_usd === 0) return t('monitor.usage.cost.unknown')
     return t('monitor.usage.cost.knownPlusUnknown', {
-      cost: new Intl.NumberFormat(locale.value, {
-        style: 'currency',
-        currency: 'USD',
-        minimumFractionDigits: 6,
-        maximumFractionDigits: 6,
-      }).format(aggregate.estimated_cost_usd),
+      cost: formatEstimatedUSD(aggregate.estimated_cost_usd, locale.value),
     })
   }
-  return new Intl.NumberFormat(locale.value, {
-    style: 'currency',
-    currency: 'USD',
-    minimumFractionDigits: 6,
-    maximumFractionDigits: 6,
-  }).format(aggregate.estimated_cost_usd)
+  return formatEstimatedUSD(aggregate.estimated_cost_usd, locale.value)
+}
+
+function groupLabel(groupID: number): string {
+  const known = groupsQuery.data.value?.find((group) => group.id === groupID)
+  if (known) return `${known.name} · #${groupID}`
+  return t('monitor.usage.filters.deletedOrUnknown', { id: groupID })
 }
 
 function filterError(field: keyof UsageFilterDraft): string | undefined {
@@ -173,7 +167,11 @@ async function navigate(filters: UsageFilters): Promise<void> {
                 "
                 :value="draft.group_id"
               >
-                #{{ draft.group_id }}
+                {{
+                  t('monitor.usage.filters.deletedOrUnknown', {
+                    id: draft.group_id,
+                  })
+                }}
               </option>
               <option
                 v-for="group in groupsQuery.data.value ?? []"
@@ -205,6 +203,14 @@ async function navigate(filters: UsageFilters): Promise<void> {
         </FormField>
       </div>
       <div class="usage-filter-actions">
+        <AppButton
+          data-test="usage-refresh"
+          type="button"
+          variant="secondary"
+          @click="usageQuery.refetch()"
+        >
+          <RefreshCw :size="16" aria-hidden="true" />{{ t('monitor.usage.filters.refresh') }}
+        </AppButton>
         <AppButton type="submit">{{ t('monitor.usage.filters.apply') }}</AppButton>
         <AppButton data-test="usage-reset" variant="ghost" @click="resetFilters">
           {{ t('monitor.usage.filters.reset') }}
@@ -270,15 +276,15 @@ async function navigate(filters: UsageFilters): Promise<void> {
               <span>{{ t('monitor.usage.kpi.requests') }}</span>
               <strong>{{ formatCount(report.summary.request_count) }}</strong>
             </SurfaceCard>
-            <SurfaceCard class="usage-kpi">
+            <SurfaceCard class="usage-kpi" data-test="usage-kpi-outcomes">
               <Gauge :size="20" aria-hidden="true" />
-              <span>{{ t('monitor.usage.kpi.successRate') }}</span>
+              <span>{{ t('monitor.usage.kpi.outcomes') }}</span>
               <strong>
                 {{
-                  new Intl.NumberFormat(locale, {
-                    style: 'percent',
-                    maximumFractionDigits: 1,
-                  }).format(report.summary.success_count / report.summary.request_count)
+                  t('monitor.usage.kpi.outcomeCounts', {
+                    success: formatCount(report.summary.success_count),
+                    failure: formatCount(report.summary.failure_count),
+                  })
                 }}
               </strong>
             </SurfaceCard>
@@ -293,58 +299,160 @@ async function navigate(filters: UsageFilters): Promise<void> {
               <strong>{{ formatEstimatedCost(report.summary) }}</strong>
             </SurfaceCard>
           </div>
+          <dl
+            class="usage-token-definition"
+            data-test="usage-summary-token-definition"
+            :aria-label="t('monitor.usage.tokens.title')"
+          >
+            <div>
+              <dt>{{ t('monitor.usage.tokens.uncachedInput') }}</dt>
+              <dd>{{ formatCount(report.summary.uncached_input_tokens) }}</dd>
+            </div>
+            <div>
+              <dt>{{ t('monitor.usage.tokens.cacheRead') }}</dt>
+              <dd>{{ formatCount(report.summary.cache_read_tokens) }}</dd>
+            </div>
+            <div>
+              <dt>{{ t('monitor.usage.tokens.cacheWrite5m') }}</dt>
+              <dd>{{ formatCount(report.summary.cache_write_5m_tokens) }}</dd>
+            </div>
+            <div>
+              <dt>{{ t('monitor.usage.tokens.cacheWrite1h') }}</dt>
+              <dd>{{ formatCount(report.summary.cache_write_1h_tokens) }}</dd>
+            </div>
+            <div>
+              <dt>{{ t('monitor.usage.tokens.output') }}</dt>
+              <dd>{{ formatCount(report.summary.output_tokens) }}</dd>
+            </div>
+          </dl>
         </section>
 
-        <section class="usage-section" aria-labelledby="usage-quality-title">
+        <section
+          class="usage-section"
+          data-test="usage-window-quality"
+          aria-labelledby="usage-quality-title"
+        >
           <div class="usage-heading">
             <div>
               <h2 id="usage-quality-title">{{ t('monitor.usage.quality.title') }}</h2>
-              <p>{{ t('monitor.usage.quality.description') }}</p>
+              <p>{{ t('monitor.usage.quality.windowDescription') }}</p>
             </div>
           </div>
           <div class="usage-quality-grid">
             <SurfaceCard data-test="usage-quality-missing">
-              <StatusBadge :tone="report.summary.usage_missing_count ? 'warning' : 'success'">
+              <StatusBadge :tone="report.summary.usage_missing_count ? 'warning' : 'neutral'">
                 {{ t('monitor.usage.quality.missing') }}
               </StatusBadge>
               <strong>{{ formatCount(report.summary.usage_missing_count) }}</strong>
             </SurfaceCard>
             <SurfaceCard data-test="usage-quality-partial">
-              <StatusBadge :tone="report.summary.partial_count ? 'warning' : 'success'">
+              <StatusBadge :tone="report.summary.partial_count ? 'warning' : 'neutral'">
                 {{ t('monitor.usage.quality.partial') }}
               </StatusBadge>
               <strong>{{ formatCount(report.summary.partial_count) }}</strong>
             </SurfaceCard>
             <SurfaceCard data-test="usage-quality-unpriced">
-              <StatusBadge :tone="report.summary.unpriced_request_count ? 'warning' : 'success'">
+              <StatusBadge :tone="report.summary.unpriced_request_count ? 'warning' : 'neutral'">
                 {{ t('monitor.usage.quality.unpriced') }}
               </StatusBadge>
               <strong>{{ formatCount(report.summary.unpriced_request_count) }}</strong>
             </SurfaceCard>
-            <SurfaceCard data-test="usage-quality-dropped">
-              <StatusBadge :tone="report.request_log.dropped_total ? 'danger' : 'success'">
-                {{ t('monitor.usage.quality.dropped') }}
-              </StatusBadge>
-              <strong>{{ formatCount(report.request_log.dropped_total) }}</strong>
-            </SurfaceCard>
-            <SurfaceCard data-test="usage-quality-write-failures">
-              <StatusBadge :tone="report.request_log.write_failure_total ? 'danger' : 'success'">
-                {{ t('monitor.usage.quality.writeFailures') }}
-              </StatusBadge>
-              <strong>{{ formatCount(report.request_log.write_failure_total) }}</strong>
-            </SurfaceCard>
           </div>
-          <InlineFeedback v-if="hasQualityOverlap" data-test="usage-quality-overlap" tone="warning">
+          <InlineFeedback data-test="usage-quality-overlap" tone="info">
             {{ t('monitor.usage.quality.overlap') }}
           </InlineFeedback>
+          <InlineFeedback
+            v-if="report.summary.partial_count > 0"
+            data-test="usage-partial-explanation"
+            tone="warning"
+          >
+            {{ t('monitor.usage.quality.partialExplanation') }}
+          </InlineFeedback>
+          <InlineFeedback
+            v-if="report.summary.unpriced_request_count > 0"
+            data-test="usage-unpriced-explanation"
+            tone="warning"
+          >
+            {{ t('monitor.usage.quality.unpricedExplanation') }}
+          </InlineFeedback>
           <p class="usage-note" data-test="usage-aggregation-note">
             {{ t('monitor.usage.quality.aggregation') }}
-            <RouterLink data-test="usage-prices-link" to="/settings/model-prices">
+            <RouterLink
+              v-if="report.summary.unpriced_request_count > 0"
+              data-test="usage-prices-link"
+              to="/settings/model-prices"
+            >
               {{ t('monitor.usage.quality.openPrices') }}
             </RouterLink>
           </p>
         </section>
+      </template>
 
+      <section
+        class="usage-section"
+        data-test="usage-process-health"
+        aria-labelledby="usage-process-health-title"
+      >
+        <div class="usage-heading">
+          <div>
+            <h2 id="usage-process-health-title">{{ t('monitor.usage.process.title') }}</h2>
+            <p>{{ t('monitor.usage.process.description') }}</p>
+          </div>
+        </div>
+        <div class="usage-process-grid">
+          <SurfaceCard data-test="usage-quality-dropped">
+            <StatusBadge :tone="report.collection_health.dropped_total ? 'danger' : 'neutral'">
+              {{ t('monitor.usage.quality.dropped') }}
+            </StatusBadge>
+            <strong>{{ formatCount(report.collection_health.dropped_total) }}</strong>
+          </SurfaceCard>
+          <SurfaceCard data-test="usage-quality-write-failures">
+            <StatusBadge
+              :tone="report.collection_health.write_failure_total ? 'danger' : 'neutral'"
+            >
+              {{ t('monitor.usage.quality.writeFailures') }}
+            </StatusBadge>
+            <strong>{{ formatCount(report.collection_health.write_failure_total) }}</strong>
+          </SurfaceCard>
+          <SurfaceCard>
+            <span>{{ t('monitor.usage.process.lastWriteFailure') }}</span>
+            <strong>
+              <time
+                v-if="report.collection_health.last_write_failure_at"
+                :datetime="report.collection_health.last_write_failure_at"
+              >
+                {{ report.collection_health.last_write_failure_at }}
+              </time>
+              <template v-else>{{ t('monitor.usage.process.never') }}</template>
+            </strong>
+          </SurfaceCard>
+        </div>
+        <InlineFeedback
+          v-if="report.collection_health.dropped_total > 0"
+          data-test="usage-process-dropped-warning"
+          tone="danger"
+        >
+          {{ t('monitor.usage.process.droppedWarning') }}
+        </InlineFeedback>
+        <InlineFeedback
+          v-if="report.collection_health.write_failure_total > 0"
+          data-test="usage-process-write-failure-warning"
+          tone="danger"
+        >
+          {{ t('monitor.usage.process.writeFailureWarning') }}
+        </InlineFeedback>
+        <InlineFeedback
+          v-if="
+            report.collection_health.dropped_total === 0 &&
+            report.collection_health.write_failure_total === 0
+          "
+          tone="info"
+        >
+          {{ t('monitor.usage.process.clear') }}
+        </InlineFeedback>
+      </section>
+
+      <template v-if="hasData">
         <section class="usage-section" aria-labelledby="usage-trend-title">
           <div class="usage-heading">
             <div>
@@ -354,7 +462,11 @@ async function navigate(filters: UsageFilters): Promise<void> {
           </div>
           <SurfaceCard>
             <UsageSparkline
-              :range="report.range"
+              :range="{
+                from: report.from,
+                to: report.to,
+                granularity: report.granularity,
+              }"
               :series="report.series"
               :title="t('monitor.usage.trend.title')"
               :description="t('monitor.usage.trend.accessibleDescription')"
@@ -439,6 +551,11 @@ async function navigate(filters: UsageFilters): Promise<void> {
                 <th scope="col">{{ t('monitor.usage.columns.group') }}</th>
                 <th scope="col">{{ t('monitor.usage.columns.upstreamModel') }}</th>
                 <th scope="col">{{ t('monitor.usage.columns.requests') }}</th>
+                <th scope="col">{{ t('monitor.usage.tokens.uncachedInput') }}</th>
+                <th scope="col">{{ t('monitor.usage.tokens.cacheRead') }}</th>
+                <th scope="col">{{ t('monitor.usage.tokens.cacheWrite5m') }}</th>
+                <th scope="col">{{ t('monitor.usage.tokens.cacheWrite1h') }}</th>
+                <th scope="col">{{ t('monitor.usage.tokens.output') }}</th>
                 <th scope="col">{{ t('monitor.usage.columns.totalTokens') }}</th>
                 <th scope="col">{{ t('monitor.usage.columns.estimatedCost') }}</th>
                 <th scope="col">{{ t('monitor.usage.columns.quality') }}</th>
@@ -447,15 +564,17 @@ async function navigate(filters: UsageFilters): Promise<void> {
             <tbody>
               <tr v-for="(row, index) in report.breakdown" :key="`${row.group_id}:${row.model}`">
                 <td>
-                  {{
-                    groupsQuery.data.value?.find((group) => group.id === row.group_id)?.name ??
-                    `#${row.group_id}`
-                  }}
+                  {{ groupLabel(row.group_id) }}
                 </td>
                 <td>
                   <code>{{ row.model }}</code>
                 </td>
                 <td>{{ formatCount(row.request_count) }}</td>
+                <td>{{ formatCount(row.uncached_input_tokens) }}</td>
+                <td>{{ formatCount(row.cache_read_tokens) }}</td>
+                <td>{{ formatCount(row.cache_write_5m_tokens) }}</td>
+                <td>{{ formatCount(row.cache_write_1h_tokens) }}</td>
+                <td>{{ formatCount(row.output_tokens) }}</td>
                 <td>{{ formatCount(row.total_tokens) }}</td>
                 <td :data-test="`usage-breakdown-cost-${index}`">
                   {{ formatEstimatedCost(row) }}
@@ -550,7 +669,9 @@ async function navigate(filters: UsageFilters): Promise<void> {
 }
 
 .usage-kpi-grid,
-.usage-quality-grid {
+.usage-quality-grid,
+.usage-process-grid,
+.usage-token-definition {
   display: grid;
   gap: var(--space-3);
 }
@@ -560,11 +681,37 @@ async function navigate(filters: UsageFilters): Promise<void> {
 }
 
 .usage-quality-grid {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.usage-process-grid {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.usage-token-definition {
   grid-template-columns: repeat(5, minmax(0, 1fr));
+  margin: 0;
+}
+
+.usage-token-definition > div {
+  border-top: 1px solid var(--color-border);
+  padding-top: var(--space-2);
+}
+
+.usage-token-definition dt,
+.usage-process-grid span {
+  color: var(--color-text-muted);
+  font-size: 0.8125rem;
+}
+
+.usage-token-definition dd {
+  margin: var(--space-1) 0 0;
+  font-weight: 700;
 }
 
 .usage-kpi,
-.usage-quality-grid > :deep(.surface-card) {
+.usage-quality-grid > :deep(.surface-card),
+.usage-process-grid > :deep(.surface-card) {
   display: grid;
   min-width: 0;
   gap: var(--space-2);
@@ -580,7 +727,8 @@ async function navigate(filters: UsageFilters): Promise<void> {
 }
 
 .usage-kpi strong,
-.usage-quality-grid strong {
+.usage-quality-grid strong,
+.usage-process-grid strong {
   font-size: 1.25rem;
   overflow-wrap: anywhere;
 }
@@ -602,7 +750,9 @@ async function navigate(filters: UsageFilters): Promise<void> {
 
 @media (max-width: 1000px) {
   .usage-kpi-grid,
-  .usage-quality-grid {
+  .usage-quality-grid,
+  .usage-process-grid,
+  .usage-token-definition {
     grid-template-columns: repeat(2, minmax(0, 1fr));
   }
 }
@@ -610,7 +760,9 @@ async function navigate(filters: UsageFilters): Promise<void> {
 @media (max-width: 720px) {
   .usage-filter-grid,
   .usage-kpi-grid,
-  .usage-quality-grid {
+  .usage-quality-grid,
+  .usage-process-grid,
+  .usage-token-definition {
     grid-template-columns: minmax(0, 1fr);
   }
 }
diff --git a/web/src/features/usage/estimated-cost.ts b/web/src/features/usage/estimated-cost.ts
new file mode 100644
index 00000000..853453cc
--- /dev/null
+++ b/web/src/features/usage/estimated-cost.ts
@@ -0,0 +1,11 @@
+const minimumVisibleEstimatedUSD = 0.00000001
+
+export function formatEstimatedUSD(value: number, locale: string): string {
+  if (value === 0) return '$0.00'
+  if (value < minimumVisibleEstimatedUSD) return '<$0.00000001'
+
+  return `$${new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 8,
+  }).format(value)}`
+}
diff --git a/web/src/i18n/locales/en-US.ts b/web/src/i18n/locales/en-US.ts
index e160c0ea..e368af9e 100644
--- a/web/src/i18n/locales/en-US.ts
+++ b/web/src/i18n/locales/en-US.ts
@@ -340,6 +340,8 @@ export default {
         anyGroup: 'All Groups',
         model: 'Upstream model',
         modelHelp: 'Optional exact upstream model after routing.',
+        deletedOrUnknown: '#{id} · Deleted or unknown',
+        refresh: 'Refresh',
         apply: 'Apply',
         reset: 'Reset',
       },
@@ -361,9 +363,19 @@ export default {
         description: 'Backend aggregate observed at {time}.',
         requests: 'Persisted requests',
         successRate: 'Success rate',
+        outcomes: 'Success and failure',
+        outcomeCounts: 'Success {success} · Failure {failure}',
         totalTokens: 'Total reported tokens',
         estimatedCost: 'Estimated cost',
       },
+      tokens: {
+        title: 'Reported token categories',
+        uncachedInput: 'Uncached input',
+        cacheRead: 'Cache read',
+        cacheWrite5m: 'Cache write (5m)',
+        cacheWrite1h: 'Cache write (1h)',
+        output: 'Output',
+      },
       cost: {
         unknown: 'Unknown',
         knownPlusUnknown: '{cost} + unknown',
@@ -371,17 +383,34 @@ export default {
       quality: {
         title: 'Usage and persistence quality',
         description: 'Counts remain separate so incomplete usage is not hidden by a single score.',
+        windowDescription:
+          'Durable quality counts apply only to persisted records in the selected window.',
         missing: 'Usage missing',
         partial: 'Usage partial',
         unpriced: 'Cost unpriced',
-        dropped: 'Requests dropped',
+        dropped: 'Dropped requests',
         writeFailures: 'Write failures',
         overlap:
           'Missing, partial, and unpriced counts may overlap. Do not add them into a request total.',
+        partialExplanation:
+          'Partial usage is recorded when only a usage-only final chunk supplies incomplete token detail; those tokens are excluded from default totals.',
+        unpricedExplanation:
+          'Unpriced requests can reflect an unsupported billing detail or diagnostics. Their tokens are excluded from default token and estimated-cost totals.',
         aggregation:
           'Only complete usage with priced cost is included in default token and estimated-cost totals. Partial, missing, unpriced, and not-applicable requests are excluded from both.',
         openPrices: 'Review model prices',
       },
+      process: {
+        title: 'Current process collection health',
+        description:
+          'These current process counters ignore report filters and reset when the process restarts.',
+        lastWriteFailure: 'Last write failure',
+        never: 'None reported',
+        clear: 'The current process has not reported dropped telemetry or write failures.',
+        droppedWarning:
+          'Dropped telemetry means the report covers only requests persisted successfully.',
+        writeFailureWarning: 'A request-log persistence batch failed in the current process.',
+      },
       trend: {
         title: 'Persisted request trend',
         description: 'Sparse UTC buckets remain sparse; absent points are not inferred.',
@@ -913,7 +942,15 @@ export default {
     priceUnit: 'USD per one million tokens',
     historyNote:
       'Price changes affect future estimated costs. Historical usage and cost are not recalculated.',
+    modelIdentityNote:
+      'Rules match the upstream model ID after routing; the same model ID shares one global price across Groups.',
+    precedenceNote: 'User overrides take precedence over every built-in exact and prefix rule.',
+    wholeRuleNote:
+      'A user override replaces the whole five-slot rule. Unset slots do not fall back to built-in values.',
     notConfigured: 'Not configured',
+    explicitlyFree: '$0 · Explicitly free',
+    configuredPrice: '${price} / 1M',
+    globalUserOverride: 'Global user override',
     kind: {
       exact: 'Exact model',
       prefix: 'Prefix rule',
@@ -934,6 +971,7 @@ export default {
       pattern: 'Model pattern',
       kind: 'Rule kind',
       source: 'Source',
+      updatedAt: 'Updated',
       actions: 'Actions',
     },
     builtin: {
@@ -971,6 +1009,20 @@ export default {
       globalWarning:
         'All user rules take precedence over built-in rules. A bare * shadows every built-in price rule; more specific user rules still take precedence over *.',
       globalConfirm: 'I understand that * shadows every built-in price rule.',
+      globalDialog: {
+        title: 'Create a global user price override?',
+        description:
+          'A bare * changes the estimated price rule for every model without a more specific user override.',
+        close: 'Close global price override confirmation',
+        precedence:
+          'This global user override takes precedence over every built-in exact and prefix rule.',
+        noFallback:
+          'Unset price slots do not fall back; the whole five-slot user rule replaces the built-in rule.',
+        futureOnly:
+          'The change applies only to future completed or Emit requests and does not recalculate history.',
+        reset: 'Reset restores the remaining user and built-in rules for future requests.',
+        confirm: 'Create global override',
+      },
       save: 'Save override',
       saveFailed: 'Unable to save the model price override. Your input is unchanged.',
       errors: {
diff --git a/web/src/i18n/locales/ja-JP.ts b/web/src/i18n/locales/ja-JP.ts
index 561f9a0b..f10ab943 100644
--- a/web/src/i18n/locales/ja-JP.ts
+++ b/web/src/i18n/locales/ja-JP.ts
@@ -339,6 +339,8 @@ export default {
         anyGroup: 'すべての Group',
         model: 'アップストリームモデル',
         modelHelp: 'ルーティング後のアップストリームモデルを完全一致で絞り込みます。',
+        deletedOrUnknown: '#{id} · 削除済みまたは不明',
+        refresh: '更新',
         apply: '適用',
         reset: 'リセット',
       },
@@ -361,9 +363,19 @@ export default {
         description: 'バックエンド集計の観測時刻: {time}。',
         requests: '永続化リクエスト',
         successRate: '成功率',
+        outcomes: '成功と失敗',
+        outcomeCounts: '成功 {success} · 失敗 {failure}',
         totalTokens: '報告済みトークン合計',
         estimatedCost: '推定コスト',
       },
+      tokens: {
+        title: '報告済みトークン分類',
+        uncachedInput: 'キャッシュなし入力',
+        cacheRead: 'キャッシュ読み取り',
+        cacheWrite5m: 'キャッシュ書き込み（5 分）',
+        cacheWrite1h: 'キャッシュ書き込み（1 時間）',
+        output: '出力',
+      },
       cost: {
         unknown: '不明',
         knownPlusUnknown: '{cost} + 不明',
@@ -371,6 +383,8 @@ export default {
       quality: {
         title: '使用量と永続化の品質',
         description: '不完全な使用量を単一の指標で隠さないよう、各件数を分けて表示します。',
+        windowDescription:
+          '永続化品質の件数は、選択期間内に永続化されたレコードだけを対象とします。',
         missing: '使用量なし',
         partial: '使用量が部分的',
         unpriced: 'コスト未設定',
@@ -378,10 +392,25 @@ export default {
         writeFailures: '書き込み失敗',
         overlap:
           '使用量なし、部分的、未設定の件数は重複する場合があります。リクエスト総数として加算しないでください。',
+        partialExplanation:
+          '使用量専用の最終チャンクに不完全なトークン詳細だけがある場合、部分使用量として記録され、そのトークンは既定の合計から除外されます。',
+        unpricedExplanation:
+          '価格未設定は、未対応の課金詳細や診断経路で発生する場合があります。そのトークンは既定のトークン合計と推定コスト合計から除外されます。',
         aggregation:
           '既定のトークンと推定コスト合計には、使用量が完全で価格設定済みのリクエストのみ含まれます。部分的、使用量なし、価格未設定、該当なしのリクエストはいずれの合計からも除外されます。',
         openPrices: 'モデル価格を確認',
       },
+      process: {
+        title: '現在プロセスの収集状態',
+        description:
+          '現在プロセスのカウンターはレポートフィルターに従わず、プロセス再起動時にリセットされます。',
+        lastWriteFailure: '直近の書き込み失敗',
+        never: '報告なし',
+        clear: '現在プロセスではテレメトリ破棄や書き込み失敗が報告されていません。',
+        droppedWarning:
+          'テレメトリが破棄された場合、統計は正常に永続化されたリクエストだけを対象とします。',
+        writeFailureWarning: '現在プロセスで RequestLog 永続化バッチの失敗が発生しました。',
+      },
       trend: {
         title: '永続化リクエストの推移',
         description: '疎な UTC バケットはそのまま表示し、欠落点を推測しません。',
@@ -909,7 +938,16 @@ export default {
     stale: 'バックグラウンド更新に失敗したため、モデル価格が古い可能性があります。',
     priceUnit: '100 万 Token あたりの米ドル',
     historyNote: '価格変更は今後のコスト推定だけに影響し、過去の使用量やコストは再計算されません。',
+    modelIdentityNote:
+      'ルールはルーティング後のアップストリームモデル ID に一致し、同じモデル ID はすべての Group で 1 つのグローバル価格を共有します。',
+    precedenceNote:
+      'ユーザー上書きは、すべての組み込み完全一致ルールとプレフィックスルールより優先されます。',
+    wholeRuleNote:
+      'ユーザー上書きは 5 枠のルール全体を置き換え、未設定の枠は組み込み値へフォールバックしません。',
     notConfigured: '未設定',
+    explicitlyFree: '$0 · 明示的に無料',
+    configuredPrice: '${price} / 1M',
+    globalUserOverride: 'グローバルユーザー上書き',
     kind: {
       exact: '完全一致モデル',
       prefix: 'プレフィックスルール',
@@ -930,6 +968,7 @@ export default {
       pattern: 'モデルパターン',
       kind: 'ルール種別',
       source: '出典',
+      updatedAt: '更新日時',
       actions: '操作',
     },
     builtin: {
@@ -968,6 +1007,21 @@ export default {
       globalWarning:
         'すべてのユーザールールは組み込みルールより優先されます。* はすべての組み込み価格ルールを覆い隠します。より具体的なユーザールールは引き続き * より優先されます。',
       globalConfirm: '* がすべての組み込み価格ルールを覆い隠すことを理解しました。',
+      globalDialog: {
+        title: 'グローバルユーザー価格オーバーライドを作成しますか？',
+        description:
+          '単独の * は、より具体的なユーザー上書きがない全モデルの推定価格ルールを変更します。',
+        close: 'グローバル価格上書きの確認を閉じる',
+        precedence:
+          'このグローバルユーザー上書きは、すべての組み込み完全一致ルールとプレフィックスルールより優先されます。',
+        noFallback:
+          '未設定の価格枠はフォールバックせず、5 枠のユーザールール全体が組み込みルールを置き換えます。',
+        futureOnly:
+          '変更は今後の完了済みまたは Emit リクエストだけに適用され、履歴は再計算されません。',
+        reset:
+          'リセットすると、今後のリクエストでは残りのユーザールールと組み込みルールが復元されます。',
+        confirm: 'グローバル上書きを作成',
+      },
       save: '上書きを保存',
       saveFailed: 'モデル価格上書きを保存できません。入力内容は保持されています。',
       errors: {
diff --git a/web/src/i18n/locales/zh-CN.ts b/web/src/i18n/locales/zh-CN.ts
index cec37d6b..c6271d77 100644
--- a/web/src/i18n/locales/zh-CN.ts
+++ b/web/src/i18n/locales/zh-CN.ts
@@ -329,6 +329,8 @@ export default {
         anyGroup: '全部 Group',
         model: '上游模型',
         modelHelp: '可选，精确限定路由后的上游模型。',
+        deletedOrUnknown: '#{id} · 已删除或未知',
+        refresh: '刷新',
         apply: '应用',
         reset: '重置',
       },
@@ -350,9 +352,19 @@ export default {
         description: '后端聚合观测时间：{time}。',
         requests: '持久化请求',
         successRate: '成功率',
+        outcomes: '成功与失败',
+        outcomeCounts: '成功 {success} · 失败 {failure}',
         totalTokens: '已报告 Token 总数',
         estimatedCost: '预估成本',
       },
+      tokens: {
+        title: '已报告 Token 分类',
+        uncachedInput: '非缓存输入',
+        cacheRead: '缓存读取',
+        cacheWrite5m: '缓存写入（5 分钟）',
+        cacheWrite1h: '缓存写入（1 小时）',
+        output: '输出',
+      },
       cost: {
         unknown: '未知',
         knownPlusUnknown: '{cost} + 未知',
@@ -360,16 +372,30 @@ export default {
       quality: {
         title: '用量与持久化质量',
         description: '各项计数分开呈现，避免单一分数掩盖不完整用量。',
+        windowDescription: '持久化质量计数只适用于所选时间窗内已持久化的记录。',
         missing: '用量缺失',
         partial: '用量部分缺失',
         unpriced: '成本未定价',
         dropped: '请求丢弃',
         writeFailures: '写入失败',
         overlap: '用量缺失、部分缺失与未定价计数可能重叠，请勿将其相加作为请求总数。',
+        partialExplanation:
+          '只有用量专用的最终数据块提供不完整 Token 明细时会记录部分用量；这些 Token 不计入默认总计。',
+        unpricedExplanation:
+          '未定价请求可能来自不支持的计费明细或诊断路径；其 Token 不计入默认 Token 与预估成本总计。',
         aggregation:
           '默认 Token 与预估成本总计仅纳入用量完整且已定价的请求。部分缺失、缺失、未定价和不适用请求均不纳入两项总计。',
         openPrices: '查看模型价格',
       },
+      process: {
+        title: '当前进程采集健康',
+        description: '这些当前进程计数不受报告筛选影响，并会在进程重启时重置。',
+        lastWriteFailure: '最近写入失败',
+        never: '尚无记录',
+        clear: '当前进程未报告遥测丢弃或写入失败。',
+        droppedWarning: '发生遥测丢弃时，统计只覆盖成功持久化的请求。',
+        writeFailureWarning: '当前进程发生过 RequestLog 持久化批次失败。',
+      },
       trend: {
         title: '持久化请求趋势',
         description: '稀疏 UTC 桶保持稀疏，不推断缺失点。',
@@ -878,7 +904,13 @@ export default {
     stale: '后台刷新失败，模型价格可能已过期。',
     priceUnit: '美元 / 每百万 Token',
     historyNote: '价格变更只影响后续成本估算，不会重新计算历史用量或成本。',
+    modelIdentityNote: '规则匹配路由后的上游模型 ID；相同模型 ID 在所有 Group 间共用一个全局价格。',
+    precedenceNote: '所有用户覆盖都优先于内置精确规则和前缀规则。',
+    wholeRuleNote: '用户覆盖会替换完整的五槽位规则；未配置槽位不会回退到内置值。',
     notConfigured: '未配置',
+    explicitlyFree: '$0 · 显式免费',
+    configuredPrice: '${price} / 1M',
+    globalUserOverride: '全局用户覆盖',
     kind: {
       exact: '精确模型',
       prefix: '前缀规则',
@@ -899,6 +931,7 @@ export default {
       pattern: '模型模式',
       kind: '规则类型',
       source: '来源',
+      updatedAt: '更新时间',
       actions: '操作',
     },
     builtin: {
@@ -933,6 +966,16 @@ export default {
       globalWarning:
         '所有用户规则都优先于内置规则。单独的 * 会遮蔽全部内置价格规则；更具体的用户规则仍优先于 *。',
       globalConfirm: '我理解 * 会遮蔽全部内置价格规则。',
+      globalDialog: {
+        title: '创建全局用户价格覆盖？',
+        description: '单独的 * 会更改所有没有更具体用户覆盖的模型预估价格规则。',
+        close: '关闭全局价格覆盖确认',
+        precedence: '此全局用户覆盖优先于所有内置精确规则和前缀规则。',
+        noFallback: '未配置价格槽位不会回退；完整的五槽位用户规则会替换内置规则。',
+        futureOnly: '更改只影响后续已完成或 Emit 请求，不会重新计算历史记录。',
+        reset: '重置后，后续请求会恢复使用剩余的用户规则和内置规则。',
+        confirm: '创建全局覆盖',
+      },
       save: '保存覆盖',
       saveFailed: '无法保存模型价格覆盖，输入内容已保留。',
       errors: {