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

package/src/config/model-registry.ts

@@ -851,6 +851,12 @@ export class ModelRegistry {
 
 	/**
 	 * @param authStorage - Auth storage for API key resolution
+	 *
+	 * Sync constructor — eagerly loads bundled + cached models so tests and
+	 * synchronous callers see a fully-populated registry immediately. Production
+	 * boot paths SHOULD prefer {@link ModelRegistry.create} so the YAML/JSONC
+	 * migration step lands off the event loop's hot path before the first
+	 * `tryLoad()` runs.
 	 */
 	constructor(
 		readonly authStorage: AuthStorage,
@@ -866,7 +872,7 @@ export class ModelRegistry {
 			}
 			return undefined;
 		});
-		// Load models synchronously in constructor
+		// Load models synchronously in constructor.
 		this.#loadModels();
 	}
 

package/src/config/settings-schema.ts

@@ -14,9 +14,12 @@ import {
 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,
@@ -1136,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",
@@ -1149,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",
@@ -1327,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",
@@ -1398,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": {
@@ -2984,8 +2998,8 @@ 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,
 		},
 	},
@@ -3004,6 +3018,19 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"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,
@@ -3292,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";
@@ -48,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(
@@ -79,13 +142,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		if (!options.skipHashValidation) {
-			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;
 }