feat: v5.8.7 — per-session VS Code extension, fairer efficiency, self-healing dashboard

VS Code extension: resolve the status bar to this window's workspace session
(no cross-session bleed), compute context fill from transcript tokens ÷ the real
context window (correct for 200k and 1M sessions), add an expanded click-to-open
status panel, brighter grey for secondary info, honest no-folder/warming-up
states, and drop the Regime indicator.

Efficiency metric: a brand-new session no longer scores low for having no
decisions yet — decision density stays neutral until there's enough conversation
to judge, so a fresh session reads high instead of mid-B. Established low-density
sessions are still scored normally.

Dashboard daemon: self-heal a stale tombstone instead of staying dead until
re-setup, and regenerate the dashboard in the background when it's opened stale,
so the localhost view reflects recent activity.

Status line: show 5h/7d usage limits with reset times, brighter grey, regime removed.

Author: alexgreensh

.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "name": "token-optimizer",
       "source": "./",
       "description": "Audit, fix, and monitor Claude Code context window usage. Find the ghost tokens.",
-      "version": "5.8.6",
+      "version": "5.8.7",
       "author": {
         "name": "Alex Greenshpun",
         "url": "https://linkedin.com/in/alexgreensh"

.claude-plugin/plugin.json

@@ -7,7 +7,7 @@
   },
   "homepage": "https://github.com/alexgreensh/token-optimizer",
   "repository": "https://github.com/alexgreensh/token-optimizer",
-  "version": "5.8.6",
+  "version": "5.8.7",
   "license": "PolyForm-Noncommercial-1.0.0",
   "keywords": ["token", "optimization", "context", "audit", "cost", "coach"]
 }

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "token-optimizer",
-  "version": "5.8.6",
+  "version": "5.8.7",
   "description": "Audit, monitor, and reduce Codex context waste with continuity helpers and explicit outline tools.",
   "skills": "./skills/",
   "interface": {

skills/token-optimizer/scripts/measure.py

@@ -9876,7 +9876,7 @@ def setup_hook(dry_run=False):
 
 # ========== Persistent Dashboard Daemon ==========
 
-TOKEN_OPTIMIZER_VERSION = "5.8.6"  # Keep in sync with plugin.json + marketplace.json
+TOKEN_OPTIMIZER_VERSION = "5.8.7"  # Keep in sync with plugin.json + marketplace.json
 _DASHBOARD_CSP = "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com; connect-src 'self'; img-src 'self' data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
 _DAEMON_RUNTIME = detect_runtime()
 _DAEMON_RUNTIME_SUFFIX = "codex" if _DAEMON_RUNTIME == "codex" else "claude"
@@ -10018,6 +10018,12 @@ def _generate_daemon_script():
 # respawning us. Uninstall also writes this tombstone directly.
 THRASH_LIMIT = 3
 
+# Freshness-on-open: if the cached dashboard HTML is older than this when a GET
+# arrives, kick off one background regen (throttled by the same interval) and
+# serve the current file immediately, so the next open reflects recent activity.
+DASHBOARD_FRESH_SECONDS = 120
+_last_regen = 0.0
+
 
 def _read_token():
     """Read per-install CSRF token from disk. Empty string if missing/unreadable."""
@@ -10144,11 +10150,36 @@ def _serve_or_redirect(self, method):
         if not self._require_localhost():
             return
         if self._is_dashboard_request():
+            if method == "do_GET":
+                self._maybe_refresh_dashboard()
             self.path = "/" + os.path.basename(DASHBOARD)
             getattr(super(), method)()
         else:
             self.send_error(403, "Forbidden")
 
+    def _maybe_refresh_dashboard(self):
+        # Stale-while-revalidate: serve the current HTML now, and if it's stale
+        # kick off ONE throttled background regen so the next open is fresh. Never
+        # blocks the request; failures are silently ignored (best-effort).
+        global _last_regen
+        try:
+            mtime = os.path.getmtime(DASHBOARD)
+        except OSError:
+            return
+        now = time.time()
+        if now - mtime <= DASHBOARD_FRESH_SECONDS or now - _last_regen <= DASHBOARD_FRESH_SECONDS:
+            return
+        _last_regen = now
+        try:
+            import subprocess
+            subprocess.Popen(
+                [sys.executable, {measure_py_literal}, "dashboard", "--quiet"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL, close_fds=True,
+            )
+        except (OSError, ValueError):
+            pass
+
     def do_OPTIONS(self):
         self.send_response(200)
         origin = self.headers.get("Origin", "")
@@ -10238,7 +10269,22 @@ def _thrash_check_and_update():
             size = 0
         # Size 0 = uninstall tombstone. >0 = thrash counter; process it below.
         if size == 0:
-            return False
+            # Honor it only if FRESH (an uninstall genuinely in progress). A real
+            # uninstall removes the plist + this very script within milliseconds,
+            # so a stale 0-byte tombstone sitting next to a healthy dashboard with
+            # this daemon still running is a stuck state, not an uninstall — clear
+            # it and serve. This self-heals daemons wrongly tombstoned by an
+            # update-window thrash, instead of staying dead until setup-daemon.
+            try:
+                age = time.time() - os.path.getmtime(THRASH_PATH)
+            except OSError:
+                age = 0  # unreadable mtime: treat as fresh, preserve uninstall safety
+            if age < 60:
+                return False
+            try:
+                os.unlink(THRASH_PATH)
+            except OSError:
+                pass
 
     if os.path.exists(DASHBOARD):
         # Healthy start: clear any thrash counter.
@@ -11979,6 +12025,10 @@ def _float_env(key: str, default: float) -> float:
 # use only the last N operations to prevent denominator-expansion bias where
 # scores climb as the session progresses even though context health is degrading.
 _QUALITY_ROLLING_WINDOW = _int_env("TOKEN_OPTIMIZER_QUALITY_WINDOW", 20)
+# Below this many messages a session is too new to judge decision density — a
+# brand-new session hasn't accumulated decisions yet, so scoring it 0 would
+# wrongly drag SessionEfficiency down ~20 points. Stay neutral instead.
+_DENSITY_MIN_MESSAGES = _int_env("TOKEN_OPTIMIZER_DENSITY_MIN_MESSAGES", 6)
 
 # Fill-based warning thresholds that fire independently of the composite score.
 # These cannot be masked by improving ratio signals.
@@ -12528,12 +12578,14 @@ def compute_quality_score(quality_data, session_id=None):
     window_messages = all_messages[-_QUALITY_ROLLING_WINDOW:]
     substantive = sum(1 for _, _, _, s in window_messages if s)
     window_msg_count = len(window_messages)
-    if window_msg_count > 0:
+    if window_msg_count >= _DENSITY_MIN_MESSAGES:
         density_ratio = substantive / window_msg_count
         density_score = min(100, density_ratio * 200)  # 50% substantive = 100
     else:
-        density_ratio = 0
-        density_score = 50
+        # Too few messages to judge decision density (brand-new session). Stay
+        # neutral instead of penalizing — mirrors agent_efficiency's no-data 80.
+        density_ratio = substantive / window_msg_count if window_msg_count else 0
+        density_score = 80
 
     # 6. Agent efficiency: rolling window over last N dispatches.
     all_dispatches = quality_data["agent_dispatches"]

skills/token-optimizer/scripts/statusline.js

@@ -29,7 +29,9 @@ process.stdin.on('end', () => {
     // status line, persisted nowhere else, so we bridge it to a sidecar file
     // for the VS Code companion (rate limits are account-wide, not per-session).
     const rateLimits = data.rate_limits || null;
-    const DIM = '\x1b[2m';
+    // A readable medium grey instead of ANSI faint (\x1b[2m), which renders too
+    // low-contrast for secondary info like session time on most terminals.
+    const DIM = '\x1b[38;5;245m';
     const RESET = '\x1b[0m';
     const SEP = ` ${DIM}|${RESET} `;
     const gradeFor = (s) => s >= 90 ? 'S' : s >= 80 ? 'A' : s >= 70 ? 'B' : s >= 55 ? 'C' : s >= 40 ? 'D' : 'F';
@@ -199,8 +201,6 @@ process.stdin.on('end', () => {
         } else if (fw.level === 'WARNING') {
           row2Parts.push(`\x1b[33mFill:${Math.round(fw.fill_pct)}%${RESET}`);
         }
-      } else if (q.regime_change) {
-        row2Parts.push(`\x1b[33mRegime:${Math.round(q.regime_change.fill_pct)}%${RESET}`);
       }
 
       // Tool call fatigue warning

vscode-extension/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.1.8
+
+- Hardening pass: runtime-allowlist the panel's actions, dedupe fill clamping, and make warnings array-based (no join/re-split). No behavior change.
+
+## 0.1.7
+
+- Improve: brighter, higher-contrast grey for secondary info (session time, labels, reset times) in the panel and terminal status line — the old faint grey was hard to read.
+
+## 0.1.6
+
+- Remove: the "Regime" indicator (obscure context-fill-shift signal that confused more than it helped). The underlying detection stays in the plugin; it's just off the status line now.
+
+## 0.1.5
+
+- Fix: context fill is now computed from the transcript's own token count divided by the real context window (from the quality-cache's `model_context_window`). This is the only source that's correct for both 200k and 1M-context sessions, and it ignores a 0% fill the plugin sometimes writes when it can't attribute fill.
+
+## 0.1.4
+
+- Fix: context fill is now read from the per-session quality-cache's authoritative `fill_pct` (computed against the real context window), fixing badly-wrong fill on 1M-context sessions. Priority: matched live-fill → quality-cache → transcript tail.
+- Honest: with no folder open, the status bar can't scope to this window's session, so it now says so plainly (in tooltip and panel) instead of showing volatile global data.
+- Note: VS Code shows one status bar per window, so multiple Claude tabs in the same window reflect the most-recently-active session — a platform limitation, now documented.
+
+## 0.1.3
+
+- New: clicking the status bar opens an **expanded status panel** — a focused, theme-matched view of context fill, ContextQ, Eff, warnings, compactions, duration, agents, and 5h/7d limits, live-updating. The full browser dashboard is now an explicit "Open full dashboard" button.
+
+## 0.1.2
+
+- Fix: context fill is now read per-session. The shared `live-fill.json` was leaking one session's fill into other windows; the status bar now uses it only when it matches this window's session, falling back to the transcript otherwise.
+- Improve: the 7-day usage limit now shows the reset **date and days remaining** (e.g. "Jun 4, 8:00pm · in 4d"), not just a time-of-day.
+- Improve: a fresh session with no quality scores yet shows "warming up…" instead of an empty gap.
+
+## 0.1.1
+
+- Fix: the status bar now reflects the Claude Code session for **this** window (scoped to the workspace folder), instead of whichever session was most recently active anywhere. Resolves wrong scores showing in one window when another session is running.
+
 ## 0.1.0
 
 - Initial release: Token Optimizer status line in the VS Code status bar.

vscode-extension/package.json

@@ -2,7 +2,7 @@
   "name": "token-optimizer-statusline",
   "displayName": "Token Optimizer",
   "description": "See your Claude Code context health, efficiency, and usage limits in the VS Code status bar.",
-  "version": "0.1.0",
+  "version": "0.1.8",
   "publisher": "alexgreensh",
   "license": "PolyForm-Noncommercial-1.0.0",
   "icon": "icon.png",
@@ -21,6 +21,10 @@
   "activationEvents": ["onStartupFinished"],
   "contributes": {
     "commands": [
+      {
+        "command": "tokenOptimizer.showStatus",
+        "title": "Token Optimizer: Show Status Panel"
+      },
       {
         "command": "tokenOptimizer.openDashboard",
         "title": "Token Optimizer: Open Dashboard"

vscode-extension/src/cacheReader.ts

@@ -3,17 +3,20 @@
 // unit-testable; the actual fs reads live in dataSource.
 import { Snapshot, RateLimits, AgentInfo, emptySnapshot } from './types';
 import { parseRateWindow } from './rateWindow';
+import { sanitizeSessionId } from './paths';
+import { windowForModel } from './jsonlTail';
 
 const STALE_QUALITY_SECONDS = 300; // mirror statusline.js: score older than 5min => stale
 
 export interface RawInputs {
   qualityJson: string | null;
   liveFillJson: string | null;
   rateLimitsJson: string | null;
-  jsonlFill: number | null;
+  jsonlTokens: number | null; // raw context tokens from the transcript tail
   jsonlModel: string | null;
   effort: string | null;
   sessionId: string | null; // to confirm the cache belongs to the active session
+  scoped: boolean; // resolved via the window's workspace folder?
   nowMs: number;
   staleAfterSeconds: number; // for rate-limit staleness labeling
 }
@@ -64,15 +67,54 @@ export function buildSnapshot(inputs: RawInputs): Snapshot {
 
   snap.model = inputs.jsonlModel;
   snap.effort = inputs.effort;
-
-  // ---- Context fill: live-fill.json wins (authoritative from statusline),
-  // else JSONL tail. ----
-  if (live && typeof live.used_percentage === 'number') {
-    snap.fillPct = Math.max(0, Math.min(100, Math.round(live.used_percentage)));
+  snap.scoped = inputs.scoped;
+
+  // ---- Context fill ----
+  // The only fully reliable per-session fill = the transcript's own token count
+  // divided by the REAL context window. The token count comes from the JSONL
+  // tail (accurate per-session); the window size comes from the quality-cache's
+  // `model_context_window` (so 1M-context sessions aren't mis-scored against
+  // 200k). We do NOT trust:
+  //   - the global live-fill.json unless its session_id matches (it's the last
+  //     terminal's fill, leaks across windows), and
+  //   - the quality-cache's own fill_pct, which measure.py can write as 0 when it
+  //     can't attribute fill (same global-leak problem on the plugin side).
+  // Order: matched live-fill (authoritative) → JSONL tokens ÷ window → qc.fill_pct.
+  const liveSessionId =
+    live && live.session_id ? sanitizeSessionId(String(live.session_id)) : null;
+  const liveMatchesSession =
+    live &&
+    typeof live.used_percentage === 'number' &&
+    !!liveSessionId &&
+    !!inputs.sessionId &&
+    liveSessionId === inputs.sessionId;
+  const windowTokens =
+    isPlainObject(q) &&
+    typeof q.model_context_window === 'number' &&
+    Number.isFinite(q.model_context_window) &&
+    q.model_context_window > 0
+      ? q.model_context_window
+      : windowForModel(inputs.jsonlModel);
+  const jsonlFill =
+    inputs.jsonlTokens != null && Number.isFinite(inputs.jsonlTokens)
+      ? clampScore((inputs.jsonlTokens / windowTokens) * 100)
+      : null;
+  // Only trust a quality-cache fill that rounds above 0 — measure.py writes 0
+  // when it couldn't attribute fill, which we'd rather skip than display.
+  const qcFillRounded =
+    isPlainObject(q) && typeof q.fill_pct === 'number' && Number.isFinite(q.fill_pct)
+      ? clampScore(q.fill_pct)
+      : null;
+  const qcFill = qcFillRounded != null && qcFillRounded > 0 ? qcFillRounded : null;
+  if (liveMatchesSession) {
+    snap.fillPct = clampScore(live.used_percentage);
     snap.fillSource = 'live-fill';
-  } else if (inputs.jsonlFill != null) {
-    snap.fillPct = inputs.jsonlFill;
+  } else if (jsonlFill != null) {
+    snap.fillPct = jsonlFill;
     snap.fillSource = 'jsonl';
+  } else if (qcFill != null) {
+    snap.fillPct = qcFill;
+    snap.fillSource = 'quality';
   }
 
   // ---- Quality scores ----
@@ -108,8 +150,6 @@ export function buildSnapshot(inputs: RawInputs): Snapshot {
         level: q.fill_warning.level,
         value: Math.round(q.fill_warning.fill_pct || 0),
       };
-    } else if (q.regime_change && typeof q.regime_change.fill_pct === 'number') {
-      snap.regimeChangeFillPct = Math.round(q.regime_change.fill_pct);
     }
 
     if (q.tool_call_warning && q.tool_call_warning.level) {

vscode-extension/src/dataSource.ts

@@ -19,6 +19,7 @@ const EFFORT_MAP: Record<string, string> = { low: 'lo', medium: 'med', high: 'hi
 export class DataSource {
   private watcher: vscode.FileSystemWatcher | undefined;
   private focusSub: vscode.Disposable | undefined;
+  private workspaceSub: vscode.Disposable | undefined;
   private timer: NodeJS.Timeout | undefined;
   private debounce: NodeJS.Timeout | undefined;
   private tailer: JsonlTailer | undefined;
@@ -67,11 +68,29 @@ export class DataSource {
     } catch {
       // window state API unavailable — timer + watcher still cover us.
     }
+    try {
+      this.workspaceSub = vscode.workspace.onDidChangeWorkspaceFolders(() => {
+        this.needsRescan = true;
+        this.refresh();
+      });
+    } catch {
+      // ignore — folder rarely changes mid-session.
+    }
     // Defer the first (synchronous, fs-walking) refresh off the activation path
     // so activate() returns immediately and never trips VS Code's >500ms watchdog.
     setImmediate(() => this.refresh());
   }
 
+  // The window's workspace folder, used to scope session resolution to this
+  // window. First folder when a multi-root workspace; undefined if none open.
+  private workspaceDir(): string | null {
+    try {
+      return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   private isFocused(): boolean {
     try {
       return vscode.window.state.focused;
@@ -99,19 +118,21 @@ export class DataSource {
 
   private buildFromDisk(): Snapshot {
     if (this.needsRescan) {
-      this.cachedSession = findActiveSession(this.paths.projectsDir);
+      this.cachedSession = findActiveSession(this.paths.projectsDir, {
+        workspaceDir: this.workspaceDir(),
+      });
       this.cachedEffort = this.readEffort();
       this.needsRescan = false;
     }
     const session = this.cachedSession;
 
-    let jsonlFill: number | null = null;
+    let jsonlTokens: number | null = null;
     let jsonlModel: string | null = null;
     if (session) {
       if (!this.tailer) this.tailer = new JsonlTailer(session.jsonlPath);
       else this.tailer.setPath(session.jsonlPath);
       const tail = this.tailer.read();
-      jsonlFill = tail.fillPct;
+      jsonlTokens = tail.tokens;
       jsonlModel = tail.model;
     } else {
       // No session: drop the tailer so a future session starts from offset 0.
@@ -122,10 +143,11 @@ export class DataSource {
       qualityJson: session ? readIfExists(this.paths.qualityCache(session.sessionId)) : null,
       liveFillJson: readIfExists(this.paths.liveFill),
       rateLimitsJson: readIfExists(this.paths.rateLimits),
-      jsonlFill,
+      jsonlTokens,
       jsonlModel,
       effort: this.cachedEffort,
       sessionId: session ? session.sessionId : null,
+      scoped: this.workspaceDir() != null,
       nowMs: Date.now(),
       staleAfterSeconds: this.getStaleAfterSeconds(),
     });
@@ -148,6 +170,7 @@ export class DataSource {
     if (this.timer) clearInterval(this.timer);
     this.watcher?.dispose();
     this.focusSub?.dispose();
+    this.workspaceSub?.dispose();
   }
 }