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

package/src/config/file-lock.ts

@@ -1,5 +1,6 @@
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
-import { isEnoent } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 
 export interface FileLockOptions {
 	staleMs?: number;
@@ -16,14 +17,15 @@ const DEFAULT_OPTIONS: Required<FileLockOptions> = {
 interface LockInfo {
 	pid: number;
 	timestamp: number;
+	token: string;
 }
 
 function getLockPath(filePath: string): string {
 	return `${filePath}.lock`;
 }
 
-async function writeLockInfo(lockPath: string): Promise<void> {
-	const info: LockInfo = { pid: process.pid, timestamp: Date.now() };
+async function writeLockInfo(lockPath: string, token: string): Promise<void> {
+	const info: LockInfo = { pid: process.pid, timestamp: Date.now(), token };
 	await Bun.write(`${lockPath}/info`, JSON.stringify(info));
 }
 
@@ -47,33 +49,58 @@ function isProcessAlive(pid: number): boolean {
 
 async function isLockStale(lockPath: string, staleMs: number): Promise<boolean> {
 	const info = await readLockInfo(lockPath);
-	if (!info) return true;
-
-	if (!isProcessAlive(info.pid)) return true;
-
-	if (Date.now() - info.timestamp > staleMs) return true;
+	if (info) {
+		if (!isProcessAlive(info.pid)) return true;
+		if (Date.now() - info.timestamp > staleMs) return true;
+		return false;
+	}
 
-	return false;
+	// No info file. Either the lock holder is between mkdir and writeLockInfo
+	// (fresh dir, do not reap) or the dir was already removed (also do not
+	// reap — there is nothing to clean up, and an unguarded fs.rm here would
+	// race with another contender's successful mkdir and wipe their dir).
+	try {
+		const stat = await fs.stat(lockPath);
+		return Date.now() - stat.mtimeMs > staleMs;
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
 }
 
-async function tryAcquireLock(lockPath: string): Promise<boolean> {
+async function tryAcquireLock(lockPath: string): Promise<string | null> {
 	try {
 		await fs.mkdir(lockPath);
-		await writeLockInfo(lockPath);
-		return true;
+		const token = randomUUID();
+		await writeLockInfo(lockPath, token);
+		return token;
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-			return false;
+			return null;
 		}
 		throw error;
 	}
 }
 
-async function releaseLock(lockPath: string): Promise<void> {
+async function releaseLock(lockPath: string, expectedToken?: string): Promise<void> {
 	try {
+		if (expectedToken !== undefined) {
+			const info = await readLockInfo(lockPath);
+			if (!info || info.token !== expectedToken) {
+				// We are not the owner. The lock either expired and was reaped
+				// or another process has reclaimed it. Do nothing — releasing
+				// here would wipe the rightful owner's lock.
+				logger.debug("file-lock: skipping release for non-owned lock", {
+					lockPath,
+					expectedToken,
+					actualToken: info?.token,
+				});
+				return;
+			}
+		}
 		await fs.rm(lockPath, { recursive: true });
 	} catch {
-		// Ignore errors on release
+		// Ignore errors on release.
 	}
 }
 
@@ -92,11 +119,14 @@ async function acquireLock(filePath: string, options: FileLockOptions = {}): Pro
 	const lockPath = getLockPath(filePath);
 
 	for (let attempt = 0; attempt < opts.retries; attempt++) {
-		if (await tryAcquireLock(lockPath)) {
-			return () => releaseLock(lockPath);
+		const token = await tryAcquireLock(lockPath);
+		if (token !== null) {
+			return () => releaseLock(lockPath, token);
 		}
 
 		if ((await lockExists(lockPath)) && (await isLockStale(lockPath, opts.staleMs))) {
+			// Reaping a stale lock — no token because we didn't acquire it. The
+			// rightful owner is presumed dead; rm without ownership check.
 			await releaseLock(lockPath);
 			continue;
 		}
@@ -119,3 +149,16 @@ export async function withFileLock<T>(
 		await release();
 	}
 }
+
+/**
+ * Test-only handles for the internal lock primitives. These are NOT part of
+ * the public API — they exist so the contract tests can validate token-keyed
+ * release semantics and the mkdir-race window without re-implementing them.
+ */
+export const __internalsForTesting = {
+	tryAcquireLock,
+	releaseLock,
+	readLockInfo,
+	isLockStale,
+	getLockPath,
+};

package/src/config/keybindings.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import {
 	type Keybinding,
@@ -10,6 +10,7 @@ import {
 	KeybindingsManager as TuiKeybindingsManager,
 } from "@oh-my-pi/pi-tui";
 import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
 
 /**
  * Application-level keybindings (coding agent specific).
@@ -330,17 +331,29 @@ function orderKeybindingsConfig(config: KeybindingsConfig): KeybindingsConfig {
 	return ordered;
 }
 
+const KEYBINDINGS_YML = "keybindings.yml";
+const KEYBINDINGS_YAML = "keybindings.yaml";
+const LEGACY_KEYBINDINGS_JSON = "keybindings.json";
+
+interface KeybindingsConfigPaths {
+	readPath: string;
+	writeBackPath: string;
+}
+
 /**
  * Load raw config from a file synchronously.
- * Returns parsed JSON or null if file doesn't exist or is invalid.
+ * Returns parsed JSON/YAML or null if file doesn't exist or is invalid.
  */
 function loadRawConfig(filePath: string): unknown {
 	try {
-		if (!existsSync(filePath)) {
-			return null;
+		const content = fs.readFileSync(filePath, "utf-8");
+		if (filePath.endsWith(".json")) {
+			return JSON.parse(content);
+		}
+		if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) {
+			return YAML.parse(content);
 		}
-		const content = readFileSync(filePath, "utf-8");
-		return JSON.parse(content);
+		throw new Error(`Unsupported keybindings config extension: ${filePath}`);
 	} catch (error) {
 		if (isEnoent(error)) {
 			return null;
@@ -350,34 +363,67 @@ function loadRawConfig(filePath: string): unknown {
 	}
 }
 
+function writeKeybindingsConfig(filePath: string, config: KeybindingsConfig): boolean {
+	try {
+		fs.writeFileSync(filePath, YAML.stringify(config, null, 2), "utf-8");
+		logger.debug("Migrated keybindings config", { path: filePath });
+		return true;
+	} catch (error) {
+		logger.warn("Failed to write migrated keybindings config", { path: filePath, error: String(error) });
+		return false;
+	}
+}
+
+function resolveKeybindingsConfigPaths(agentDir: string): KeybindingsConfigPaths {
+	const ymlPath = path.join(agentDir, KEYBINDINGS_YML);
+	if (fs.existsSync(ymlPath)) {
+		return { readPath: ymlPath, writeBackPath: ymlPath };
+	}
+
+	const yamlPath = path.join(agentDir, KEYBINDINGS_YAML);
+	if (fs.existsSync(yamlPath)) {
+		return { readPath: yamlPath, writeBackPath: yamlPath };
+	}
+
+	const jsonPath = path.join(agentDir, LEGACY_KEYBINDINGS_JSON);
+	if (fs.existsSync(jsonPath)) {
+		return { readPath: jsonPath, writeBackPath: ymlPath };
+	}
+
+	return { readPath: ymlPath, writeBackPath: ymlPath };
+}
+
 /**
- * Migrate keybindings config file from old format to new.
- * Reads from agentDir/keybindings.json, migrates old names, and writes back.
+ * Load and migrate keybindings config.
+ * Legacy JSON is read for compatibility, but successful write-back goes to YAML.
  */
-function loadKeybindingsConfig(filePath: string, writeBack: boolean): KeybindingsConfig {
+function loadKeybindingsConfig(
+	filePath: string,
+	writeBackPath: string | undefined,
+): {
+	config: KeybindingsConfig;
+	persistedPath: string;
+} {
 	const rawConfig = loadRawConfig(filePath);
 
 	if (rawConfig === null) {
-		return {};
+		return { config: {}, persistedPath: filePath };
 	}
 
 	const { config: migratedConfig, migrated } = migrateKeybindingNames(rawConfig);
-	if (writeBack && migrated) {
+	const shouldWriteBack = writeBackPath !== undefined && (migrated || writeBackPath !== filePath);
+	if (shouldWriteBack) {
 		const ordered = orderKeybindingsConfig(migratedConfig);
-		try {
-			writeFileSync(filePath, `${JSON.stringify(ordered, null, 2)}\n`, "utf-8");
-			logger.debug("Migrated keybindings config", { path: filePath });
-		} catch (error) {
-			logger.warn("Failed to write migrated keybindings config", { path: filePath, error: String(error) });
-		}
+		const persistedPath = writeKeybindingsConfig(writeBackPath, ordered) ? writeBackPath : filePath;
+		return { config: migratedConfig, persistedPath };
 	}
 
-	return migratedConfig;
+	return { config: migratedConfig, persistedPath: filePath };
 }
 
 function migrateKeybindingsConfigFile(agentDir: string): void {
-	const configPath = path.join(agentDir, "keybindings.json");
-	loadKeybindingsConfig(configPath, true);
+	const { readPath, writeBackPath } = resolveKeybindingsConfigPaths(agentDir);
+	loadKeybindingsConfig(readPath, writeBackPath);
 }
 
 /**
@@ -393,12 +439,13 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	}
 
 	/**
-	 * Create from config file at agentDir/keybindings.json.
+	 * Create from config file at agentDir/keybindings.yml.
+	 * Legacy keybindings.json is migrated to keybindings.yml on load.
 	 */
 	static create(agentDir: string = getAgentDir()): KeybindingsManager {
-		const configPath = path.join(agentDir, "keybindings.json");
-		const userBindings = KeybindingsManager.#loadFromFile(configPath);
-		const manager = new KeybindingsManager(userBindings, configPath);
+		const { readPath, writeBackPath } = resolveKeybindingsConfigPaths(agentDir);
+		const { config: userBindings, persistedPath } = KeybindingsManager.#loadFromFile(readPath, writeBackPath);
+		const manager = new KeybindingsManager(userBindings, persistedPath);
 		// Set globally so getKeybindings() returns this manager
 		setKeybindings(manager);
 		return manager;
@@ -416,7 +463,8 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	 */
 	reload(): void {
 		if (!this.#configPath) return;
-		this.setUserBindings(KeybindingsManager.#loadFromFile(this.#configPath));
+		const { config } = KeybindingsManager.#loadFromFile(this.#configPath);
+		this.setUserBindings(config);
 	}
 
 	/**
@@ -437,8 +485,11 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	/**
 	 * Load user bindings from a file, migrating old names if needed.
 	 */
-	static #loadFromFile(filePath: string): KeybindingsConfig {
-		return loadKeybindingsConfig(filePath, true);
+	static #loadFromFile(
+		filePath: string,
+		writeBackPath?: string,
+	): { config: KeybindingsConfig; persistedPath: string } {
+		return loadKeybindingsConfig(filePath, writeBackPath);
 	}
 }
 

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

@@ -1136,12 +1136,13 @@ export const SETTINGS_SCHEMA = {
 
 	"compaction.strategy": {
 		type: "enum",
-		values: ["context-full", "handoff", "off"] as const,
+		values: ["context-full", "handoff", "shake", "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), or disable auto maintenance (off)",
 			options: [
 				{
 					value: "context-full",
@@ -1149,6 +1150,11 @@ 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: "off",
 					label: "Off",
@@ -1327,70 +1333,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 +1404,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 +2990,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,
 		},
 	},
@@ -3292,7 +3298,7 @@ export type TreeFilterMode = SettingValue<"treeFilterMode">;
 
 export interface CompactionSettings {
 	enabled: boolean;
-	strategy: "context-full" | "handoff" | "off";
+	strategy: "context-full" | "handoff" | "shake" | "off";
 	thresholdPercent: number;
 	thresholdTokens: number;
 	reserveTokens: number;

package/src/config/settings.ts

@@ -663,6 +663,16 @@ export class Settings {
 			raw["edit.mode"] = "hashline";
 		}
 
+		// compaction.strategy: removed local-model shake-summary mode; plain shake
+		// keeps the same mechanical artifact-backed reduction without background CPU.
+		const compactionObj = raw.compaction as Record<string, unknown> | undefined;
+		if (compactionObj?.strategy === "shake-summary") {
+			compactionObj.strategy = "shake";
+		}
+		if (raw["compaction.strategy"] === "shake-summary") {
+			raw["compaction.strategy"] = "shake";
+		}
+
 		// statusLine: rename "plan_mode" segment to "mode"
 		const statusLineObj = raw.statusLine as Record<string, unknown> | undefined;
 		if (statusLineObj) {
@@ -692,6 +702,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