@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.3

package/src/config/settings-schema.ts

@@ -1,6 +1,6 @@
 import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
-import { getThinkingLevelMetadata } from "../thinking";
+import { AUTO_THINKING, getConfiguredThinkingLevelMetadata, getThinkingLevelMetadata } from "../thinking";
 import {
 	TINY_MODEL_DEVICE_DEFAULT,
 	TINY_MODEL_DEVICE_SETTING_OPTIONS,
@@ -12,8 +12,14 @@ import {
 	TINY_MODEL_DTYPE_SETTING_VALUES,
 } from "../tiny/dtype";
 import {
+	AUTO_THINKING_MODEL_OPTIONS,
+	AUTO_THINKING_MODEL_VALUES,
+	DEFAULT_SHAKE_SUMMARY_MODEL_KEY,
+	ONLINE_AUTO_THINKING_MODEL_KEY,
 	ONLINE_MEMORY_MODEL_KEY,
 	ONLINE_TINY_TITLE_MODEL_KEY,
+	SHAKE_SUMMARY_MODEL_OPTIONS,
+	SHAKE_SUMMARY_MODEL_VALUES,
 	TINY_MEMORY_MODEL_OPTIONS,
 	TINY_MEMORY_MODEL_VALUES,
 	TINY_TITLE_MODEL_OPTIONS,
@@ -671,13 +677,16 @@ export const SETTINGS_SCHEMA = {
 	// Reasoning and prompts
 	defaultThinkingLevel: {
 		type: "enum",
-		values: THINKING_EFFORTS,
+		values: [...THINKING_EFFORTS, AUTO_THINKING],
 		default: "high",
 		ui: {
 			tab: "model",
 			label: "Thinking Level",
 			description: "Reasoning depth for thinking-capable models",
-			options: [...THINKING_EFFORTS.map(getThinkingLevelMetadata)],
+			options: [
+				getConfiguredThinkingLevelMetadata(AUTO_THINKING),
+				...THINKING_EFFORTS.map(getThinkingLevelMetadata),
+			],
 		},
 	},
 
@@ -1130,12 +1139,13 @@ export const SETTINGS_SCHEMA = {
 
 	"compaction.strategy": {
 		type: "enum",
-		values: ["context-full", "handoff", "off"] as const,
+		values: ["context-full", "handoff", "shake", "shake-summary", "off"] as const,
 		default: "context-full",
 		ui: {
 			tab: "context",
 			label: "Compaction Strategy",
-			description: "Choose in-place context-full maintenance, auto-handoff, or disable auto maintenance (off)",
+			description:
+				"Choose in-place context-full maintenance, auto-handoff, surgical shake (drop heavy content), shake with local-model summaries, or disable auto maintenance (off)",
 			options: [
 				{
 					value: "context-full",
@@ -1143,6 +1153,16 @@ export const SETTINGS_SCHEMA = {
 					description: "Summarize in-place and keep the current session",
 				},
 				{ value: "handoff", label: "Handoff", description: "Generate handoff and continue in a new session" },
+				{
+					value: "shake",
+					label: "Shake",
+					description: "Drop heavy content (tool results + large blocks) in place; recover via artifact",
+				},
+				{
+					value: "shake-summary",
+					label: "Shake (summary)",
+					description: "Shake, but compress heavy regions with a local on-device model instead of dropping",
+				},
 				{
 					value: "off",
 					label: "Off",
@@ -1321,70 +1341,70 @@ export const SETTINGS_SCHEMA = {
 	"memories.summaryInjectionTokenLimit": { type: "number", default: 5000 },
 
 	// Memory backend selector — picks between local memories pipeline,
-	// Mnemosyne local SQLite, Hindsight remote memory, or off. Legacy
+	// Mnemopi local SQLite, Hindsight remote memory, or off. Legacy
 	// `memories.enabled` keeps gating the local backend; see config/settings.ts
 	// migration for details.
 	"memory.backend": {
 		type: "enum",
-		values: ["off", "local", "hindsight", "mnemosyne"] as const,
+		values: ["off", "local", "hindsight", "mnemopi"] as const,
 		default: "off",
 		ui: {
 			tab: "memory",
 			label: "Memory Backend",
-			description: "Off, local summary pipeline, Mnemosyne SQLite, or Hindsight remote memory",
+			description: "Off, local summary pipeline, Mnemopi SQLite, or Hindsight remote memory",
 			options: [
 				{ value: "off", label: "Off", description: "No memory subsystem runs" },
 				{ value: "local", label: "Local", description: "Local rollout summarisation pipeline (memory_summary.md)" },
 				{ value: "hindsight", label: "Hindsight", description: "Vectorize Hindsight remote memory service" },
 				{
-					value: "mnemosyne",
-					label: "Mnemosyne",
+					value: "mnemopi",
+					label: "Mnemopi",
 					description: "Local SQLite recall/retain backend with optional embeddings",
 				},
 			],
 		},
 	},
 
-	// Mnemosyne local SQLite memory backend.
-	"mnemosyne.dbPath": {
+	// Mnemopi local SQLite memory backend.
+	"mnemopi.dbPath": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne DB Path",
+			label: "Mnemopi DB Path",
 			description: "Optional SQLite DB path. Defaults to the agent memories directory.",
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.bank": {
+	"mnemopi.bank": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Bank",
+			label: "Mnemopi Bank",
 			description: "Optional shared bank base name. Per-project modes derive project-local banks from it.",
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.scoping": {
+	"mnemopi.scoping": {
 		type: "enum",
 		values: ["global", "per-project", "per-project-tagged"] as const,
 		default: "per-project",
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Scoping",
+			label: "Mnemopi Scoping",
 			description:
 				"global = one shared bank; per-project = isolated bank per cwd; per-project-tagged = project-local writes plus global recall visibility",
 			options: [
 				{
 					value: "global",
 					label: "Global",
-					description: "One shared Mnemosyne bank for every project",
+					description: "One shared Mnemopi bank for every project",
 				},
 				{
 					value: "per-project",
 					label: "Per project",
-					description: "Project-local Mnemosyne bank per cwd basename",
+					description: "Project-local Mnemopi bank per cwd basename",
 				},
 				{
 					value: "per-project-tagged",
@@ -1392,121 +1412,121 @@ export const SETTINGS_SCHEMA = {
 					description: "Write to a project-local bank but merge project + shared recall results",
 				},
 			],
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.autoRecall": {
+	"mnemopi.autoRecall": {
 		type: "boolean",
 		default: true,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Auto Recall",
+			label: "Mnemopi Auto Recall",
 			description: "Recall local memories into the first turn of each session",
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.autoRetain": {
+	"mnemopi.autoRetain": {
 		type: "boolean",
 		default: true,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Auto Retain",
-			description: "Retain completed conversation turns into local Mnemosyne memory",
-			condition: "mnemosyneActive",
+			label: "Mnemopi Auto Retain",
+			description: "Retain completed conversation turns into local Mnemopi memory",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.noEmbeddings": {
+	"mnemopi.noEmbeddings": {
 		type: "boolean",
 		default: false,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Disable Embeddings",
+			label: "Mnemopi Disable Embeddings",
 			description: "Force deterministic FTS-only recall instead of vector embeddings",
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.embeddingModel": {
+	"mnemopi.embeddingModel": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Embedding Model",
-			description: "Optional embedding model override passed to Mnemosyne",
-			condition: "mnemosyneActive",
+			label: "Mnemopi Embedding Model",
+			description: "Optional embedding model override passed to Mnemopi",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.embeddingApiUrl": {
+	"mnemopi.embeddingApiUrl": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Embedding API URL",
-			description: "Optional OpenAI-compatible embedding endpoint passed to Mnemosyne",
-			condition: "mnemosyneActive",
+			label: "Mnemopi Embedding API URL",
+			description: "Optional OpenAI-compatible embedding endpoint passed to Mnemopi",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.embeddingApiKey": {
+	"mnemopi.embeddingApiKey": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne Embedding API Key",
-			description: "Optional embedding API key passed to Mnemosyne",
-			condition: "mnemosyneActive",
+			label: "Mnemopi Embedding API Key",
+			description: "Optional embedding API key passed to Mnemopi",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.llmMode": {
+	"mnemopi.llmMode": {
 		type: "enum",
 		values: ["none", "smol", "remote"] as const,
 		default: "smol",
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne LLM Mode",
+			label: "Mnemopi LLM Mode",
 			description: "Use no LLM, the configured smol model, or a remote OpenAI-compatible endpoint",
-			condition: "mnemosyneActive",
+			condition: "mnemopiActive",
 			options: [
-				{ value: "none", label: "None", description: "Disable Mnemosyne LLM-backed extraction" },
+				{ value: "none", label: "None", description: "Disable Mnemopi LLM-backed extraction" },
 				{ value: "smol", label: "Smol", description: "Use the configured pi-ai smol model" },
-				{ value: "remote", label: "Remote", description: "Use the Mnemosyne remote LLM settings below" },
+				{ value: "remote", label: "Remote", description: "Use the Mnemopi remote LLM settings below" },
 			],
 		},
 	},
-	"mnemosyne.llmBaseUrl": {
+	"mnemopi.llmBaseUrl": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne LLM Base URL",
-			description: "Optional OpenAI-compatible LLM endpoint for Mnemosyne remote mode",
-			condition: "mnemosyneActive",
+			label: "Mnemopi LLM Base URL",
+			description: "Optional OpenAI-compatible LLM endpoint for Mnemopi remote mode",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.llmApiKey": {
+	"mnemopi.llmApiKey": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne LLM API Key",
-			description: "Optional LLM API key for Mnemosyne remote mode",
-			condition: "mnemosyneActive",
+			label: "Mnemopi LLM API Key",
+			description: "Optional LLM API key for Mnemopi remote mode",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.llmModel": {
+	"mnemopi.llmModel": {
 		type: "string",
 		default: undefined,
 		ui: {
 			tab: "memory",
-			label: "Mnemosyne LLM Model",
-			description: "Optional LLM model name for Mnemosyne remote mode",
-			condition: "mnemosyneActive",
+			label: "Mnemopi LLM Model",
+			description: "Optional LLM model name for Mnemopi remote mode",
+			condition: "mnemopiActive",
 		},
 	},
-	"mnemosyne.retainEveryNTurns": { type: "number", default: 4 },
-	"mnemosyne.recallLimit": { type: "number", default: 8 },
-	"mnemosyne.recallContextTurns": { type: "number", default: 3 },
-	"mnemosyne.recallMaxQueryChars": { type: "number", default: 4000 },
-	"mnemosyne.injectionTokenLimit": { type: "number", default: 5000 },
-	"mnemosyne.debug": { type: "boolean", default: false },
+	"mnemopi.retainEveryNTurns": { type: "number", default: 4 },
+	"mnemopi.recallLimit": { type: "number", default: 8 },
+	"mnemopi.recallContextTurns": { type: "number", default: 3 },
+	"mnemopi.recallMaxQueryChars": { type: "number", default: 4000 },
+	"mnemopi.injectionTokenLimit": { type: "number", default: 5000 },
+	"mnemopi.debug": { type: "boolean", default: false },
 
 	// Hindsight (https://hindsight.vectorize.io)
 	"hindsight.apiUrl": {
@@ -2954,7 +2974,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "providers",
 			label: "Tiny Model Device",
 			description:
-				"ONNX execution provider for local tiny models (titles + memory). Default picks DirectML on Windows, CUDA on Linux x64, CPU elsewhere. The PI_TINY_DEVICE env var overrides this.",
+				"ONNX execution provider for local tiny models (titles + memory). Default uses CPU-only inference. The PI_TINY_DEVICE env var overrides this.",
 			options: TINY_MODEL_DEVICE_SETTING_OPTIONS,
 		},
 	},
@@ -2978,12 +2998,39 @@ export const SETTINGS_SCHEMA = {
 			tab: "memory",
 			label: "Memory Model",
 			description:
-				"Mnemosyne LLM for fact extraction + consolidation: online (smol/remote) by default, or a local on-device model",
-			condition: "mnemosyneActive",
+				"Mnemopi LLM for fact extraction + consolidation: online (smol/remote) by default, or a local on-device model",
+			condition: "mnemopiActive",
 			options: TINY_MEMORY_MODEL_OPTIONS,
 		},
 	},
 
+	"providers.autoThinkingModel": {
+		type: "enum",
+		values: AUTO_THINKING_MODEL_VALUES,
+		default: ONLINE_AUTO_THINKING_MODEL_KEY,
+		ui: {
+			tab: "model",
+			label: "Auto Thinking Model",
+			description:
+				"Difficulty classifier for the `auto` thinking level: online smol by default, or a local on-device model",
+			condition: "autoThinkingActive",
+			options: AUTO_THINKING_MODEL_OPTIONS,
+		},
+	},
+
+	"providers.shakeSummaryModel": {
+		type: "enum",
+		values: SHAKE_SUMMARY_MODEL_VALUES,
+		default: DEFAULT_SHAKE_SUMMARY_MODEL_KEY,
+		ui: {
+			tab: "context",
+			label: "Shake Summary Model",
+			description:
+				"Local on-device model used by /shake summary and the shake-summary compaction strategy to compress heavy regions. Runs entirely on-device; downloads on first use. Falls back to plain elide when unavailable.",
+			options: SHAKE_SUMMARY_MODEL_OPTIONS,
+		},
+	},
+
 	"providers.kimiApiFormat": {
 		type: "enum",
 		values: ["openai", "anthropic"] as const,
@@ -3272,7 +3319,7 @@ export type TreeFilterMode = SettingValue<"treeFilterMode">;
 
 export interface CompactionSettings {
 	enabled: boolean;
-	strategy: "context-full" | "handoff" | "off";
+	strategy: "context-full" | "handoff" | "shake" | "shake-summary" | "off";
 	thresholdPercent: number;
 	thresholdTokens: number;
 	reserveTokens: number;

package/src/config/settings.ts

@@ -692,6 +692,18 @@ export class Settings {
 			raw.memory = memoryRoot;
 		}
 
+		// Rename the legacy local `mnemosyne` memory backend to `mnemopi`.
+		// - `memory.backend: "mnemosyne"` now selects the renamed backend.
+		// - the top-level `mnemosyne` settings object becomes `mnemopi`.
+		// Idempotent: skips the object move once `mnemopi` is materialised.
+		if (memoryBackendObj && memoryBackendObj.backend === "mnemosyne") {
+			memoryBackendObj.backend = "mnemopi";
+		}
+		if ("mnemosyne" in raw && !("mnemopi" in raw)) {
+			raw.mnemopi = raw.mnemosyne;
+			delete raw.mnemosyne;
+		}
+
 		// hindsight: dynamicBankId/agentName -> scoping enum + bankId
 		// - dynamicBankId=true  → scoping="per-project" (closest semantic match;
 		//   the legacy `agent::project::channel::user` tuple was per-project in

package/src/edit/hashline/diff.ts

@@ -5,17 +5,25 @@
  * pair to {@link generateDiffString} so the renderer can show the diff
  * while the tool call is still streaming.
  *
- * Validation is intentionally light: only the section snapshot tag is checked
- * (so the preview goes red when anchors are stale), no plan-mode guards
- * and no auto-generated-file refusal — those belong on the write path.
+ * Uses the same snapshot-tag semantics as the apply path: a live content-hash
+ * match is accepted even when the tag was minted by a source that did not keep
+ * history, and stale tags recover through the session snapshot store when possible.
  */
 import {
+	type ApplyResult,
+	applyEdits,
+	computeFileHash,
+	type Edit,
 	Patch as HashlinePatch,
+	hasBlockEdit,
+	MismatchError,
 	missingSnapshotTagMessage,
 	normalizeToLF,
 	type Patch,
 	type PatchSection,
-	type Snapshot,
+	parsePatchStreaming,
+	Recovery,
+	resolveBlockEdits,
 	type SnapshotStore,
 	stripBom,
 } from "@oh-my-pi/hashline";
@@ -31,6 +39,12 @@ export interface HashlineDiffOptions {
 	 * preview path only.
 	 */
 	streaming?: boolean;
+	/**
+	 * Skip snapshot-tag validation. Streaming previews use this so transient
+	 * stale/missing tags do not flash re-read errors while the model is still
+	 * authoring input; the final apply path still validates through Patcher.
+	 */
+	skipHashValidation?: boolean;
 }
 
 async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
@@ -42,24 +56,79 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
-function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
-	return snapshot.text === currentText;
+function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
+	return edits.some(edit => {
+		if (edit.kind === "delete") return true;
+		if (edit.kind === "block") return true;
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+	});
 }
-function validateSectionHash(
+
+function createMismatchError(
 	section: PatchSection,
 	absolutePath: string,
-	text: string,
+	normalized: string,
 	snapshots: SnapshotStore,
-): string | null {
-	if (section.fileHash === undefined) {
-		// The snapshot tag is mandatory on every section — head/tail inserts
-		// included — to keep this preview path in lockstep with the apply path
-		// (`Patcher.prepare`), which rejects tagless sections unconditionally.
-		return missingSnapshotTagMessage(section.path);
+	expected: string,
+): MismatchError {
+	return new MismatchError({
+		path: section.path,
+		expectedFileHash: expected,
+		actualFileHash: computeFileHash(normalized),
+		fileLines: normalized.split("\n"),
+		anchorLines: section.collectAnchorLines(),
+		hashRecognized: snapshots.byHash(absolutePath, expected) !== null,
+	});
+}
+
+function parsePreviewEdits(section: PatchSection, streaming: boolean | undefined): readonly Edit[] {
+	return streaming ? parsePatchStreaming(section.diff).edits : section.edits;
+}
+
+function resolvePreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	expected: string | undefined;
+	liveMatches: boolean;
+	edits: readonly Edit[];
+}): readonly Edit[] {
+	const { section, absolutePath, normalized, snapshots, expected, liveMatches, edits } = args;
+	if (!hasBlockEdit(edits)) return edits;
+	const baseText = expected === undefined || liveMatches ? normalized : snapshots.byHash(absolutePath, expected)?.text;
+	if (baseText === undefined) {
+		throw createMismatchError(section, absolutePath, normalized, snapshots, expected ?? "");
 	}
-	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
-	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;
-	return `Hashline snapshot tag mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file does not match that snapshot; re-read and try again.`;
+	return resolveBlockEdits(edits, baseText, section.path, nativeBlockResolver, { onUnresolved: "throw" });
+}
+
+function applyPreviewEdits(args: {
+	section: PatchSection;
+	absolutePath: string;
+	normalized: string;
+	snapshots: SnapshotStore;
+	options: HashlineDiffOptions;
+}): ApplyResult {
+	const { section, absolutePath, normalized, snapshots, options } = args;
+	const expected = section.fileHash;
+	if (!options.skipHashValidation && expected === undefined) {
+		throw new Error(missingSnapshotTagMessage(section.path));
+	}
+	const liveMatches = expected !== undefined && computeFileHash(normalized) === expected;
+	const edits = parsePreviewEdits(section, options.streaming);
+	const resolved = resolvePreviewEdits({ section, absolutePath, normalized, snapshots, expected, liveMatches, edits });
+	if (options.skipHashValidation || expected === undefined || liveMatches) return applyEdits(normalized, resolved);
+	if (!hasAnchorScopedEdit(resolved)) return applyEdits(normalized, resolved);
+
+	const recovered = new Recovery(snapshots).tryRecover({
+		path: absolutePath,
+		currentText: normalized,
+		fileHash: expected,
+		edits: resolved,
+	});
+	if (recovered) return recovered;
+	throw createMismatchError(section, absolutePath, normalized, snapshots, expected);
 }
 
 export async function computeHashlineSectionDiff(
@@ -73,11 +142,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const hashError = validateSectionHash(section, absolutePath, normalized, snapshots);
-		if (hashError) return { error: hashError };
-		const result = options.streaming
-			? section.applyPartialTo(normalized, nativeBlockResolver)
-			: section.applyTo(normalized, nativeBlockResolver);
+		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
 		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.text);
 	} catch (err) {

package/src/edit/renderer.ts

@@ -235,23 +235,27 @@ function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string)
 
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
-	// Hunk-aware truncation keeps the change rows themselves visible. Tail-mode
-	// pins the visible window to the bottom of the diff so newly streamed
-	// hunks stay on screen as more arrives, instead of leaving the user stuck
-	// staring at the head of the file while the tail scrolls offscreen.
-	const {
-		text: truncatedDiff,
-		hiddenHunks,
-		hiddenLines,
-	} = truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, EDIT_STREAMING_PREVIEW_LINES, { fromTail: true });
+	// "Cursor" tail window: pin the last EDIT_STREAMING_PREVIEW_LINES rows to the
+	// bottom of the diff so freshly streamed changes stay on screen, and accept
+	// the trailing rows "from the back" once the diff outgrows the window. The
+	// whole-file diff is recomputed on every streamed chunk and its Myers
+	// alignment is not monotonic in payload length, so a hunk-aware window that
+	// kept whole change segments gained and lost rows tick to tick — the box
+	// stuttered, and the earlier high-water fix traded that for a half-empty
+	// rectangle. A strict fixed-height window keeps the box steady and always
+	// full of real diff context instead of blank padding.
+	const allLines = diff.replace(/\n+$/u, "").split("\n");
+	const hiddenLines = Math.max(0, allLines.length - EDIT_STREAMING_PREVIEW_LINES);
+	const visible = hiddenLines > 0 ? allLines.slice(hiddenLines) : allLines;
 	let text = "\n\n";
-	if (hiddenHunks > 0 || hiddenLines > 0) {
+	if (hiddenLines > 0) {
+		const hiddenHunks = getDiffStats(allLines.slice(0, hiddenLines).join("\n")).hunks;
 		const remainder: string[] = [];
 		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
-		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		remainder.push(`${hiddenLines} more lines`);
 		text += `${uiTheme.fg("dim", `… (${remainder.join(", ")} above)`)}\n`;
 	}
-	text += renderDiffColored(truncatedDiff, { filePath: rawPath });
+	text += renderDiffColored(visible.join("\n"), { filePath: rawPath });
 	text += uiTheme.fg("dim", `\n(${label})`);
 	return text;
 }

package/src/edit/streaming.ts

@@ -314,8 +314,14 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	},
 	async computeDiffPreview(args, ctx) {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
-		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
-		if (input.length === 0) return null;
+		// Unlike apply_patch, hashline previews flow through `applyPartialTo`,
+		// whose streaming-tolerant parser (`parsePatchStreaming` → `endStreaming`)
+		// drops a payload-less trailing op and projects a partially-typed payload
+		// line onto the file as it grows. Trimming the trailing partial line here
+		// would instead strip the sole payload of a single-op `replace`/`insert`
+		// for almost the entire stream, collapsing the preview to "No changes" and
+		// rendering a blank box. Feed the raw in-flight text straight through.
+		const input = args.input;
 		ctx.signal.throwIfAborted();
 
 		let sections: readonly HashlineInputSection[];
@@ -347,12 +353,17 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, ctx.snapshots, {
 				streaming: ctx.isStreaming,
+				skipHashValidation: ctx.isStreaming === true,
 			});
 			ctx.signal.throwIfAborted();
-			// In a multi-section preview, ignore parse/apply errors from the
-			// last section: it's still streaming and the partial op may not
-			// parse yet. Earlier sections are stable and stay rendered.
-			if (sectionsToProcess.length > 1 && i === trailingProcessedIndex && "error" in result) {
+			// Ignore parse/apply errors from the trailing (actively-typed)
+			// section while streaming: a mid-typed op may transiently resolve to
+			// "No changes" or an out-of-bounds anchor, and surfacing that would
+			// wipe the already-stable previews (or, for a lone section, the prior
+			// good frame). Returning no entry preserves the last preview. Earlier
+			// sections, and every section once args are complete, stay rendered so
+			// real errors still reach the model.
+			if ((ctx.isStreaming || sectionsToProcess.length > 1) && i === trailingProcessedIndex && "error" in result) {
 				continue;
 			}
 			previews.push(toPerFilePreview(section.path, result));