one-code-extension 0.4.0 → 0.5.0

package/extensions/file-tracker/results.ts

@@ -0,0 +1,66 @@
+/**
+ * Claude Code's result and error texts for pi's built-in read, write and edit
+ * (pure). pi's tools keep their call shapes (`path`, `edits[]`) and their own
+ * behavior; only what the model reads back changes, by rewriting the first
+ * text block of a result whose text is pi's exact wording. Anything else
+ * (pi's truncation notes, an image, a block another hook appended) passes
+ * through untouched.
+ *
+ * The success texts say the file state is current, which is true here: the
+ * file-tracker observes the file after every successful write or edit, so the
+ * next edit is not refused as unread or stale.
+ */
+
+type Block = { type: string; text?: string };
+
+export const FILE_STATE_CURRENT = " (file state is current in your context — no need to read it back)";
+
+/** Claude Code's missing-file error for read and edit. */
+export function fileDoesNotExist(cwd: string): string {
+	return `File does not exist. Note: your current working directory is ${cwd}.`;
+}
+
+/** Claude Code's empty-file read result. */
+export const EMPTY_FILE_WARNING = "<system-reminder>Warning: the file exists but the contents are empty.</system-reminder>";
+
+export interface FileToolResult {
+	toolName: string;
+	isError: boolean;
+	content: Block[];
+	/** The absolute path the tool touched. */
+	path: string;
+	cwd: string;
+	/** For a write: whether the file existed before the call (Claude Code says "updated" then, "created" otherwise). */
+	existedBefore?: boolean;
+	/** For a read: whether the file is empty on disk (asked only for an empty result). */
+	isEmptyFile?: () => boolean;
+}
+
+/** The first block's replacement text, or undefined to leave the result as pi wrote it. */
+function rewrite(result: FileToolResult, text: string): string | undefined {
+	const { toolName, isError, path, cwd } = result;
+	if (toolName === "write" && !isError && text.startsWith("Successfully wrote to ")) {
+		return result.existedBefore
+			? `The file ${path} has been updated successfully.${FILE_STATE_CURRENT}`
+			: `File created successfully at: ${path}${FILE_STATE_CURRENT}`;
+	}
+	if (toolName === "edit" && !isError && /^Successfully replaced \d+ block\(s\) in /.test(text)) {
+		return `The file ${path} has been updated successfully.${FILE_STATE_CURRENT}`;
+	}
+	if (toolName === "edit" && isError && /^Could not edit file: .*\. Error code: ENOENT\.$/s.test(text)) return fileDoesNotExist(cwd);
+	if (toolName === "read" && isError) {
+		if (/^ENOENT: no such file or directory, \w+ '/.test(text)) return fileDoesNotExist(cwd);
+		if (text === "EISDIR: illegal operation on a directory, read") return `${text} '${path}'`;
+	}
+	if (toolName === "read" && !isError && text === "" && result.isEmptyFile?.()) return EMPTY_FILE_WARNING;
+	return undefined;
+}
+
+/** The result's content with Claude Code's text in place of pi's, or undefined when nothing changes. */
+export function fileToolResultContent<B extends Block>(result: FileToolResult & { content: B[] }): B[] | undefined {
+	if (!Array.isArray(result.content)) return undefined;
+	const [first, ...rest] = result.content;
+	if (first?.type !== "text" || typeof first.text !== "string") return undefined;
+	const text = rewrite(result, first.text);
+	return text === undefined ? undefined : [{ ...first, text }, ...rest];
+}

package/extensions/file-tracker/shell-reads.ts

@@ -0,0 +1,211 @@
+/**
+ * Files a shell command showed the model in full (pure apart from the bash
+ * grammar, which the caller awaits).
+ *
+ * The auto-mode note tells the model to read files with cat, head or sed, and
+ * GPT-6 models do. Before this, the edit that followed was refused as
+ * "not read in this conversation" although the whole file was in the
+ * transcript: 16 refused edits in one 72-run battery (2026-10-04). A file now
+ * counts as read when a line that runs a reader names it and the output holds
+ * the file's entire current content. That one check covers every way the
+ * model could have seen less: a pipe into `head`, `cat -n`, a slice, an output
+ * persisted or clipped for size, a write later in the same command. The
+ * stale-edit guard is unchanged, since the file is observed with that content.
+ */
+
+import { isAbsolute } from "node:path";
+import { toAbsoluteBash } from "../auto-mode/paths.ts";
+import { globComponentRegex, isUnknownTilde, movesDirectory, resolvePayload } from "../auto-mode/shell-analysis.ts";
+import { LOOPS, parseCommand, type ParseResult, scopedTracker, type Segment, type Token } from "../auto-mode/shell-parse.ts";
+
+/** Commands whose file arguments may print a whole file. */
+const READERS = new Set(["cat", "head", "tail", "sed"]);
+
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+
+/** A word a reader may have printed, with the absolute directory the shell resolves it in. */
+export interface ShellReadCandidate {
+	word: string;
+	dir: string;
+}
+
+/**
+ * The files `command` may have printed, as written: the plain arguments of
+ * its reader commands, plus every path-like word of a line that runs a reader
+ * at all. Candidates only, each still to be checked with {@link shownInFull}.
+ * Each comes with the directory its reader runs in, starting from `cwd` and
+ * following a literal `cd` ({@link segmentDirectories}); a reader whose
+ * directory cannot be known offers nothing. Empty when no reader runs or the
+ * command does not parse (the grammar not loaded included).
+ */
+export function shellReadCandidates(command: string, cwd: string, home: string): ShellReadCandidate[] {
+	const parsed = parseCommand(command);
+	if (parsed.parseFailed) return [];
+	const readers = parsed.segments.flatMap((segment, index) => {
+		const first = segment.tokens.findIndex((token) => !ASSIGNMENT.test(token.value));
+		if (first === -1) return [];
+		const [head, ...args] = segment.tokens.slice(first);
+		return head && !head.dynamic && READERS.has(head.value.split("/").pop() ?? "") ? [{ segment, index, args }] : [];
+	});
+	// Most commands run no reader: skip the directory walk for them.
+	if (readers.length === 0) return [];
+	const dirs = segmentDirectories(parsed, cwd, home);
+	const candidates = new Map<string, ShellReadCandidate>();
+	const add = (word: string, dir: string) => candidates.set(`${dir}\0${word}`, { word, dir });
+	const readerDirs = new Set<string>();
+	for (const { segment, index, args } of readers) {
+		const dir = dirs[index];
+		if (dir === undefined) continue;
+		readerDirs.add(dir);
+		if (segment.substitution !== undefined) continue;
+		for (const arg of args) if (isPlainPath(arg)) add(arg.value, dir);
+	}
+	// A reader fed from a variable (`for f in a.py b.py; do cat "$f"; done`)
+	// names its files elsewhere in the line. Every plain path-like word is a
+	// candidate then, in each directory a reader ran in: the full-content
+	// check, not the parse, decides.
+	if (readerDirs.size > 0) {
+		const words = new Set<string>();
+		for (const word of [...(command.match(PATH_WORD) ?? []), ...(command.match(GLOB_WORD) ?? [])]) if (words.size < MAX_CANDIDATES) words.add(word);
+		for (const dir of [...readerDirs].slice(0, MAX_READER_DIRS)) for (const word of words) add(word, dir);
+	}
+	return [...candidates.values()];
+}
+
+/**
+ * The absolute paths `command` may have printed: its candidates
+ * ({@link shellReadCandidates}) resolved as the shell resolves them, from
+ * the directory each one's reader runs in, with a glob expanded through
+ * `readdir` (given an absolute directory). The shell's own resolution
+ * (`toAbsoluteBash`), not the file tools' (`resolveToolPath` strips a leading
+ * `@`, which `cat @x` keeps): `~/` and the shell's directory only.
+ */
+export function shellReadPaths(command: string, cwd: string, home: string, readdir: (dir: string) => string[]): string[] {
+	const paths = new Set<string>();
+	for (const { word, dir } of shellReadCandidates(command, cwd, home)) {
+		for (const name of expandCandidate(word, (sub) => readdir(toAbsoluteBash(dir, sub, home)))) paths.add(toAbsoluteBash(dir, name, home));
+	}
+	return [...paths];
+}
+
+/**
+ * The directory each segment runs in, or undefined where it cannot be known.
+ * Only a plain `cd <literal>` (or `cd -- <literal>`) that surely ran moves
+ * the commands after it in its own subshell scope (`scopedTracker`). One that
+ * may not run moves only the later members of its own `&&` list
+ * (`Segment.andList`), which run only once it succeeded (`cd src && cat x`
+ * inside the worktree's `cd <wt> && ( … )`). Anything else that may change
+ * the directory makes the commands after it unknown, never guessed: a
+ * dynamic, glob, `-` or `~user` target, an option, `pushd` and `popd`, a
+ * wrapper, assignment or `!` in front, a `cd` that may not run (an `if`
+ * branch, after `||`) for everything outside its `&&` list, a `cd` last in a
+ * pipeline (`lastpipe` runs it in the shell around), a backgrounded line,
+ * `eval` and `source`, and a line that defines a function (which may replace
+ * `cd`). A loop body runs more than once, so after a move in any loop every
+ * command in a loop is unknown too. A miss costs one re-read; a wrong
+ * directory would certify a read that never happened.
+ */
+function segmentDirectories(parsed: ParseResult, cwd: string, home: string): (string | undefined)[] {
+	const { segments } = parsed;
+	const dirs = scopedTracker<string | undefined>(cwd);
+	/** Where a `cd` that may not have run moved the later members of its `&&` list, by list. */
+	const listDirs = new Map<number, string | undefined>();
+	const inLoop = (segment: Segment) => segment.enclosing.some((construct) => LOOPS.has(construct));
+	const moves = segments.map(mayMove);
+	const loopMoves = segments.some((segment, index) => moves[index] && inLoop(segment));
+	return segments.map((segment, index) => {
+		const inList = segment.andList !== undefined && listDirs.has(segment.andList);
+		const dir = loopMoves && inLoop(segment) ? undefined : inList ? listDirs.get(segment.andList!) : dirs.get(segment);
+		if (!moves[index]) return dir;
+		const certain = !parsed.background && !parsed.definesFunction && !segment.pipelineShell && !segment.enclosing.includes("negated_command");
+		const target = certain ? literalCdTarget(segment) : undefined;
+		// A relative target from an unknown directory stays unknown; an absolute one re-anchors.
+		const next = target === undefined ? undefined : dir === undefined && !isAbsoluteTarget(target) ? undefined : toAbsoluteBash(dir ?? cwd, target, home);
+		if (segment.pipelineShell) dirs.set({ scopes: segment.pipelineShell }, undefined);
+		if (segment.conditional) {
+			dirs.set(segment, undefined);
+			if (segment.andList !== undefined) listDirs.set(segment.andList, next);
+		} else {
+			dirs.set(segment, next);
+		}
+		return dir;
+	});
+}
+
+/** Whether a segment may change the shell's directory: a `cd`/`pushd`/`popd` in any spelling, or a script run in this shell. */
+function mayMove(segment: Segment): boolean {
+	return movesDirectory(segment) || ["eval", "source", "."].includes(resolvePayload(segment.tokens).command);
+}
+
+/** The target of `cd <word>` or `cd -- <word>` written plainly, or undefined for any other form. */
+function literalCdTarget(segment: Segment): string | undefined {
+	const [head, ...args] = segment.tokens;
+	if (head?.value !== "cd" || head.dynamic) return undefined;
+	const rest = args[0]?.value === "--" ? args.slice(1) : args;
+	if (rest.length > 1) return undefined;
+	const target = rest[0];
+	// A bare `cd` goes home.
+	if (!target) return "~";
+	if (target.dynamic || target.glob || target.value === "" || target.value.startsWith("-") || isUnknownTilde(target.value)) return undefined;
+	return target.value;
+}
+
+/** Whether a `cd` target lands in the same place from any directory. */
+function isAbsoluteTarget(target: string): boolean {
+	return isAbsolute(target) || target === "~" || target.startsWith("~/");
+}
+
+/**
+ * The files a candidate names: itself, or for a glob in its last component
+ * (`src/*.py`, a loop's word list), the matching entries of that directory,
+ * listed through `readdir` (no shell). Globs in a directory component are not
+ * expanded.
+ */
+export function expandCandidate(word: string, readdir: (dir: string) => string[]): string[] {
+	if (!/[*?[]/.test(word)) return [word];
+	const slash = word.lastIndexOf("/");
+	const dir = slash === -1 ? "" : word.slice(0, slash);
+	if (/[*?[]/.test(dir)) return [];
+	const pattern = globComponentRegex(word.slice(slash + 1));
+	if (!pattern) return [];
+	let names: string[];
+	try {
+		names = readdir(dir || ".");
+	} catch {
+		return [];
+	}
+	return names.filter((name) => !name.startsWith(".") && pattern.test(name)).map((name) => (dir ? `${dir}/${name}` : name)).slice(0, MAX_CANDIDATES);
+}
+
+/** A word that could be a file path as written, absolute or relative: no quoting, expansion or glob characters. */
+const PATH_WORD = /(?<![\w$\-/])\/?[\w.@+~][\w.@+~/,-]*/g;
+/** A word with a glob character, which the shell would expand (`src/*.py`). */
+const GLOB_WORD = /(?<![\w$\-])[\w.@+~/,-]*[*?[][\w.@+~/,*?[\]-]*/g;
+const MAX_CANDIDATES = 50;
+/** The path-like words of a line are tried in at most this many reader directories. */
+const MAX_READER_DIRS = 4;
+
+function isPlainPath(token: Token): boolean {
+	return !token.dynamic && !token.glob && token.value !== "" && !token.value.startsWith("-");
+}
+
+/**
+ * Whether `output` shows the whole of `content`. Trailing whitespace is
+ * ignored because the shell tool trims it. A tiny one-line file is never
+ * counted: its text turns up in outputs by chance (an adversarial GPT-6 Astra
+ * run matched `completed` to "(bash completed with no output)", `1` to
+ * "Exit code 1", an error line, a persisted-output tag), so the match would
+ * not show that the file was printed. What the guard protects still holds for
+ * a larger match under another file's name: every byte of the file was in
+ * front of the model, so an edit cannot discard content it has not seen.
+ */
+export function shownInFull(output: string, content: string): boolean {
+	const body = content.trimEnd();
+	if (body.length < MIN_SHOWN_CHARS && !(body.includes("\n") && body.length >= MIN_SHOWN_LINES_CHARS)) return false;
+	return output.includes(body);
+}
+
+/** A one-line file shorter than this is never counted as shown. */
+const MIN_SHOWN_CHARS = 40;
+/** A multi-line file shorter than this is never counted as shown. */
+const MIN_SHOWN_LINES_CHARS = 16;

package/extensions/file-tracker/tracker.ts

@@ -13,8 +13,15 @@
 export type FreshnessStatus = "fresh" | "unread" | "stale" | "absent";
 
 export interface TrackedFile {
-	/** Content as of the last read or write we performed. */
+	/** Content as of the last read or write we performed ("" when `oversized`). */
 	content: string;
+	/**
+	 * Too large to keep: we saw the file but hold no content to compare. An
+	 * explicit flag, never the empty string, so a file read while EMPTY
+	 * compares like any other and cannot be overwritten after someone fills
+	 * it (TOOLS-REVIEW-2026-09-26 M2).
+	 */
+	oversized: boolean;
 	at: number;
 }
 
@@ -54,9 +61,9 @@ export class FileTracker {
 		this.notified.delete(path);
 		if (content.length > MAX_TRACKED_BYTES) {
 			// Too large to diff usefully; remember that we saw it, not its content.
-			this.files.set(path, { content: "", at });
+			this.files.set(path, { content: "", oversized: true, at });
 		} else {
-			this.files.set(path, { content, at });
+			this.files.set(path, { content, oversized: false, at });
 		}
 		if (stamp) this.stamps.set(path, stamp);
 		else this.stamps.delete(path);
@@ -103,8 +110,10 @@ export class FileTracker {
 		return this.files.has(path);
 	}
 
+	/** The content last seen, or undefined when untracked or tracked without content (oversized). */
 	lastSeen(path: string): string | undefined {
-		return this.files.get(path)?.content;
+		const known = this.files.get(path);
+		return known && !known.oversized ? known.content : undefined;
 	}
 
 	get tracked(): string[] {
@@ -123,7 +132,7 @@ export class FileTracker {
 		if (!known) return "unread";
 		// Oversized files are tracked without content; treat them as fresh rather
 		// than blocking edits we cannot reason about.
-		if (known.content === "" && currentContent !== "") return "fresh";
+		if (known.oversized) return "fresh";
 		return known.content === currentContent ? "fresh" : "stale";
 	}
 }
@@ -173,20 +182,28 @@ export function describeChanges(
 }
 
 export const UNREAD_REASON = (path: string, tool: string) =>
-	`Read ${path} before using ${tool} on it. The file exists and has not been read in this conversation, so an edit could silently discard content you have not seen.`;
+	`Read ${path} before using ${tool} on it. The file exists and has not been read in this conversation, so an edit could silently discard content you have not seen. A shell read counts only when it printed the whole file as it is on disk (a plain \`cat\`); after a partial one (head, sed -n, a pipe, or output cut off at the size limit) or another version of it (such as \`git show HEAD:<file>\`), use the read tool.`;
+
+/**
+ * The same notice when one of this session's subagents or workflow agents
+ * changed the file (lib/child-writes.ts): saying "someone else, a formatter or
+ * a command" there sent the model looking for an outside cause.
+ */
+export const CHILD_CHANGE_REMINDER = (path: string, agent: string | undefined, excerpt: ChangeExcerpt) =>
+	`Note: ${path} was changed by ${agent ? `the agent "${agent}"` : "an agent"} you started in this session since you last read it. Take it as the current state. Here are the relevant changes (shown with line numbers); re-read the file before editing it:\n${excerpt.text}`;
 
 export const STALE_REASON = (path: string) =>
 	`${path} has changed on disk since you last read it — someone else, a formatter, or a command may have modified it. Read it again before editing, or your change would overwrite theirs.`;
 
 /**
- * Claude Code's `edited_text_file` attachment text, with two additions: the
- * cause list also names a command (our tracker sees bash writes too), and the
- * closing clause tells the model to re-read before editing — CC marks the file
- * as read when it attaches the snippet, we deliberately do not (the stale-edit
- * guard keeps firing), so without that clause the model's next edit is blocked
- * and costs a round trip. The "intentional / don't revert / don't tell the
- * user" steer is CC's: without it a model mid-edit tends to restore its own
- * version and narrate linter noise (STEERING-REVIEW-2026-09-05 M5).
+ * Claude Code's `edited_text_file` attachment text, plus One Code's closing
+ * clause telling the model to re-read before editing: Claude Code marks the
+ * file as read when it attaches the snippet, we deliberately do not (the
+ * stale-edit guard keeps firing), so without that clause the model's next
+ * edit is blocked and costs a round trip. The "take it as the current state
+ * rather than reverting it" steer is Claude Code's: without it a model
+ * mid-edit tends to restore its own version and narrate linter noise
+ * (STEERING-REVIEW-2026-09-05 M5).
  */
 export const EXTERNAL_CHANGE_REMINDER = (path: string, excerpt: ChangeExcerpt) =>
-	`Note: ${path} was modified, either by the user, a linter, or a command, after you last read it. This change was intentional, so make sure to take it into account as you proceed (ie. don't revert it unless the user asks you to). Don't tell the user this, since they are already aware. Here are the relevant changes (shown with line numbers); re-read the file before editing it:\n${excerpt.text}`;
+	`Note: ${path} changed on disk since you last read it. That's usually deliberate, so take it as the current state rather than reverting it; if the change looks wrong, say so rather than undoing it yourself — otherwise no need to call it out. Here are the relevant changes (shown with line numbers); re-read the file before editing it:\n${excerpt.text}`;

package/extensions/footer/footer-line.ts

@@ -7,10 +7,13 @@
  * Everything here is pure and paint-injected so it unit-tests with an identity
  * paint. `paint(color, text)` matches `safeThemePaint`; in tests it returns the
  * text unchanged, so assertions see the plain line. Inclusion decisions use
- * plain lengths only, so the painted result (ANSI adds zero display width)
- * always fits the width it was built for.
+ * the plain text's terminal columns (`visibleWidth`, never `.length`, so a CJK
+ * path or branch counts two columns a glyph), so the painted result (ANSI adds
+ * zero display width) always fits the width it was built for.
  */
 
+import { cutPlainText } from "../lib/tui-render.ts";
+import { tailColumns, visibleWidth } from "../lib/text-width.ts";
 import { costOf, usageEntryCost } from "../lib/usage-bus.ts";
 import type { WorktreeLocation } from "../lib/worktree-channel.ts";
 
@@ -21,8 +24,12 @@ export interface FooterData {
 	cwd: string;
 	home: string;
 	branch?: string;
-	/** Context tokens in use and the model's window; both needed to show fill. */
-	contextTokens?: number;
+	/**
+	 * Context tokens in use and the model's window. Tokens are unknown right
+	 * after a compaction until the next reply; the fill then reads `?/window`,
+	 * as pi's own footer shows it.
+	 */
+	contextTokens?: number | null;
 	contextWindow?: number;
 	/** Context percentage, shown in parens after the fill; `null`/undefined omits it
 	 * (e.g. right after compaction, unknown until the next reply). */
@@ -73,12 +80,13 @@ function tilde(cwd: string, home: string): string {
 
 /**
  * Fit a path into `max` columns, keeping the tail (the deepest, most specific
- * folders) with a leading `…`. `max <= 1` collapses to just `…`.
+ * folders) with a leading `…`. `max <= 1` collapses to just `…`. Cut by
+ * columns on a grapheme boundary, so a wide glyph or an emoji stays whole.
  */
 function truncatePath(path: string, max: number): string {
-	if (path.length <= max) return path;
+	if (visibleWidth(path) <= max) return path;
 	if (max <= 1) return "…";
-	return `…${path.slice(path.length - (max - 1))}`;
+	return `…${tailColumns(path, max - 1).text}`;
 }
 
 interface Part {
@@ -86,6 +94,8 @@ interface Part {
 	painted: string;
 	/** Higher drops first when the line is too narrow; 0 = never dropped. */
 	dropPriority: number;
+	/** The model name: the one core part cut (with an ellipsis) when even the core overflows. */
+	model: boolean;
 }
 
 const SEP = " · ";
@@ -103,17 +113,19 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// A labelled metric: the label is muted, the value takes `color`. The plain
 	// form (label + value) drives the width/drop math; the painted form colours
 	// the two halves separately.
-	const push = (label: string, value: string, color: string, dropPriority = 0) => {
+	const push = (label: string, value: string, color: string, dropPriority = 0, model = false) => {
 		if (!value) return;
 		const plain = label ? `${label} ${value}` : value;
 		const painted = label ? `${paint("muted", label)} ${paint(color, value)}` : paint(color, value);
-		parts.push({ plain, painted, dropPriority });
+		parts.push({ plain, painted, dropPriority, model });
 	};
 
-	// Context fill as "usage: tokens/window (pct%)".
-	if (typeof data.contextTokens === "number" && typeof data.contextWindow === "number" && data.contextWindow > 0) {
-		const pct = typeof data.contextPercent === "number" ? ` (${data.contextPercent.toFixed(0)}%)` : "";
-		push("usage:", `${formatTokens(data.contextTokens)}/${formatTokens(data.contextWindow)}${pct}`, "dim");
+	// Context fill as "usage: tokens/window (pct%)", or "?/window" while the
+	// tokens are unknown (right after a compaction).
+	if (typeof data.contextWindow === "number" && data.contextWindow > 0) {
+		const tokens = typeof data.contextTokens === "number" ? formatTokens(data.contextTokens) : "?";
+		const pct = typeof data.contextTokens === "number" && typeof data.contextPercent === "number" ? ` (${data.contextPercent.toFixed(0)}%)` : "";
+		push("usage:", `${tokens}/${formatTokens(data.contextWindow)}${pct}`, "dim");
 	}
 	// Total cost, always shown once known.
 	push("cost:", formatCost(data.cost), "dim");
@@ -123,7 +135,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 		push("cache-hit:", `${data.cacheHitPercent.toFixed(0)}%`, color, 2);
 	}
 	// Model, then effort — no labels; both self-describing.
-	if (data.model) push("", data.model, "dim");
+	if (data.model) push("", data.model, "dim", 0, true);
 	if (data.effort) push("", data.effort, "accent");
 
 	// Left chunk: path + branch, with the open PR attached to the branch as
@@ -132,7 +144,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// branch (bare-branch fallback), and only when there is no room even for the
 	// bare branch does the whole chunk go, leaving metrics alone. The three
 	// segments paint separately — path dim, branch in accent, PR in the link
-	// colour — but every width/gap decision uses their plain lengths.
+	// colour — but every width/gap decision uses their plain columns.
 	const path = tilde(data.cwd, data.home);
 	const branchSeg = data.branch ? ` ⎇ ${data.branch}` : "";
 	const prSeg = data.branch && typeof data.pr === "number" ? ` ← PR #${data.pr}` : "";
@@ -140,7 +152,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// Drop optional right parts (highest priority first) until the metrics fit.
 	let kept = parts.slice();
 	const rightPlain = () => kept.map((p) => p.plain).join(SEP);
-	while (rightPlain().length > width) {
+	while (visibleWidth(rightPlain()) > width) {
 		const droppable = kept
 			.map((p, i) => ({ p, i }))
 			.filter((x) => x.p.dropPriority > 0)
@@ -149,25 +161,34 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 		kept = kept.filter((_, i) => i !== droppable.i);
 	}
 
-	const rightLen = rightPlain().length;
-
-	// Even the core overflows: last resort, truncate the plain metrics to width.
-	if (rightLen > width) {
-		return [paint("dim", rightPlain().slice(0, width))];
+	// Even the core overflows: cut the model name with an ellipsis so the
+	// effort after it stays; when that is not enough, cut the whole line.
+	const overflow = visibleWidth(rightPlain()) - width;
+	if (overflow > 0) {
+		const model = kept.find((p) => p.model);
+		const room = model ? visibleWidth(model.plain) - overflow : 0;
+		if (model && room >= 4) {
+			const shortened = cutPlainText(model.plain, room);
+			kept = kept.map((p) => (p === model ? { ...p, plain: shortened, painted: paint("dim", shortened) } : p));
+		} else {
+			return [paint("dim", cutPlainText(rightPlain(), width))];
+		}
 	}
 
+	const rightLen = visibleWidth(rightPlain());
+
 	const rightPaintedStr = kept.map((p) => p.painted).join(paint("dim", SEP));
 
 	// Room for the left chunk after the metrics and at least one space of gap.
 	// Keep the PR only if the branch+PR both fit; otherwise drop it and keep the
 	// bare branch.
 	const room = width - rightLen - 1;
-	const keptPr = room >= branchSeg.length + prSeg.length + 1 ? prSeg : "";
-	const suffixLen = branchSeg.length + keptPr.length;
+	const keptPr = room >= visibleWidth(branchSeg) + visibleWidth(prSeg) + 1 ? prSeg : "";
+	const suffixLen = visibleWidth(branchSeg) + visibleWidth(keptPr);
 	if (room >= suffixLen + 1) {
 		const shownPath = truncatePath(path, room - suffixLen);
 		const leftPlain = `${shownPath}${branchSeg}${keptPr}`;
-		const gap = " ".repeat(width - leftPlain.length - rightLen);
+		const gap = " ".repeat(Math.max(0, width - visibleWidth(leftPlain) - rightLen));
 		const leftPainted = `${paint("dim", shownPath)}${paint("accent", branchSeg)}${paint("mdLink", keptPr)}`;
 		return [`${leftPainted}${gap}${rightPaintedStr}`];
 	}

package/extensions/footer/index.ts

@@ -24,7 +24,7 @@ import { ULTRACODE_STATUS_KEY } from "../effort/slider.ts";
 import { USAGE_CHANNEL } from "../lib/usage-bus.ts";
 import { buildFooterLines, computeMainUsage, footerLocation, type FooterData } from "./footer-line.ts";
 import { WORKTREE_CHANNEL, type WorktreeLocation } from "../lib/worktree-channel.ts";
-import { fetchPrNumber } from "./pr.ts";
+import { fetchPrNumber, nextPrPollDelay, PR_SLOW_LOOKUP_MS } from "./pr.ts";
 
 export default function footerExtension(pi: ExtensionAPI) {
 	if (process.env.CC_FOOTER === "0") return;
@@ -38,6 +38,27 @@ export default function footerExtension(pi: ExtensionAPI) {
 	let pr: number | undefined;
 	/** Bumped per branch change so a slow gh lookup for an old branch is ignored. */
 	let prToken = 0;
+	/**
+	 * The PR is looked up again once a minute while the session is in use, so a
+	 * PR merged or closed mid-session disappears (pr.ts nextPrPollDelay). A slow
+	 * or missing `gh` turns polling off; branch changes still look up.
+	 */
+	const prPoll = { lastLookupAt: 0, lastInputAt: Date.now(), disabled: false };
+	let prPollTimer: ReturnType<typeof setTimeout> | undefined;
+	const stopPrPoll = () => {
+		clearTimeout(prPollTimer);
+		prPollTimer = undefined;
+	};
+	const schedulePrPoll = () => {
+		stopPrPoll();
+		const delay = nextPrPollDelay(prPoll, Date.now());
+		if (delay === undefined) return;
+		prPollTimer = setTimeout(() => {
+			prPollTimer = undefined;
+			refreshLocation();
+		}, delay);
+		prPollTimer.unref?.();
+	};
 
 	/** Invalidate the memoized line and repaint; set once the footer mounts. */
 	let repaint = () => {};
@@ -71,20 +92,43 @@ export default function footerExtension(pi: ExtensionAPI) {
 
 	const refreshPr = (cwd: string, branch: string | null) => {
 		const token = ++prToken;
+		stopPrPoll();
 		if (!branch) {
 			pr = undefined;
 			repaint();
 			return;
 		}
+		const startedAt = Date.now();
+		prPoll.lastLookupAt = startedAt;
 		void fetchPrNumber(cwd, branch).then((found) => {
 			if (token !== prToken) return; // a newer branch superseded this lookup
-			pr = found;
+			if (found.ghMissing || Date.now() - startedAt > PR_SLOW_LOOKUP_MS) prPoll.disabled = true;
+			pr = found.pr;
 			repaint();
+			schedulePrPoll();
 		});
 	};
 
+	// Input keeps polling alive; after an hour without any, the next input
+	// resumes it. A turn boundary asks again, never sooner than a minute after
+	// the last lookup.
+	pi.on("input", () => {
+		prPoll.lastInputAt = Date.now();
+		if (!prPollTimer) schedulePrPoll();
+	});
+	pi.on("agent_settled", () => {
+		if (!prPollTimer) schedulePrPoll();
+	});
+	pi.on("session_shutdown", () => {
+		stopPrPoll();
+		prToken++;
+	});
+
 	pi.on("session_start", (_event, ctx) => {
 		recomputeMain(ctx);
+		// A slow or missing gh turns polling off for one session, not the process.
+		prPoll.disabled = false;
+		prPoll.lastInputAt = Date.now();
 		if (!ctx.hasUI) return;
 
 		ctx.ui.setFooter((tui: unknown, theme: unknown, footerData: unknown) => {
@@ -144,6 +188,7 @@ export default function footerExtension(pi: ExtensionAPI) {
 			return Object.assign(component, {
 				dispose: () => {
 					stopFollowingBranch();
+					stopPrPoll();
 					repaint = () => {};
 					refreshLocation = () => {};
 				},