@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/src/internal-urls/history-protocol.ts

@@ -12,7 +12,7 @@
 import type { AgentRef } from "../registry/agent-registry";
 import { AgentRegistry } from "../registry/agent-registry";
 import { formatSessionHistoryMarkdown } from "../session/session-history-format";
-import { loadSessionMessagesReadOnly } from "../session/session-manager";
+import { loadSessionMessagesReadOnly } from "../session/session-loader";
 import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 /** Humanize a last-activity timestamp as `Ns/Nm/Nh/Nd ago`. */

package/src/internal-urls/local-protocol.ts

@@ -26,6 +26,20 @@ function toLocalValidationError(error: unknown): Error {
 	const message = error instanceof Error ? error.message : String(error);
 	return new Error(message.replace("skill://", "local://"));
 }
+const WINDOWS_LOCAL_ROOT_MAX_CHARS = 180;
+
+function safeSessionId(options: LocalProtocolOptions): string {
+	const raw = options.getSessionId?.() ?? "session";
+	const safe = raw.replace(/[^a-zA-Z0-9_.-]/g, "_");
+	return safe.length > 0 ? safe : "session";
+}
+
+function shortLocalRoot(options: LocalProtocolOptions): string {
+	// Derive the short root from the stable session id, never the artifact path,
+	// so `SessionManager.moveTo()` and the resume-after-move flow keep finding
+	// the same `local://` directory the session wrote pre-move.
+	return path.join(os.tmpdir(), "omp-local", safeSessionId(options));
+}
 
 function getContentType(filePath: string): InternalResource["contentType"] {
 	const ext = path.extname(filePath).toLowerCase();
@@ -108,20 +122,28 @@ function extractRelativePath(url: InternalUrl): string {
 	return decoded;
 }
 
-export function resolveLocalRoot(options: LocalProtocolOptions): string {
+/** Resolve the session-scoped local:// root, shortening long Windows artifact paths before writes hit MAX_PATH. */
+export function resolveLocalRoot(options: LocalProtocolOptions, platform: NodeJS.Platform = process.platform): string {
 	const artifactsDir = options.getArtifactsDir?.();
 	if (artifactsDir) {
-		return path.resolve(artifactsDir, "local");
+		const candidate = path.resolve(artifactsDir, "local");
+		if (platform === "win32" && candidate.length >= WINDOWS_LOCAL_ROOT_MAX_CHARS) {
+			return shortLocalRoot(options);
+		}
+		return candidate;
 	}
 
-	const sessionId = options.getSessionId?.() ?? "session";
-	const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_");
-	return path.join(os.tmpdir(), "omp-local", safeSessionId);
+	return path.join(os.tmpdir(), "omp-local", safeSessionId(options));
 }
 
-export function resolveLocalUrlToPath(input: string | InternalUrl, options: LocalProtocolOptions): string {
+/** Resolve a local:// URL to an on-disk path under the active session's local root. */
+export function resolveLocalUrlToPath(
+	input: string | InternalUrl,
+	options: LocalProtocolOptions,
+	platform: NodeJS.Platform = process.platform,
+): string {
 	const url = typeof input === "string" ? parseLocalUrl(input) : input;
-	const localRoot = path.resolve(resolveLocalRoot(options));
+	const localRoot = path.resolve(resolveLocalRoot(options, platform));
 	const relativePath = extractRelativePath(url);
 
 	if (!relativePath) {

package/src/lsp/types.ts

@@ -1,5 +1,5 @@
 import type { ptree } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 
 // =============================================================================
 // Tool Schema

package/src/main.ts

@@ -21,11 +21,10 @@ import {
 } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { reset as resetCapabilities } from "./capability";
-import type { Args } from "./cli/args";
+import { type Args, reportUnrecognizedFlags } from "./cli/args";
 import { applyExtensionFlags, type ExtensionFlagSink } from "./cli/extension-flags";
 import { processFileArguments } from "./cli/file-processor";
 import { buildInitialMessage } from "./cli/initial-message";
-import { runListModelsCommand } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { applyStartupCwd } from "./cli/startup-cwd";
 import { findConfigFile } from "./config";
@@ -65,7 +64,8 @@ import {
 } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
-import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
+import { resolveResumableSession, type SessionInfo } from "./session/session-listing";
+import { SessionManager } from "./session/session-manager";
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "./system-prompt";
 import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
@@ -265,7 +265,7 @@ export async function submitInteractiveInput(
 		InteractiveMode,
 		"markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested"
 	>,
-	session: Pick<AgentSession, "prompt" | "promptCustomMessage">,
+	session: Pick<AgentSession, "prompt" | "promptCustomMessage" | "isStreaming">,
 	input: SubmittedUserInput,
 ): Promise<void> {
 	if (input.cancelled) {
@@ -274,22 +274,32 @@ export async function submitInteractiveInput(
 
 	try {
 		using _keepalive = new EventLoopKeepalive();
+		const streamingBehavior = session.isStreaming ? ("followUp" as const) : undefined;
 		// Continue shortcuts submit an already-started synthetic developer prompt with
 		// no optimistic user message.
 		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
 			return;
 		}
 		if (input.customType) {
-			await session.promptCustomMessage({
+			const message = {
 				customType: input.customType,
 				content: input.text,
 				display: input.display ?? false,
-				attribution: "agent",
-			});
+				attribution: "agent" as const,
+			};
+			await (streamingBehavior
+				? session.promptCustomMessage(message, { streamingBehavior })
+				: session.promptCustomMessage(message));
 		} else if (input.synthetic) {
+			// Synthetic continue shortcuts are hidden developer prompts. The streaming
+			// queue (#queueUserMessage) only carries user-attributed messages, so we do
+			// NOT pass streamingBehavior here: queueing would silently demote the
+			// developer directive to a visible user message. A synthetic submit while
+			// streaming keeps its prior behavior (rejected as busy) rather than changing
+			// its role.
 			await session.prompt(input.text, { synthetic: true, expandPromptTemplates: false });
 		} else {
-			await session.prompt(input.text, { images: input.images });
+			await session.prompt(input.text, { images: input.images, ...(streamingBehavior && { streamingBehavior }) });
 		}
 	} catch (error: unknown) {
 		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
@@ -920,30 +930,6 @@ export async function runRootCommand(
 		process.exit(0);
 	}
 
-	if (parsedArgs.listModels !== undefined) {
-		const settingsInstance = await logger.time("settings:init:list-models", Settings.init, {
-			cwd: getProjectDir(),
-			configFiles: parsedArgs.config,
-		});
-		await modelRegistry.refresh("online");
-		const cliExtensionPaths = parsedArgs.noExtensions
-			? []
-			: [...(parsedArgs.extensions ?? []), ...(parsedArgs.hooks ?? [])];
-		const settingsExtensions = settingsInstance.get("extensions") ?? [];
-		const disabledExtensionIds = settingsInstance.get("disabledExtensions") ?? [];
-		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
-		await runListModelsCommand({
-			modelRegistry,
-			cwd: getProjectDir(),
-			additionalExtensionPaths: cliExtensionPaths,
-			settingsExtensions,
-			disabledExtensionIds,
-			disableExtensionDiscovery: Boolean(parsedArgs.noExtensions),
-			searchPattern,
-		});
-		process.exit(0);
-	}
-
 	if (parsedArgs.export) {
 		let result: string;
 		try {
@@ -1222,6 +1208,15 @@ export async function runRootCommand(
 			},
 		};
 		const initialArgs = applyExtensionFlags(extensionFlagSink, rawArgs) ?? parsedArgs;
+		// Fail fast on stale/typo flags (e.g. `omp --list-models`) now that we
+		// know the real extension flag set. Without this check the unrecognized
+		// token gets silently consumed and any following positional leaks as the
+		// initial prompt — kicking off a real LLM session, MCP connection, and
+		// tool calls (issue #2459). Exit code 2 matches the conventional
+		// "command line usage error" convention.
+		if (reportUnrecognizedFlags(initialArgs)) {
+			process.exit(2);
+		}
 		const processedFiles =
 			initialArgs.fileArgs.length > 0
 				? await logger.time("processFileArguments", () =>

package/src/mcp/config-writer.ts

@@ -67,9 +67,13 @@ export function validateServerName(name: string): string | undefined {
 	if (name.length > 100) {
 		return "Server name is too long (max 100 characters)";
 	}
-	// Check for invalid characters (only allow alphanumeric, dash, underscore, dot)
-	if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
-		return "Server name can only contain letters, numbers, dash, underscore, and dot";
+	// Check for invalid characters. Colon is allowed so namespaced plugin servers
+	// (e.g. "cloudflare:cloudflare-api" from a Claude Code marketplace plugin) can
+	// be persisted: the runtime already accepts colons in server names (tool names
+	// sanitize them via createMCPToolName) and `/mcp reauth` writes such names back
+	// as a user-config override that shadows the discovered entry.
+	if (!/^[a-zA-Z0-9_.:-]+$/.test(name)) {
+		return "Server name can only contain letters, numbers, dash, underscore, dot, and colon";
 	}
 	return undefined;
 }

package/src/mcp/manager.ts

@@ -643,6 +643,17 @@ export class MCPManager {
 		return this.#sources.get(name) ?? this.#connections.get(name)?._source;
 	}
 
+	/**
+	 * Get the preserved (pre-auth) config for a known server — whether currently
+	 * connected or merely discovered (a connect was attempted but may have failed,
+	 * e.g. an OAuth server that has not been authorized yet). Mirrors the
+	 * reconnect lookup at {@link reconnectServer} so callers like `/mcp reauth`
+	 * can recover a discovered server's config without re-reading config files.
+	 */
+	getServerConfig(name: string): MCPServerConfig | undefined {
+		return this.#connections.get(name)?.config ?? this.#serverConfigs.get(name);
+	}
+
 	/**
 	 * Wait for a connection to complete (or fail).
 	 */

package/src/mcp/startup-events.ts

@@ -0,0 +1,21 @@
+export const MCP_CONNECTING_EVENT_CHANNEL = "mcp:connecting";
+
+export type McpConnectingEvent = { serverNames: string[] };
+
+export function formatMCPConnectingMessage(serverNames: string[]): string {
+	return `Connecting to MCP servers: ${serverNames.join(", ")}…`;
+}
+
+/**
+ * Runtime validator for the cross-module event payload. The event bus is
+ * untyped at runtime, so the subscriber verifies the shape before formatting
+ * rather than trusting a cast — a malformed emit is ignored instead of throwing.
+ */
+export function isMcpConnectingEvent(data: unknown): data is McpConnectingEvent {
+	return (
+		typeof data === "object" &&
+		data !== null &&
+		Array.isArray((data as { serverNames?: unknown }).serverNames) &&
+		(data as { serverNames: unknown[] }).serverNames.every(name => typeof name === "string")
+	);
+}

package/src/mcp/transports/stdio.ts

@@ -589,7 +589,8 @@ export class StdioTransport implements MCPTransport {
 		}
 
 		if (this.#readLoop) {
-			await this.#readLoop.catch(() => {});
+			// Do not block/await the read loop as it can hang indefinitely in some environments
+			this.#readLoop.catch(() => {});
 			this.#readLoop = null;
 		}
 	}

package/src/memories/index.ts

@@ -5,11 +5,12 @@ import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { type ApiKey, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
-import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath, getMemoriesDir, isEnoent, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
 
 import type { ModelRegistry } from "../config/model-registry";
 import { getModelMatchPreferences, resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
+import type { MemoryBackendSaveInput, MemoryBackendSaveResult } from "../memory-backend/types";
 import consolidationTemplate from "../prompts/memories/consolidation.md" with { type: "text" };
 import consolidationSystemTemplate from "../prompts/memories/consolidation_system.md" with { type: "text" };
 import readPathTemplate from "../prompts/memories/read-path.md" with { type: "text" };
@@ -156,22 +157,31 @@ export async function buildMemoryToolDeveloperInstructions(
 	const cfg = loadMemoryConfig(settings);
 	if (!cfg.enabled) return undefined;
 	const memoryRoot = getMemoryRoot(agentDir, settings.getCwd());
-	const summaryPath = path.join(memoryRoot, "memory_summary.md");
 
-	let text: string;
+	let summary = "";
 	try {
-		text = await Bun.file(summaryPath).text();
+		summary = (await Bun.file(path.join(memoryRoot, "memory_summary.md")).text()).trim();
 	} catch {
-		return undefined;
+		// Missing or unreadable summary — injection is best-effort; fall through
+		// so any captured lessons still surface on their own.
 	}
-
-	const summary = text.trim();
-	if (!summary) return undefined;
-	const truncated = truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit);
-	if (!truncated.trim()) return undefined;
+	const learned = await readLearnedLessons(memoryRoot);
+	if (!summary && !learned) return undefined;
+
+	const summaryOut = summary ? truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit).trim() : "";
+	// Lessons share ONE injection budget with the summary so the combined block
+	// stays within `summaryInjectionTokenLimit` (~4 chars/token, matching
+	// truncateByApproxTokens). With no summary, lessons get the whole budget.
+	// Clamp to 0: truncateByApproxTokens appends a marker, so a truncated summary
+	// can exceed `limit * 4` chars and drive the remainder negative — when the
+	// summary already fills the budget, lessons are simply dropped.
+	const learnedBudget = Math.max(0, cfg.summaryInjectionTokenLimit - Math.ceil(summaryOut.length / 4));
+	const learnedOut = learned && learnedBudget > 0 ? truncateByApproxTokens(learned, learnedBudget).trim() : "";
+	if (!summaryOut && !learnedOut) return undefined;
 
 	return prompt.render(readPathTemplate, {
-		memory_summary: truncated,
+		memory_summary: summaryOut,
+		learned: learnedOut,
 	});
 }
 
@@ -982,6 +992,12 @@ function redactSecrets(input: string): string {
 		/(?:sk|pk|rk|tok|key|secret|token|password)[-_A-Za-z0-9]{12,}/g,
 		/[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g,
 		/(?:AKIA|ASIA)[A-Z0-9]{16}/g,
+		// Common provider token prefixes (GitHub, npm, Slack, Google).
+		/(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g,
+		/github_pat_[A-Za-z0-9_]{20,}/g,
+		/npm_[A-Za-z0-9]{30,}/g,
+		/xox[baprs]-[A-Za-z0-9-]{10,}/g,
+		/AIza[A-Za-z0-9_-]{30,}/g,
 	];
 	for (const pattern of patterns) {
 		out = out.replace(pattern, "[REDACTED]");
@@ -1071,7 +1087,9 @@ function truncateByApproxTokens(text: string, tokenLimit: number): string {
 
 function computeModelTokenBudget(model: Model, config: MemoryRuntimeConfig): number {
 	const maxTokens =
-		Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : config.fallbackTokenLimit;
+		model.contextWindow !== null && Number.isFinite(model.contextWindow) && model.contextWindow > 0
+			? model.contextWindow
+			: config.fallbackTokenLimit;
 	return Math.max(2048, Math.floor(maxTokens));
 }
 
@@ -1119,6 +1137,125 @@ export function getMemoryRoot(agentDir: string, cwd: string): string {
 	return path.join(getMemoriesDir(agentDir), encodeProjectPath(cwd));
 }
 
+/**
+ * Filename of the captured-lessons file under a project's memory root.
+ *
+ * Written by the `learn` tool via {@link saveLearnedLesson} and read back by
+ * {@link buildMemoryToolDeveloperInstructions}. Deliberately distinct from the
+ * consolidation artifacts (`MEMORY.md`, `memory_summary.md`, `skills/`) so a
+ * consolidation pass never clobbers manually captured lessons.
+ */
+const LEARNED_LESSONS_FILE = "learned.md";
+/** Newest-first cap on retained lessons, bounding file growth by entry count. */
+const MAX_LEARNED_LESSONS = 100;
+/** Per-field char caps so a single huge capture can't bloat learned.md. */
+const MAX_LEARNED_CONTENT_CHARS = 2000;
+const MAX_LEARNED_CONTEXT_CHARS = 400;
+
+/**
+ * Strip prompt-injection vectors from a single line of lesson text: control/
+ * format chars, angle brackets (`</skills>`), backticks, and `~~~` fences, then
+ * collapse whitespace. Applied on BOTH write and read (the block renders
+ * unescaped into the system prompt), mirroring managed-skill descriptions.
+ */
+function neutralizeInjection(text: string): string {
+	return text
+		.replace(/[\p{Cc}\p{Cf}]/gu, " ")
+		.replace(/[<>`]/g, "")
+		.replace(/~{2,}/g, "~")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/** Slice to `maxChars`, dropping a trailing unpaired high surrogate. */
+function boundChars(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	const sliced = text.slice(0, maxChars);
+	return /[\uD800-\uDBFF]$/.test(sliced) ? sliced.slice(0, -1) : sliced;
+}
+
+/**
+ * Normalize one lesson field for storage: neutralize injection delimiters
+ * FIRST, then redact secrets (so delimiter stripping can't reassemble a token
+ * the redactor would have caught), then bound the length.
+ */
+function normalizeLearnedText(text: string, maxChars: number): string {
+	return boundChars(redactSecrets(neutralizeInjection(text)).trim(), maxChars);
+}
+
+/** Per-path write chains serializing `learned.md` read-modify-write. */
+const learnedWriteChains = new Map<string, Promise<unknown>>();
+
+/**
+ * Append one lesson to the project's `learned.md` (newest-first, deduped,
+ * capped, secret-redacted, injection-neutralized). The file backs the `learn`
+ * tool when `memory.backend` is `local`.
+ */
+export async function saveLearnedLesson(
+	agentDir: string,
+	cwd: string,
+	input: MemoryBackendSaveInput,
+): Promise<MemoryBackendSaveResult> {
+	const content = normalizeLearnedText(input.content, MAX_LEARNED_CONTENT_CHARS);
+	if (!content) {
+		return { backend: "local", stored: 0, message: "Empty lesson; nothing stored." };
+	}
+	const context = input.context ? normalizeLearnedText(input.context, MAX_LEARNED_CONTEXT_CHARS) : "";
+	const line = context ? `- ${content} _(context: ${context})_` : `- ${content}`;
+	const filePath = path.join(getMemoryRoot(agentDir, cwd), LEARNED_LESSONS_FILE);
+
+	// Serialize the read-modify-write per file: parallel `learn` calls (sibling
+	// subagents, or two shared tool calls in one turn) share the project memory
+	// root, so an unguarded RMW would let the last writer drop the other's lesson.
+	const run = (learnedWriteChains.get(filePath) ?? Promise.resolve()).then(() => appendLearnedLine(filePath, line));
+	const guarded = run.catch(() => {});
+	learnedWriteChains.set(filePath, guarded);
+	try {
+		await run;
+	} finally {
+		// Drop the entry once this write is the chain tail, so the map does not
+		// retain one promise per distinct memory root for the process lifetime.
+		if (learnedWriteChains.get(filePath) === guarded) learnedWriteChains.delete(filePath);
+	}
+	return { backend: "local", stored: 1, message: `Lesson saved to ${LEARNED_LESSONS_FILE}.` };
+}
+
+async function appendLearnedLine(filePath: string, line: string): Promise<void> {
+	let existing = "";
+	try {
+		existing = await Bun.file(filePath).text();
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
+	}
+	const prior = existing
+		.split("\n")
+		.map(l => l.trim())
+		.filter(l => l.startsWith("- ") && l !== line);
+	const lessons = [line, ...prior].slice(0, MAX_LEARNED_LESSONS);
+	await Bun.write(filePath, `${lessons.join("\n")}\n`);
+}
+
+/**
+ * Read `learned.md`, neutralizing each line on read too — a hand-edited or
+ * pre-existing file bypasses write-time normalization and the block renders
+ * unescaped into the system prompt. Returns "" when absent/unreadable.
+ */
+async function readLearnedLessons(memoryRoot: string): Promise<string> {
+	let raw = "";
+	try {
+		raw = (await Bun.file(path.join(memoryRoot, LEARNED_LESSONS_FILE)).text()).trim();
+	} catch {
+		return "";
+	}
+	if (!raw) return "";
+	// Neutralize delimiters THEN redact per line — mirrors the write path so a
+	// hand-edited line cannot reassemble a token after delimiter stripping.
+	return raw
+		.split("\n")
+		.map(line => redactSecrets(neutralizeInjection(line)))
+		.join("\n");
+}
+
 function encodeProjectPath(cwd: string): string {
 	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
 }

package/src/memories/storage.ts

@@ -46,10 +46,11 @@ function globalJobKey(cwd: string): string {
 
 export function openMemoryDb(dbPath: string): Database {
 	const db = new Database(dbPath);
+	// Install the busy handler BEFORE any lock-taking statement. See #2421.
+	db.exec("PRAGMA busy_timeout = 5000");
 	db.exec(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS threads (
 	id TEXT PRIMARY KEY,

package/src/memory-backend/local-backend.ts

@@ -2,6 +2,7 @@ import {
 	buildMemoryToolDeveloperInstructions,
 	clearMemoryData,
 	enqueueMemoryConsolidation,
+	saveLearnedLesson,
 	startMemoryStartupTask,
 } from "../memories";
 import type { MemoryBackend } from "./types";
@@ -9,9 +10,10 @@ import type { MemoryBackend } from "./types";
 /**
  * Wraps the existing `memories/` module as a `MemoryBackend`.
  *
- * No behavioural change — every call delegates to the legacy entry points so
- * the local memory pipeline (rollout summarisation → SQLite → memory_summary.md)
- * keeps working exactly as before.
+ * The rollout-summarisation pipeline (rollouts → SQLite → memory_summary.md) is
+ * delegated unchanged. On top of it, `save()` persists `learn`-tool lessons to
+ * `learned.md` (so `status()` reports `writable: true`); structured search is
+ * still unavailable.
  */
 export const localBackend: MemoryBackend = {
 	id: "local",
@@ -27,13 +29,17 @@ export const localBackend: MemoryBackend = {
 	async enqueue(agentDir, cwd) {
 		enqueueMemoryConsolidation(agentDir, cwd);
 	},
+	async save(context, input) {
+		return saveLearnedLesson(context.agentDir, context.cwd, input);
+	},
 	async status() {
 		return {
 			backend: "local" as const,
 			active: true,
-			writable: false,
+			writable: true,
 			searchable: false,
-			message: "Local rollout-summary memory is active; structured search/save is not available.",
+			message:
+				"Local rollout-summary memory is active; lessons from the `learn` tool are saved to learned.md. Structured search is not available.",
 		};
 	},
 };

package/src/mnemopi/backend.ts

@@ -305,6 +305,7 @@ function createStatsMemory(config: MnemopiBackendConfig, bank: string): Mnemopi
 		authorType: "agent",
 		channelId: bank,
 		...providerOptions,
+		reconcile: false,
 	} as ConstructorParameters<typeof Mnemopi>[0]);
 }