@xzzpig/pi-starline 0.5.1 → 0.7.1

package/extensions/starline/fork-editor-cursor.ts

@@ -0,0 +1,14 @@
+/**
+ * Pi 1.2+ delays drawing its software cursor: the editor emits APC markers
+ * around the cursor cell and the TUI resolves them after our editor renders.
+ * Restyle the marked cell before that resolution, keeping CURSOR_MARKER intact
+ * for hardware cursor/IME positioning. Pi 1.1's SGR cursor stays upstream's
+ * responsibility in editor-cursor.ts.
+ */
+const MARKED_CURSOR = /\x1b_pi:fc\x07([^\x1b]+)\x1b_pi:\/fc\x07/g;
+
+export function applyMarkedCursorStyle(line: string, style: "underline" | "terminal"): string {
+	return line.replace(MARKED_CURSOR, (_match, cell: string) =>
+		style === "underline" ? `\x1b[4m${cell}\x1b[0m` : cell,
+	);
+}

package/extensions/starline/format.ts

@@ -55,19 +55,16 @@ export function formatGitMetricsSegment(
 	metrics: GitMetricsInfo | null | undefined,
 	config: { onlyNonzero: boolean },
 	colorSource: ColorSource,
-	addedStyle: ColorSpec,
-	deletedStyle: ColorSpec,
+	style: ColorSpec,
 ): string {
 	if (!metrics) return "";
 	const showAdded = !config.onlyNonzero || metrics.added > 0;
 	const showDeleted = !config.onlyNonzero || metrics.deleted > 0;
 	if (!showAdded && !showDeleted) return "";
 	const parts: string[] = [];
-	if (showAdded) {
-		parts.push(renderStyleForSource(theme, colorSource, addedStyle, `+${metrics.added}`));
-	}
+	if (showAdded) parts.push(renderStyleForSource(theme, colorSource, style, `+${metrics.added}`));
 	if (showDeleted) {
-		parts.push(renderStyleForSource(theme, colorSource, deletedStyle, `−${metrics.deleted}`));
+		parts.push(renderStyleForSource(theme, colorSource, style, `−${metrics.deleted}`));
 	}
 	return parts.join(" ");
 }
@@ -150,6 +147,37 @@ function buildUsageFingerprint(entries: readonly SessionEntry[]): string {
 	return `${entries.length}\0${entryIdentity(first)}\0${entryIdentity(last)}`;
 }
 
+/** The slice of an entry's usage this footer reads. */
+type UsageShape = {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: { total?: number };
+};
+
+/**
+ * An entry as far as usage goes. Read structurally rather than through
+ * `SessionEntry`: Pi 1.4 added a `usage` entry type that the type surface this
+ * package builds against does not know about, and a footer that silently stopped
+ * counting it would be worse than one that reads the field defensively.
+ */
+type UsageEntryShape = {
+	type?: string;
+	usage?: UsageShape;
+	message?: { role?: string; usage?: UsageShape };
+};
+
+/**
+ * Everything the session spent, following Pi's own footer.
+ *
+ * A usage entry, an assistant message, a tool result and the summaries that
+ * compaction and branching write are all LLM calls the user paid for, and Pi
+ * counts all of them (`dist/modes/interactive/components/footer.js:99-114`).
+ * Counting only assistant messages undercounted every session that compacted,
+ * branched or ran a tool that reports its own usage — and compaction is exactly
+ * the kind of call you do not want to hide from a budget.
+ */
 function computeUsageTotals(entries: readonly SessionEntry[]): UsageTotals {
 	usageTotalsComputeCount += 1;
 	let input = 0;
@@ -159,19 +187,42 @@ function computeUsageTotals(entries: readonly SessionEntry[]): UsageTotals {
 	let latestCacheHitRate: number | undefined;
 	let cost = 0;
 
+	const addUsage = (usage: UsageShape | undefined) => {
+		if (!usage) return;
+		input += usage.input ?? 0;
+		output += usage.output ?? 0;
+		cacheRead += usage.cacheRead ?? 0;
+		cacheWrite += usage.cacheWrite ?? 0;
+		cost += usage.cost?.total ?? 0;
+	};
+
 	for (const entry of entries) {
-		if (entry.type !== "message" || entry.message?.role !== "assistant") continue;
-		const usage = entry.message.usage;
-		const entryInput = usage?.input ?? 0;
-		const entryCacheRead = usage?.cacheRead ?? 0;
-		const entryCacheWrite = usage?.cacheWrite ?? 0;
-
-		input += entryInput;
-		output += usage?.output ?? 0;
-		cacheRead += entryCacheRead;
-		cacheWrite += entryCacheWrite;
-		cost += usage?.cost?.total ?? 0;
-		latestCacheHitRate = calculateCacheHitRate(entryInput, entryCacheRead, entryCacheWrite);
+		const record = entry as unknown as UsageEntryShape;
+		switch (record.type) {
+			case "usage":
+				addUsage(record.usage);
+				break;
+			case "message":
+				if (record.message?.role === "assistant") {
+					addUsage(record.message.usage);
+					// Only a real assistant turn tells you how well the prompt cache
+					// did; a tool result's usage carries no prompt of its own.
+					latestCacheHitRate = calculateCacheHitRate(
+						record.message.usage?.input ?? 0,
+						record.message.usage?.cacheRead ?? 0,
+						record.message.usage?.cacheWrite ?? 0,
+					);
+				} else if (record.message?.role === "toolResult") {
+					addUsage(record.message.usage);
+				}
+				break;
+			case "compaction":
+			case "branch_summary":
+				addUsage(record.usage);
+				break;
+			default:
+				break;
+		}
 	}
 
 	return Object.freeze({ input, output, cacheRead, cacheWrite, latestCacheHitRate, cost });
@@ -248,8 +299,31 @@ export function buildCostLabel(totals: UsageTotals): string {
 	return `$${totals.cost.toFixed(3)}`;
 }
 
-export function buildSessionDurationLabel(startEpoch: number): string {
-	const totalSeconds = Math.max(0, Math.floor((Date.now() - startEpoch) / 1000));
+/**
+ * Throughput label for the `tps` pill.
+ *
+ * One decimal under 10 keeps slow models from all reading `1 t/s`, and an
+ * integer above it because the second digit is noise at that point and the pill
+ * would jitter in width. Undefined or non-positive input draws nothing: the
+ * segment has no content until a message has actually been measured.
+ */
+export function buildTpsLabel(tokensPerSecond: number | undefined): string {
+	if (tokensPerSecond === undefined || !Number.isFinite(tokensPerSecond)) return "";
+	if (tokensPerSecond <= 0) return "";
+	const rounded =
+		tokensPerSecond < 10 ? tokensPerSecond.toFixed(1) : Math.round(tokensPerSecond).toString();
+	return `${rounded} t/s`;
+}
+
+/**
+ * Elapsed time at pill width: `45s`, `2m 13s`, `1h 5m`.
+ *
+ * Two units at most. The pill is a glance, not a stopwatch, and dropping the
+ * fine unit once the coarser one carries the meaning keeps the bar from growing
+ * a column every second. Negative input clamps to `0s`.
+ */
+export function buildElapsedLabel(elapsedMs: number): string {
+	const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
 	const hours = Math.floor(totalSeconds / 3600);
 	const minutes = Math.floor((totalSeconds % 3600) / 60);
 	const seconds = totalSeconds % 60;
@@ -258,6 +332,49 @@ export function buildSessionDurationLabel(startEpoch: number): string {
 	return `${seconds}s`;
 }
 
+export function buildSessionDurationLabel(startEpoch: number): string {
+	return buildElapsedLabel(Date.now() - startEpoch);
+}
+
+/**
+ * When the session really started.
+ *
+ * A resumed session (`--continue`, `--resume`) keeps the header of the session it
+ * continues, so the elapsed-time segment has to read that instead of the moment
+ * this process attached to it — otherwise every resumed session reads `0s`.
+ */
+/**
+ * What to tell the user when compaction fails, or undefined when there is nothing
+ * to say.
+ *
+ * Pi emits \`session_compact_failed\` but draws nothing for it, so a failure late in
+ * a long session looks like the agent simply forgetting the conversation. An
+ * abort is the user's own doing and stays silent.
+ */
+export function compactionFailureNotice(event: {
+	aborted?: boolean;
+	errorMessage?: string;
+	reason?: string;
+}): string | undefined {
+	if (event.aborted) return undefined;
+	const reason =
+		event.reason === "overflow"
+			? " (context was full)"
+			: event.reason === "manual"
+				? ""
+				: " (context threshold)";
+	const detail = event.errorMessage?.trim();
+	return detail ? `Compaction failed${reason}: ${detail}` : `Compaction failed${reason}`;
+}
+
+export function resolveSessionStartEpoch(
+	header: { timestamp?: string } | null | undefined,
+	now = Date.now(),
+): number {
+	const parsed = header?.timestamp ? Date.parse(header.timestamp) : Number.NaN;
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : now;
+}
+
 export function contextColorTier(
 	percent: number | null | undefined,
 	thresholds: ContextThresholds = { warning: 70, error: 90 },
@@ -471,3 +588,17 @@ export function formatOsLabel(
 ): string {
 	return resolveOsIcon(configuredIcon, mode, platform);
 }
+
+/**
+ * The number a status is about, for statuses configured as `formats: value`:
+ * `Tavily: 41.1%` → `41.1%`, `1 proc` → `1`, `¥1,447.55 spent` → `1,447.55`.
+ *
+ * Text with no number is returned unchanged: a status that is a word ("ready",
+ * "offline") is still the whole of what it has to say, and blanking it would
+ * leave an icon that means nothing.
+ */
+export function statusValueText(text: string): string {
+	const match = text.match(/-?\d[\d,.]*%?/);
+	if (!match) return text;
+	return match[0].replace(/\s+/g, "");
+}

package/extensions/starline/git-live.ts

@@ -0,0 +1,20 @@
+/**
+ * The git state the last project refresh produced.
+ *
+ * The footer draws from it every render; the pill's bubble reads it on click, so
+ * a click costs no `git status` of its own. `index.ts` sets it once per session
+ * (the state object is mutated in place) and clears it on shutdown, so a bubble
+ * opened after the session ended shows nothing rather than a stale tree.
+ */
+
+import type { GitStatusSummary } from "./git";
+
+let current: GitStatusSummary | undefined;
+
+export function setActiveGitStatus(status: GitStatusSummary | undefined): void {
+	current = status;
+}
+
+export function activeGitStatus(): GitStatusSummary | undefined {
+	return current;
+}

package/extensions/starline/git-probe.ts

@@ -0,0 +1,40 @@
+/**
+ * What the bar needs git to read.
+ *
+ * Every optional probe costs a process: `git tag --points-at` for an exact tag,
+ * `git diff HEAD --numstat` for line counts, `git remote -v` for a forge logo.
+ * This decides which of them a given segment list asks for, so what is on the
+ * bar and what gets read cannot drift apart — the bug that made a `gitTag` pill
+ * render empty unless the unrelated `footerSegments.gitCommit` toggle was on.
+ *
+ * It also answers whether git should be read at all. A bar with no git pill
+ * draws nothing from `git status`, so the refresh skip the two processes it
+ * would otherwise start every thirty seconds.
+ */
+
+export type GitProbeOptions = {
+	/** Whether any pill on the bar shows something read from the repository. */
+	enabled: boolean;
+	/** The pills that show a commit hash want its tag too, when tags are on. */
+	readExactTag: boolean;
+	readMetrics: boolean;
+	readHost: boolean;
+};
+
+/** Pills whose content comes from a git read. */
+const GIT_SEGMENTS = ["git", "gitCommit", "gitTag", "gitMetrics"] as const;
+
+/** Read options for `readGitStatus` plus the host lookup, from one segment list. */
+export function gitProbeOptions(
+	segments: readonly string[],
+	config: { showTag: boolean; hostIcon: boolean },
+): GitProbeOptions {
+	const wants = (name: string) => segments.includes(name);
+	const wantsCommit = wants("gitCommit");
+	return {
+		enabled: GIT_SEGMENTS.some(wants),
+		readExactTag: wants("gitTag") || (wantsCommit && config.showTag),
+		readMetrics: wants("gitMetrics"),
+		readHost: wants("git") && config.hostIcon,
+	};
+}

package/extensions/starline/git-segments.ts

@@ -0,0 +1,175 @@
+/**
+ * The git part of the footer, rendered once.
+ *
+ * The bar asks for seven strings: branch icon, branch name, dirty-state block,
+ * operation label, commit, tag and line metrics. They live here rather than in
+ * `footer.ts` so that everything which decides *what a git segment says* — the
+ * icon set, the colours, branch length, hash length, counts instead of glyphs —
+ * is in one file, and `footer.ts` stays layout.
+ */
+
+import type { ColorSource, ColorSpec, PolishedTuiConfig } from "./config";
+import { formatGitBranchText, formatGitCommitSegment, formatGitMetricsSegment } from "./format";
+import type { GitHost, GitStatusSummary } from "./git";
+import type { ResolvedIcons } from "./icons";
+import { renderStyleForSource, type ThemeLike } from "./style";
+
+/** The state fields the git segments read. */
+export type GitSegmentState = Pick<
+	GitStatusSummary,
+	| "branch"
+	| "ahead"
+	| "behind"
+	| "conflicted"
+	| "untracked"
+	| "stashed"
+	| "modified"
+	| "staged"
+	| "renamed"
+	| "deleted"
+	| "typechanged"
+	| "gitStateLabel"
+	| "commit"
+	| "metrics"
+> & { gitHost?: GitHost };
+
+/** The config the git segments read. */
+export type GitSegmentConfig = Pick<PolishedTuiConfig, "colors" | "icons" | "git">;
+
+export type GitSegments = {
+	/** Branch icon in branch colour; "" when the repository has no branch. */
+	icon: string;
+	/** Shortened branch name in branch colour; undefined on a detached HEAD. */
+	branchText: string | undefined;
+	/** `icon branch` as the bar shows it; "" when there is no branch. */
+	branch: string;
+	/**
+	 * The whole thing in one pill: `icon branch [status] OPERATION`. This is what
+	 * the `git` segment draws, so a dirty tree reads next to the branch it is
+	 * dirty on rather than in a second pill of its own.
+	 */
+	label: string;
+	/** Dirty-worktree glyphs and ahead/behind in a `[...]` block; "" when clean. */
+	status: string;
+	/** `REBASING`-style operation label; "" when no operation is in progress. */
+	state: string;
+	/** Short hash (and tag, when `gitCommit.showTag`), or "" when hidden. */
+	commit: string;
+	/** The tag on its own, for a `gitTag` segment; "" when there is none. */
+	tag: string;
+	/** `+added −deleted` line counts; "" when there are none to show. */
+	metrics: string;
+};
+
+/** Forge logo for the branch segment. Empty in ascii mode, which has no glyphs. */
+export function gitHostIconGlyph(icons: ResolvedIcons, host: GitHost): string {
+	switch (host) {
+		case "github":
+			return icons.gitHostGithub;
+		case "gitlab":
+			return icons.gitHostGitlab;
+		case "bitbucket":
+			return icons.gitHostBitbucket;
+		default:
+			return icons.gitHostGeneric;
+	}
+}
+
+/**
+ * Render every git segment.
+ *
+ * Everything the output depends on — colours, icons, branch length, hash length,
+ * counts instead of lone glyphs — comes from `config.git` and `config.colors`.
+ */
+export function renderGitSegments(
+	state: GitSegmentState,
+	config: GitSegmentConfig,
+	theme: ThemeLike,
+	colorSource: ColorSource,
+): GitSegments {
+	const git = config.git;
+	const counts = git.counts;
+	const paint = (spec: ColorSpec, text: string) =>
+		renderStyleForSource(theme, colorSource, spec, text);
+	const icons = config.icons;
+
+	// With git.hostIcon on, the branch icon becomes the origin remote's forge
+	// logo. Repos with no origin, and ascii mode (whose host glyphs are all
+	// empty), fall back to the plain branch icon.
+	const hostGlyph = git.hostIcon && state.gitHost ? gitHostIconGlyph(icons, state.gitHost) : "";
+	const glyph = hostGlyph || icons.git;
+	const icon = glyph ? paint(config.colors.gitBranch, glyph) : "";
+
+	const branchText = state.branch
+		? paint(config.colors.gitBranch, formatGitBranchText(state.branch, git.branch.maxLength))
+		: undefined;
+	// A detached HEAD has no branch name; `HEAD` still says where the tree is, and
+	// it is what the text footer used to print.
+	const headText =
+		branchText ??
+		(state.commit && !state.branch
+			? paint(config.colors.gitBranch, state.commit.oid ? "HEAD" : "")
+			: undefined);
+
+	const stashLabel =
+		state.stashed > 0 ? (counts ? `${icons.stashed}${state.stashed}` : icons.stashed) : "";
+	const dirty = [
+		state.conflicted > 0 ? icons.conflicted : "",
+		stashLabel,
+		state.deleted > 0 ? icons.deleted : "",
+		state.renamed > 0 ? icons.renamed : "",
+		state.modified > 0 ? icons.modified : "",
+		state.typechanged > 0 ? icons.typechanged : "",
+		state.staged > 0 ? icons.staged : "",
+		state.untracked > 0 ? icons.untracked : "",
+	].join("");
+	const aheadBehind = (() => {
+		if (state.ahead > 0 && state.behind > 0) {
+			return counts ? `${icons.ahead}${state.ahead}${icons.behind}${state.behind}` : icons.diverged;
+		}
+		if (state.ahead > 0) return counts ? `${icons.ahead}${state.ahead}` : icons.ahead;
+		if (state.behind > 0) return counts ? `${icons.behind}${state.behind}` : icons.behind;
+		return "";
+	})();
+	// Plain text: the pill paints its whole label in one contrast colour, so
+	// colouring pieces here would only be stripped again.
+	const status = dirty || aheadBehind ? `[${dirty}${aheadBehind}]` : "";
+
+	const operation = state.gitStateLabel ?? "";
+
+	const commit = formatGitCommitSegment(
+		theme,
+		state.commit,
+		git.commit,
+		colorSource,
+		config.colors.gitCommit,
+	);
+	const tag =
+		git.commit.showTag && state.commit?.tag ? paint(config.colors.gitCommit, state.commit.tag) : "";
+	const metrics = formatGitMetricsSegment(
+		theme,
+		state.metrics,
+		git.metrics,
+		colorSource,
+		config.colors.gitMetricsAdded,
+	);
+
+	const branch = branchText ? (icon ? `${icon} ${branchText}` : branchText) : "";
+	const labelParts = [
+		headText ? (icon ? `${icon} ${headText}` : headText) : "",
+		status,
+		operation,
+	].filter(Boolean);
+
+	return {
+		icon,
+		branchText,
+		branch,
+		label: labelParts.join(" "),
+		status,
+		state: operation,
+		commit,
+		tag,
+		metrics,
+	};
+}

package/extensions/starline/git.ts

@@ -6,6 +6,20 @@ import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const GIT_COMMAND_TIMEOUT_MS = 2_000;
 
+/**
+ * Read the repository without writing to it.
+ *
+ * `status` and `diff` refresh the index's stat information as a side effect,
+ * which means taking `.git/index.lock` and rewriting `.git/index`. From a footer
+ * that polls every thirty seconds that is churn on the user's repository, and a
+ * lock that can collide with their own `git commit`. `GIT_OPTIONAL_LOCKS=0` tells
+ * git to skip every lock it does not need to answer the question (git 2.15+).
+ *
+ * An environment variable rather than `--no-optional-locks`: an older git ignores
+ * a variable it does not know, and fails on a flag it does not know.
+ */
+const GIT_READ_ENV: NodeJS.ProcessEnv = { ...process.env, GIT_OPTIONAL_LOCKS: "0" };
+
 export type GitOperationState =
 	| "REBASING"
 	| "MERGING"
@@ -37,6 +51,17 @@ export type GitMetricsInfo = {
 	deleted: number;
 };
 
+/**
+ * One changed path, as `git status` reports it.
+ *
+ * `code` is a single letter for the pill's bubble: the index side when there is
+ * one (`M` staged), the worktree side otherwise. `?` untracked, `U` conflicted.
+ */
+export type GitChange = {
+	code: string;
+	path: string;
+};
+
 export type GitStatusSummary = {
 	branch?: string;
 	dirty: boolean;
@@ -54,6 +79,11 @@ export type GitStatusSummary = {
 	gitStateLabel?: string;
 	commit?: GitCommitInfo;
 	metrics?: GitMetricsInfo | null;
+	/**
+	 * Changed paths, in `git status` order, capped at `MAX_TRACKED_CHANGES`. Only
+	 * the bubble reads them; the pill itself is drawn from the counts.
+	 */
+	changes: GitChange[];
 };
 
 export type GitReadResult =
@@ -90,9 +120,36 @@ export function emptyGitStatus(): GitStatusSummary {
 		gitStateLabel: undefined,
 		commit: undefined,
 		metrics: undefined,
+		changes: [],
 	};
 }
 
+/** Cap on remembered paths: the bubble shows a dozen, the rest is `+N more`. */
+const MAX_TRACKED_CHANGES = 200;
+
+/**
+ * The rest of a porcelain v2 line after its fixed fields.
+ *
+ * The path is whatever follows the last space-separated field, so paths with
+ * spaces survive: `1 .M N... 100644 100644 100644 abc def my file.txt` keeps
+ * `my file.txt` whole.
+ */
+function porcelainPath(line: string, fields: number): string {
+	let index = 0;
+	for (let field = 0; field < fields; field += 1) {
+		index = line.indexOf(" ", index);
+		if (index < 0) return "";
+		index += 1;
+	}
+	return line.slice(index);
+}
+
+function addChange(status: GitStatusSummary, code: string, path: string): void {
+	const trimmed = path.trim();
+	if (!trimmed || status.changes.length >= MAX_TRACKED_CHANGES) return;
+	status.changes.push({ code: code === "." || code === " " ? "M" : code, path: trimmed });
+}
+
 export function parseGitStatusPorcelain(stdoutText: string, stashCount: number): GitStatusSummary {
 	const status = emptyGitStatus();
 	status.stashed = stashCount;
@@ -133,10 +190,12 @@ export function parseGitStatusPorcelain(stdoutText: string, stashCount: number):
 
 		if (line.startsWith("? ")) {
 			status.untracked += 1;
+			addChange(status, "?", line.slice(2));
 			continue;
 		}
 		if (line.startsWith("u ")) {
 			status.conflicted += 1;
+			addChange(status, "U", porcelainPath(line, 10));
 			continue;
 		}
 		if (!(line.startsWith("1 ") || line.startsWith("2 "))) continue;
@@ -153,6 +212,11 @@ export function parseGitStatusPorcelain(stdoutText: string, stashCount: number):
 		if (y === "M") status.modified += 1;
 		else if (y === "D") status.deleted += 1;
 		else if (y === "T") status.typechanged += 1;
+
+		// `2` lines carry an extra score field before the path, and a rename adds
+		// `<tab>original` to it; the new name is what the bubble lists.
+		const path = porcelainPath(line, line.startsWith("2 ") ? 9 : 8).split("\t")[0] ?? "";
+		addChange(status, x !== "." ? x : y, path);
 	}
 
 	// Only populate commit info when we actually saw branch headers (inside
@@ -236,6 +300,7 @@ async function resolveGitPath(cwd: string, pathSpec: string): Promise<string | u
 			["--no-optional-locks", "rev-parse", "--git-path", pathSpec],
 			{
 				cwd,
+				env: GIT_READ_ENV,
 				timeout: GIT_COMMAND_TIMEOUT_MS,
 			},
 		);
@@ -313,10 +378,12 @@ export async function readGitStatus(
 		const [{ stdout: statusStdout }, stashResult, tagResult, metricsResult] = await Promise.all([
 			execFileAsync("git", ["--no-optional-locks", "status", "--porcelain=2", "--branch"], {
 				cwd,
+				env: GIT_READ_ENV,
 				timeout: GIT_COMMAND_TIMEOUT_MS,
 			}),
 			execFileAsync("git", ["--no-optional-locks", "stash", "list"], {
 				cwd,
+				env: GIT_READ_ENV,
 				timeout: GIT_COMMAND_TIMEOUT_MS,
 			}).catch(() => ({ stdout: "" })),
 			readExactTag
@@ -325,6 +392,7 @@ export async function readGitStatus(
 						["--no-optional-locks", "describe", "--tags", "--exact-match", "HEAD"],
 						{
 							cwd,
+							env: GIT_READ_ENV,
 							timeout: GIT_COMMAND_TIMEOUT_MS,
 						},
 					).then(
@@ -335,6 +403,7 @@ export async function readGitStatus(
 			readMetrics
 				? execFileAsync("git", numstatArgs, {
 						cwd,
+						env: GIT_READ_ENV,
 						timeout: GIT_COMMAND_TIMEOUT_MS,
 					}).then(
 						(r) => ({ stdout: typeof r.stdout === "string" ? r.stdout : String(r.stdout) }),
@@ -382,6 +451,7 @@ export async function readGitStatus(
 				["--no-optional-locks", "rev-parse", "--is-inside-work-tree"],
 				{
 					cwd,
+					env: GIT_READ_ENV,
 					timeout: GIT_COMMAND_TIMEOUT_MS,
 				},
 			);
@@ -450,6 +520,7 @@ export async function readGitHost(cwd: string): Promise<GitHost | undefined> {
 			["--no-optional-locks", "remote", "get-url", "origin"],
 			{
 				cwd,
+				env: GIT_READ_ENV,
 				timeout: GIT_COMMAND_TIMEOUT_MS,
 			},
 		);

package/extensions/starline/icons.ts

@@ -38,6 +38,12 @@ export type IconGlyphs = {
 	context: string;
 	cost: string;
 	tokens: string;
+	/** Decode throughput, shown only after a message has been measured. */
+	tps: string;
+	/** The queued-messages pill, shown in front of the count. */
+	queue: string;
+	/** The running-subagents pill. Same glyph pi-tidy uses for subagent tool rows. */
+	subagents: string;
 	/** Forge logos for the branch segment, used only when gitHostIcon is on. */
 	gitHostGithub: string;
 	gitHostGitlab: string;
@@ -73,6 +79,9 @@ export const ICON_GLYPH_KEYS = [
 	"context",
 	"cost",
 	"tokens",
+	"tps",
+	"queue",
+	"subagents",
 	"gitHostGithub",
 	"gitHostGitlab",
 	"gitHostBitbucket",
@@ -114,6 +123,11 @@ export const NERD_DEFAULT_ICONS: IconGlyphs = {
 	context: "",
 	cost: "",
 	tokens: "",
+	tps: "",
+	// fa-inbox: messages waiting their turn.
+	queue: "\uf01c",
+	// fa-users, the glyph pi-tidy draws for a subagent tool row.
+	subagents: "\uf0c0",
 	gitHostGithub: "",
 	gitHostGitlab: "",
 	gitHostBitbucket: "",
@@ -146,6 +160,9 @@ export const ASCII_DEFAULT_ICONS: IconGlyphs = {
 	context: "",
 	cost: "",
 	tokens: "",
+	tps: "",
+	queue: "",
+	subagents: "",
 	// gitHostIcon is a Nerd Font feature; it disables itself in ascii mode.
 	gitHostGithub: "",
 	gitHostGitlab: "",