@oh-my-pi/pi-coding-agent 15.10.2 → 15.10.4

package/src/modes/components/session-selector.ts

@@ -1,7 +1,7 @@
 import {
 	type Component,
 	Container,
-	fuzzyFilter,
+	fuzzyMatch,
 	Input,
 	matchesKey,
 	padding,
@@ -46,43 +46,107 @@ function formatSessionStatus(status: SessionStatus | undefined): string | undefi
 /** Returns the IDs of sessions whose recorded prompts match a query, best first. */
 export type SessionHistoryMatcher = (query: string) => string[];
 
+function sessionSearchText(session: SessionInfo): string {
+	const parts = [
+		session.id,
+		session.title ?? "",
+		session.cwd ?? "",
+		session.firstMessage ?? "",
+		session.allMessagesText,
+		session.path,
+	];
+	return parts.filter(Boolean).join(" ");
+}
+
+function tokenizeSessionQuery(query: string): string[] {
+	const trimmed = query.trim().toLowerCase();
+	return trimmed ? trimmed.split(/\s+/) : [];
+}
+
+function compareSessionRecency(a: SessionInfo, b: SessionInfo): number {
+	return b.modified.getTime() - a.modified.getTime();
+}
+
+/**
+ * Filter and rank session picker search results.
+ *
+ * Resume search narrows a recency-sorted list: once every query token appears
+ * as a literal substring, newer sessions should beat a slightly better fuzzy
+ * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
+ * literal matches.
+ */
+export function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[] {
+	const tokens = tokenizeSessionQuery(query);
+	if (tokens.length === 0) return allSessions;
+
+	const results: Array<{ session: SessionInfo; score: number; literal: boolean; index: number }> = [];
+	for (let index = 0; index < allSessions.length; index++) {
+		const session = allSessions[index]!;
+		const text = sessionSearchText(session);
+		const textLower = text.toLowerCase();
+		let score = 0;
+		let literal = true;
+		let matches = true;
+
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, textLower);
+			if (!match.matches) {
+				matches = false;
+				break;
+			}
+			score += match.score;
+			if (!textLower.includes(token)) literal = false;
+		}
+
+		if (matches) results.push({ session, score, literal, index });
+	}
+
+	results.sort((a, b) => {
+		if (a.literal !== b.literal) return a.literal ? -1 : 1;
+		if (a.literal) return compareSessionRecency(a.session, b.session) || a.index - b.index;
+		return a.score - b.score || compareSessionRecency(a.session, b.session) || a.index - b.index;
+	});
+
+	return results.map(result => result.session);
+}
+
 /**
- * Combine fuzzy session matches with prompt-history matches for ranking, using
- * both signals rather than replacing one with the other.
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
  *
- * - `fuzzy` is the ordered fuzzy-filter result over session metadata (best first).
+ * - `fuzzy` is the ordered metadata/session-text result.
  * - `historyIds` are session IDs whose recorded prompts matched the query,
  *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
  *
- * Ranking: sessions matched by **both** signals lead (keeping fuzzy order), then
- * fuzzy-only matches, then history-only matches (by prompt-history order). A fuzzy match
- * is never dropped, and history matches not present in `allSessions` (e.g. deleted
- * or out-of-scope sessions) are ignored since they cannot be resumed from here.
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
  */
 export function mergeSessionRanking(
 	allSessions: SessionInfo[],
 	fuzzy: SessionInfo[],
 	historyIds: string[],
 ): SessionInfo[] {
-	const historyRank = new Map<string, number>();
-	historyIds.forEach((id, index) => {
-		if (!historyRank.has(id)) historyRank.set(id, index);
-	});
-	if (historyRank.size === 0) return fuzzy;
-
-	const both: SessionInfo[] = [];
-	const fuzzyOnly: SessionInfo[] = [];
-	const fuzzyPaths = new Set<string>();
-	for (const session of fuzzy) {
-		fuzzyPaths.add(session.path);
-		(historyRank.has(session.id) ? both : fuzzyOnly).push(session);
+	if (historyIds.length === 0) return fuzzy;
+
+	const sessionsById = new Map<string, SessionInfo>();
+	for (const session of allSessions) {
+		if (!sessionsById.has(session.id)) sessionsById.set(session.id, session);
 	}
 
-	const historyOnly = allSessions
-		.filter(session => historyRank.has(session.id) && !fuzzyPaths.has(session.path))
-		.sort((a, b) => (historyRank.get(a.id) ?? 0) - (historyRank.get(b.id) ?? 0));
+	const historyMatches: SessionInfo[] = [];
+	const historyPaths = new Set<string>();
+	for (const id of historyIds) {
+		const session = sessionsById.get(id);
+		if (!session || historyPaths.has(session.path)) continue;
+		historyMatches.push(session);
+		historyPaths.add(session.path);
+	}
+	if (historyMatches.length === 0) return fuzzy;
 
-	return [...both, ...fuzzyOnly, ...historyOnly];
+	const metadataOnly = fuzzy.filter(session => !historyPaths.has(session.path));
+	return [...historyMatches, ...metadataOnly];
 }
 
 /**
@@ -156,17 +220,7 @@ class SessionList implements Component {
 	}
 
 	#filterSessions(query: string): void {
-		const fuzzy = fuzzyFilter(this.#allSessions, query, session => {
-			const parts = [
-				session.id,
-				session.title ?? "",
-				session.cwd ?? "",
-				session.firstMessage ?? "",
-				session.allMessagesText,
-				session.path,
-			];
-			return parts.filter(Boolean).join(" ");
-		});
+		const fuzzy = rankSessionSearchMatches(this.#allSessions, query);
 		this.#filteredSessions = this.#mergeHistoryMatches(query, fuzzy);
 		this.#selectedIndex = Math.min(this.#selectedIndex, Math.max(0, this.#filteredSessions.length - 1));
 	}

package/src/modes/components/tips.txt

@@ -4,7 +4,7 @@ Use /tan to fork the current conversation into a background agent
 Ctrl+D can be used to exit, but with your draft saved!
 Find out which model you emotionally abuse the most with `omp stats`
 Try task isolation to create CoW worktrees
-Your LLM can call an LLM using `llm(x...)`. Have a big batch of tasks? Ask clanker to use it!
+Need a cheap nested model call? Use `completion(x...)`. Have a big batch of tasks? Ask clanker to use it!
 Spaghetti code? Try complaining with /omfg
 Did you know? Each kitty/tmux/cmux split keeps its own session — `omp -c` resumes the right one
 Drop the word `ultrathink` in your message for harder multi-step reasoning — watch it glow rainbow as you type

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

@@ -15,7 +15,6 @@ import {
 } from "@oh-my-pi/pi-tui";
 import { getProjectDir, logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import { EDIT_MODE_STRATEGIES, type EditMode, type PerFileDiffPreview } from "../../edit";
-import { shimmerEnabled } from "../../modes/theme/shimmer";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
@@ -31,7 +30,7 @@ import {
 	renderJsonTreeLines,
 } from "../../tools/json-tree";
 import { formatExpandHint, replaceTabs, resolveImageOptions, truncateToWidth } from "../../tools/render-utils";
-import { type ToolRenderer, toolRenderers } from "../../tools/renderers";
+import { toolRenderers } from "../../tools/renderers";
 import { TODO_STRIKE_TOTAL_FRAMES } from "../../tools/todo";
 import { isFramedBlockComponent, renderStatusLine } from "../../tui";
 import { sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
@@ -133,9 +132,10 @@ export interface ToolExecutionHandle {
 	setExpanded(expanded: boolean): void;
 }
 
-/** Drive pending-tool redraws at 30fps so the animated border sweep stays
- * smooth without spending twice the frame budget. The TUI throttles at the same
- * cadence, and static frames diff to a no-op redraw at ~zero cost. */
+/** Drive pending-tool redraws at 30fps so the running `task` row's shimmered
+ * subagent name stays smooth without spending twice the frame budget. The TUI
+ * throttles at the same cadence, and static frames diff to a no-op redraw at
+ * ~zero cost. */
 const SPINNER_RENDER_INTERVAL_MS = 1000 / 30;
 /** Advance the spinner glyph at its classic ~12.5fps step, decoupled from the
  * render cadence (mirrors `Loader`). */
@@ -425,16 +425,7 @@ 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;
-		// Sweep the border of bash/eval execution blocks while they're pending — but
-		// not once they've been backgrounded: a backgrounded job's block gets
-		// committed to scrollback and finalizes later via the async update path, so a
-		// mid-sweep frame would freeze a stray dark "bar" segment into the border.
-		const isPendingExecBlock =
-			this.#isPartial &&
-			shimmerEnabled() &&
-			(this.#toolName === "bash" || this.#toolName === "eval") &&
-			!isBackgroundAsyncRunning;
-		const needsSpinner = isStreamingArgs || isPartialTask || isPendingExecBlock;
+		const needsSpinner = isStreamingArgs || isPartialTask;
 		if (needsSpinner && !this.#spinnerInterval) {
 			const now = performance.now();
 			const frameCount = theme.spinnerFrames.length;
@@ -446,7 +437,7 @@ export class ToolExecutionComponent extends Container {
 			this.#spinnerInterval = setInterval(() => {
 				const now = performance.now();
 				const frameCount = theme.spinnerFrames.length;
-				// Redraw at 30fps for a smooth border sweep, but keep the spinner
+				// Redraw at 30fps for a smooth `task` name shimmer, but keep the spinner
 				// glyph phase-locked to its classic ~12.5fps cadence. Advancing the
 				// anchor by elapsed frames instead of resetting to `now` avoids the
 				// 30fps timer quantizing the glyph down to one step every three ticks.
@@ -529,39 +520,6 @@ export class ToolExecutionComponent extends Container {
 		return (this.#result.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 	}
 
-	/**
-	 * While a tool's preview is still streaming, a block whose preview is
-	 * append-only (rows only grow at the bottom, never re-layout) lets the
-	 * renderer commit the scrolled-off head of an over-tall preview to native
-	 * scrollback instead of dropping it — the same anti-yank path a streaming
-	 * assistant reply uses (see {@link TranscriptContainer} +
-	 * `NativeScrollbackLiveRegion`). Covers both phases: a pre-result call preview
-	 * (a `write` whose content streams in) and a partial-result preview that
-	 * streams output below fixed input (an `eval`/`bash` whose stdout grows under
-	 * its code cell). Gated on {@link isTranscriptBlockFinalized} so the boundary
-	 * closes the instant the block reaches a terminal state — a final result that
-	 * may collapse to a compact view, a backgrounded async tool, or a seal — and
-	 * the renderer decides whether its current preview shape qualifies via
-	 * `isStreamingPreviewAppendOnly` (typically: only the expanded full view,
-	 * which is top-anchored; the collapsed tail window re-layouts but is bounded
-	 * so it never overflows anyway).
-	 */
-	isTranscriptBlockAppendOnly(): boolean {
-		// A finalized block's preview can collapse/re-layout; only a live,
-		// still-streaming block is a candidate.
-		if (this.isTranscriptBlockFinalized()) return false;
-		const predicate =
-			(this.#tool as { isStreamingPreviewAppendOnly?: ToolRenderer["isStreamingPreviewAppendOnly"] } | undefined)
-				?.isStreamingPreviewAppendOnly ?? toolRenderers[this.#toolName]?.isStreamingPreviewAppendOnly;
-		if (!predicate) return false;
-		try {
-			return predicate(this.#getCallArgsForRender(), this.#renderState, this.#result);
-		} catch (err) {
-			logger.warn("Tool append-only predicate failed", { tool: this.#toolName, error: String(err) });
-			return false;
-		}
-	}
-
 	/**
 	 * Mark the tool terminal even though no result arrived (the turn aborted or
 	 * abandoned it) and stop animating, so it can freeze and stops pinning the

package/src/modes/components/transcript-container.ts

@@ -6,6 +6,8 @@ interface FrozenRender {
 	width: number;
 	lines: string[];
 	generation: number;
+	appendOnly: boolean;
+	volatile: boolean;
 }
 
 interface SnapshotCarrier {
@@ -17,16 +19,9 @@ interface SnapshotCarrier {
  * result, an assistant message mid-stream) reports `false` so the container
  * keeps it inside the live (repaintable) region instead of freezing it. Blocks
  * without the method are treated as finalized — the default, stable behavior.
- *
- * `isTranscriptBlockAppendOnly` marks a still-live block whose rendered rows
- * only grow at the bottom and never re-layout (a streaming assistant reply).
- * Such a block's scrolled-off head is safe to commit to native scrollback even
- * while live; blocks that omit it (tool previews that collapse to a compact
- * result) keep their mutable rows deferred. Default is `false`.
  */
 interface FinalizableBlock {
 	isTranscriptBlockFinalized?(): boolean;
-	isTranscriptBlockAppendOnly?(): boolean;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -34,11 +29,6 @@ function isBlockFinalized(child: Component): boolean {
 	return fn ? fn.call(child) : true;
 }
 
-function isBlockAppendOnly(child: Component): boolean {
-	const fn = (child as Component & FinalizableBlock).isTranscriptBlockAppendOnly;
-	return fn ? fn.call(child) : false;
-}
-
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -59,6 +49,73 @@ function stripPlainBlankEdges(lines: string[]): string[] {
 	return start === 0 && end === lines.length ? lines : lines.slice(start, end);
 }
 
+interface LiveCommitState {
+	appendOnly: boolean;
+	volatile: boolean;
+	safeLength: number;
+}
+
+function hasValidSnapshot(
+	snapshot: FrozenRender | undefined,
+	width: number,
+	generation: number,
+): snapshot is FrozenRender {
+	return snapshot !== undefined && snapshot.generation === generation && snapshot.width === width;
+}
+
+function commonPrefixLength(prev: string[], cur: string[]): number {
+	const limit = Math.min(prev.length, cur.length);
+	let i = 0;
+	while (i < limit && prev[i] === cur[i]) i++;
+	return i;
+}
+
+function commonSuffixLength(prev: string[], cur: string[], prefixLength: number): number {
+	const prevLimit = prev.length - prefixLength;
+	const curLimit = cur.length - prefixLength;
+	const limit = Math.min(prevLimit, curLimit);
+	let i = 0;
+	while (i < limit && prev[prev.length - 1 - i] === cur[cur.length - 1 - i]) i++;
+	return i;
+}
+
+function deriveLiveCommitState(
+	previous: FrozenRender | undefined,
+	current: string[],
+	width: number,
+	generation: number,
+): LiveCommitState {
+	let appendOnly = false;
+	let volatile = false;
+	if (hasValidSnapshot(previous, width, generation)) {
+		appendOnly = previous.appendOnly;
+		volatile = previous.volatile;
+
+		const prefixLength = commonPrefixLength(previous.lines, current);
+		const staticRender = prefixLength === previous.lines.length && prefixLength === current.length;
+		if (!staticRender) {
+			const suffixLength = commonSuffixLength(previous.lines, current, prefixLength);
+			const stablePreviousLength = prefixLength + suffixLength;
+			const appendGrew =
+				previous.lines.length > 0 &&
+				current.length > previous.lines.length &&
+				stablePreviousLength >= previous.lines.length;
+			if (appendGrew && !volatile) {
+				appendOnly = true;
+			} else if (stablePreviousLength < previous.lines.length) {
+				volatile = true;
+				appendOnly = false;
+			}
+		}
+	}
+
+	return {
+		appendOnly,
+		volatile,
+		safeLength: volatile ? 0 : appendOnly ? current.length : 0,
+	};
+}
+
 /**
  * Transcript container that freezes the rendered output of every block except
  * the bottom-most (live) one on terminals where committed native scrollback is
@@ -97,11 +154,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	// render. TUI extends the native-scrollback pinned region from this point
 	// through the live blocks and the root chrome rendered below them.
 	#nativeScrollbackLiveRegionStart: number | undefined;
-	// Local line index up to which the leading run of live blocks is append-only
-	// (a streaming assistant reply): everything in [liveRegionStart,
-	// commitSafeEnd) only grows at the bottom and never re-layouts, so its
-	// scrolled-off head is safe to commit to native scrollback. `undefined` when
-	// the first live block is volatile (a tool preview).
+	// Local line index up to which the leading run of live blocks is safe to
+	// commit. Finalized blocks contribute their full frozen body; still-live
+	// blocks contribute only after their stripped render has been observed
+	// growing without changing a previously rendered interior row.
 	#nativeScrollbackCommitSafeEnd: number | undefined;
 
 	override invalidate(): void {
@@ -164,8 +220,9 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 		if (risk) this.#prevLiveStartIndex = liveStartIndex;
 
 		const lines: string[] = [];
-		// Tracks whether we are still inside the leading run of append-only live
-		// blocks. The first non-append-only live block closes it.
+		// Tracks whether we are still inside the leading run of commit-safe live
+		// blocks. The first still-live volatile block closes it, but rendering
+		// continues so lower blocks remain visible.
 		let commitSafeOpen = true;
 		// The live-region start is recorded at the first visible row at/after the
 		// cutoff; empty leading blocks (or a separator) must not claim it early.
@@ -179,24 +236,41 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			// instead of recomputing; a stale generation (post-thaw) or width
 			// mismatch (resize) recomputes, as does a block still live last frame.
 			let contribution: string[] | undefined;
+			const previousSnapshot = risk ? child[kSnapshot] : undefined;
 			if (risk && i < liveStartIndex && i < replayCutoff) {
-				const snapshot = child[kSnapshot];
-				if (snapshot && snapshot.generation === this.#generation && snapshot.width === width) {
-					contribution = snapshot.lines;
+				if (hasValidSnapshot(previousSnapshot, width, this.#generation)) {
+					contribution = previousSnapshot.lines;
 				}
 			}
+			let liveCommitState: LiveCommitState | undefined;
 			if (contribution === undefined) {
 				const rendered = child.render(width);
 				contribution = stripPlainBlankEdges(rendered);
+				if (risk && i >= liveStartIndex && !isBlockFinalized(child)) {
+					liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
+				}
 				// Cache every block's latest contribution. While a block is in the
 				// live region this keeps its snapshot current; on the frame it crosses
 				// out, the recompute above refreshes it before it freezes.
-				if (risk) child[kSnapshot] = { width, lines: contribution, generation: this.#generation };
+				if (risk) {
+					child[kSnapshot] = {
+						width,
+						lines: contribution,
+						generation: this.#generation,
+						appendOnly: liveCommitState?.appendOnly ?? false,
+						volatile: liveCommitState?.volatile ?? false,
+					};
+				}
 			}
 
 			// Empty (or stripped-to-nothing) children contribute nothing and never
-			// affect spacing or the live-region offsets.
-			if (contribution.length === 0) continue;
+			// affect spacing or the live-region offsets. An empty still-live child
+			// still closes the commit-safe run: if it later gains rows, it pushes
+			// everything below it.
+			if (contribution.length === 0) {
+				if (risk && i >= liveStartIndex && commitSafeOpen && !isBlockFinalized(child)) commitSafeOpen = false;
+				continue;
+			}
 
 			// Every block is separated from preceding visible content by exactly one
 			// blank row — skipped when it opens the transcript or the prior row is
@@ -212,17 +286,19 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			}
 
 			if (sep) lines.push("");
+			const blockStart = lines.length;
 			for (let j = 0; j < contribution.length; j++) lines.push(contribution[j]!);
 
-			// Extend the commit-safe boundary through each leading append-only live
-			// block. The first volatile live block closes the run so its mutable
-			// rows stay deferred.
 			if (risk && i >= liveStartIndex && commitSafeOpen) {
-				if (isBlockAppendOnly(child)) {
-					this.#nativeScrollbackCommitSafeEnd = lines.length;
-				} else {
-					commitSafeOpen = false;
+				const finalized = isBlockFinalized(child);
+				const safeLength = finalized ? contribution.length : (liveCommitState?.safeLength ?? 0);
+				if (safeLength > 0) {
+					this.#nativeScrollbackCommitSafeEnd = blockStart + safeLength;
 				}
+				// A finalized, fully safe block may let the contiguous safe run extend
+				// into blocks rendered below it. A still-live block keeps pushing lower
+				// rows around as it grows, so the run closes there.
+				if (!(finalized && safeLength >= contribution.length)) commitSafeOpen = false;
 			}
 		}
 		return lines;

package/src/modes/controllers/event-controller.ts

@@ -720,7 +720,12 @@ export class EventController {
 				// seal it so it freezes (and stops animating) rather than lingering in
 				// the transcript live region as a streaming preview until the next thaw.
 				const component = this.ctx.pendingTools.get(toolCallId);
-				if (component instanceof ToolExecutionComponent) component.seal();
+				// A foreground read still pending at turn end shares a group component
+				// keyed by every read's id; seal it too so a never-delivered read does
+				// not keep the group live (and pinning the live region) indefinitely.
+				if (component instanceof ToolExecutionComponent || component instanceof ReadToolGroupComponent) {
+					component.seal();
+				}
 				this.ctx.pendingTools.delete(toolCallId);
 			}
 		}

package/src/modes/controllers/input-controller.ts

@@ -10,6 +10,7 @@ import { expandEmoticons } from "../../modes/emoji-autocomplete";
 import { materializeImageReferenceLinks } from "../../modes/image-references";
 import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
 import type { InteractiveModeContext } from "../../modes/types";
+import manualContinuePrompt from "../../prompts/system/manual-continue.md" with { type: "text" };
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails, USER_INTERRUPT_LABEL } from "../../session/messages";
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { isTinyTitleLocalModelKey } from "../../tiny/models";
@@ -286,14 +287,21 @@ export class InputController {
 
 			if (!text) return;
 
-			// Continue shortcuts: "." or "c" sends empty message (agent continues, no visible message)
+			// Continue shortcuts: "." or "c" resume the agent with a hidden agent-authored
+			// developer directive (no visible user message) instead of an empty turn, so the
+			// model continues the prior intent rather than second-guessing the interrupt.
 			if (text === "." || text === "c") {
 				if (this.ctx.onInputCallback) {
 					this.ctx.editor.setText("");
 					this.ctx.pendingImages = [];
 					this.ctx.pendingImageLinks = [];
 					this.ctx.editor.imageLinks = undefined;
-					this.ctx.onInputCallback({ text: "", cancelled: false, started: true });
+					this.ctx.onInputCallback({
+						text: manualContinuePrompt,
+						cancelled: false,
+						started: true,
+						synthetic: true,
+					});
 				}
 				return;
 			}

package/src/modes/types.ts

@@ -42,6 +42,10 @@ export type SubmittedUserInput = {
 	images?: ImageContent[];
 	imageLinks?: (string | undefined)[];
 	customType?: string;
+	/** Route through `session.prompt(text, { synthetic: true })` so the text lands
+	 *  as a hidden agent-authored `developer` message rather than a visible user
+	 *  turn. Used by the `c`/`.` continue shortcut. */
+	synthetic?: boolean;
 	display?: boolean;
 	cancelled: boolean;
 	started: boolean;

package/src/modes/utils/ui-helpers.ts

@@ -10,6 +10,10 @@ import { CompactionSummaryMessageComponent } from "../../modes/components/compac
 import { CustomMessageComponent } from "../../modes/components/custom-message";
 import { DynamicBorder } from "../../modes/components/dynamic-border";
 import { EvalExecutionComponent } from "../../modes/components/eval-execution";
+import {
+	type LateDiagnosticsFile,
+	LateDiagnosticsMessageComponent,
+} from "../../modes/components/late-diagnostics-message";
 import {
 	ReadToolGroupComponent,
 	readArgsHaveTarget,
@@ -25,6 +29,7 @@ import type { CompactionQueuedMessage, InteractiveModeContext } from "../../mode
 import {
 	type CustomMessage,
 	isSilentAbort,
+	LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE,
 	resolveAbortLabel,
 	SKILL_PROMPT_MESSAGE_TYPE,
 	type SkillPromptDetails,
@@ -168,6 +173,17 @@ export class UiHelpers {
 						this.ctx.chatContainer.addChild(block);
 						break;
 					}
+					if (message.customType === LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE) {
+						const details = (
+							message as CustomMessage<{
+								files?: LateDiagnosticsFile[];
+							}>
+						).details;
+						const component = new LateDiagnosticsMessageComponent(details?.files ?? []);
+						component.setExpanded(this.ctx.toolOutputExpanded);
+						this.ctx.chatContainer.addChild(component);
+						break;
+					}
 					if (message.customType === SKILL_PROMPT_MESSAGE_TYPE) {
 						const component = new SkillMessageComponent(message as CustomMessage<SkillPromptDetails>);
 						component.setExpanded(this.ctx.toolOutputExpanded);
@@ -342,7 +358,11 @@ export class UiHelpers {
 						(content.type === "thinking" && content.thinking.trim().length > 0),
 				);
 				if (hasVisibleAssistantContent) {
-					readGroup?.finalize();
+					// Rebuild reconstructs immutable history; seal (not finalize) so the
+					// group freezes even if a read's result was never persisted —
+					// finalize alone keeps a pending entry live and would stop the whole
+					// transcript below it from committing to native scrollback.
+					readGroup?.seal();
 					readGroup = null;
 				}
 				const isAbortedSilently = message.stopReason === "aborted" && isSilentAbort(message.errorMessage);
@@ -392,7 +412,7 @@ export class UiHelpers {
 						continue;
 					}
 
-					readGroup?.finalize();
+					readGroup?.seal();
 					readGroup = null;
 					const tool = this.ctx.session.getToolByName(content.name);
 					const renderArgs =
@@ -480,9 +500,10 @@ export class UiHelpers {
 			}
 		}
 
-		// The trailing read run has no following break to close it; finalize so the
-		// rebuilt group commits to native scrollback like every other historical block.
-		readGroup?.finalize();
+		// The trailing read run has no following break to close it; seal so the
+		// rebuilt group freezes (even with a never-persisted result) and commits to
+		// native scrollback like every other historical block.
+		readGroup?.seal();
 
 		// Render deferred messages (compaction summaries) at the bottom so they're visible
 		for (const message of deferredMessages) {

package/src/prompts/system/manual-continue.md

@@ -0,0 +1,7 @@
+<system-notice>
+Continue. Keep going from where you left off.
+
+- You MUST resume the most recent intent and carry the unfinished work to completion.
+- Interrupted mid-step? Pick it back up from where it stopped.
+- You NEVER pause to summarize progress, re-confirm the plan, or ask whether to proceed — just continue.
+</system-notice>