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

package/src/session/session-storage.ts

@@ -272,8 +272,8 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		if (this.#closed) throw new Error("Writer closed");
 		if (this.#error) throw this.#error;
 		try {
-			const existing = this.#storage.existsSync(this.#path) ? this.#storage.readTextSync(this.#path) : "";
-			this.#storage.writeTextSync(this.#path, `${existing}${line}`);
+			// O(1) chunked append — see MemorySessionStorage.appendChunkSync.
+			this.#storage.appendChunkSync(this.#path, line);
 		} catch (err) {
 			throw this.#recordError(err);
 		}
@@ -302,8 +302,26 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 	}
 }
 
+/**
+ * Mirror entry stored per path. Chunks accumulate via O(1) `push` on
+ * `appendChunkSync`; readers materialise into a single string lazily.
+ * `byteLen` is kept in sync so `statSync` is O(1) (and returns true UTF-8
+ * bytes, not character count).
+ */
+interface MirrorEntry {
+	chunks: string[];
+	byteLen: number;
+	mtimeMs: number;
+}
+
+function materialiseMirror(entry: MirrorEntry): string {
+	if (entry.chunks.length === 0) return "";
+	if (entry.chunks.length === 1) return entry.chunks[0];
+	return entry.chunks.join("");
+}
+
 export class MemorySessionStorage implements SessionStorage {
-	#files = new Map<string, { content: string; mtimeMs: number }>();
+	#files = new Map<string, MirrorEntry>();
 
 	ensureDirSync(_dir: string): void {
 		// No-op for in-memory storage.
@@ -314,20 +332,40 @@ export class MemorySessionStorage implements SessionStorage {
 	}
 
 	writeTextSync(path: string, content: string): void {
-		this.#files.set(path, { content, mtimeMs: Date.now() });
+		this.#files.set(path, {
+			chunks: content.length === 0 ? [] : [content],
+			byteLen: Buffer.byteLength(content, "utf-8"),
+			mtimeMs: Date.now(),
+		});
+	}
+
+	/**
+	 * Internal O(1) append used by {@link MemorySessionStorageWriter}. Lazily
+	 * creates the entry. External callers should go through `openWriter()`
+	 * rather than touching the mirror directly.
+	 */
+	appendChunkSync(path: string, chunk: string): void {
+		let entry = this.#files.get(path);
+		if (!entry) {
+			entry = { chunks: [], byteLen: 0, mtimeMs: Date.now() };
+			this.#files.set(path, entry);
+		}
+		entry.chunks.push(chunk);
+		entry.byteLen += Buffer.byteLength(chunk, "utf-8");
+		entry.mtimeMs = Date.now();
 	}
 
 	readTextSync(path: string): string {
 		const entry = this.#files.get(path);
 		if (!entry) throw new Error(`File not found: ${path}`);
-		return entry.content;
+		return materialiseMirror(entry);
 	}
 
 	statSync(path: string): SessionStorageStat {
 		const entry = this.#files.get(path);
 		if (!entry) throw new Error(`File not found: ${path}`);
 		return {
-			size: entry.content.length,
+			size: entry.byteLen,
 			mtimeMs: entry.mtimeMs,
 			mtime: new Date(entry.mtimeMs),
 		};
@@ -353,13 +391,35 @@ export class MemorySessionStorage implements SessionStorage {
 	readText(path: string): Promise<string> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		return Promise.resolve(entry.content);
+		return Promise.resolve(materialiseMirror(entry));
 	}
 
 	readTextPrefix(path: string, maxBytes: number): Promise<string> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		return Promise.resolve(entry.content.slice(0, maxBytes));
+		if (entry.chunks.length === 0 || maxBytes <= 0) return Promise.resolve("");
+
+		// Walk chunks until the byte budget is exhausted. Avoids materialising
+		// the full mirror just to slice a prefix — bounded work for big files.
+		let accumulatedBytes = 0;
+		const out: string[] = [];
+		for (const chunk of entry.chunks) {
+			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+			if (accumulatedBytes + chunkBytes <= maxBytes) {
+				out.push(chunk);
+				accumulatedBytes += chunkBytes;
+				if (accumulatedBytes === maxBytes) break;
+				continue;
+			}
+			// Boundary chunk: slice in byte space and decode. Result MAY be
+			// shorter than the budget if a multi-byte codepoint straddles the
+			// boundary — matches `peekFile` semantics (partial decode at cap).
+			const remainingBytes = maxBytes - accumulatedBytes;
+			const utf8 = Buffer.from(chunk, "utf-8");
+			out.push(utf8Decoder.decode(utf8.subarray(0, remainingBytes)));
+			break;
+		}
+		return Promise.resolve(out.join(""));
 	}
 
 	writeText(path: string, content: string): Promise<void> {

package/src/session/shake-types.ts

@@ -0,0 +1,43 @@
+/**
+ * Public shape of the `shake` operation, kept in a dependency-free leaf module
+ * so slash-command registries and controllers can import `formatShakeSummary`
+ * without pulling in the heavy `agent-session` module graph (which would form
+ * an import cycle through the slash-command registry).
+ */
+
+/** Mode selector for `AgentSession.shake`. */
+export type ShakeMode = "elide" | "images";
+
+/** Outcome of an `AgentSession.shake` run. */
+export interface ShakeResult {
+	mode: ShakeMode;
+	/** Whole tool-call results dropped. */
+	toolResultsDropped: number;
+	/** Large fenced/XML blocks dropped. */
+	blocksDropped: number;
+	/** Image blocks removed (images mode only). */
+	imagesDropped?: number;
+	/** Estimated context tokens reclaimed. */
+	tokensFreed: number;
+	/** Session artifact holding the dropped originals, when persisted. */
+	artifactId?: string;
+}
+
+/** One-line operator summary of a {@link ShakeResult} (shared by TUI + ACP). */
+export function formatShakeSummary(result: ShakeResult): string {
+	if (result.mode === "images") {
+		const n = result.imagesDropped ?? 0;
+		return n === 0
+			? "No images found in this session."
+			: `Dropped ${n} image${n === 1 ? "" : "s"} from this session.`;
+	}
+	const parts: string[] = [];
+	if (result.toolResultsDropped > 0) {
+		parts.push(`${result.toolResultsDropped} tool result${result.toolResultsDropped === 1 ? "" : "s"}`);
+	}
+	if (result.blocksDropped > 0) {
+		parts.push(`${result.blocksDropped} block${result.blocksDropped === 1 ? "" : "s"}`);
+	}
+	if (parts.length === 0) return "Nothing to shake.";
+	return `Shook ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
+}

package/src/slash-commands/builtin-registry.ts

@@ -21,6 +21,7 @@ import {
 } from "../extensibility/plugins/marketplace";
 import { resolveMemoryBackend } from "../memory-backend";
 import type { InteractiveModeContext } from "../modes/types";
+import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
 import { getChangelogPath, parseChangelog } from "../utils/changelog";
 import { buildContextReportText } from "./helpers/context-report";
 import { formatDuration } from "./helpers/format";
@@ -57,6 +58,14 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 	return commandConsumed();
 };
 
+/** Parse the `/shake` subcommand into a {@link ShakeMode}; empty defaults to elide. */
+function parseShakeMode(args: string): ShakeMode | { error: string } {
+	const verb = args.trim().toLowerCase();
+	if (verb === "" || verb === "elide") return "elide";
+	if (verb === "images") return "images";
+	return { error: `Unknown /shake mode "${verb}". Use elide or images.` };
+}
+
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "settings",
@@ -811,27 +820,30 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		},
 	},
 	{
-		name: "drop-images",
-		description: "Strip every image from this session's history",
-		acpDescription: "Drop all images from the conversation history",
-		handle: async (_command, runtime) => {
-			const { removed } = await runtime.session.dropImages();
-			await runtime.output(
-				removed === 0
-					? "No images found in this session."
-					: `Dropped ${removed} image${removed === 1 ? "" : "s"} from this session.`,
-			);
+		name: "shake",
+		description: "Drop heavy content from context (tool results, large blocks)",
+		acpDescription: "Shake heavy content out of the conversation context",
+		subcommands: [
+			{ name: "elide", description: "Strip tool results + large blocks (default)" },
+			{ name: "images", description: "Strip image blocks" },
+		],
+		acpInputHint: "[elide|images]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") return usage(mode.error, runtime);
+			const result = await runtime.session.shake(mode);
+			await runtime.output(formatShakeSummary(result));
 			return commandConsumed();
 		},
-		handleTui: async (_command, runtime) => {
+		handleTui: async (command, runtime) => {
 			runtime.ctx.editor.setText("");
-			const { removed } = await runtime.ctx.session.dropImages();
-			if (removed === 0) {
-				runtime.ctx.showStatus("No images found in this session.");
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") {
+				runtime.ctx.showWarning(mode.error);
 				return;
 			}
-			runtime.ctx.rebuildChatFromMessages();
-			runtime.ctx.showStatus(`Dropped ${removed} image${removed === 1 ? "" : "s"} from this session.`);
+			await runtime.ctx.handleShakeCommand(mode);
 		},
 	},
 	{
@@ -864,6 +876,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleBtwCommand(question);
 		},
 	},
+	{
+		name: "omfg",
+		description: "Forge a TTSR rule from a complaint to stop a recurring behavior",
+		inlineHint: "<complaint>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const complaint = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleOmfgCommand(complaint);
+		},
+	},
 	{
 		name: "retry",
 		description: "Retry the last failed agent turn",

package/src/task/executor.ts

@@ -21,7 +21,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
-import type { MnemosyneSessionState } from "../mnemosyne/state";
+import type { MnemopiSessionState } from "../mnemopi/state";
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
 import submitReminderTemplate from "../prompts/system/subagent-yield-reminder.md" with { type: "text" };
 import { AgentRegistry } from "../registry/agent-registry";
@@ -186,7 +186,7 @@ export interface ExecutorOptions {
 	 */
 	parentArtifactManager?: ArtifactManager;
 	parentHindsightSessionState?: HindsightSessionState;
-	parentMnemosyneSessionState?: MnemosyneSessionState;
+	parentMnemopiSessionState?: MnemopiSessionState;
 	/** Parent agent's eval executor session id. Subagents reuse it so eval state is shared. */
 	parentEvalSessionId?: string;
 	/**
@@ -633,7 +633,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (atMaxDepth && toolNames?.includes("task")) {
 		toolNames = toolNames.filter(name => name !== "task");
 	}
-	// IRC is always available; the [COOP] prompt advertises it, so a restricted
+	// IRC is always available; the COOP prompt section advertises it, so a restricted
 	// whitelist must still carry `irc` for the subagent to actually use it.
 	if (toolNames && !toolNames.includes("irc")) {
 		toolNames = [...toolNames, "irc"];
@@ -1245,7 +1245,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					spawns: spawnsEnv,
 					taskDepth: childDepth,
 					parentHindsightSessionState: options.parentHindsightSessionState,
-					parentMnemosyneSessionState: options.parentMnemosyneSessionState,
+					parentMnemopiSessionState: options.parentMnemopiSessionState,
 					parentTaskPrefix: id,
 					agentId: id,
 					agentDisplayName: agent.name,
@@ -1446,9 +1446,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					);
 					await awaitAbortable(session.waitForIdle());
 				} catch (err) {
-					logger.error("Subagent prompt failed", {
-						error: err instanceof Error ? err.message : String(err),
-					});
+					if (abortSignal.aborted || err instanceof ToolAbortError) {
+						// Benign control-flow exit — user cancel (^C) or compaction aborting
+						// pending operations both surface here as ToolAbortError. The outer
+						// catch and finally already mark the run aborted; logging at ERROR
+						// would spam operator dashboards with non-failures.
+						logger.debug("Subagent prompt aborted", {
+							reason: abortReason ?? "signal",
+						});
+					} else {
+						logger.error("Subagent prompt failed", {
+							error: err instanceof Error ? err.message : String(err),
+						});
+					}
 				}
 			}
 

package/src/task/index.ts

@@ -48,6 +48,7 @@ import { runSubprocess } from "./executor";
 import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit, Semaphore } from "./parallel";
 import { renderResult, renderCall as renderTaskCall } from "./render";
+import { repairTaskParams } from "./repair-args";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import {
 	applyNestedPatches,
@@ -247,7 +248,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	}
 
 	renderCall(args: unknown, options: Parameters<typeof renderTaskCall>[1], theme: Theme) {
-		return renderTaskCall(args as TaskParams, options, theme);
+		return renderTaskCall(repairTaskParams(args as TaskParams), options, theme);
 	}
 
 	/** Dynamic description that reflects current disabled-agent settings */
@@ -292,7 +293,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
 	): Promise<AgentToolResult<TaskToolDetails>> {
-		const params = rawParams as TaskParams;
+		const params = repairTaskParams(rawParams as TaskParams);
 		const simpleMode = this.#getTaskSimpleMode();
 		const validationError = validateTaskModeParams(simpleMode, params);
 		if (validationError) {
@@ -762,8 +763,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const tempArtifactsDir = artifactsDir ? null : path.join(os.tmpdir(), `omp-task-${Snowflake.next()}`);
 		const effectiveArtifactsDir = artifactsDir || tempArtifactsDir!;
 
-		// Share the parent session's local:// root with subagents so they read/write the same scratch space
-		const localProtocolOptions: LocalProtocolOptions = {
+		const localProtocolOptions: LocalProtocolOptions = this.session.localProtocolOptions ?? {
 			getArtifactsDir: this.session.getArtifactsDir ?? (() => null),
 			getSessionId: this.session.getSessionId ?? (() => null),
 		};
@@ -864,6 +864,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			);
 			const promptTemplates = this.session.promptTemplates;
 			const parentEvalSessionId = this.session.getEvalSessionId?.() ?? undefined;
+			const mcpManager = this.session.mcpManager ?? MCPManager.instance();
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithUniqueIds.length; i++) {
@@ -921,7 +922,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
-						mcpManager: MCPManager.instance(),
+						mcpManager,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -930,7 +931,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						localProtocolOptions,
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
-						parentMnemosyneSessionState: this.session.getMnemosyneSessionState?.(),
+						parentMnemopiSessionState: this.session.getMnemopiSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
 						parentEvalSessionId,
 					});
@@ -978,7 +979,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
-						mcpManager: MCPManager.instance(),
+						mcpManager,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -987,7 +988,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						localProtocolOptions,
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
-						parentMnemosyneSessionState: this.session.getMnemosyneSessionState?.(),
+						parentMnemopiSessionState: this.session.getMnemopiSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
 						parentEvalSessionId,
 					});

package/src/task/repair-args.ts

@@ -0,0 +1,117 @@
+/**
+ * Repair double-encoded JSON string arguments for the task tool.
+ *
+ * Models occasionally JSON-escape a string value twice when emitting a
+ * `task` tool call, so a `context`/`assignment` that should read
+ *
+ *     # Role
+ *     You are a judge … "describe this" … return —
+ *
+ * arrives — after the one JSON decode the provider already applied — as the
+ * literal text
+ *
+ *     # Role\nYou are a judge … \"describe this\" … return \u2014
+ *
+ * i.e. every newline, quote, and unicode character is still backslash-escaped.
+ * The subagent then receives that garbled prompt, and the call preview renders
+ * one long blob with visible `\n` / `\"` / `\uXXXX`.
+ *
+ * The *whole-arguments* form of this quirk (the entire `arguments` blob is a
+ * JSON string) is already auto-corrected by the validator's JSON-string
+ * coercion. This module handles the *per-field* form, where the object parses
+ * fine but an individual string value is double-encoded — the validator never
+ * fires there because a double-encoded string is still a structurally valid
+ * string.
+ *
+ * This is deliberately scoped to the task tool's natural-language fields
+ * (`context`, `assignment`, `description`). It is NOT applied to code-bearing
+ * tools (write/edit/bash/search), where a backslash or quote is load-bearing
+ * and a false-positive unescape would silently corrupt a file or command.
+ */
+import type { TaskItem, TaskParams } from "./types";
+
+/** A backslash that escapes a structural char — `\"`, `\\`, `\/`, or `\uXXXX`. */
+const STRUCTURAL_ESCAPE = /\\(?:["\\/]|u[0-9a-fA-F]{4})/;
+
+/**
+ * Whether `value` carries the signature of whole-string double-encoding rather
+ * than an incidental escape mention. A lone `\n`/`\t` in an instruction (e.g.
+ * "split lines on \n") is far more likely a literal mention than a
+ * double-encoded document, so it is left alone; a structural escape (`\"`,
+ * `\\`, `\uXXXX`) or two-plus escape sequences indicates a re-escaped payload.
+ */
+function hasDoubleEncodeSignature(value: string): boolean {
+	if (STRUCTURAL_ESCAPE.test(value)) return true;
+	let count = 0;
+	for (let i = 0; i < value.length; i++) {
+		if (value.charCodeAt(i) === 0x5c /* \ */) {
+			count += 1;
+			if (count >= 2) return true;
+			i += 1; // skip the escaped char so `\\` counts once
+		}
+	}
+	return false;
+}
+
+/**
+ * Return the once-unescaped string when `value` is uniformly double-encoded
+ * JSON (a well-formed JSON string body that decodes to a different string);
+ * otherwise return `value` unchanged.
+ *
+ * The `JSON.parse(\`"${value}"\`)` round-trip is the safety net: it only
+ * succeeds when *every* backslash begins a valid JSON escape and no bare
+ * double-quote exists — exactly the signature of double-encoding. Genuine
+ * prose with a Windows path (`C:\Users`), a regex (`\d+`), an embedded quote,
+ * or a real (already-decoded) newline makes the parse throw, so the value is
+ * returned untouched.
+ */
+export function repairDoubleEncodedJsonString(value: string): string {
+	// Fast path: no backslash → nothing was escaped → the parse can never differ.
+	if (!value.includes("\\")) return value;
+	if (!hasDoubleEncodeSignature(value)) return value;
+	let decoded: unknown;
+	try {
+		decoded = JSON.parse(`"${value}"`);
+	} catch {
+		return value;
+	}
+	return typeof decoded === "string" && decoded !== value ? decoded : value;
+}
+
+/** Repair a single (possibly partial) task item's prose fields. */
+function repairTaskItem(task: TaskItem): TaskItem {
+	if (task === null || typeof task !== "object") return task;
+	const assignment =
+		typeof task.assignment === "string" ? repairDoubleEncodedJsonString(task.assignment) : task.assignment;
+	const description =
+		typeof task.description === "string" ? repairDoubleEncodedJsonString(task.description) : task.description;
+	if (assignment === task.assignment && description === task.description) return task;
+	return { ...task, assignment, description };
+}
+
+/**
+ * Repair double-encoded prose in task-tool params (`context` and each task's
+ * `assignment`/`description`). Returns the same reference when nothing changed
+ * so callers can cheaply skip work. Defensive against partially-streamed args
+ * (missing/undefined fields, partial task arrays) so it is safe on the render
+ * path as well as on execution.
+ */
+export function repairTaskParams(params: TaskParams): TaskParams {
+	if (params === null || typeof params !== "object") return params;
+
+	const context = typeof params.context === "string" ? repairDoubleEncodedJsonString(params.context) : params.context;
+
+	let tasks = params.tasks;
+	if (Array.isArray(params.tasks)) {
+		let changed = false;
+		const repaired = params.tasks.map(task => {
+			const next = repairTaskItem(task);
+			if (next !== task) changed = true;
+			return next;
+		});
+		if (changed) tasks = repaired;
+	}
+
+	if (context === params.context && tasks === params.tasks) return params;
+	return { ...params, context, tasks };
+}

package/src/tiny/models.ts

@@ -108,7 +108,7 @@ export const ONLINE_MEMORY_MODEL_KEY = "online";
 export const DEFAULT_MEMORY_LOCAL_MODEL_KEY = "qwen3-1.7b";
 
 /**
- * Local models for Mnemosyne memory tasks (fact extraction + consolidation).
+ * Local models for Mnemopi memory tasks (fact extraction + consolidation).
  * These are larger (1B-1.7B) than the title models: structured extraction and
  * faithful summarization need more capacity than 3-6 word titles. All q4.
  * Ranking/recipe rationale lives in docs/local-models.md.
@@ -177,7 +177,7 @@ export const TINY_MEMORY_MODEL_OPTIONS = [
 		value: ONLINE_MEMORY_MODEL_KEY,
 		label: "Online (smol/remote)",
 		description:
-			"Use the configured Mnemosyne LLM mode (smol or remote); no local model download or on-device inference.",
+			"Use the configured Mnemopi LLM mode (smol or remote); no local model download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,