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

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";
@@ -33,12 +34,13 @@ 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";
@@ -73,13 +75,14 @@ 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";
@@ -152,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). */
@@ -301,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> = {
@@ -417,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);
 			}
@@ -463,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));
+			},
+		);
+	},
+};

package/src/tools/memory-retain.ts

@@ -0,0 +1,91 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const memoryRetainSchema = z.object({
+	items: z
+		.array(
+			z.object({
+				content: z.string().describe("information to remember"),
+				context: z.string().describe("source context").optional(),
+			}),
+		)
+		.min(1)
+		.describe("memories to retain"),
+});
+
+export type MemoryRetainParams = z.infer<typeof memoryRetainSchema>;
+export class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
+	readonly name = "retain";
+	readonly approval = "read" as const;
+	readonly label = "Retain";
+	readonly description = retainDescription;
+	readonly parameters = memoryRetainSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Store important facts in long-term memory";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): MemoryRetainTool | null {
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		return new MemoryRetainTool(session);
+	}
+
+	async execute(_id: string, params: MemoryRetainParams): Promise<AgentToolResult> {
+		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.");
+			}
+
+			for (const item of params.items) {
+				state.rememberScoped(item.content, {
+					source: "coding-agent-retain",
+					importance: 0.75,
+					metadata: {
+						session_id: state.sessionId,
+						cwd: state.session.sessionManager.getCwd(),
+						context: item.context ?? null,
+						tool: "retain",
+					},
+					scope: "bank",
+					extract: true,
+					extractEntities: true,
+					veracity: "tool",
+					memoryType: "fact",
+				});
+			}
+
+			const count = params.items.length;
+			const noun = count === 1 ? "memory" : "memories";
+			return {
+				content: [{ type: "text", text: `${count} ${noun} stored.` }],
+				details: { count },
+			};
+		}
+
+		const state = this.session.getHindsightSessionState?.();
+		if (!state) {
+			throw new Error("Hindsight backend is not initialised for this session.");
+		}
+
+		// Push every item onto the session-owned queue and return immediately.
+		// The queue flushes either when it reaches its batch threshold or when
+		// its debounce timer fires. If the eventual batch fails, the queue
+		// surfaces a UI-only warning notice — the LLM is not informed.
+		for (const item of params.items) {
+			state.enqueueRetain(item.content, item.context);
+		}
+
+		const count = params.items.length;
+		const noun = count === 1 ? "memory" : "memories";
+		return {
+			content: [{ type: "text", text: `${count} ${noun} queued.` }],
+			details: { count },
+		};
+	}
+}

package/src/tools/renderers.ts

@@ -22,6 +22,7 @@ import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
+import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory-render";
 import { readToolRenderer } from "./read";
 import { recipeToolRenderer } from "./recipe/render";
 import { resolveToolRenderer } from "./resolve";
@@ -62,6 +63,9 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	read: readToolRenderer as ToolRenderer,
 	job: jobToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,
+	retain: retainToolRenderer as ToolRenderer,
+	recall: recallToolRenderer as ToolRenderer,
+	reflect: reflectToolRenderer as ToolRenderer,
 	search_tool_bm25: searchToolBm25Renderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,