@oh-my-pi/pi-coding-agent 15.5.13 → 15.6.0

package/src/tools/eval.ts

@@ -13,10 +13,19 @@ import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
-import { getTreeBranch, getTreeContinuePrefix, renderCodeCell } from "../tui";
+import { renderCodeCell } from "../tui";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { resolveEvalBackends, type ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
+import {
+	JSON_TREE_MAX_DEPTH_COLLAPSED,
+	JSON_TREE_MAX_DEPTH_EXPANDED,
+	JSON_TREE_MAX_LINES_COLLAPSED,
+	JSON_TREE_MAX_LINES_EXPANDED,
+	JSON_TREE_SCALAR_LEN_COLLAPSED,
+	JSON_TREE_SCALAR_LEN_EXPANDED,
+	renderJsonTreeLines,
+} from "./json-tree";
 import {
 	formatStyledTruncationWarning,
 	resolveOutputMaxColumns,
@@ -61,15 +70,6 @@ export type EvalToolResult = {
 
 export type EvalProxyExecutor = (params: EvalToolParams, signal?: AbortSignal) => Promise<EvalToolResult>;
 
-function formatJsonScalar(value: unknown): string {
-	if (value === null) return "null";
-	if (value === undefined) return "undefined";
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
-	if (typeof value === "function") return "[function]";
-	return "[object]";
-}
-
 /** Cap per `display()` value sent back to the model. */
 const MAX_DISPLAY_TEXT_BYTES = 8000;
 
@@ -102,41 +102,6 @@ function formatDisplayOutputsForText(outputs: EvalDisplayOutput[]): string {
 	return chunks.join("\n\n");
 }
 
-function renderJsonTree(value: unknown, theme: Theme, expanded: boolean, maxDepth = expanded ? 6 : 2): string[] {
-	const maxItems = expanded ? 20 : 5;
-
-	const renderNode = (node: unknown, prefix: string, depth: number, isLast: boolean, label?: string): string[] => {
-		const branch = getTreeBranch(isLast, theme);
-		const displayLabel = label ? `${label}: ` : "";
-
-		if (depth >= maxDepth || node === null || typeof node !== "object") {
-			return [`${prefix}${branch} ${displayLabel}${formatJsonScalar(node)}`];
-		}
-
-		const isArray = Array.isArray(node);
-		const entries = isArray
-			? node.map((val, index) => [String(index), val] as const)
-			: Object.entries(node as object);
-		const header = `${prefix}${branch} ${displayLabel}${isArray ? `Array(${entries.length})` : `Object(${entries.length})`}`;
-		const lines = [header];
-
-		const childPrefix = prefix + getTreeContinuePrefix(isLast, theme);
-		const visible = entries.slice(0, maxItems);
-		for (let i = 0; i < visible.length; i++) {
-			const [key, val] = visible[i];
-			const childLast = i === visible.length - 1 && (expanded || entries.length <= maxItems);
-			lines.push(...renderNode(val, childPrefix, depth + 1, childLast, isArray ? `[${key}]` : key));
-		}
-		if (!expanded && entries.length > maxItems) {
-			const moreBranch = theme.tree.last;
-			lines.push(`${childPrefix}${moreBranch} ${entries.length - maxItems} more item(s)`);
-		}
-		return lines;
-	};
-
-	return renderNode(value, "", 0, true);
-}
-
 export interface EvalToolDescriptionOptions {
 	py?: boolean;
 	js?: boolean;
@@ -669,6 +634,7 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		sh: "icon.package",
 		env: "icon.package",
 		batch: "icon.package",
+		llm: "icon.package",
 	};
 
 	const iconKey = opIcons[op] ?? "icon.file";
@@ -735,6 +701,11 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		case "batch":
 			parts.push(`${data.files} file${(data.files as number) !== 1 ? "s" : ""} processed`);
 			break;
+		case "llm":
+			if (data.model) parts.push(String(data.model));
+			if (data.tier && data.tier !== data.model) parts.push(`(${data.tier})`);
+			parts.push(`${data.chars ?? 0} chars`);
+			break;
 		case "wc":
 			parts.push(`${data.lines}L ${data.words}W ${data.chars}C`);
 			break;
@@ -950,10 +921,15 @@ export const evalToolRenderer = {
 		const output = stripOutputNotice(rawOutput, details?.meta).trimEnd();
 
 		const jsonOutputs = details?.jsonOutputs ?? [];
+		const treeExpanded = options.renderContext?.expanded ?? options.expanded;
+		const treeDepth = treeExpanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+		const treeLineCap = treeExpanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+		const treeScalarLen = treeExpanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+		const labelOutputs = jsonOutputs.length > 1;
 		const jsonLines = jsonOutputs.flatMap((value, index) => {
-			const header = `JSON output ${index + 1}`;
-			const treeLines = renderJsonTree(value, uiTheme, options.renderContext?.expanded ?? options.expanded);
-			return [header, ...treeLines];
+			const tree = renderJsonTreeLines(value, uiTheme, treeDepth, treeLineCap, treeScalarLen);
+			const body = tree.truncated ? [...tree.lines, uiTheme.fg("dim", "…")] : tree.lines;
+			return labelOutputs ? [uiTheme.fg("dim", `display[${index + 1}]`), ...body] : body;
 		});
 
 		const timeoutSeconds = options.renderContext?.timeout;

package/src/tools/index.ts

@@ -11,6 +11,7 @@ import type { GoalModeState, GoalRuntime } from "../goals";
 import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import { LspTool } from "../lsp";
+import type { MnemosyneSessionState } from "../mnemosyne/state";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import type { ArtifactManager } from "../session/artifacts";
@@ -28,18 +29,18 @@ import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
-import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
 import { FindTool } from "./find";
 import { GithubTool } from "./gh";
-import { HindsightRecallTool } from "./hindsight-recall";
-import { HindsightReflectTool } from "./hindsight-reflect";
-import { HindsightRetainTool } from "./hindsight-retain";
 import { InspectImageTool } from "./inspect-image";
 import { IrcTool } from "./irc";
 import { JobTool } from "./job";
+import { MemoryEditTool } from "./memory-edit";
+import { MemoryRecallTool } from "./memory-recall";
+import { MemoryReflectTool } from "./memory-reflect";
+import { MemoryRetainTool } from "./memory-retain";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
 import { RecipeTool } from "./recipe";
@@ -69,19 +70,19 @@ export * from "./ast-edit";
 export * from "./ast-grep";
 export * from "./bash";
 export * from "./browser";
-export * from "./calculator";
 export * from "./checkpoint";
 export * from "./debug";
 export * from "./eval";
 export * from "./find";
 export * from "./gh";
-export * from "./hindsight-recall";
-export * from "./hindsight-reflect";
-export * from "./hindsight-retain";
 export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
+export * from "./memory-edit";
+export * from "./memory-recall";
+export * from "./memory-reflect";
+export * from "./memory-retain";
 export * from "./read";
 export * from "./recipe";
 export * from "./render-mermaid";
@@ -154,6 +155,8 @@ export interface ToolSession {
 	getSessionId?: () => string | null;
 	/** Get Hindsight runtime state for this agent session. */
 	getHindsightSessionState?: () => HindsightSessionState | undefined;
+	/** Get Mnemosyne runtime state for this agent session. */
+	getMnemosyneSessionState?: () => MnemosyneSessionState | undefined;
 	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
@@ -286,7 +289,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: AskTool.createIf,
 	debug: DebugTool.createIf,
 	eval: s => new EvalTool(s),
-	calc: s => new CalculatorTool(s),
 	ssh: loadSshTool,
 	github: GithubTool.createIf,
 	find: s => new FindTool(s),
@@ -304,9 +306,10 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	web_search: s => new WebSearchTool(s),
 	search_tool_bm25: SearchToolBm25Tool.createIf,
 	write: s => new WriteTool(s),
-	retain: HindsightRetainTool.createIf,
-	recall: HindsightRecallTool.createIf,
-	reflect: HindsightReflectTool.createIf,
+	memory_edit: MemoryEditTool.createIf,
+	retain: MemoryRetainTool.createIf,
+	recall: MemoryRecallTool.createIf,
+	reflect: MemoryReflectTool.createIf,
 };
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
@@ -420,7 +423,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		) {
 			requestedTools.push("recipe");
 		}
-		if (session.settings.get("memory.backend") === "hindsight") {
+		if (["hindsight", "mnemosyne"].includes(session.settings.get("memory.backend") ?? "")) {
 			for (const name of ["recall", "retain", "reflect"]) {
 				if (!requestedTools.includes(name)) requestedTools.push(name);
 			}
@@ -455,7 +458,6 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
 		if (name === "search_tool_bm25") return discoveryActive;
-		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") {
@@ -467,7 +469,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		}
 		if (name === "recipe") return session.settings.get("recipe.enabled");
 		if (name === "retain" || name === "recall" || name === "reflect") {
-			return session.settings.get("memory.backend") === "hindsight";
+			return ["hindsight", "mnemosyne"].includes(session.settings.get("memory.backend") ?? "");
 		}
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;

package/src/tools/memory-edit.ts

@@ -0,0 +1,59 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import memoryEditDescription from "../prompts/tools/memory-edit.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const memoryEditSchema = z.object({
+	op: z.enum(["update", "forget", "invalidate"]).describe("memory edit operation"),
+	id: z.string().describe("memory id from recall output"),
+	content: z.string().optional().describe("replacement content for update"),
+	importance: z.number().optional().describe("replacement importance for update, clamped to [0, 1]"),
+	replacement_id: z.string().optional().describe("replacement memory id for invalidate"),
+});
+
+export type MemoryEditParams = z.infer<typeof memoryEditSchema>;
+
+export class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
+	readonly name = "memory_edit";
+	readonly approval = "read" as const;
+	readonly label = "Memory Edit";
+	readonly description = memoryEditDescription;
+	readonly parameters = memoryEditSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Update, forget, or invalidate Mnemosyne memories";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): MemoryEditTool | null {
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "mnemosyne") return null;
+		return new MemoryEditTool(session);
+	}
+
+	async execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult> {
+		const state = this.session.getMnemosyneSessionState?.();
+		if (!state) {
+			throw new Error("Mnemosyne backend is not initialised for this session.");
+		}
+		if (params.op === "update" && params.content === undefined && params.importance === undefined) {
+			throw new Error("memory_edit update requires content or importance.");
+		}
+
+		const importance = params.importance === undefined ? undefined : Math.max(0, Math.min(1, params.importance));
+		const result = state.editScopedMemory(params.op, params.id, {
+			content: params.content,
+			importance,
+			replacementId: params.replacement_id,
+		});
+		const location = result.bank ? ` in bank ${result.bank}${result.store ? ` (${result.store})` : ""}` : "";
+		const text =
+			result.status === "not_found"
+				? `Memory ${params.id} was not found${location}.`
+				: `Memory ${params.id} ${result.status}${location}.`;
+		return {
+			content: [{ type: "text", text }],
+			details: result,
+		};
+	}
+}

package/src/tools/memory-recall.ts

@@ -0,0 +1,100 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import * as z from "zod/v4";
+import { formatCurrentTime, formatMemories } from "../hindsight/content";
+import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const memoryRecallSchema = z.object({
+	query: z.string().describe("natural language search query"),
+});
+
+export type MemoryRecallParams = z.infer<typeof memoryRecallSchema>;
+
+export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
+	readonly name = "recall";
+	readonly approval = "read" as const;
+	readonly label = "Recall";
+	readonly description = recallDescription;
+	readonly parameters = memoryRecallSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Search memory for relevant prior context";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): MemoryRecallTool | null {
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		return new MemoryRecallTool(session);
+	}
+
+	async execute(_id: string, params: MemoryRecallParams, signal?: AbortSignal): Promise<AgentToolResult> {
+		return untilAborted(signal, async () => {
+			const backend = this.session.settings.get("memory.backend");
+			if (backend === "mnemosyne") {
+				const state = this.session.getMnemosyneSessionState?.();
+				if (!state) {
+					throw new Error("Mnemosyne backend is not initialised for this session.");
+				}
+				try {
+					const results = state.recallResultsScoped(params.query);
+					if (results.length === 0) {
+						return {
+							content: [{ type: "text", text: "No relevant memories found." }],
+							details: {},
+						};
+					}
+					const formatted = state.formatScopedRecallWithIds(results);
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Found ${results.length} relevant ${results.length === 1 ? "memory" : "memories"} (as of ${formatCurrentTime()} UTC):\n\n${formatted}`,
+							},
+						],
+						details: {},
+					};
+				} catch (err) {
+					logger.warn("recall failed", { backend: "mnemosyne", bank: state.config.bank, error: String(err) });
+					throw err instanceof Error ? err : new Error(String(err));
+				}
+			}
+
+			const state = this.session.getHindsightSessionState?.();
+			if (!state) {
+				throw new Error("Hindsight backend is not initialised for this session.");
+			}
+
+			try {
+				const response = await state.client.recall(state.bankId, params.query, {
+					budget: state.config.recallBudget,
+					maxTokens: state.config.recallMaxTokens,
+					types: state.config.recallTypes.length > 0 ? state.config.recallTypes : undefined,
+					tags: state.recallTags,
+					tagsMatch: state.recallTagsMatch,
+				});
+				const results = response.results ?? [];
+				if (results.length === 0) {
+					return {
+						content: [{ type: "text", text: "No relevant memories found." }],
+						details: {},
+					};
+				}
+				const formatted = formatMemories(results);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Found ${results.length} relevant ${results.length === 1 ? "memory" : "memories"} (as of ${formatCurrentTime()} UTC):\n\n${formatted}`,
+						},
+					],
+					details: {},
+				};
+			} catch (err) {
+				logger.warn("recall failed", { bankId: state.bankId, error: String(err) });
+				throw err instanceof Error ? err : new Error(String(err));
+			}
+		});
+	}
+}

package/src/tools/memory-reflect.ts

@@ -0,0 +1,88 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import * as z from "zod/v4";
+import { ensureBankMission } from "../hindsight/bank";
+import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const memoryReflectSchema = z.object({
+	query: z.string().describe("question to answer"),
+	context: z.string().describe("optional context").optional(),
+});
+
+export type MemoryReflectParams = z.infer<typeof memoryReflectSchema>;
+
+export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema> {
+	readonly name = "reflect";
+	readonly approval = "read" as const;
+	readonly label = "Reflect";
+	readonly description = reflectDescription;
+	readonly parameters = memoryReflectSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Synthesize an answer from long-term memory";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): MemoryReflectTool | null {
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		return new MemoryReflectTool(session);
+	}
+
+	async execute(_id: string, params: MemoryReflectParams, signal?: AbortSignal): Promise<AgentToolResult> {
+		return untilAborted(signal, async () => {
+			const backend = this.session.settings.get("memory.backend");
+			if (backend === "mnemosyne") {
+				const state = this.session.getMnemosyneSessionState?.();
+				if (!state) {
+					throw new Error("Mnemosyne backend is not initialised for this session.");
+				}
+
+				try {
+					const query = params.context?.trim()
+						? `${params.query.trim()}\n\nAdditional context:\n${params.context.trim()}`
+						: params.query;
+					const results = state.recallResultsScoped(query);
+					if (results.length === 0) {
+						return {
+							content: [{ type: "text", text: "No relevant information found to reflect on." }],
+							details: {},
+						};
+					}
+					const summary = state.formatContextScoped(results);
+					return {
+						content: [{ type: "text", text: `Based on recalled memories:\n\n${summary}` }],
+						details: {},
+					};
+				} catch (err) {
+					logger.warn("reflect failed", { backend: "mnemosyne", bank: state.config.bank, error: String(err) });
+					throw err instanceof Error ? err : new Error(String(err));
+				}
+			}
+
+			const state = this.session.getHindsightSessionState?.();
+			if (!state) {
+				throw new Error("Hindsight backend is not initialised for this session.");
+			}
+
+			try {
+				await ensureBankMission(state.client, state.bankId, state.config, state.missionsSet);
+				const response = await state.client.reflect(state.bankId, params.query, {
+					context: params.context,
+					budget: state.config.recallBudget,
+					tags: state.recallTags,
+					tagsMatch: state.recallTagsMatch,
+				});
+				const text = response.text?.trim() || "No relevant information found to reflect on.";
+				return {
+					content: [{ type: "text", text }],
+					details: {},
+				};
+			} catch (err) {
+				logger.warn("reflect failed", { bankId: state.bankId, error: String(err) });
+				throw err instanceof Error ? err : new Error(String(err));
+			}
+		});
+	}
+}

package/src/tools/memory-render.ts

@@ -0,0 +1,185 @@
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { Ellipsis, renderStatusLine, truncateToWidth } from "../tui";
+import {
+	createCachedComponent,
+	formatErrorMessage,
+	formatExpandHint,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	type ToolUIStatus,
+} from "./render-utils";
+
+// Each stored memory renders as `<bullet> <content>`; the bullet glyph comes
+// from the active theme (`•` by default, a nerd-font dot under nerd themes).
+
+interface RetainRenderArgs {
+	items?: Array<{ content?: string; context?: string }>;
+}
+
+interface QueryRenderArgs {
+	query?: string;
+}
+
+function retainContents(args: RetainRenderArgs | undefined): string[] {
+	return (args?.items ?? []).map(item => replaceTabs((item?.content ?? "").trim())).filter(line => line.length > 0);
+}
+
+function resultText(result: { content?: Array<{ type: string; text?: string }> }): string {
+	return (result.content?.find(c => c.type === "text")?.text ?? "").trim();
+}
+
+/** Single-line query header used by `recall`/`reflect` calls and results. */
+function queryHeader(
+	title: string,
+	query: string | undefined,
+	icon: ToolUIStatus,
+	theme: Theme,
+	meta?: string[],
+): string {
+	const trimmed = replaceTabs((query ?? "").trim());
+	const description = trimmed ? truncateToWidth(trimmed, 80, Ellipsis.Unicode) : undefined;
+	return renderStatusLine({ icon, title, description, meta }, theme);
+}
+
+function retainComponent(contents: string[], header: string, getExpanded: () => boolean, theme: Theme): Component {
+	return createCachedComponent(getExpanded, (width, expanded) => {
+		const lines = [header];
+		const limit = expanded ? contents.length : PREVIEW_LIMITS.COLLAPSED_ITEMS;
+		const shown = contents.slice(0, limit);
+		const bullet = theme.format.bullet;
+		const contentWidth = Math.max(8, width - 2 - Bun.stringWidth(bullet) - 1);
+		for (const content of shown) {
+			const value = truncateToWidth(content, contentWidth, Ellipsis.Unicode);
+			lines.push(`  ${theme.fg("muted", bullet)} ${theme.fg("toolOutput", value)}`);
+		}
+		const remaining = contents.length - shown.length;
+		if (remaining > 0) {
+			lines.push(`  ${theme.fg("dim", `… ${remaining} more`)} ${formatExpandHint(theme, expanded, true)}`);
+		}
+		return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+	});
+}
+
+export const retainToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component {
+		const contents = retainContents(args);
+		const header = renderStatusLine({ icon: "pending", title: "Retain" }, theme);
+		return retainComponent(contents, header, () => options.expanded, theme);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: { count?: number }; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: RetainRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Retain failed", theme), 0, 0);
+		}
+		const contents = retainContents(args);
+		// `summary` is the tool's own "N memories stored/queued." line; drop the
+		// trailing period so it reads cleanly as a status meta segment.
+		const summary = resultText(result).replace(/\.$/, "");
+		const header = renderStatusLine(
+			{ icon: "success", title: "Retain", meta: summary ? [summary] : undefined },
+			theme,
+		);
+		return retainComponent(contents, header, () => options.expanded, theme);
+	},
+};
+
+export const recallToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(queryHeader("Recall", args.query, "pending", theme), 0, 0);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: QueryRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Recall failed", theme), 0, 0);
+		}
+		const text = resultText(result);
+		const match = text.match(/^Found (\d+) relevant/);
+		const found = match ? Number(match[1]) : 0;
+		const icon: ToolUIStatus = found > 0 ? "success" : "warning";
+		const meta = [found > 0 ? `${found} found` : "no matches"];
+		const header = queryHeader("Recall", args?.query, icon, theme, meta);
+		if (found === 0) {
+			return new Text(header, 0, 0);
+		}
+		// Collapsed view is the header alone; expand to inspect the recalled
+		// memories without dumping the whole block into the transcript.
+		const body = text.replace(/^[^\n]*\n+/, "");
+		return createCachedComponent(
+			() => options.expanded,
+			(width, expanded) => {
+				const lines = [header];
+				if (expanded) {
+					const bodyLines = body.split("\n").slice(0, PREVIEW_LIMITS.OUTPUT_EXPANDED);
+					for (const line of bodyLines) {
+						lines.push(`  ${theme.fg("muted", replaceTabs(line))}`);
+					}
+				} else {
+					lines.push(`  ${formatExpandHint(theme, false, true)}`);
+				}
+				return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+			},
+		);
+	},
+};
+
+export const reflectToolRenderer = {
+	inline: true,
+	mergeCallAndResult: true,
+	renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(queryHeader("Reflect", args.query, "pending", theme), 0, 0);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: QueryRenderArgs,
+	): Component {
+		if (result.isError) {
+			return new Text(formatErrorMessage(resultText(result) || "Reflect failed", theme), 0, 0);
+		}
+		const header = queryHeader("Reflect", args?.query, "success", theme);
+		const answer = resultText(result);
+		const answerLines = answer.split("\n").filter(line => line.trim().length > 0);
+		return createCachedComponent(
+			() => options.expanded,
+			(width, expanded) => {
+				const limit = expanded ? PREVIEW_LIMITS.OUTPUT_EXPANDED : PREVIEW_LIMITS.OUTPUT_COLLAPSED;
+				const shown = answerLines.slice(0, limit);
+				const lines = [header];
+				for (const line of shown) {
+					lines.push(`  ${theme.fg("toolOutput", replaceTabs(line))}`);
+				}
+				const remaining = answerLines.length - shown.length;
+				if (remaining > 0) {
+					lines.push(
+						`  ${theme.fg("dim", `… ${remaining} more lines`)} ${formatExpandHint(theme, expanded, true)}`,
+					);
+				}
+				return lines.map(line => truncateToWidth(line, width, Ellipsis.Omit));
+			},
+		);
+	},
+};