codex-usage-tracking 0.3.1__tar.gz → 0.3.2__tar.gz

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-usage-tracker",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Unofficial local tracker for aggregate Codex token usage from local session logs.",
   "author": {
     "name": "Douglas Monsky"

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.3.2 - 2026-06-08
+
+- Make `open-dashboard` and `serve-dashboard` refresh active-session logs by default, with `--no-refresh` as the explicit cached-index mode.
+- Add a token-protected dashboard action for enabling context loading without restarting a localhost server that started with context loading off.
+
 ## 0.3.1 - 2026-06-08
 
 - Fix packaged Codex Usage Tracker skills so dashboard-open requests start the live localhost dashboard instead of a static snapshot.

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-usage-tracking
-Version: 0.3.1
+Version: 0.3.2
 Summary: Unofficial local Codex plugin and dashboard for investigating aggregate token usage, costs, caching, and thread patterns.
 Author: Douglas Monsky
 License-Expression: MIT
@@ -68,6 +68,8 @@ codex-usage-tracker serve-dashboard --open
 
 Use your normal Python launcher for your platform: `python3` is common on macOS/Linux, and `py` may be preferable on Windows. On macOS with Homebrew, `brew install pipx` is also fine.
 
+`serve-dashboard` refreshes active-session usage before opening by default. Use `--no-refresh` only when you intentionally want to inspect the cached local index.
+
 Package naming: the PyPI distribution is `codex-usage-tracking`; the installed command is `codex-usage-tracker`; the GitHub repository remains `douglasmonsky/codex-usage-tracker`. The `codex-usage-tracker` PyPI name is not this project, so avoid similarly named packages when following these docs.
 
 Source install for development or branch testing:
@@ -193,7 +195,7 @@ codex-usage-tracker summary --preset last-7-days
 codex-usage-tracker query --since 2026-06-01 --min-credits 1
 codex-usage-tracker session <session-id>
 codex-usage-tracker export --output usage.csv
-codex-usage-tracker dashboard --open
+codex-usage-tracker open-dashboard
 codex-usage-tracker support-bundle --output ~/.codex-usage-tracker/support-bundle.json
 ```
 
@@ -205,7 +207,7 @@ The tracker stores aggregate metrics only: session ids, timestamps, local source
 
 It does **not** store prompts, assistant messages, tool output, pasted secrets, raw transcript snippets, or raw context in SQLite, CSV exports, generated dashboard HTML, or synthetic screenshots.
 
-On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can be disabled with:
+On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can start off until you enable it from the details panel:
 
 ```bash
 codex-usage-tracker serve-dashboard --no-context-api --open

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/README.md

@@ -32,6 +32,8 @@ codex-usage-tracker serve-dashboard --open
 
 Use your normal Python launcher for your platform: `python3` is common on macOS/Linux, and `py` may be preferable on Windows. On macOS with Homebrew, `brew install pipx` is also fine.
 
+`serve-dashboard` refreshes active-session usage before opening by default. Use `--no-refresh` only when you intentionally want to inspect the cached local index.
+
 Package naming: the PyPI distribution is `codex-usage-tracking`; the installed command is `codex-usage-tracker`; the GitHub repository remains `douglasmonsky/codex-usage-tracker`. The `codex-usage-tracker` PyPI name is not this project, so avoid similarly named packages when following these docs.
 
 Source install for development or branch testing:
@@ -157,7 +159,7 @@ codex-usage-tracker summary --preset last-7-days
 codex-usage-tracker query --since 2026-06-01 --min-credits 1
 codex-usage-tracker session <session-id>
 codex-usage-tracker export --output usage.csv
-codex-usage-tracker dashboard --open
+codex-usage-tracker open-dashboard
 codex-usage-tracker support-bundle --output ~/.codex-usage-tracker/support-bundle.json
 ```
 
@@ -169,7 +171,7 @@ The tracker stores aggregate metrics only: session ids, timestamps, local source
 
 It does **not** store prompts, assistant messages, tool output, pasted secrets, raw transcript snippets, or raw context in SQLite, CSV exports, generated dashboard HTML, or synthetic screenshots.
 
-On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can be disabled with:
+On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can start off until you enable it from the details panel:
 
 ```bash
 codex-usage-tracker serve-dashboard --no-context-api --open

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/SECURITY.md

@@ -22,7 +22,7 @@ The MCP `usage_call_context` tool is disabled unless the MCP server process expl
 
 ## Localhost Dashboard Token
 
-`serve-dashboard` creates a random per-server API token and embeds it in the generated dashboard HTML for that local server session. The token is used for localhost `/api/usage` refreshes and `/api/context` requests. Treat generated active dashboard files and URLs as local-only artifacts; do not publish them or send them to someone else.
+`serve-dashboard` creates a random per-server API token and embeds it in the generated dashboard HTML for that local server session. The token is used for localhost `/api/usage` refreshes, `/api/context` requests, and runtime context-loading settings. Treat generated active dashboard files and URLs as local-only artifacts; do not publish them or send them to someone else.
 
 The dashboard server rejects non-loopback hosts and cross-origin requests. This is a local hardening measure, not a reason to expose the server on a network interface.
 

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/docs/cli-reference.md

@@ -33,11 +33,15 @@ codex-usage-tracker inspect-log ~/.codex/sessions/YYYY/MM/DD/rollout-...jsonl --
 codex-usage-tracker dashboard --open
 codex-usage-tracker dashboard --include-archived --open
 codex-usage-tracker open-dashboard
+codex-usage-tracker open-dashboard --no-refresh
 codex-usage-tracker serve-dashboard --open
+codex-usage-tracker serve-dashboard --no-refresh --open
 codex-usage-tracker serve-dashboard --no-context-api --open
 ```
 
-`serve-dashboard --context-api explicit` is the default and keeps context loading as an explicit per-row action. `serve-dashboard --no-context-api` or `--context-api disabled` serves live aggregate refresh while disabling `/api/context` entirely.
+`serve-dashboard --context-api explicit` is the default and keeps context loading as an explicit per-row action. `serve-dashboard --no-context-api` or `--context-api disabled` starts with context loading off; a token-protected button in the local details panel can enable it without restarting the server.
+
+`open-dashboard` and `serve-dashboard` refresh active-session logs before opening by default. Use `--no-refresh` only for an intentionally cached snapshot. The lower-level `dashboard` command writes from the current SQLite index and does not rescan logs.
 
 Dashboards default to active sessions only. Use `--include-archived` for an all-history static/opened dashboard, or switch the served dashboard's `History` control from `Active sessions only` to `All history` when you intentionally want archived logs scanned and included.
 

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/docs/dashboard-guide.md

@@ -35,6 +35,8 @@ codex-usage-tracker --privacy-mode strict dashboard --open
 
 Redacted mode hides raw cwd/source paths, hides Git remote labels, and hashes unnamed projects while preserving configured aliases. Strict mode also hides project-relative cwd, Git branch, and tags. The dashboard header shows the active metadata mode.
 
+`serve-dashboard` refreshes active-session logs before opening by default. Use `--no-refresh` only when you intentionally want a cached view of the existing local index.
+
 The server keeps the HTML aggregate-only and enables two live features:
 
 - `Refresh` rescans local Codex logs and updates the dashboard rows.
@@ -43,12 +45,12 @@ The server keeps the HTML aggregate-only and enables two live features:
 For a static snapshot, use:
 
 ```bash
-codex-usage-tracker dashboard --open
+codex-usage-tracker open-dashboard
 ```
 
-Static file mode can still filter, sort, and inspect aggregate call fields. It cannot refresh from logs or load raw context until you open the dashboard through `serve-dashboard`.
+Static file mode can still filter, sort, and inspect aggregate call fields. `open-dashboard` refreshes before writing the snapshot unless you pass `--no-refresh`. Static files cannot refresh from logs or load raw context after opening; use `serve-dashboard` when you want those live controls.
 
-The localhost server uses a random per-server token for refresh and context API calls, validates loopback `Host` and `Origin` headers, and can run as aggregate-only with `codex-usage-tracker serve-dashboard --no-context-api`.
+The localhost server uses a random per-server token for refresh and context API calls, validates loopback `Host` and `Origin` headers, and can start with context loading off through `codex-usage-tracker serve-dashboard --no-context-api`.
 
 ## Insights View
 
@@ -141,12 +143,12 @@ When served from localhost, the details panel includes `Load context` and `Inclu
 - `Load context` fetches a size-limited, redacted context excerpt for only that call.
 - `Include tool output` repeats the request with tool output included, still redacted and capped.
 - Raw context is not written to SQLite, CSV, or the generated dashboard HTML.
-- If the server was started with `--no-context-api`, the context buttons stay disabled and the dashboard remains aggregate-only.
+- If the server was started with `--no-context-api`, context loading starts off. Use `Enable context loading` in the details panel when you want to allow explicit row actions without restarting the dashboard server.
 
 ## Practical Workflow
 
 1. Start with `serve-dashboard --open`.
-2. Use `Refresh` after a Codex run finishes, or leave `Live` enabled while you work.
+2. Leave `Live` enabled while you work, or click `Refresh` after a Codex run finishes.
 3. Leave `History` on `Active sessions only` for current work. Switch to `All history` when you intentionally want archived sessions included in the live refresh.
 4. Optionally run `parse-allowance` with copied values from Codex Usage or `/status`, or initialize and edit `allowance.json` manually.
 5. Start in `Insights` view and review the highest-severity attention cards.

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/docs/development.md

@@ -119,10 +119,11 @@ The release checker verifies version alignment, required public docs, packaged p
 
 Publishing uses GitHub Actions Trusted Publishing through `.github/workflows/publish.yml`; do not upload from a local machine and do not add PyPI or TestPyPI API tokens.
 
-The first public package release, `0.3.0`, was published on June 8, 2026. Patch release `0.3.1` followed the same day to ship the live-dashboard skill launch fix:
+The first public package release, `0.3.0`, was published on June 8, 2026. Patch release `0.3.1` followed the same day to ship the live-dashboard skill launch fix. Patch release `0.3.2` made dashboard launch refresh the default and added runtime enablement for context loading:
 
 - GitHub Release: `https://github.com/douglasmonsky/codex-usage-tracker/releases/tag/v0.3.0`
 - GitHub Release: `https://github.com/douglasmonsky/codex-usage-tracker/releases/tag/v0.3.1`
+- GitHub Release: `https://github.com/douglasmonsky/codex-usage-tracker/releases/tag/v0.3.2`
 - PyPI: `https://pypi.org/project/codex-usage-tracking/`
 - TestPyPI: `https://test.pypi.org/project/codex-usage-tracking/`
 

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/docs/install.md

@@ -26,6 +26,8 @@ Package naming: the public PyPI distribution is [`codex-usage-tracking`](https:/
 
 Restart Codex after plugin registration if you want Codex to discover the MCP tools in a fresh session. The localhost dashboard can run immediately.
 
+`serve-dashboard` and `open-dashboard` refresh active-session usage before opening by default. Add `--no-refresh` only when you intentionally want to inspect the cached local index without scanning logs first.
+
 ## Platform Support
 
 The CLI, SQLite index, dashboard generator, and localhost server are Python-based and are not macOS-only. CI runs the package on Ubuntu with Python 3.10, 3.11, 3.12, and 3.13.
@@ -107,8 +109,8 @@ codex-usage-tracker install-plugin --python .venv/bin/python --force
 Generate a static dashboard:
 
 ```bash
-codex-usage-tracker dashboard --open
 codex-usage-tracker open-dashboard
+codex-usage-tracker open-dashboard --no-refresh
 ```
 
 Serve the dashboard with live aggregate refresh and lazy context loading:
@@ -119,6 +121,9 @@ codex-usage-tracker serve-dashboard --no-context-api --open
 ```
 
 The server binds to localhost, requires a per-server token for refresh/context endpoints, and rejects non-loopback `Host` or cross-origin `Origin` headers.
+`--no-context-api` starts context loading off; the details panel can enable it later without restarting the server.
+
+`open-dashboard` and `serve-dashboard` refresh active-session logs before opening by default. The lower-level `dashboard --open` command writes from the current SQLite index when you need a fully static file-generation step.
 
 ## Setup Checks
 

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/docs/privacy.md

@@ -29,12 +29,14 @@ Those fields are not written to SQLite, CSV exports, generated dashboard HTML, o
 
 `usage_call_context`, `codex-usage-tracker context`, and the `serve-dashboard` context endpoint read a single source JSONL file only when explicitly requested. Returned context is redacted for common secret patterns and capped in size.
 
-The context API can be disabled:
+Dashboard context loading can start off and then be enabled from the local details panel without restarting:
 
 ```bash
 codex-usage-tracker serve-dashboard --no-context-api --open
 ```
 
+The enable action is still token-protected, localhost-only, and does not load any context until you click a row-level context action.
+
 For MCP users, `usage_call_context` is additionally disabled unless the MCP server process has this environment variable:
 
 ```bash

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-usage-tracking"
-version = "0.3.1"
+version = "0.3.2"
 description = "Unofficial local Codex plugin and dashboard for investigating aggregate token usage, costs, caching, and thread patterns."
 readme = "README.md"
 requires-python = ">=3.10"

{codex_usage_tracking-0.3.1/src/codex_usage_tracker/plugin_data → codex_usage_tracking-0.3.2}/skills/codex-usage-api/SKILL.md

@@ -17,7 +17,7 @@ The only exception is `usage_call_context`, which reads one selected record's lo
 
 ## First Steps
 
-1. For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --refresh --context-api explicit --open` so Refresh and Live can use the local API, then report the localhost URL or a brief failure. Use `codex-usage-tracker open-dashboard --refresh` only for explicit static/offline snapshots or when the environment cannot keep a long-running server process alive; if you fall back, say the dashboard is static and Live requires `serve-dashboard`.
+1. For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --context-api explicit --open` so Refresh and Live can use the local API, then report the localhost URL or a brief failure. Refresh is the default for dashboard launch commands; use `--no-refresh` only when the user explicitly asks for a cached snapshot. Use `codex-usage-tracker open-dashboard` only for explicit static/offline snapshots or when the environment cannot keep a long-running server process alive; if you fall back, say the dashboard is static and Live requires `serve-dashboard`.
 2. For "Heaviest thread?", "Thread leaderboard", or similar thread-ranking requests, do not inspect repository files, SQLite schemas, plugin manifests, process lists, dashboard servers, or local logs manually. Refresh the aggregate index, then call `usage_summary(group_by="thread", limit=10, response_format="json")`. If MCP tools are unavailable, run `codex-usage-tracker refresh --json` and `codex-usage-tracker summary --group-by thread --limit 10 --json`.
 3. For normal usage questions, do not inspect repository files, plugin manifests, or local logs first. Start with the aggregate MCP tools. If MCP tools are unavailable, use the CLI JSON fallback below.
 4. Refresh before analysis with `refresh_usage_index` unless the user asks for a static historical snapshot. Keep archived sessions excluded unless the user explicitly asks for all history.

{codex_usage_tracking-0.3.1/src/codex_usage_tracker/plugin_data → codex_usage_tracking-0.3.2}/skills/codex-usage-tracker/SKILL.md

@@ -17,11 +17,11 @@ The only exception is `usage_call_context`, which intentionally reads one select
 
 ## Fast Paths
 
-- For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --refresh --context-api explicit --open` so Refresh, Live, load-limit, and history-scope controls can call the local API. Keep the server running while the user is using the dashboard. Use `codex-usage-tracker open-dashboard --refresh` only when the user explicitly asks for a static/offline snapshot or when the current environment cannot keep a server process running, and say that the result is static and Live requires `serve-dashboard`.
+- For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --context-api explicit --open` so Refresh, Live, load-limit, and history-scope controls can call the local API. Refresh is the default for dashboard launch commands; use `--no-refresh` only when the user explicitly asks for a cached snapshot. Keep the server running while the user is using the dashboard. Use `codex-usage-tracker open-dashboard` only when the user explicitly asks for a static/offline snapshot or when the current environment cannot keep a server process running, and say that the result is static and Live requires `serve-dashboard`.
 - For "Heaviest thread?", "Thread leaderboard", or similar thread-ranking requests, do not inspect repository files, SQLite schemas, plugin manifests, process lists, dashboard servers, or local logs manually. Use the tracker API: refresh the aggregate index, then rank threads with `usage_summary(group_by="thread", limit=10, response_format="json")`.
 - If MCP tools are unavailable for thread-ranking requests, run `codex-usage-tracker refresh --json` and `codex-usage-tracker summary --group-by thread --limit 10 --json`. The summary is already ordered by `total_tokens` descending.
 - Answer thread-ranking requests directly from the summary rows. For the heaviest-thread question, lead with the first row's thread and total tokens; for leaderboard requests, show a compact ranked list.
-- If the CLI command is missing for dashboard-open requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli serve-dashboard --refresh --context-api explicit --open`. Use the source-checkout `open-dashboard --refresh` fallback only for static/offline snapshots or when a long-running server cannot be kept alive.
+- If the CLI command is missing for dashboard-open requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli serve-dashboard --context-api explicit --open`. Use the source-checkout `open-dashboard` fallback only for static/offline snapshots or when a long-running server cannot be kept alive.
 - If the CLI command is missing for thread-ranking requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli refresh --json` and `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli summary --group-by thread --limit 10 --json`.
 - If neither command is available, say briefly that the tracker CLI is not on `PATH` and ask the user to run `codex-usage-tracker setup` or reinstall with `pipx`.
 - Keep dashboard-open narration minimal: one short progress note if needed, then the localhost URL, or if falling back to a static file, the file path plus a note that Live requires `serve-dashboard`. Do not narrate plugin discovery.

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/skills/codex-usage-tracker/scripts/run_mcp.py

@@ -15,9 +15,9 @@ from pathlib import Path
 
 PACKAGE_SPEC = os.environ.get(
     "CODEX_USAGE_TRACKER_PACKAGE_SPEC",
-    "git+https://github.com/douglasmonsky/codex-usage-tracker.git@97cd456bffaf41cbb14cd8afffcf6f37ad8a242d",
+    "git+https://github.com/douglasmonsky/codex-usage-tracker.git@262f51960747a3eb061602e92c929684f8490adb",
 )
-RUNTIME_VERSION = "0.3.1"
+RUNTIME_VERSION = "0.3.2"
 PACKAGE_SPEC_MARKER = ".codex-usage-tracker-package-spec"
 MODULE_CHECK = (
     "import importlib.metadata; "

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/__init__.py

@@ -2,6 +2,6 @@
 
 from codex_usage_tracker.models import UsageEvent
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 __all__ = ["UsageEvent", "__version__"]

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/cli.py

@@ -394,8 +394,12 @@ def _add_dashboard_parsers(
     )
     open_dashboard.add_argument(
         "--refresh",
-        action="store_true",
-        help="Refresh the SQLite index before generating the dashboard",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Refresh the SQLite index before generating the dashboard. "
+            "This is the default; use --no-refresh to open the cached index only."
+        ),
     )
     open_dashboard.add_argument("--codex-home", type=Path, default=DEFAULT_CODEX_HOME)
     open_dashboard.add_argument("--json", action="store_true", dest="as_json")
@@ -419,13 +423,17 @@ def _add_dashboard_parsers(
     serve.add_argument(
         "--no-context-api",
         action="store_true",
-        help="Serve aggregate dashboard refresh only and disable /api/context.",
+        help="Start with dashboard context loading off; it can be enabled from the local dashboard.",
     )
     serve.add_argument("--open", action="store_true")
     serve.add_argument(
         "--refresh",
-        action="store_true",
-        help="Refresh the SQLite index before generating and serving the dashboard",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Refresh the SQLite index before generating and serving the dashboard. "
+            "This is the default; use --no-refresh to serve the cached index only."
+        ),
     )
     serve.add_argument("--codex-home", type=Path, default=DEFAULT_CODEX_HOME)
     serve.add_argument("--include-archived", action="store_true")

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/plugin_data/dashboard/dashboard.css

@@ -875,6 +875,11 @@
       cursor: pointer;
     }
     .context-button:hover { background: #eff6ff; }
+    .context-button:disabled {
+      cursor: not-allowed;
+      opacity: 0.62;
+      background: var(--panel);
+    }
     .context-button.secondary { color: var(--muted); }
     .context-result {
       margin-top: 12px;

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/plugin_data/dashboard/dashboard.js

@@ -1345,17 +1345,24 @@
     }
     function contextControls(row) {
       const fileMode = window.location.protocol === 'file:';
-      const apiUnavailable = !contextApiEnabled || !apiToken;
-      const disabled = fileMode || apiUnavailable ? ' disabled' : '';
+      const apiMissing = !apiToken;
+      const apiDisabled = !contextApiEnabled;
+      const disabled = fileMode || apiMissing || apiDisabled ? ' disabled' : '';
       const hint = fileMode
         ? 'Open this dashboard with codex-usage-tracker serve-dashboard to load raw context on demand.'
-        : apiUnavailable
-          ? 'Context loading is disabled for this dashboard server. Restart with --context-api explicit to enable explicit row actions.'
+        : apiMissing
+          ? 'Context loading requires a localhost dashboard API token.'
+          : apiDisabled
+            ? 'Context loading is off for this dashboard server. Enable it here to load local JSONL context on demand.'
           : 'Context is not embedded in this dashboard. Press a button to read this call from the local JSONL source.';
+      const enableButton = !fileMode && !apiMissing && apiDisabled
+        ? '<button class="context-button" type="button" data-context-enable>Enable context loading</button>'
+        : '';
       return `
         <div class="context-actions">
           <button class="context-button" type="button" data-context-load${disabled}>Load context</button>
           <button class="context-button secondary" type="button" data-context-load-output${disabled}>Include tool output</button>
+          ${enableButton}
         </div>
         <div id="contextResult" class="context-result"><p class="context-note">${escapeHtml(hint)}</p></div>
       `;
@@ -1363,8 +1370,38 @@
     function bindContextButtons(row) {
       const loadButton = detailEl.querySelector('[data-context-load]');
       const outputButton = detailEl.querySelector('[data-context-load-output]');
+      const enableButton = detailEl.querySelector('[data-context-enable]');
       if (loadButton) loadButton.addEventListener('click', () => loadContext(row, false));
       if (outputButton) outputButton.addEventListener('click', () => loadContext(row, true));
+      if (enableButton) enableButton.addEventListener('click', () => enableContextApi(row));
+    }
+    async function enableContextApi(row) {
+      const target = document.getElementById('contextResult');
+      if (!target) return;
+      target.innerHTML = '<p class="context-note">Enabling context loading for this dashboard server...</p>';
+      try {
+        const params = new URLSearchParams({ enabled: '1', _: String(Date.now()) });
+        const response = await fetch(`/api/context-settings?${params.toString()}`, {
+          headers: {
+            'Accept': 'application/json',
+            'X-Codex-Usage-Token': apiToken,
+          },
+          cache: 'no-store',
+        });
+        if (!response.ok) {
+          throw new Error(`Context settings returned HTTP ${response.status}.`);
+        }
+        const payload = await response.json();
+        if (payload.error) throw new Error(payload.error);
+        contextApiEnabled = Boolean(payload.context_api_enabled);
+        showDetail(row);
+        const nextTarget = document.getElementById('contextResult');
+        if (nextTarget && contextApiEnabled) {
+          nextTarget.innerHTML = '<p class="context-note">Context loading is enabled. Press Load context to read this call from the local JSONL source.</p>';
+        }
+      } catch (error) {
+        target.innerHTML = `<p class="context-note">${escapeHtml(error.message || String(error))}</p>`;
+      }
     }
     async function loadContext(row, includeToolOutput) {
       const target = document.getElementById('contextResult');

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/plugin_data/docs/dashboard-guide.html

@@ -86,8 +86,9 @@ codex-usage-tracker serve-dashboard --open</code></pre>
     <p>To tune review thresholds locally, run <code>codex-usage-tracker init-thresholds</code> and edit <code>~/.codex-usage-tracker/thresholds.json</code>. These thresholds control low-cache, high-context, high-uncached-input, large-thread, reasoning-spike, low-output, and high-cost recommendations.</p>
     <p>To tune project attribution locally, run <code>codex-usage-tracker init-projects</code> and edit <code>~/.codex-usage-tracker/projects.json</code>. The dashboard derives project name, relative cwd, branch, tags, and a hashed remote origin from aggregate <code>cwd</code> and local Git metadata when available.</p>
     <p>Before sharing screenshots or generated artifacts, put <code>--privacy-mode redacted</code> or <code>--privacy-mode strict</code> before the subcommand, such as <code>codex-usage-tracker --privacy-mode strict serve-dashboard --open</code>. Redacted mode hides raw cwd/source paths, hides Git remote labels, and hashes unnamed projects while preserving configured aliases. Strict mode also hides project-relative cwd, Git branch, and tags. The dashboard header shows the active metadata mode.</p>
-    <p>The server enables live aggregate refresh and on-demand context loading. Static file mode can still filter, sort, and inspect aggregate fields, but cannot refresh logs or load context.</p>
-    <p>The localhost server uses a random per-server token for refresh and context API calls, validates loopback <code>Host</code> and <code>Origin</code> headers, and can run as aggregate-only with <code>codex-usage-tracker serve-dashboard --no-context-api</code>.</p>
+    <p><code>serve-dashboard</code> refreshes active-session logs before opening by default. Use <code>--no-refresh</code> only when you intentionally want a cached view of the existing local index.</p>
+    <p>The server enables live aggregate refresh and on-demand context loading. Static file mode can still filter, sort, and inspect aggregate fields. <code>open-dashboard</code> refreshes before writing the snapshot unless you pass <code>--no-refresh</code>. Static files cannot refresh logs or load context after opening.</p>
+    <p>The localhost server uses a random per-server token for refresh and context API calls, validates loopback <code>Host</code> and <code>Origin</code> headers, and can start with context loading off through <code>codex-usage-tracker serve-dashboard --no-context-api</code>.</p>
 
     <h2>Insights View</h2>
     <img src="assets/dashboard-insights.png" alt="Insights view with ranked attention cards, investigation presets, and top threads by attention score.">
@@ -121,7 +122,7 @@ codex-usage-tracker serve-dashboard --open</code></pre>
 
     <h2>Details And Context</h2>
     <img src="assets/dashboard-details.png" alt="Details panel showing aggregate usage fields for a selected call.">
-    <p>The details panel shows primary cost, Codex credits, allowance impact, cache, context, pricing, and next-action signals first. It then groups thread narrative, token/pricing breakdowns, credit confidence and rate-card source metadata, collapsed raw identifiers, and source metadata. When served from localhost with the context API enabled, <code>Load context</code> fetches one redacted, size-limited source excerpt on demand. When started with <code>--no-context-api</code>, context buttons stay disabled and the dashboard remains aggregate-only.</p>
+    <p>The details panel shows primary cost, Codex credits, allowance impact, cache, context, pricing, and next-action signals first. It then groups thread narrative, token/pricing breakdowns, credit confidence and rate-card source metadata, collapsed raw identifiers, and source metadata. When served from localhost with the context API enabled, <code>Load context</code> fetches one redacted, size-limited source excerpt on demand. When started with <code>--no-context-api</code>, context loading starts off; use <code>Enable context loading</code> in the details panel when you want to allow explicit row actions without restarting the dashboard server.</p>
 
     <h2>Investigating Long Chat Growth</h2>
     <p class="note">Prompt caching helps, but cached input is not free. Long-running chats can carry a large cached prefix into later turns, so usage can climb quickly even when the visible request looks small.</p>

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2/src/codex_usage_tracker/plugin_data}/skills/codex-usage-api/SKILL.md

@@ -17,7 +17,7 @@ The only exception is `usage_call_context`, which reads one selected record's lo
 
 ## First Steps
 
-1. For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --refresh --context-api explicit --open` so Refresh and Live can use the local API, then report the localhost URL or a brief failure. Use `codex-usage-tracker open-dashboard --refresh` only for explicit static/offline snapshots or when the environment cannot keep a long-running server process alive; if you fall back, say the dashboard is static and Live requires `serve-dashboard`.
+1. For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --context-api explicit --open` so Refresh and Live can use the local API, then report the localhost URL or a brief failure. Refresh is the default for dashboard launch commands; use `--no-refresh` only when the user explicitly asks for a cached snapshot. Use `codex-usage-tracker open-dashboard` only for explicit static/offline snapshots or when the environment cannot keep a long-running server process alive; if you fall back, say the dashboard is static and Live requires `serve-dashboard`.
 2. For "Heaviest thread?", "Thread leaderboard", or similar thread-ranking requests, do not inspect repository files, SQLite schemas, plugin manifests, process lists, dashboard servers, or local logs manually. Refresh the aggregate index, then call `usage_summary(group_by="thread", limit=10, response_format="json")`. If MCP tools are unavailable, run `codex-usage-tracker refresh --json` and `codex-usage-tracker summary --group-by thread --limit 10 --json`.
 3. For normal usage questions, do not inspect repository files, plugin manifests, or local logs first. Start with the aggregate MCP tools. If MCP tools are unavailable, use the CLI JSON fallback below.
 4. Refresh before analysis with `refresh_usage_index` unless the user asks for a static historical snapshot. Keep archived sessions excluded unless the user explicitly asks for all history.

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2/src/codex_usage_tracker/plugin_data}/skills/codex-usage-tracker/SKILL.md

@@ -17,11 +17,11 @@ The only exception is `usage_call_context`, which intentionally reads one select
 
 ## Fast Paths
 
-- For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --refresh --context-api explicit --open` so Refresh, Live, load-limit, and history-scope controls can call the local API. Keep the server running while the user is using the dashboard. Use `codex-usage-tracker open-dashboard --refresh` only when the user explicitly asks for a static/offline snapshot or when the current environment cannot keep a server process running, and say that the result is static and Live requires `serve-dashboard`.
+- For "Open dashboard" or similar dashboard-open requests, do not inspect repository files, plugin manifests, tool registries, git status, or local logs first. Start the live localhost dashboard with `codex-usage-tracker serve-dashboard --context-api explicit --open` so Refresh, Live, load-limit, and history-scope controls can call the local API. Refresh is the default for dashboard launch commands; use `--no-refresh` only when the user explicitly asks for a cached snapshot. Keep the server running while the user is using the dashboard. Use `codex-usage-tracker open-dashboard` only when the user explicitly asks for a static/offline snapshot or when the current environment cannot keep a server process running, and say that the result is static and Live requires `serve-dashboard`.
 - For "Heaviest thread?", "Thread leaderboard", or similar thread-ranking requests, do not inspect repository files, SQLite schemas, plugin manifests, process lists, dashboard servers, or local logs manually. Use the tracker API: refresh the aggregate index, then rank threads with `usage_summary(group_by="thread", limit=10, response_format="json")`.
 - If MCP tools are unavailable for thread-ranking requests, run `codex-usage-tracker refresh --json` and `codex-usage-tracker summary --group-by thread --limit 10 --json`. The summary is already ordered by `total_tokens` descending.
 - Answer thread-ranking requests directly from the summary rows. For the heaviest-thread question, lead with the first row's thread and total tokens; for leaderboard requests, show a compact ranked list.
-- If the CLI command is missing for dashboard-open requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli serve-dashboard --refresh --context-api explicit --open`. Use the source-checkout `open-dashboard --refresh` fallback only for static/offline snapshots or when a long-running server cannot be kept alive.
+- If the CLI command is missing for dashboard-open requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli serve-dashboard --context-api explicit --open`. Use the source-checkout `open-dashboard` fallback only for static/offline snapshots or when a long-running server cannot be kept alive.
 - If the CLI command is missing for thread-ranking requests and you are already inside the source checkout, use `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli refresh --json` and `PYTHONPATH=src .venv/bin/python -m codex_usage_tracker.cli summary --group-by thread --limit 10 --json`.
 - If neither command is available, say briefly that the tracker CLI is not on `PATH` and ask the user to run `codex-usage-tracker setup` or reinstall with `pipx`.
 - Keep dashboard-open narration minimal: one short progress note if needed, then the localhost URL, or if falling back to a static file, the file path plus a note that Live requires `serve-dashboard`. Do not narrate plugin discovery.

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracker/server.py

@@ -30,6 +30,21 @@ from codex_usage_tracker.paths import (
 from codex_usage_tracker.store import refresh_usage_index
 
 
+class _ContextApiState:
+    def __init__(self, enabled: bool) -> None:
+        self._enabled = enabled
+        self._lock = threading.Lock()
+
+    @property
+    def enabled(self) -> bool:
+        with self._lock:
+            return self._enabled
+
+    def set_enabled(self, enabled: bool) -> None:
+        with self._lock:
+            self._enabled = enabled
+
+
 def serve_dashboard(
     db_path: Path,
     output_path: Path = DEFAULT_DASHBOARD_PATH,
@@ -55,6 +70,7 @@ def serve_dashboard(
     _validate_context_api_mode(context_api)
     api_token = secrets.token_urlsafe(32)
     context_api_enabled = context_api != "disabled"
+    context_api_state = _ContextApiState(context_api_enabled)
     output = generate_dashboard(
         db_path=db_path,
         output_path=output_path,
@@ -87,13 +103,17 @@ def serve_dashboard(
         dashboard_name=output.name,
         context_chars=context_chars,
         api_token=api_token,
-        context_api_enabled=context_api_enabled,
+        context_api_state=context_api_state,
         refresh_lock=threading.Lock(),
     )
     server = ThreadingHTTPServer((host, port), handler)
     url = f"http://{_url_host(host)}:{port}/{output.name}"
     print(f"Serving Codex usage dashboard at {url}")
-    context_mode = "enabled for explicit row actions" if context_api_enabled else "disabled"
+    context_mode = (
+        "enabled for explicit row actions"
+        if context_api_enabled
+        else "disabled until enabled from the dashboard"
+    )
     print("Aggregate rows refresh through /api/usage with a per-server token.")
     print(f"Raw context API is {context_mode}; context is never embedded in the dashboard HTML.")
     if open_browser:
@@ -122,8 +142,9 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
         dashboard_name: str,
         context_chars: int,
         api_token: str,
-        context_api_enabled: bool,
         refresh_lock: threading.Lock,
+        context_api_enabled: bool = False,
+        context_api_state: _ContextApiState | None = None,
         privacy_mode: str = "normal",
         rate_card_path: Path = DEFAULT_RATE_CARD_PATH,
         **kwargs: object,
@@ -142,7 +163,7 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
         self._dashboard_name = dashboard_name
         self._context_chars = context_chars
         self._api_token = api_token
-        self._context_api_enabled = context_api_enabled
+        self._context_api_state = context_api_state or _ContextApiState(context_api_enabled)
         self._refresh_lock = refresh_lock
         super().__init__(*args, **kwargs)
 
@@ -154,6 +175,9 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
         if parsed.path == "/api/context":
             self._handle_context(parsed.query)
             return
+        if parsed.path == "/api/context-settings":
+            self._handle_context_settings(parsed.query)
+            return
         if parsed.path == "/api/usage":
             self._handle_usage(parsed.query)
             return
@@ -179,10 +203,14 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
 
     def _handle_context(self, query: str) -> None:
         params = parse_qs(query)
-        if not self._context_api_enabled:
+        if not self._context_api_state.enabled:
             self._send_json(
                 HTTPStatus.FORBIDDEN,
-                {"error": "Context API is disabled for this dashboard server."},
+                {
+                    "error": "Context loading is disabled for this dashboard server.",
+                    "context_api_enabled": False,
+                    "can_enable_context_api": True,
+                },
             )
             return
         if not self._has_valid_api_token(params):
@@ -223,6 +251,22 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
             return
         self._send_json(HTTPStatus.OK, payload)
 
+    def _handle_context_settings(self, query: str) -> None:
+        params = parse_qs(query)
+        if not self._has_valid_api_token(params):
+            self._send_json(HTTPStatus.FORBIDDEN, {"error": "Valid API token is required"})
+            return
+        enabled = _parse_bool(_first(params.get("enabled")), True)
+        self._context_api_state.set_enabled(enabled)
+        self._send_json(
+            HTTPStatus.OK,
+            {
+                "schema": "codex-usage-tracker-context-settings-v1",
+                "context_api_enabled": self._context_api_state.enabled,
+                "raw_context_persisted": False,
+            },
+        )
+
     def _handle_usage(self, query: str) -> None:
         params = parse_qs(query)
         limit = _parse_limit(_first(params.get("limit")), self._limit)
@@ -264,7 +308,7 @@ class _UsageDashboardHandler(SimpleHTTPRequestHandler):
                 privacy_mode=self._privacy_mode,
                 since=self._since,
                 api_token=self._api_token,
-                context_api_enabled=self._context_api_enabled,
+                context_api_enabled=self._context_api_state.enabled,
                 include_archived=include_archived,
             )
         except sqlite3.Error as exc:

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/src/codex_usage_tracking.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-usage-tracking
-Version: 0.3.1
+Version: 0.3.2
 Summary: Unofficial local Codex plugin and dashboard for investigating aggregate token usage, costs, caching, and thread patterns.
 Author: Douglas Monsky
 License-Expression: MIT
@@ -68,6 +68,8 @@ codex-usage-tracker serve-dashboard --open
 
 Use your normal Python launcher for your platform: `python3` is common on macOS/Linux, and `py` may be preferable on Windows. On macOS with Homebrew, `brew install pipx` is also fine.
 
+`serve-dashboard` refreshes active-session usage before opening by default. Use `--no-refresh` only when you intentionally want to inspect the cached local index.
+
 Package naming: the PyPI distribution is `codex-usage-tracking`; the installed command is `codex-usage-tracker`; the GitHub repository remains `douglasmonsky/codex-usage-tracker`. The `codex-usage-tracker` PyPI name is not this project, so avoid similarly named packages when following these docs.
 
 Source install for development or branch testing:
@@ -193,7 +195,7 @@ codex-usage-tracker summary --preset last-7-days
 codex-usage-tracker query --since 2026-06-01 --min-credits 1
 codex-usage-tracker session <session-id>
 codex-usage-tracker export --output usage.csv
-codex-usage-tracker dashboard --open
+codex-usage-tracker open-dashboard
 codex-usage-tracker support-bundle --output ~/.codex-usage-tracker/support-bundle.json
 ```
 
@@ -205,7 +207,7 @@ The tracker stores aggregate metrics only: session ids, timestamps, local source
 
 It does **not** store prompts, assistant messages, tool output, pasted secrets, raw transcript snippets, or raw context in SQLite, CSV exports, generated dashboard HTML, or synthetic screenshots.
 
-On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can be disabled with:
+On-demand context loading reads a single original local JSONL file only after an explicit row action, redacts common secret patterns, caps returned text size, and can start off until you enable it from the details panel:
 
 ```bash
 codex-usage-tracker serve-dashboard --no-context-api --open

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/tests/test_cli_release.py

@@ -20,7 +20,7 @@ def test_module_cli_version() -> None:
         env=_subprocess_env(),
     )
 
-    assert "codex-usage-tracker 0.3.1" in result.stdout
+    assert "codex-usage-tracker 0.3.2" in result.stdout
 
 
 def test_release_check_script_passes() -> None:
@@ -91,15 +91,29 @@ def test_usage_skills_prefer_live_dashboard_for_open_requests() -> None:
 
     for skill_path in skill_paths:
         skill_text = skill_path.read_text(encoding="utf-8")
-        live_command_index = skill_text.find("serve-dashboard --refresh --context-api explicit --open")
-        static_command_index = skill_text.find("open-dashboard --refresh")
+        live_command_index = skill_text.find("serve-dashboard --context-api explicit --open")
+        static_command_index = skill_text.find("open-dashboard")
 
         assert live_command_index != -1, skill_path
         assert static_command_index != -1, skill_path
         assert live_command_index < static_command_index, skill_path
+        assert "Refresh is the default" in skill_text
         assert "Live requires `serve-dashboard`" in skill_text
 
 
+def test_dashboard_launch_commands_refresh_by_default() -> None:
+    from codex_usage_tracker.cli import _build_parser
+
+    parser = _build_parser()
+
+    assert parser.parse_args(["open-dashboard"]).refresh is True
+    assert parser.parse_args(["open-dashboard", "--refresh"]).refresh is True
+    assert parser.parse_args(["open-dashboard", "--no-refresh"]).refresh is False
+    assert parser.parse_args(["serve-dashboard"]).refresh is True
+    assert parser.parse_args(["serve-dashboard", "--refresh"]).refresh is True
+    assert parser.parse_args(["serve-dashboard", "--no-refresh"]).refresh is False
+
+
 def test_cli_json_schema_doc_lists_tracked_contracts() -> None:
     repo_root = Path(__file__).resolve().parents[1]
     docs = (repo_root / "docs" / "cli-json-schemas.md").read_text(encoding="utf-8")

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/tests/test_plugin_installer.py

@@ -34,7 +34,7 @@ def test_install_plugin_writes_generated_wrapper_and_marketplace(tmp_path: Path)
     assert result.replaced_existing is False
     assert second.replaced_existing is False
     assert manifest["name"] == "codex-usage-tracker"
-    assert manifest["version"] == "0.3.1"
+    assert manifest["version"] == "0.3.2"
     assert manifest["interface"]["defaultPrompt"][:3] == [
         "Open dashboard",
         "Heaviest thread?",

{codex_usage_tracking-0.3.1 → codex_usage_tracking-0.3.2}/tests/test_store_dashboard_mcp.py

@@ -833,42 +833,83 @@ def test_dashboard_server_returns_json_for_sqlite_errors(tmp_path: Path, monkeyp
     assert "Database error" in context_error["payload"]["error"]
 
 
-def test_dashboard_server_can_disable_context_api(tmp_path: Path) -> None:
-    from codex_usage_tracker.server import _UsageDashboardHandler
+def test_dashboard_server_can_enable_context_api_at_runtime(tmp_path: Path) -> None:
+    from codex_usage_tracker.server import _ContextApiState, _UsageDashboardHandler
+
+    codex_home = _make_codex_home(tmp_path)
+    db_path = tmp_path / "usage.sqlite3"
+    refresh_usage_index(codex_home=codex_home, db_path=db_path)
+    record_id = query_session_usage(db_path=db_path, session_id=SESSION_ID)[0]["record_id"]
+    context_api_state = _ContextApiState(False)
 
     handler = partial(
         _UsageDashboardHandler,
         directory=str(tmp_path),
-        db_path=tmp_path / "usage.sqlite3",
+        db_path=db_path,
         pricing_path=tmp_path / "pricing.json",
         allowance_path=tmp_path / "allowance.json",
         thresholds_path=tmp_path / "thresholds.json",
         projects_path=tmp_path / "projects.json",
         limit=5000,
         since=None,
-        codex_home=tmp_path / ".codex",
+        codex_home=codex_home,
         include_archived=False,
         dashboard_name="dashboard.html",
         context_chars=2000,
         api_token="test-token",
-        context_api_enabled=False,
+        context_api_state=context_api_state,
         refresh_lock=threading.Lock(),
     )
     server = ThreadingHTTPServer(("127.0.0.1", 0), handler)
     thread = threading.Thread(target=server.serve_forever, daemon=True)
     thread.start()
     try:
-        context_error = _http_error_json(
-            f"http://127.0.0.1:{server.server_port}/api/context?record_id=abc",
+        disabled_error = _http_error_json(
+            f"http://127.0.0.1:{server.server_port}/api/context?record_id={record_id}",
             headers={"X-Codex-Usage-Token": "test-token"},
         )
+        enable_without_token = _http_error_json(
+            f"http://127.0.0.1:{server.server_port}/api/context-settings?enabled=1"
+        )
+        with urllib.request.urlopen(  # noqa: S310 - local test server only
+            urllib.request.Request(
+                f"http://127.0.0.1:{server.server_port}/api/context-settings?enabled=1",
+                headers={"X-Codex-Usage-Token": "test-token"},
+            ),
+            timeout=5,
+        ) as response:
+            settings_payload = json.loads(response.read().decode("utf-8"))
+        with urllib.request.urlopen(  # noqa: S310 - local test server only
+            urllib.request.Request(
+                f"http://127.0.0.1:{server.server_port}/api/usage?limit=1",
+                headers={"X-Codex-Usage-Token": "test-token"},
+            ),
+            timeout=5,
+        ) as response:
+            usage_payload = json.loads(response.read().decode("utf-8"))
+        with urllib.request.urlopen(  # noqa: S310 - local test server only
+            urllib.request.Request(
+                f"http://127.0.0.1:{server.server_port}/api/context?record_id={record_id}",
+                headers={"X-Codex-Usage-Token": "test-token"},
+            ),
+            timeout=5,
+        ) as response:
+            context_payload = json.loads(response.read().decode("utf-8"))
     finally:
         server.shutdown()
         server.server_close()
         thread.join(timeout=5)
 
-    assert context_error["status"] == 403
-    assert "disabled" in context_error["payload"]["error"]
+    assert disabled_error["status"] == 403
+    assert disabled_error["payload"]["context_api_enabled"] is False
+    assert disabled_error["payload"]["can_enable_context_api"] is True
+    assert enable_without_token["status"] == 403
+    assert settings_payload["schema"] == "codex-usage-tracker-context-settings-v1"
+    assert settings_payload["context_api_enabled"] is True
+    assert settings_payload["raw_context_persisted"] is False
+    assert usage_payload["context_api_enabled"] is True
+    assert context_payload["loaded_on_demand"] is True
+    assert context_payload["raw_context_persisted"] is False
 
 
 def test_dashboard_query_limit_zero_loads_all_rows(tmp_path: Path) -> None: