pi-plus 0.1.4 → 0.1.6

package/README.md

@@ -4,9 +4,10 @@ Claude Code-exact context usage detection for [pi](https://github.com/earendil-w
 
 This extension measures pi's context usage with the **same arithmetic as Claude Code** —
 usage-based prefix counting plus rough tail estimation, CC's context-window resolution,
-and CC's warning thresholds — and renders CC's `TokenWarning` indicator as a footer
-status line. Optionally, it can also take over auto-compaction and fire `ctx.compact()`
-at CC's auto-compact threshold.
+and CC's warning thresholds. It replaces pi's built-in footer so its context field
+shows the plugin's CC-exact usage measured against the auto-compact threshold.
+Optionally, it can also take over auto-compaction and fire `ctx.compact()` at CC's
+auto-compact threshold.
 
 ## What it replicates (from Claude Code's source)
 
@@ -19,7 +20,7 @@ at CC's auto-compact threshold.
 | Context measurement: last API usage (input+cacheWrite+cacheRead+output) + chars/4 tail estimate; images/PDFs flat 2000 | `utils/tokens.ts`, `services/tokenEstimation.ts` | `src/usage.ts` |
 | Statusline percentage excludes output tokens; raw window denominator | `utils/context.ts` | `src/percentages.ts` |
 | Warning/error/blocking thresholds (20k/20k/3k buffers) | `services/compact/autoCompact.ts` | `src/percentages.ts` |
-| Indicator text: dim `N% until auto-compact`, `Context low (N% remaining) · Run /compact to compact & continue` | `components/TokenWarning.tsx` | `src/indicator.ts` |
+| Footer replication: cwd/branch line, token stats, model right side, extension-status line | `modes/interactive/components/footer.ts` | `src/footer-render.ts` |
 
 This plugin supports **no Claude Code environment variables**
 (`CLAUDE_CODE_*`, `DISABLE_COMPACT`, … are all ignored). All configuration is
@@ -42,6 +43,39 @@ ln -s "$PWD/src" ~/.pi/agent/extensions/pi-plus
 # (or copy src/ there)
 ```
 
+## Custom footer (default on)
+
+By default the plugin takes over pi's footer via `ctx.ui.setFooter()` and
+replicates the built-in rendering — cwd/git-branch line, token stats
+(`↑ ↓ R W CH $`), right-aligned model/thinking level, and the extension-status
+line — with one substitution: **the context field shows the plugin's CC-exact
+usage measured against the auto-compact threshold**, e.g. `17%/187k (auto)`.
+
+Semantics differ deliberately from pi's native `1.8%/1.0M` field:
+
+- **Numerator** is the same measurement both sides already share (last valid
+  API usage + chars/4 tail estimation).
+- **Denominator is the threshold** (effective window − 13k, settings-overridable),
+  not the raw registry window — so the percentage reaches 100% exactly when
+  the plugin's auto-compact fires. It rises as context fills, like pi's field.
+- ` (auto)` is appended when auto-compact is enabled; right after `/compact`
+  the field shows `?/187k` until the next assistant response (pi's own
+  convention for unknown post-compaction usage).
+- Colors follow the plugin's warning state: warning color inside the 20k
+  warning buffer, error past the error threshold or blocking limit.
+
+Two built-in details are not reproducible from the extension API and are
+omitted: the `• xp` experimental-features marker, and the `(sub)` suffix for
+subscription providers other than `kimi-coding`.
+
+**Conflict warning:** `setFooter` is last-caller-wins — pi-plus must be the
+only footer-taking extension. Another extension calling `setFooter` (e.g.
+`better-claude-code-ui`) replaces this footer entirely. Plain `setStatus`
+extensions are fine; they appear on the status line as usual.
+
+Set `"customFooter": "false"` (below) and `/reload` (or start a new session)
+to restore pi's built-in footer.
+
 ## Auto-compact takeover (optional)
 
 pi's built-in auto-compaction fires at `contextWindow − 16,384` tokens, which is
@@ -61,7 +95,7 @@ auto-compact and CC's autocompact use). The trigger is edge-triggered: it
 fires once per crossing and re-arms after post-compact usage drops below the
 threshold. Manual `/compact` keeps working.
 
-Set `PI_PLUS_NO_AUTO_COMPACT=1` to disable the plugin's trigger (indicator only).
+Set `PI_PLUS_NO_AUTO_COMPACT=1` to disable the plugin's trigger (footer field only).
 
 ## Configuration
 
@@ -83,7 +117,8 @@ also appear in its `/extension-settings` UI.
     "autoCompactWindowCap": "200000",
     "maxOutputTokens": "8192",
     "disableOutputTokenCap": "false",
-    "blockingLimit": "190000"
+    "blockingLimit": "190000",
+    "customFooter": "true"
   }
 }
 ```
@@ -91,6 +126,7 @@ also appear in its `/extension-settings` UI.
 | Setting | Effect | Default |
 |---|---|---|
 | `autoCompact` | Master switch for the plugin's auto-compact trigger (`true`/`false`) | `true` |
+| `customFooter` | Replace pi's built-in footer with the plugin's (see above); takes effect on next session/`/reload` | `true` |
 | `contextWindow` | Override the model-derived context window (tokens) | model default (200k) |
 | `autoCompactThreshold` | Absolute token threshold for auto-compact; wins over everything below | effective window − 13k |
 | `autoCompactPercent` | Threshold as % of effective window (1–100, for testing) | off |
@@ -116,8 +152,11 @@ Set `PI_PLUS_NO_LOG=1` to disable it.
 
 ## Known limits
 
-- pi's built-in footer keeps showing its own `percent%` (different math: includes
-  output tokens). This plugin adds its own status line; it does not replace the footer.
+- With `customFooter` off (or replaced by another extension), pi's built-in
+  footer keeps showing its own `percent%` (raw-window denominator — a much
+  larger number for models like `kimi-for-coding` whose registry window is 1M);
+  the plugin then has no on-screen display, only the log and the auto-compact
+  trigger.
 - pi core owns the compaction cut point (keeps last ~20k tokens) — only the trigger
   threshold is CC-exact.
 - Exactness is guaranteed for Anthropic-style usage fields; other providers may map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-plus",
-	"version": "0.1.4",
+	"version": "0.1.6",
 	"description": "Claude Code-exact context usage detection for pi (extension)",
 	"type": "module",
 	"pi": {
@@ -16,6 +16,7 @@
 	"devDependencies": {
 		"@earendil-works/pi-ai": "0.85.1",
 		"@earendil-works/pi-coding-agent": "0.85.1",
+		"@earendil-works/pi-tui": "0.85.1",
 		"typescript": "^5.6.0",
 		"vitest": "^2.1.9"
 	},
@@ -43,7 +44,8 @@
 	],
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",
-		"@earendil-works/pi-coding-agent": "*"
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
 	},
 	"dependencies": {
 		"@juanibiapina/pi-extension-settings": "^0.10.0"

package/src/context-usage.ts

@@ -0,0 +1,91 @@
+/**
+ * Shared CC-exact context usage computation for pi-plus.
+ *
+ * Single source of truth for both display surfaces — the footer status line
+ * (setStatus) and the custom footer's context field — so the two can never
+ * diverge. Extracted from index.ts when the custom footer landed.
+ *
+ * The "known" flag ports pi's own getContextUsage boundary logic
+ * (core/agent-session.ts): after a compaction entry, the pre-compaction usage
+ * no longer describes the context, so the count is unknown until a valid
+ * assistant response arrives.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAutoCompactThreshold, getEffectiveContextWindowSize } from "./model-config.ts";
+import { calculateTokenWarningState, isAutoCompactEnabled, type TokenWarningState } from "./percentages.ts";
+import type { PiPlusSettings } from "./settings.ts";
+import { getTokenCountFromUsage, tokenCountWithEstimation, type RoughMessage } from "./usage.ts";
+
+export interface PluginContextUsage {
+	/** false right after compaction, before the next valid assistant response
+	 *  (mirrors pi's "?/window" convention). */
+	known: boolean;
+	/** CC-exact token count (meaningful only when known). */
+	tokens: number;
+	/** The threshold percentUsed is measured against: the auto-compact
+	 *  threshold when auto-compact is on, else the effective window. */
+	threshold: number;
+	autoCompactEnabled: boolean;
+	state: TokenWarningState;
+}
+
+export function branchMessages(ctx: ExtensionContext): RoughMessage[] {
+	return ctx.sessionManager
+		.getBranch()
+		.filter((entry) => entry.type === "message")
+		.map((entry) => entry.message as unknown as RoughMessage);
+}
+
+/**
+ * Port of agent-session.ts getContextUsage's boundary rule: the count is
+ * unknown ONLY when a `compaction` entry exists with no valid assistant usage
+ * after it (the pre-compaction usage no longer describes the context).
+ * `branch_summary` is NOT a boundary — matching getLatestCompactionEntry.
+ * With no compaction, even a usage-less session is "known": both pi and the
+ * plugin's tokenCountWithEstimation fall back to estimating every message.
+ */
+export function hasPostCompactionUsage(ctx: ExtensionContext): boolean {
+	const entries = ctx.sessionManager.getBranch();
+	let compactionIndex = -1;
+	for (let i = entries.length - 1; i >= 0; i--) {
+		if (entries[i].type === "compaction") {
+			compactionIndex = i;
+			break;
+		}
+	}
+	if (compactionIndex === -1) return true;
+	for (let i = entries.length - 1; i > compactionIndex; i--) {
+		const entry = entries[i];
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		const assistant = entry.message;
+		if (assistant.stopReason === "aborted" || assistant.stopReason === "error") continue;
+		const usage = assistant.usage;
+		if (usage && getTokenCountFromUsage(usage) > 0) return true;
+	}
+	return false;
+}
+
+/**
+ * Compute the plugin's context usage snapshot for the current session state.
+ * Returns undefined when no model is selected.
+ */
+export function computePluginContextUsage(
+	ctx: ExtensionContext,
+	settings: PiPlusSettings,
+): PluginContextUsage | undefined {
+	const model = ctx.model;
+	if (!model) return undefined;
+
+	const tokens = tokenCountWithEstimation(branchMessages(ctx));
+	const known = hasPostCompactionUsage(ctx);
+	const autoCompactEnabled = isAutoCompactEnabled(settings);
+	// Mirror calculateTokenWarningState's denominator: the auto-compact
+	// threshold when auto-compact is on, else the effective window.
+	const threshold = autoCompactEnabled
+		? getAutoCompactThreshold(model.id, model.contextWindow, model.maxTokens, settings)
+		: getEffectiveContextWindowSize(model.id, model.contextWindow, model.maxTokens, settings);
+	const state = calculateTokenWarningState(tokens, model.id, model.contextWindow, model.maxTokens, settings);
+
+	return { known, tokens, threshold, autoCompactEnabled, state };
+}

package/src/footer-render.ts

@@ -0,0 +1,248 @@
+/**
+ * Pure line builders for pi-plus's custom footer — exact ports of pi's
+ * built-in footer rendering (coding-agent src/modes/interactive/components/footer.ts),
+ * minus the pieces extensions cannot access (the `xp` experimental marker and
+ * `modelRuntime.isUsingSubscription`), with the context-usage field replaced
+ * by pi-plus's CC-exact "% used of threshold".
+ *
+ * Everything here is pure and free of runtime pi dependencies: truncation and
+ * width measurement are injected via `Measure` so the module stays testable
+ * without pi-tui, and the theme is the structural `ThemeLike` subset.
+ */
+
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { PluginContextUsage } from "./context-usage.ts";
+
+export interface ThemeLike {
+	fg(color: string, text: string): string;
+}
+
+/** Width primitives supplied by the caller (pi-tui at runtime, test stubs in vitest). */
+export interface Measure {
+	truncate(text: string, width: number, ellipsis: string): string;
+	visibleWidth(text: string): number;
+}
+
+/** Sanitize text for display in a single-line status (footer.ts:13). */
+export function sanitizeStatusText(text: string): string {
+	return text
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
+}
+
+/** Format token counts for compact footer display (footer.ts:24). */
+export function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1000000) return `${Math.round(count / 1000)}k`;
+	if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+	return `${Math.round(count / 1000000)}M`;
+}
+
+/** Replace the home directory with ~ (footer.ts:33). */
+export function formatCwdForFooter(cwd: string, home: string | undefined): string {
+	if (!home) return cwd;
+
+	const resolvedCwd = resolve(cwd);
+	const resolvedHome = resolve(home);
+	const relativeToHome = relative(resolvedHome, resolvedCwd);
+	const isInsideHome =
+		relativeToHome === "" ||
+		(relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+
+	if (!isInsideHome) return cwd;
+	return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
+
+export interface UsageTotals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+}
+
+/**
+ * Cumulative usage over ALL session entries plus the latest assistant cache
+ * hit rate — a port of footer.ts:88-104. The entry scan: assistant messages,
+ * toolResult messages with usage, and branch_summary/compaction entries with
+ * usage. The CH rate comes from the latest assistant message regardless of
+ * stopReason, matching the built-in footer.
+ */
+export function computeUsageTotals(entries: readonly SessionEntry[]): {
+	totals: UsageTotals;
+	latestCacheHitRate: number | undefined;
+} {
+	const totals: UsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+	let latestCacheHitRate: number | undefined;
+
+	for (const entry of entries) {
+		if (entry.type === "message" && entry.message.role === "assistant") {
+			const usage = entry.message.usage;
+			totals.input += usage.input;
+			totals.output += usage.output;
+			totals.cacheRead += usage.cacheRead;
+			totals.cacheWrite += usage.cacheWrite;
+			totals.cost += usage.cost.total;
+
+			const latestPromptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+			latestCacheHitRate = latestPromptTokens > 0 ? (usage.cacheRead / latestPromptTokens) * 100 : undefined;
+		} else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
+			const usage = entry.message.usage;
+			totals.input += usage.input;
+			totals.output += usage.output;
+			totals.cacheRead += usage.cacheRead;
+			totals.cacheWrite += usage.cacheWrite;
+			totals.cost += usage.cost.total;
+		} else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+			const usage = entry.usage;
+			totals.input += usage.input;
+			totals.output += usage.output;
+			totals.cacheRead += usage.cacheRead;
+			totals.cacheWrite += usage.cacheWrite;
+			totals.cost += usage.cost.total;
+		}
+	}
+
+	return { totals, latestCacheHitRate };
+}
+
+/**
+ * The substituted context field: `{percentUsed}%/{threshold}` + ` (auto)`.
+ * percentUsed is the complement of the plugin's percentLeft (CC's
+ * calculateTokenWarningState), measured against the auto-compact threshold —
+ * so the number rises as context fills, like pi's native field, but the
+ * denominator is the threshold (effective window − 13k), not the raw window.
+ * Colors follow the plugin's warning state; `?/{threshold}` when unknown.
+ */
+export function buildContextField(usage: PluginContextUsage | undefined, theme: ThemeLike): string {
+	const autoIndicator = usage?.autoCompactEnabled ? " (auto)" : "";
+	if (!usage || !usage.known) {
+		return `?/${formatTokens(usage?.threshold ?? 0)}${autoIndicator}`;
+	}
+	const percentUsed = 100 - usage.state.percentLeft;
+	const display = `${percentUsed}%/${formatTokens(usage.threshold)}${autoIndicator}`;
+	if (usage.state.isAboveErrorThreshold || usage.state.isAtBlockingLimit) return theme.fg("error", display);
+	if (usage.state.isAboveWarningThreshold) return theme.fg("warning", display);
+	return display;
+}
+
+export interface StatsLineInput {
+	totals: UsageTotals;
+	latestCacheHitRate: number | undefined;
+	/** Pre-colored context field from buildContextField. */
+	contextField: string;
+	/** model.provider === "kimi-coding" (the only subscription check extensions can port). */
+	usingKimiCoding: boolean;
+	modelName: string;
+	modelReasoning: boolean;
+	thinkingLevel: string | undefined;
+	provider: string | undefined;
+	availableProviderCount: number;
+}
+
+/**
+ * Port of footer.ts:128-227: stats parts, right-aligned model + thinking
+ * level, provider prefix when multiple providers are available, min-2-space
+ * gap, truncation fallbacks, and the dim-left/dim-remainder split around the
+ * colored context segment. Omits only the `xp` marker (internal API).
+ */
+export function buildStatsLine(input: StatsLineInput, width: number, measure: Measure, theme: ThemeLike): string {
+	const { totals, latestCacheHitRate, contextField } = input;
+	const statsParts: string[] = [];
+	if (totals.input) statsParts.push(`↑${formatTokens(totals.input)}`);
+	if (totals.output) statsParts.push(`↓${formatTokens(totals.output)}`);
+	if (totals.cacheRead) statsParts.push(`R${formatTokens(totals.cacheRead)}`);
+	if (totals.cacheWrite) statsParts.push(`W${formatTokens(totals.cacheWrite)}`);
+	if ((totals.cacheRead > 0 || totals.cacheWrite > 0) && latestCacheHitRate !== undefined) {
+		statsParts.push(`CH${latestCacheHitRate.toFixed(1)}%`);
+	}
+
+	if (totals.cost || input.usingKimiCoding) {
+		statsParts.push(`$${totals.cost.toFixed(3)}${input.usingKimiCoding ? " (sub)" : ""}`);
+	}
+
+	statsParts.push(contextField);
+
+	let statsLeft = statsParts.join(" ");
+
+	let statsLeftWidth = measure.visibleWidth(statsLeft);
+	if (statsLeftWidth > width) {
+		statsLeft = measure.truncate(statsLeft, width, "...");
+		statsLeftWidth = measure.visibleWidth(statsLeft);
+	}
+
+	const minPadding = 2;
+
+	let rightSideWithoutProvider = input.modelName;
+	if (input.modelReasoning) {
+		const thinkingLevel = input.thinkingLevel || "off";
+		rightSideWithoutProvider =
+			thinkingLevel === "off" ? `${input.modelName} • thinking off` : `${input.modelName} • ${thinkingLevel}`;
+	}
+
+	let rightSide = rightSideWithoutProvider;
+	if (input.availableProviderCount > 1 && input.provider) {
+		rightSide = `(${input.provider}) ${rightSideWithoutProvider}`;
+		if (statsLeftWidth + minPadding + measure.visibleWidth(rightSide) > width) {
+			rightSide = rightSideWithoutProvider;
+		}
+	}
+
+	const rightSideWidth = measure.visibleWidth(rightSide);
+	const totalNeeded = statsLeftWidth + minPadding + rightSideWidth;
+
+	let statsLine: string;
+	if (totalNeeded <= width) {
+		const padding = " ".repeat(width - statsLeftWidth - rightSideWidth);
+		statsLine = statsLeft + padding + rightSide;
+	} else {
+		const availableForRight = width - statsLeftWidth - minPadding;
+		if (availableForRight > 0) {
+			const truncatedRight = measure.truncate(rightSide, availableForRight, "");
+			const truncatedRightWidth = measure.visibleWidth(truncatedRight);
+			const padding = " ".repeat(Math.max(0, width - statsLeftWidth - truncatedRightWidth));
+			statsLine = statsLeft + padding + truncatedRight;
+		} else {
+			statsLine = statsLeft;
+		}
+	}
+
+	// statsLeft may contain color codes (the context field) that reset an outer
+	// dim wrapper, so dim the parts before and after it independently.
+	const dimStatsLeft = theme.fg("dim", statsLeft);
+	const remainder = statsLine.slice(statsLeft.length);
+	return dimStatsLeft + theme.fg("dim", remainder);
+}
+
+/** Line 1: dim cwd (home collapsed), git branch in parens, session name. */
+export function buildPwdLine(
+	cwd: string,
+	home: string | undefined,
+	branch: string | null,
+	sessionName: string | undefined,
+	width: number,
+	measure: Measure,
+	theme: ThemeLike,
+): string {
+	let pwd = formatCwdForFooter(cwd, home);
+	if (branch) pwd = `${pwd} (${branch})`;
+	if (sessionName) pwd = `${pwd} • ${sessionName}`;
+	return measure.truncate(theme.fg("dim", pwd), width, theme.fg("dim", "..."));
+}
+
+/** Line 3: extension statuses sorted by key, sanitized, space-joined. */
+export function buildStatusLine(
+	statuses: ReadonlyMap<string, string>,
+	width: number,
+	measure: Measure,
+	theme: ThemeLike,
+): string | undefined {
+	if (statuses.size === 0) return undefined;
+	const sortedStatuses = Array.from(statuses.entries())
+		.sort(([a], [b]) => a.localeCompare(b))
+		.map(([, text]) => sanitizeStatusText(text));
+	return measure.truncate(sortedStatuses.join(" "), width, theme.fg("dim", "..."));
+}

package/src/footer.ts

@@ -0,0 +1,139 @@
+/**
+ * Custom footer installer: pi-plus takes over pi's footer via
+ * ctx.ui.setFooter() and replicates the built-in rendering (see
+ * footer-render.ts) with the CC-exact "% used of threshold" in the context
+ * field.
+ *
+ * Contract with pi: the setFooter factory receives (tui, theme, footerData);
+ * pi disposes the previous custom footer before installing ours, and
+ * setFooter(undefined) restores the built-in footer. pi-plus must therefore
+ * be the ONLY extension calling setFooter — another caller silently replaces
+ * this footer (that is how better-claude-code-ui hid the status line).
+ *
+ * The usage snapshot is memoized: tokenCountWithEstimation is O(content) and
+ * renders fire on every keystroke, so we recompute only when the session leaf
+ * or the model changes.
+ */
+
+import {
+	type Component,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+} from "@earendil-works/pi-tui";
+import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
+import { computePluginContextUsage, type PluginContextUsage } from "./context-usage.ts";
+import {
+	buildContextField,
+	buildPwdLine,
+	buildStatsLine,
+	buildStatusLine,
+	computeUsageTotals,
+	type Measure,
+} from "./footer-render.ts";
+import { loadPiPlusSettings } from "./settings.ts";
+
+const measure: Measure = {
+	truncate: truncateToWidth,
+	visibleWidth,
+};
+
+interface FooterDeps {
+	ctx: ExtensionContext;
+	theme: Theme;
+	footerData: ReadonlyFooterDataProvider;
+}
+
+export class PiPlusFooterComponent implements Component {
+	private deps: FooterDeps;
+	private snapshot: {
+		leafId: string | null | undefined;
+		modelId: string | undefined;
+		usage: PluginContextUsage | undefined;
+	} = {
+		leafId: undefined,
+		modelId: undefined,
+		usage: undefined,
+	};
+	private disposeHook: (() => void) | undefined;
+
+	constructor(deps: FooterDeps) {
+		this.deps = deps;
+	}
+
+	/** pi calls dispose() before replacing the footer — release our subscriptions. */
+	onDispose(hook: () => void): void {
+		this.disposeHook = hook;
+	}
+
+	invalidate(): void {
+		// No-op: all data is pulled fresh per render (same as pi's built-in footer).
+	}
+
+	dispose(): void {
+		this.disposeHook?.();
+	}
+
+	private getUsage(): PluginContextUsage | undefined {
+		const { ctx } = this.deps;
+		const leafId = ctx.sessionManager.getLeafId();
+		const modelId = ctx.model?.id;
+		if (this.snapshot.leafId !== leafId || this.snapshot.modelId !== modelId) {
+			this.snapshot = { leafId, modelId, usage: computePluginContextUsage(ctx, loadPiPlusSettings()) };
+		}
+		return this.snapshot.usage;
+	}
+
+	render(width: number): string[] {
+		const { ctx, theme, footerData } = this.deps;
+
+		const lines = [
+			buildPwdLine(ctx.cwd, process.env.HOME || process.env.USERPROFILE, footerData.getGitBranch(), ctx.sessionManager.getSessionName(), width, measure, theme),
+		];
+
+		const { totals, latestCacheHitRate } = computeUsageTotals(ctx.sessionManager.getEntries());
+		const model = ctx.model;
+		lines.push(
+			buildStatsLine(
+				{
+					totals,
+					latestCacheHitRate,
+					contextField: buildContextField(this.getUsage(), theme),
+					usingKimiCoding: model?.provider === "kimi-coding",
+					modelName: model?.id || "no-model",
+					modelReasoning: model?.reasoning ?? false,
+					thinkingLevel: ctx.thinkingLevel,
+					provider: model?.provider,
+					availableProviderCount: footerData.getAvailableProviderCount(),
+				},
+				width,
+				measure,
+				theme,
+			),
+		);
+
+		const statusLine = buildStatusLine(footerData.getExtensionStatuses(), width, measure, theme);
+		if (statusLine !== undefined) lines.push(statusLine);
+
+		return lines;
+	}
+}
+
+/**
+ * Install (or, when the `customFooter` setting is false, explicitly restore)
+ * pi's footer. Called on session_start — pi's resetExtensionUI() drops custom
+ * footers on session switch and /reload, so this re-asserts each session.
+ */
+export function installFooter(ctx: ExtensionContext): void {
+	if (ctx.mode !== "tui") return;
+	if (loadPiPlusSettings().customFooter === false) {
+		ctx.ui.setFooter(undefined);
+		return;
+	}
+	ctx.ui.setFooter((tui: TUI, theme: Theme, footerData: ReadonlyFooterDataProvider) => {
+		const component = new PiPlusFooterComponent({ ctx, theme, footerData });
+		const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
+		component.onDispose(unsubscribe);
+		return component;
+	});
+}

package/src/index.ts

@@ -3,8 +3,8 @@
  *
  * A pi extension that measures context usage with the same arithmetic as
  * Claude Code (usage-based prefix count + rough tail estimation, CC's context
- * window resolution and warning thresholds) and renders CC's TokenWarning
- * indicator as a footer status line. When pi's built-in auto-compaction is
+ * window resolution and warning thresholds) and shows it in the footer's
+ * context field via a custom footer. When pi's built-in auto-compaction is
  * disabled, the plugin takes over and calls ctx.compact() at CC's
  * auto-compact threshold (effective window − 13,000 tokens).
  *
@@ -15,21 +15,12 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SettingDefinition } from "@juanibiapina/pi-extension-settings";
 import { initialTriggerState, shouldFireAutoCompact, type AutoCompactTriggerState } from "./auto-compact.ts";
-import { getAutoCompactThreshold } from "./model-config.ts";
-import { isAutoCompactEnabled, calculateTokenWarningState } from "./percentages.ts";
-import { renderTokenWarning } from "./indicator.ts";
+import { computePluginContextUsage } from "./context-usage.ts";
+import { installFooter } from "./footer.ts";
+import { isAutoCompactEnabled } from "./percentages.ts";
 import { appendUsageLog } from "./logger.ts";
 import { loadPiPlusSettings } from "./settings.ts";
-import { tokenCountWithEstimation, type RoughMessage } from "./usage.ts";
 
-const STATUS_KEY = "cc-context";
-
-function branchMessages(ctx: ExtensionContext): RoughMessage[] {
-	return ctx.sessionManager
-		.getBranch()
-		.filter((entry) => entry.type === "message")
-		.map((entry) => entry.message as unknown as RoughMessage);
-}
 
 export default function (pi: ExtensionAPI) {
 	// Register our settings so they appear in the /extension-settings UI
@@ -87,6 +78,14 @@ export default function (pi: ExtensionAPI) {
 				description: "Absolute token usage that blocks further work. Empty = effective window − 3k.",
 				defaultValue: "",
 			},
+			{
+				id: "customFooter",
+				label: "Custom footer (context field)",
+				description:
+					"Replace pi's built-in footer so its context field shows pi-plus's CC-exact usage (% used of the auto-compact threshold). Takes effect on the next session or /reload.",
+				defaultValue: "true",
+				values: ["true", "false"],
+			},
 		] satisfies SettingDefinition[],
 	});
 
@@ -94,28 +93,24 @@ export default function (pi: ExtensionAPI) {
 	// re-arms automatically once post-compact usage drops below the threshold.
 	let compactTrigger: AutoCompactTriggerState = initialTriggerState();
 
-	function updateIndicator(ctx: ExtensionContext): void {
+	function logUsageCheck(ctx: ExtensionContext): void {
 		const model = ctx.model;
-		if (!model) {
-			if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
-			return;
-		}
+		if (!model) return;
 		const settings = loadPiPlusSettings();
-		const tokenCount = tokenCountWithEstimation(branchMessages(ctx));
-		const state = calculateTokenWarningState(tokenCount, model.id, model.contextWindow, model.maxTokens, settings);
+		const computed = computePluginContextUsage(ctx, settings);
+		if (!computed) return;
+		const state = computed.state;
 		appendUsageLog({
 			event: "usage_check",
 			source: "indicator",
 			model: model.id,
-			tokens: tokenCount,
+			tokens: computed.tokens,
 			percentLeft: state.percentLeft,
 			aboveWarning: state.isAboveWarningThreshold,
 			aboveError: state.isAboveErrorThreshold,
 			aboveAutoCompact: state.isAboveAutoCompactThreshold,
 			atBlockingLimit: state.isAtBlockingLimit,
 		});
-		if (!ctx.hasUI) return;
-		ctx.ui.setStatus(STATUS_KEY, renderTokenWarning(state, isAutoCompactEnabled(settings), ctx.ui.theme));
 	}
 
 	/**
@@ -134,8 +129,10 @@ export default function (pi: ExtensionAPI) {
 		const settings = loadPiPlusSettings();
 		if (!isAutoCompactEnabled(settings)) return;
 		if (process.env.PI_PLUS_NO_AUTO_COMPACT !== undefined) return;
-		const tokenCount = tokenCountWithEstimation(branchMessages(ctx));
-		const threshold = getAutoCompactThreshold(model.id, model.contextWindow, model.maxTokens, settings);
+		const computed = computePluginContextUsage(ctx, settings);
+		if (!computed) return;
+		const tokenCount = computed.tokens;
+		const threshold = computed.threshold;
 		const fired = shouldFireAutoCompact(compactTrigger, tokenCount, threshold);
 		appendUsageLog({
 			event: "usage_check",
@@ -158,17 +155,18 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_start", (_event, ctx) => {
 		compactTrigger = initialTriggerState();
-		updateIndicator(ctx);
+		installFooter(ctx);
+		logUsageCheck(ctx);
 		maybeAutoCompact(ctx);
 	});
-	pi.on("turn_end", (_event, ctx) => updateIndicator(ctx));
-	pi.on("agent_settled", (_event, ctx) => updateIndicator(ctx));
+	pi.on("turn_end", (_event, ctx) => logUsageCheck(ctx));
+	pi.on("agent_settled", (_event, ctx) => logUsageCheck(ctx));
 	// Check token overflow on every tool task finish.
 	pi.on("tool_execution_end", (_event, ctx) => {
-		updateIndicator(ctx);
+		logUsageCheck(ctx);
 		maybeAutoCompact(ctx);
 	});
-	pi.on("message_end", (_event, ctx) => updateIndicator(ctx));
-	pi.on("model_select", (_event, ctx) => updateIndicator(ctx));
-	pi.on("session_compact", (_event, ctx) => updateIndicator(ctx));
+	pi.on("message_end", (_event, ctx) => logUsageCheck(ctx));
+	pi.on("model_select", (_event, ctx) => logUsageCheck(ctx));
+	pi.on("session_compact", (_event, ctx) => logUsageCheck(ctx));
 }

package/src/settings.ts

@@ -40,6 +40,8 @@ export interface PiPlusSettings extends ModelConfigSettings {
 	autoCompact?: boolean;
 	/** Override the blocking limit (absolute tokens). */
 	blockingLimit?: number;
+	/** Master switch for the custom footer takeover (default true). */
+	customFooter?: boolean;
 }
 
 const EXTENSION_NAME = "pi-plus";
@@ -84,6 +86,7 @@ export function loadPiPlusSettings(options?: SettingStorageOptions): PiPlusSetti
 	const blockingLimit = positiveInt("blockingLimit", options);
 	const autoCompact = booleanValue("autoCompact", options);
 	const disableOutputTokenCap = booleanValue("disableOutputTokenCap", options);
+	const customFooter = booleanValue("customFooter", options);
 
 	if (contextWindow !== undefined) settings.contextWindow = contextWindow;
 	if (autoCompactWindowCap !== undefined) settings.autoCompactWindowCap = autoCompactWindowCap;
@@ -93,5 +96,6 @@ export function loadPiPlusSettings(options?: SettingStorageOptions): PiPlusSetti
 	if (blockingLimit !== undefined) settings.blockingLimit = blockingLimit;
 	if (autoCompact !== undefined) settings.autoCompact = autoCompact;
 	if (disableOutputTokenCap !== undefined) settings.disableOutputTokenCap = disableOutputTokenCap;
+	if (customFooter !== undefined) settings.customFooter = customFooter;
 	return settings;
 }

package/src/indicator.ts

@@ -1,33 +0,0 @@
-/**
- * Port of Claude Code's TokenWarning indicator (src/components/TokenWarning.tsx),
- * adapted for a permanent footer status line.
- *
- * Rendering rules (auto-compact reactive/collapse modes omitted — ant-only):
- *  - below the warning threshold: dim "N% until auto-compact" (CC renders nothing
- *    here, but a status line should always show the current usage)
- *  - auto-compact on:  dim "N% until auto-compact"
- *  - auto-compact off: "Context low (N% remaining) · Run /compact to compact & continue",
- *    warning color, or error color once past the error threshold / blocking limit
- */
-
-import type { TokenWarningState } from "./percentages.ts";
-
-/** Structural subset of pi's Theme — avoids a hard pi-tui dependency. */
-export interface ThemeLike {
-	fg(color: string, text: string): string;
-}
-
-export function renderTokenWarning(
-	state: TokenWarningState,
-	autoCompactEnabled: boolean,
-	theme: ThemeLike,
-): string | undefined {
-	if (autoCompactEnabled) {
-		return theme.fg("dim", `${state.percentLeft}% until auto-compact`);
-	}
-	if (!state.isAboveWarningThreshold) {
-		return theme.fg("dim", `${state.percentLeft}% remaining`);
-	}
-	const color = state.isAboveErrorThreshold || state.isAtBlockingLimit ? "error" : "warning";
-	return theme.fg(color, `Context low (${state.percentLeft}% remaining) · Run /compact to compact & continue`);
-}