Show the context meter as an estimate when it is one

The status bar previously read only the last turn's reported input
and cache tokens, with no fallback, so a provider that omits usage
pinned the meter at a stale or 0% reading. It now trusts the same
estimate the compaction governor already computed, including the
governor's own decision on whether that number is estimated, rather
than re-deriving that decision from a second usage read. The tilde
prefix that marks an estimated percentage is written once and reused
by both the status bar and the prompt border. Cost accounting's own
input-plus-cache sum is replaced with the same shared function so
all three consumers agree on what "context size" means.

Author: TheGreatAxios

src/cost/cost-summary.test.ts

@@ -15,6 +15,7 @@ const baseInput: CostSummaryInput = {
   outputTokens: 500,
   cacheReadTokens: 200,
   contextTokens: 64_000,
+  contextIsEstimate: false,
 };
 
 describe("buildCostSummary", () => {
@@ -81,6 +82,11 @@ describe("formatStatusBarSegments", () => {
     expect(segments.contextLabel).toBe("Ctx --%");
     expect(segments.contextPercentUsed).toBeNull();
   });
+
+  it("flags an estimated context percentage with a tilde", () => {
+    const summary = buildCostSummary({ ...baseInput, contextIsEstimate: true });
+    expect(formatStatusBarSegments(summary).contextLabel).toBe("Ctx ~50%");
+  });
 });
 
 describe("formatCostCommandOutput", () => {
@@ -116,4 +122,9 @@ describe("formatCostCommandOutput", () => {
     const summary = buildCostSummary(baseInput);
     expect(formatCostCommandOutput(summary)).toContain("Context: 64000/unknown (--%)");
   });
+
+  it("flags an estimated context percentage with a tilde", () => {
+    const summary = buildCostSummary({ ...baseInput, contextIsEstimate: true });
+    expect(formatCostCommandOutput(summary)).toContain("(~50%)");
+  });
 });

src/cost/cost-summary.ts

@@ -17,6 +17,12 @@ export type CostSummaryInput = {
   outputTokens: number;
   cacheReadTokens: number;
   contextTokens: number;
+  // True when contextTokens came from the local character-count estimate
+  // because the provider omitted or zeroed usage on the latest turn, rather
+  // than from provider-reported usage. Lets the display flag the number as
+  // approximate instead of implying provider-grade precision. The caller
+  // building this input owns the decision; nothing downstream re-derives it.
+  contextIsEstimate: boolean;
 };
 
 export type CostSummary = CostSummaryInput & {
@@ -53,8 +59,13 @@ export type StatusBarCostSegments = {
   contextPercentUsed: number | null;
 };
 
-function formatContextPercent(percent: number | null): string {
-  return percent === null ? "--%" : `${String(percent)}%`;
+// "~" flags a locally estimated number so the operator doesn't read it as
+// provider-confirmed. The one place this rule is encoded; every renderer of
+// a context percentage (status bar, prompt border, /cost output) calls this
+// rather than re-deciding the prefix itself.
+export function formatContextPercentLabel(percent: number | null, isEstimate: boolean): string {
+  if (percent === null) return "--%";
+  return `${isEstimate ? "~" : ""}${String(percent)}%`;
 }
 
 // Status bar space is tight, so cost is omitted entirely (not shown as $0 or
@@ -64,7 +75,7 @@ function formatContextPercent(percent: number | null): string {
 export function formatStatusBarSegments(summary: CostSummary): StatusBarCostSegments {
   return {
     ...(summary.costHiddenReason === null ? { costLabel: summary.formattedCost } : {}),
-    contextLabel: `Ctx ${formatContextPercent(summary.contextPercentUsed)}`,
+    contextLabel: `Ctx ${formatContextPercentLabel(summary.contextPercentUsed, summary.contextIsEstimate)}`,
     contextPercentUsed: summary.contextPercentUsed,
   };
 }
@@ -84,7 +95,7 @@ export function formatCostCommandOutput(summary: CostSummary): string {
       ? `Cost: ${summary.formattedCost}`
       : `Cost: hidden (${HIDDEN_REASON_TEXT[summary.costHiddenReason]})`,
     `Tokens: ${String(summary.inputTokens)} in / ${String(summary.outputTokens)} out / ${String(summary.cacheReadTokens)} cache-read`,
-    `Context: ${String(summary.contextTokens)}/${window} (${formatContextPercent(summary.contextPercentUsed)})`,
+    `Context: ${String(summary.contextTokens)}/${window} (${formatContextPercentLabel(summary.contextPercentUsed, summary.contextIsEstimate)})`,
   ];
   return lines.join("\n");
 }

src/cost/faremeter.ts

@@ -1,6 +1,7 @@
 import type { TokenUsage } from "@intx/types/runtime";
 
 import { lookupModelPricing, type ModelPricing, type PricingCache } from "./pricing-fetcher.js";
+import { contextTokensFromUsage } from "../provider/context-window.js";
 
 export type FaremeterConfig = {
   inputPricePerToken: number;
@@ -60,7 +61,7 @@ export function createFaremeter(config: CreateFaremeterConfig = {}): Faremeter {
   return {
     addUsage(usage: TokenUsage): void {
       const { inputPricePerToken, outputPricePerToken, cacheReadPricePerToken } = pricesFor();
-      lastContextSize = usage.input + usage.cacheRead + usage.cacheWrite;
+      lastContextSize = contextTokensFromUsage(usage);
       outputTokens += usage.output + usage.thinking;
       totalCost += usage.input * inputPricePerToken + usage.output * outputPricePerToken + usage.cacheRead * cacheReadPricePerToken;
     },

src/tui-opentui/prompt-border.test.ts

@@ -155,30 +155,49 @@ describe("composeRule", () => {
 
 describe("composeCostContextMeter", () => {
   test("null when the context window is unknown", () => {
-    expect(composeCostContextMeter({ contextPercentUsed: null })).toBeNull()
+    expect(composeCostContextMeter({ contextPercentUsed: null, contextIsEstimate: false })).toBeNull()
   })
 
   test("carries the percent and cost", () => {
-    const meter = composeCostContextMeter({ contextPercentUsed: 68, costLabel: "$0.42" })
+    const meter = composeCostContextMeter({
+      contextPercentUsed: 68,
+      costLabel: "$0.42",
+      contextIsEstimate: false,
+    })
     expect(meter).not.toBeNull()
     expect(meter!.percentLabel).toBe("68%")
     expect(meter!.costLabel).toBe("$0.42")
   })
 
   test("drops the cost suffix when told to, keeping the percent", () => {
-    const meter = composeCostContextMeter({ contextPercentUsed: 68, costLabel: "$0.42" })!
+    const meter = composeCostContextMeter({
+      contextPercentUsed: 68,
+      costLabel: "$0.42",
+      contextIsEstimate: false,
+    })!
     expect(costContextText(meter, true)).toContain("$0.42")
     expect(costContextText(meter, false)).not.toContain("$0.42")
     expect(costContextText(meter, false)).toContain("68%")
   })
 
   test("turns pressured past the threshold, not before it", () => {
     const thresholdPercent = CONTEXT_PRESSURE_THRESHOLD * 100
-    const below = composeCostContextMeter({ contextPercentUsed: thresholdPercent - 1 })!
-    const atOrAbove = composeCostContextMeter({ contextPercentUsed: thresholdPercent })!
+    const below = composeCostContextMeter({
+      contextPercentUsed: thresholdPercent - 1,
+      contextIsEstimate: false,
+    })!
+    const atOrAbove = composeCostContextMeter({
+      contextPercentUsed: thresholdPercent,
+      contextIsEstimate: false,
+    })!
     expect(below.pressured).toBe(false)
     expect(atOrAbove.pressured).toBe(true)
   })
+
+  test("flags an estimated percent with a tilde", () => {
+    const meter = composeCostContextMeter({ contextPercentUsed: 68, contextIsEstimate: true })!
+    expect(meter.percentLabel).toBe("~68%")
+  })
 })
 
 describe("abbreviateHome", () => {

src/tui-opentui/prompt-border.ts

@@ -14,6 +14,7 @@
 
 import { stringWidth } from "../tui/view/height.js"
 import { renderRamp } from "./ramp.js"
+import { formatContextPercentLabel } from "../cost/cost-summary.js"
 
 /** Rounded box drawing, all single-cell. */
 export const BORDER = {
@@ -229,6 +230,9 @@ export type CostContextInput = {
   readonly contextPercentUsed: number | null
   /** Already formatted (e.g. `$0.42`); omitted or empty hides the cost suffix. */
   readonly costLabel?: string | null
+  /** True when `contextPercentUsed` came from the local estimate because the
+   * provider omitted or zeroed usage, rather than from reported usage. */
+  readonly contextIsEstimate: boolean
 }
 
 export type CostContextMeter = {
@@ -249,7 +253,7 @@ export function composeCostContextMeter(input: CostContextInput): CostContextMet
   const percent = Math.max(0, Math.min(100, Math.round(input.contextPercentUsed)))
   const cost = input.costLabel?.trim() ?? ""
   return {
-    percentLabel: `${String(percent)}%`,
+    percentLabel: formatContextPercentLabel(percent, input.contextIsEstimate),
     costLabel: cost.length > 0 ? cost : null,
     pressured: percent / 100 >= CONTEXT_PRESSURE_THRESHOLD,
   }

src/tui-opentui/runner-host.test.ts

@@ -31,6 +31,7 @@ function fakeCostSummary(): CostSummary {
     outputTokens: 50,
     cacheReadTokens: 0,
     contextTokens: 1000,
+    contextIsEstimate: false,
     costHiddenReason: null,
     contextWindow: 10000,
     contextPercentUsed: 10,

src/tui-opentui/runner-host.ts

@@ -257,6 +257,7 @@ export async function mountRunnerHost(deps: RunnerHostDeps): Promise<RunnerHost>
     setPromptCostContext(host.shell, {
       contextPercentUsed: summary.contextPercentUsed,
       costLabel: showCost && summary.costHiddenReason === null ? summary.formattedCost : null,
+      contextIsEstimate: summary.contextIsEstimate,
     })
   }
   pushCostContext()

src/tui-opentui/shell.ts

@@ -1480,7 +1480,11 @@ export function setPromptWorkspace(
  */
 export function setPromptCostContext(
   shell: AppShell,
-  input: { readonly contextPercentUsed: number | null; readonly costLabel?: string | null },
+  input: {
+    readonly contextPercentUsed: number | null
+    readonly costLabel?: string | null
+    readonly contextIsEstimate: boolean
+  },
 ): void {
   const meter = composeCostContextMeter(input)
   if (meterEquals(meter, shell.costContext)) return

src/tui/commands/built-in.test.ts

@@ -148,6 +148,7 @@ describe("/cost command", () => {
         outputTokens: 50,
         cacheReadTokens: 10,
         contextTokens: 160,
+        contextIsEstimate: false,
       });
     const result = getCommand("cost")!.handler("", ctx);
     expect(result.type).toBe("message");

src/tui/runner.ts

@@ -94,6 +94,7 @@ import { defaultPricingCachePath } from "../cost/pricing-fetcher.js";
 import { getActivePricingCache } from "../cost/cost-visibility.js";
 import { createFaremeter, formatCost } from "../cost/faremeter.js";
 import { buildCostSummary, type CostSummary } from "../cost/cost-summary.js";
+import { contextTokensFromUsage } from "../provider/context-window.js";
 import {
   advertisedToolNamesForSessionMode,
   advertisedTools,
@@ -1688,6 +1689,13 @@ export async function runTUI(initialConfig: Config): Promise<number> {
       const faremeter = createFaremeter({ modelId: config.model, pricingCache });
       faremeter.addUsage(usage);
       const totalCost = faremeter.getTotalCost();
+      // A provider that omits or zeroes usage would otherwise pin the meter at
+      // 0% forever; fall back to the director's local estimate (turns plus
+      // system-prompt/tool-schema overhead). The governor already decided
+      // whether it's estimating when it computed this turn's arming — trust
+      // that decision rather than re-deriving it from a second usage read.
+      const contextEstimate = directorHolder.instance?.getContextEstimate();
+      const isEstimate = contextEstimate !== undefined && contextEstimate.isEstimate;
       return buildCostSummary({
         modelId: config.model,
         baseURL: config.baseURL,
@@ -1697,7 +1705,8 @@ export async function runTUI(initialConfig: Config): Promise<number> {
         inputTokens: usage.input,
         outputTokens: usage.output,
         cacheReadTokens: usage.cacheRead,
-        contextTokens: lastTurnUsage.input + lastTurnUsage.cacheRead + lastTurnUsage.cacheWrite,
+        contextTokens: isEstimate ? contextEstimate.tokens : contextTokensFromUsage(lastTurnUsage),
+        contextIsEstimate: isEstimate,
       });
     },
     startWorkflow: (name) => workflowController.start(name),