@oh-my-pi/pi-coding-agent 15.10.11 → 15.11.0

package/src/modes/components/assistant-message.ts

@@ -222,7 +222,9 @@ export class AssistantMessageComponent extends Container {
 		this.#contentContainer.clear();
 
 		const hasVisibleContent = message.content.some(
-			c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()),
+			c =>
+				(c.type === "text" && c.text.trim()) ||
+				(!this.hideThinkingBlock && c.type === "thinking" && c.thinking.trim()),
 		);
 
 		// Render content in order
@@ -236,32 +238,28 @@ export class AssistantMessageComponent extends Container {
 				markdown.transientRenderCache = this.#lastUpdateTransient;
 				this.#contentContainer.addChild(markdown);
 			} else if (content.type === "thinking" && content.thinking.trim()) {
+				if (this.hideThinkingBlock) {
+					thinkingIndex += 1;
+					continue;
+				}
 				// Add spacing only when another visible assistant content block follows.
 				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
 				const hasVisibleContentAfter = message.content
 					.slice(i + 1)
 					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
 
-				if (this.hideThinkingBlock) {
-					// Show static "Thinking..." label when hidden
-					this.#contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", "Thinking...")), 1, 0));
-					if (hasVisibleContentAfter) {
-						this.#contentContainer.addChild(new Spacer(1));
-					}
-				} else {
-					const thinkingText = content.thinking.trim();
-					// Thinking traces in thinkingText color, italic
-					const thinkingMarkdown = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
-						color: (text: string) => theme.fg("thinkingText", text),
-						italic: true,
-					});
-					thinkingMarkdown.transientRenderCache = this.#lastUpdateTransient;
-					this.#contentContainer.addChild(thinkingMarkdown);
-					this.#appendThinkingExtensions(i, thinkingIndex, thinkingText);
-					thinkingIndex += 1;
-					if (hasVisibleContentAfter) {
-						this.#contentContainer.addChild(new Spacer(1));
-					}
+				const thinkingText = content.thinking.trim();
+				// Thinking traces in thinkingText color, italic
+				const thinkingMarkdown = new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
+					color: (text: string) => theme.fg("thinkingText", text),
+					italic: true,
+				});
+				thinkingMarkdown.transientRenderCache = this.#lastUpdateTransient;
+				this.#contentContainer.addChild(thinkingMarkdown);
+				this.#appendThinkingExtensions(i, thinkingIndex, thinkingText);
+				thinkingIndex += 1;
+				if (hasVisibleContentAfter) {
+					this.#contentContainer.addChild(new Spacer(1));
 				}
 			}
 		}

package/src/modes/components/compaction-summary-message.ts

@@ -1,51 +1,87 @@
-import { Box, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Box, type Component, Markdown } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import type { CompactionSummaryMessage } from "../../session/messages";
 
 /**
- * Component that renders a compaction message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 compacted · ctrl+o ────────
+ *
+ * The conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
  */
-export class CompactionSummaryMessageComponent extends Box {
+export class CompactionSummaryMessageComponent implements Component {
 	#expanded = false;
+	#cache?: { width: number; lines: string[] };
+	#detail?: Box;
 
-	constructor(private readonly message: CompactionSummaryMessage) {
-		super(1, 1, t => theme.bg("customMessageBg", t));
-		this.#updateDisplay();
-	}
+	constructor(private readonly message: CompactionSummaryMessage) {}
 
 	setExpanded(expanded: boolean): void {
+		if (this.#expanded === expanded) return;
 		this.#expanded = expanded;
-		this.#updateDisplay();
+		this.#cache = undefined;
 	}
 
-	override invalidate(): void {
-		super.invalidate();
-		this.#updateDisplay();
+	invalidate(): void {
+		this.#cache = undefined;
+		// Theme may have changed — rebuild the detail box lazily on next render.
+		this.#detail = undefined;
 	}
 
-	#updateDisplay(): void {
-		this.clear();
+	render(width: number): readonly string[] {
+		width = Math.max(1, width);
+		if (this.#cache?.width === width) {
+			return this.#cache.lines;
+		}
+		const lines = this.#expanded
+			? ["", this.#divider(width), "", ...this.#detailBox().render(width)]
+			: ["", this.#divider(width), ""];
+		this.#cache = { width, lines };
+		return lines;
+	}
 
-		const tokenStr = this.message.tokensBefore.toLocaleString();
-		const label = theme.fg("customMessageLabel", theme.bold("[compaction]"));
-		this.addChild(new Text(label, 0, 0));
-		this.addChild(new Spacer(1));
+	#divider(width: number): string {
+		const rule = theme.tree.horizontal;
+		const label = `${theme.icon.camera} compacted`;
+		// sep.dot ships pre-padded (" · "); trim so the hint joins with single spaces.
+		const hint = `${theme.sep.dot.trim()} ctrl+o`;
+		const plainWidth = Bun.stringWidth(`${label} ${hint}`, { countAnsiEscapeCodes: false });
+		// ` label hint ` framed by rules on both sides.
+		const remaining = width - plainWidth - 2;
+		if (remaining < 4) {
+			// Too narrow for a framed rule — emit the bare label.
+			return theme.fg("muted", label);
+		}
+		const left = Math.floor(remaining / 2);
+		const right = remaining - left;
+		return (
+			theme.fg("dim", rule.repeat(left)) +
+			` ${theme.fg("muted", label)} ${theme.fg("dim", hint)} ` +
+			theme.fg("dim", rule.repeat(right))
+		);
+	}
 
-		if (this.#expanded) {
-			const header = `**Compacted from ${tokenStr} tokens**\n\n`;
-			this.addChild(
-				new Markdown(header + this.message.summary, 0, 0, getMarkdownTheme(), {
+	#detailBox(): Box {
+		if (this.#detail) return this.#detail;
+		const box = new Box(1, 1, t => theme.bg("customMessageBg", t));
+		const tokenStr = this.message.tokensBefore.toLocaleString();
+		const frameCount = this.message.images?.length ?? 0;
+		const frameNote =
+			frameCount > 0 ? `\n\n_${frameCount} snapcompact frame${frameCount === 1 ? "" : "s"} attached_` : "";
+		box.addChild(
+			new Markdown(
+				`**Compacted from ${tokenStr} tokens**\n\n${this.message.summary}${frameNote}`,
+				0,
+				0,
+				getMarkdownTheme(),
+				{
 					color: (text: string) => theme.fg("customMessageText", text),
-				}),
-			);
-		} else {
-			this.addChild(
-				new Text(theme.fg("customMessageText", `Compacted from ${tokenStr} tokens (ctrl+o to expand)`), 0, 0),
-			);
-			if (this.message.shortSummary) {
-				this.addChild(new Text(theme.fg("customMessageText", this.message.shortSummary), 0, 1));
-			}
-		}
+				},
+			),
+		);
+		this.#detail = box;
+		return box;
 	}
 }

package/src/modes/components/custom-editor.ts

@@ -175,6 +175,8 @@ export class CustomEditor extends Editor {
 	onDequeue?: () => void;
 	/** Called when Caps Lock is pressed. */
 	onCapsLock?: () => void;
+	/** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
+	onLeftAtStart?: () => void;
 
 	/** Custom key handlers from extensions and non-built-in app actions. */
 	#customKeyHandlers = new Map<KeyId, () => void>();
@@ -257,6 +259,14 @@ export class CustomEditor extends Editor {
 		const parsedKey = parseKey(data);
 		const canonical = parsedKey !== undefined ? canonicalKeyId(parsedKey) : undefined;
 
+		// Left-arrow on an empty editor: surface for the agent-hub double-tap
+		// gesture. Plain "left" only — modified arrows and any in-text cursor
+		// movement fall through to normal handling.
+		if (canonical === "left" && this.onLeftAtStart && this.getText().trim() === "") {
+			this.onLeftAtStart();
+			return;
+		}
+
 		if (canonical !== undefined) {
 			// Intercept configured image paste (async - fires and handles result)
 			if (this.#matchesAction(canonical, "app.clipboard.pasteImage") && this.onPasteImage) {

package/src/modes/components/footer.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
@@ -65,7 +66,8 @@ export class FooterComponent implements Component {
 				}
 
 				try {
-					this.#gitWatcher = fs.watch(head.headPath, () => {
+					const watchPath = head.isReftable ? path.join(head.gitDir, "reftable") : head.headPath;
+					this.#gitWatcher = fs.watch(watchPath, () => {
 						this.#cachedBranch = undefined; // Invalidate cache
 						if (this.#onBranchChange) {
 							this.#onBranchChange();

package/src/modes/components/status-line/component.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
@@ -120,6 +121,18 @@ function tokensForMessage(msg: AgentMessage): number {
 	return tokens;
 }
 
+interface MessageTokenTotalsCache {
+	messagesRef: readonly AgentMessage[];
+	stableCount: number;
+	stableTokens: number;
+	lastStableMessage: AgentMessage | undefined;
+	lastStableFingerprint: string | undefined;
+}
+
+function hasContextSegment(segments: readonly StatusLineSegmentId[]): boolean {
+	return segments.includes("context_pct") || segments.includes("context_total");
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // StatusLineComponent
 // ═══════════════════════════════════════════════════════════════════════════
@@ -129,6 +142,7 @@ export class StatusLineComponent implements Component {
 	#effectiveSettings: EffectiveStatusLineSettings | undefined;
 	#cachedBranch: string | null | undefined = undefined;
 	#cachedBranchRepoId: string | null | undefined = undefined;
+	#cachedBranchCwd: string | undefined = undefined;
 	#gitWatcher: fs.FSWatcher | null = null;
 	#onBranchChange: (() => void) | null = null;
 	#autoCompactEnabled: boolean = true;
@@ -159,20 +173,19 @@ export class StatusLineComponent implements Component {
 	} | null = null;
 	#usageFetchedAt = 0;
 	#usageInFlight = false;
-	// Context breakdown — incremental cache. Replaces the previous 2-second
-	// TTL design (which re-walked every message on each refresh and produced
-	// ~1.1 s sync freezes on 2,000+ message sessions because `updateEditorTopBorder`
-	// is called on every agent event in event-controller). The new scheme
-	// caches by message-object identity (a Symbol-keyed sidecar on each
-	// message) plus a cheap content fingerprint, so in-place mutations of
-	// an existing message (post-hoc error attachment, retry-truncated
-	// branch rebuild, replaceMessages with the same length) are detected
-	// and recomputed.
+	// Context breakdown — incremental rolling cache. The status line refreshes
+	// on every agent event, so the hot path must not re-tokenize the full
+	// message list. Stable messages are accumulated once; normal streaming
+	// refreshes only recompute the current tail message and newly appended
+	// entries. History rewrites/compaction replace or shrink the message array
+	// and rebuild this cache. Stable messages are treated as immutable after
+	// promotion, matching the normal append-only session flow.
 	// Cached non-message total (system prompt + tools + skills). Invalidated
 	// when the inputs-identity fingerprint changes (model swap, skill toggle,
 	// tool registration).
 	#nonMessageTokensCache: number | undefined;
 	#nonMessageInputsKey: string | undefined;
+	#messageTokenTotalsCache: MessageTokenTotalsCache | undefined;
 
 	constructor(private readonly session: AgentSession) {
 		this.#settings = {
@@ -238,11 +251,15 @@ export class StatusLineComponent implements Component {
 			this.#gitWatcher = null;
 		}
 
-		const gitHeadPath = git.repo.resolveSync(getProjectDir())?.headPath ?? null;
-		if (!gitHeadPath) return;
+		const repository = git.repo.resolveSync(getProjectDir());
+		if (!repository) return;
+
+		const watchPath = git.repo.isReftableSync(repository)
+			? path.join(repository.gitDir, "reftable")
+			: repository.headPath;
 
 		try {
-			this.#gitWatcher = fs.watch(gitHeadPath, () => {
+			this.#gitWatcher = fs.watch(watchPath, () => {
 				this.#invalidateGitCaches();
 				if (this.#onBranchChange) {
 					this.#onBranchChange();
@@ -267,15 +284,18 @@ export class StatusLineComponent implements Component {
 	#invalidateGitCaches(): void {
 		this.#cachedBranch = undefined;
 		this.#cachedBranchRepoId = undefined;
+		this.#cachedBranchCwd = undefined;
 		this.#cachedPrContext = undefined;
 	}
 	#getCurrentBranch(): string | null {
-		const head = git.head.resolveSync(getProjectDir());
-		const gitHeadPath = head?.headPath ?? null;
-		if (this.#cachedBranch !== undefined && this.#cachedBranchRepoId === gitHeadPath) {
+		const cwd = getProjectDir();
+		if (this.#cachedBranch !== undefined && this.#cachedBranchCwd === cwd) {
 			return this.#cachedBranch;
 		}
 
+		const head = git.head.resolveSync(cwd);
+		const gitHeadPath = head?.headPath ?? null;
+		this.#cachedBranchCwd = cwd;
 		this.#cachedBranchRepoId = gitHeadPath;
 		if (!head) {
 			this.#cachedBranch = null;
@@ -503,24 +523,79 @@ export class StatusLineComponent implements Component {
 			this.#nonMessageInputsKey = inputsKey;
 		}
 
-		// 2) Message tokens — incremental. The sidecar cache lives on the
-		//    message object itself (Symbol-keyed), keyed by identity and
-		//    validated by a cheap content fingerprint. Mutations that
-		//    replace messages (replaceMessages, branch rebuild, compaction)
-		//    yield fresh objects → cache miss → recompute. In-place
-		//    mutations on the same object are caught by fingerprint
-		//    mismatch. The LAST message is always recomputed because it
-		//    may still be growing during streaming.
-		let messagesTokens = 0;
-		const lastIdx = messages.length - 1;
-		for (let i = 0; i < messages.length; i++) {
-			messagesTokens += i === lastIdx ? estimateTokens(messages[i]) : tokensForMessage(messages[i]);
-		}
+		// 2) Message tokens — incremental rolling total. The sidecar cache lives
+		//    on each stable message object (all but the current tail). Normal
+		//    streaming turns only recompute the last message and newly appended
+		//    entries. Full rebuild only when the message array is replaced,
+		//    shrinks, or the recently-promoted stable tail mutates in place.
+		const messagesTokens = this.#getCachedMessageTokens(messages);
 
 		const usedTokens = this.#nonMessageTokensCache + messagesTokens;
 		return { usedTokens, contextWindow };
 	}
 
+	#getCachedMessageTokens(messages: readonly AgentMessage[]): number {
+		const cache = this.#messageTokenTotalsCache;
+		if (!cache || cache.messagesRef !== messages || messages.length <= cache.stableCount) {
+			return this.#rebuildMessageTokenTotals(messages);
+		}
+
+		let stableTokens = cache.stableTokens;
+		let stableCount = cache.stableCount;
+		const stableLimit = Math.max(0, messages.length - 1);
+
+		if (
+			cache.lastStableMessage &&
+			stableCount > 0 &&
+			messages[stableCount - 1] === cache.lastStableMessage &&
+			cache.lastStableFingerprint !== undefined &&
+			cache.lastStableFingerprint !== messageFingerprint(cache.lastStableMessage)
+		) {
+			return this.#rebuildMessageTokenTotals(messages);
+		}
+
+		while (stableCount < stableLimit) {
+			const promoted = messages[stableCount]!;
+			stableTokens += tokensForMessage(promoted);
+			stableCount++;
+		}
+
+		const lastStableMessage = stableCount > 0 ? messages[stableCount - 1] : undefined;
+		const lastStableFingerprint = lastStableMessage ? messageFingerprint(lastStableMessage) : undefined;
+		const lastMessage = messages.at(-1);
+		const lastTokens = lastMessage ? estimateTokens(lastMessage) : 0;
+		this.#messageTokenTotalsCache = {
+			messagesRef: messages,
+			stableCount,
+			stableTokens,
+			lastStableMessage,
+			lastStableFingerprint,
+		};
+		return stableTokens + lastTokens;
+	}
+
+	#rebuildMessageTokenTotals(messages: readonly AgentMessage[]): number {
+		let stableTokens = 0;
+		const stableLimit = Math.max(0, messages.length - 1);
+		for (let i = 0; i < stableLimit; i++) {
+			stableTokens += tokensForMessage(messages[i]!);
+		}
+
+		const lastStableMessage = stableLimit > 0 ? messages[stableLimit - 1] : undefined;
+		const lastStableFingerprint = lastStableMessage ? messageFingerprint(lastStableMessage) : undefined;
+		const lastMessage = messages.at(-1);
+		const lastTokens = lastMessage ? estimateTokens(lastMessage) : 0;
+
+		this.#messageTokenTotalsCache = {
+			messagesRef: messages,
+			stableCount: stableLimit,
+			stableTokens,
+			lastStableMessage,
+			lastStableFingerprint,
+		};
+		return stableTokens + lastTokens;
+	}
+
 	/**
 	 * Build an identity fingerprint for the non-message inputs (system prompt,
 	 * tools, skills). When this changes, the non-message token cache must be
@@ -535,7 +610,11 @@ export class StatusLineComponent implements Component {
 		return `${modelId}|${sp.length}:${sp[0]?.length ?? 0}|${tools.length}|${skills.length}`;
 	}
 
-	#buildSegmentContext(width: number, segmentOptions: StatusLineSettings["segmentOptions"]): SegmentContext {
+	#buildSegmentContext(
+		width: number,
+		segmentOptions: StatusLineSettings["segmentOptions"],
+		includeContext: boolean,
+	): SegmentContext {
 		const state = this.session.state;
 
 		// Trigger background fetch (5-min TTL); render uses cached value
@@ -555,10 +634,13 @@ export class StatusLineComponent implements Component {
 			tokensPerSecond: this.#getTokensPerSecond(),
 		};
 
-		// Context usage — aligned with /context command so both surfaces report the same value
-		const breakdown = this.getCachedContextBreakdown();
-		const contextTokens = breakdown.usedTokens;
-		const contextWindow = breakdown.contextWindow || state.model?.contextWindow || 0;
+		let contextTokens = 0;
+		let contextWindow = state.model?.contextWindow ?? this.session.model?.contextWindow ?? 0;
+		if (includeContext) {
+			const breakdown = this.getCachedContextBreakdown();
+			contextTokens = breakdown.usedTokens;
+			contextWindow = breakdown.contextWindow || contextWindow;
+		}
 		const contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
 
 		return {
@@ -626,7 +708,9 @@ export class StatusLineComponent implements Component {
 
 	#buildStatusLine(width: number): string {
 		const effectiveSettings = this.#resolveSettings();
-		const ctx = this.#buildSegmentContext(width, effectiveSettings.segmentOptions);
+		const includeContext =
+			hasContextSegment(effectiveSettings.leftSegments) || hasContextSegment(effectiveSettings.rightSegments);
+		const ctx = this.#buildSegmentContext(width, effectiveSettings.segmentOptions, includeContext);
 		const separatorDef = getSeparator(effectiveSettings.separator ?? "powerline-thin", theme);
 
 		const bgAnsi = theme.getBgAnsi("statusLineBg");

package/src/modes/components/tool-execution.ts

@@ -19,6 +19,7 @@ import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
 import { EVAL_DEFAULT_PREVIEW_LINES } from "../../tools/eval";
+import { isWaitingPollDetails } from "../../tools/job";
 import {
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
@@ -194,6 +195,11 @@ export class ToolExecutionComponent extends Container {
 	// sealed the block stays in the transcript's repaintable live region so a
 	// late result still repaints instead of stranding the streaming preview.
 	#sealed = false;
+	// A `job` poll result whose watched jobs are all still running. Such a
+	// block never finalizes (stays in the transcript live region) so a
+	// follow-up `job` call can displace it instead of stacking another
+	// "waiting on N jobs" frame. Cleared by `seal()`.
+	#displaceable = false;
 	#renderState: {
 		spinnerFrame?: number;
 		expanded: boolean;
@@ -359,6 +365,11 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.#result = result;
 		this.#isPartial = isPartial;
+		// A `job` poll that found every watched job still running is transient
+		// "still waiting" chrome; keep the block displaceable so the next `job`
+		// call replaces it instead of stacking another waiting frame (see the
+		// event controller's displaceable-poll bookkeeping).
+		this.#displaceable = this.#toolName === "job" && result.isError !== true && isWaitingPollDetails(result.details);
 		// When tool is complete, ensure args are marked complete so spinner stops
 		if (!isPartial) {
 			this.#argsComplete = true;
@@ -425,7 +436,11 @@ export class ToolExecutionComponent extends Container {
 			(this.#result?.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 		const isBackgroundAsyncTask = this.#toolName === "task" && isBackgroundAsyncRunning;
 		const isPartialTask = this.#isPartial && this.#toolName === "task" && !isBackgroundAsyncTask;
-		const needsSpinner = isStreamingArgs || isPartialTask;
+		// A displaceable waiting poll keeps its spinner ticking: it reads as one
+		// persistent live poll, and the changing leading glyph keeps the
+		// transcript's stable-prefix ratchet from committing rows of a block
+		// that a follow-up `job` call may remove.
+		const needsSpinner = isStreamingArgs || isPartialTask || this.isDisplaceableBlock();
 		if (needsSpinner && !this.#spinnerInterval) {
 			const now = performance.now();
 			const frameCount = theme.spinnerFrames.length;
@@ -513,6 +528,9 @@ export class ToolExecutionComponent extends Container {
 	isTranscriptBlockFinalized(): boolean {
 		if (this.#sealed) return true;
 		if (this.#result === undefined) return false;
+		// A displaceable waiting poll stays live: its rows are kept out of
+		// native scrollback so a follow-up `job` call can remove the block.
+		if (this.#displaceable) return false;
 		if (!this.#isPartial) return true;
 		// Partial result: a background async tool is accepted to freeze (the agent
 		// continues while it runs and would otherwise pin an unbounded live region);
@@ -528,11 +546,23 @@ export class ToolExecutionComponent extends Container {
 	seal(): void {
 		if (this.#sealed) return;
 		this.#sealed = true;
+		this.#displaceable = false;
 		this.stopAnimation();
 		this.#updateDisplay();
 		this.#ui.requestRender();
 	}
 
+	/**
+	 * Whether this block is a waiting `job` poll (every watched job still
+	 * running) that has not been sealed. Such a block never finalized, so none
+	 * of its rows entered native scrollback (the ticking spinner keeps the
+	 * stable-prefix ratchet at zero) and the whole block can be removed when a
+	 * follow-up `job` call supersedes it.
+	 */
+	isDisplaceableBlock(): boolean {
+		return this.#displaceable && !this.#sealed;
+	}
+
 	/**
 	 * Stop spinner animation and cleanup resources.
 	 */