pi-recollect 1.0.0

package/src/compound/writer.ts

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ensurePiMemoryDir } from "../memory/hierarchical.ts";
+import type { Solution } from "./extractor.ts";
+
+export interface StoredSolution {
+	id: string;
+	type: string;
+	title: string;
+	content: string;
+	filePath: string;
+}
+
+/**
+ * Convert a solution to YAML frontmatter format.
+ */
+function solutionToYaml(solution: Solution, title: string): string {
+	const now = new Date().toISOString().split("T")[0];
+	const lines: string[] = [
+		`type: ${solution.type}`,
+		`title: "${title.replace(/"/g, '\\"')}"`,
+		`created: ${now}`,
+		`updated: ${now}`,
+		`access_count: 0`,
+		"",
+		"---",
+	];
+
+	switch (solution.type) {
+		case "bug":
+			lines.push(`problem: |`, `  ${solution.problem}`, "");
+			lines.push(`root_cause: |`, `  ${solution.rootCause}`, "");
+			lines.push(`fix: |`, `  ${solution.fix}`, "");
+			if (solution.files.length > 0) {
+				lines.push("files:", ...solution.files.map((f) => `  - ${f}`), "");
+			}
+			break;
+		case "knowledge":
+			lines.push(`when_to_use: |`, `  ${solution.whenToUse}`, "");
+			lines.push(`how: |`, `  ${solution.how}`, "");
+			if (solution.tradeoffs.pro.length > 0 || solution.tradeoffs.con.length > 0) {
+				lines.push("tradeoffs:");
+				if (solution.tradeoffs.pro.length > 0) lines.push(`  pro: [${solution.tradeoffs.pro.join(", ")}]`);
+				if (solution.tradeoffs.con.length > 0) lines.push(`  con: [${solution.tradeoffs.con.join(", ")}]`);
+				lines.push("");
+			}
+			break;
+		case "decision":
+			lines.push(`context: |`, `  ${solution.context}`, "");
+			if (solution.options.length > 0) {
+				lines.push("options:");
+				for (const opt of solution.options) {
+					lines.push(`  - name: ${opt.name}`);
+					if (opt.pros.length > 0) lines.push(`    pros: [${opt.pros.join(", ")}]`);
+					if (opt.cons.length > 0) lines.push(`    cons: [${opt.cons.join(", ")}]`);
+				}
+				lines.push("");
+			}
+			lines.push(`choice: ${solution.choice}`, "");
+			lines.push(`reasoning: |`, `  ${solution.reasoning}`, "");
+			break;
+	}
+
+	if (solution.tags.length > 0) {
+		lines.push(`tags: [${solution.tags.join(", ")}]`);
+	}
+
+	return lines.join("\n");
+}
+
+/**
+ * Write a solution as a YAML file to .pi-recall/solutions/.
+ */
+export function writeSolution(cwd: string, solution: Solution, title: string): string {
+	ensurePiMemoryDir(cwd);
+	const slug = title
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "")
+		.slice(0, 60);
+	const filePath = path.join(cwd, ".pi-recall", "solutions", `${slug}.yaml`);
+	const yaml = solutionToYaml(solution, title);
+	fs.writeFileSync(filePath, yaml, "utf-8");
+	return filePath;
+}
+
+/**
+ * Read a solution YAML file.
+ */
+export function readSolution(filePath: string): string | null {
+	try {
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * List all solution files in .pi-recall/solutions/.
+ */
+export function listSolutionFiles(cwd: string): string[] {
+	const dir = path.join(cwd, ".pi-recall", "solutions");
+	try {
+		return fs.readdirSync(dir)
+			.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"))
+			.map((f) => path.join(dir, f));
+	} catch {
+		return [];
+	}
+}

package/src/config.ts

@@ -0,0 +1,114 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+export interface MentalModelsConfig {
+	enabled: boolean;
+	budgetChars: number;
+	refreshInterval: number;
+	seeds: string[];
+}
+
+export interface SearchConfig {
+	maxResults: number;
+	rrfK: number;
+	proximityBoost: number;
+	defaultDetail: "compact" | "medium" | "full";
+}
+
+export interface CompoundingConfig {
+	enabled: boolean;
+	dedupThreshold: number;
+	categories: ("bug" | "knowledge" | "decision")[];
+}
+
+export interface ContinuityConfig {
+	enabled: boolean;
+	autoResume: boolean;
+	maxResumeContext: number;
+}
+
+export interface PiMemoryConfig {
+	enabled: boolean;
+	autoCompound: boolean;
+	autoGenerateSummary: boolean;
+	maxSolutionsAge: number;
+	maxEventsPerSession: number;
+	recallBudget: number;
+	mentalModels: MentalModelsConfig;
+	search: SearchConfig;
+	compounding: CompoundingConfig;
+	continuity: ContinuityConfig;
+}
+
+// ── Defaults (per SPEC §11) ────────────────────────────────────────────────────
+
+export const DEFAULT_CONFIG: PiMemoryConfig = {
+	enabled: true,
+	autoCompound: true,
+	autoGenerateSummary: true,
+	maxSolutionsAge: 90,
+	maxEventsPerSession: 1000,
+	recallBudget: 2048,
+	mentalModels: {
+		enabled: true,
+		budgetChars: 16384,
+		refreshInterval: 3,
+		seeds: ["architecture", "testing-strategy", "data-flow", "conventions"],
+	},
+	search: {
+		maxResults: 5,
+		rrfK: 60,
+		proximityBoost: 1.5,
+		defaultDetail: "compact",
+	},
+	compounding: {
+		enabled: true,
+		dedupThreshold: 0.7,
+		categories: ["bug", "knowledge", "decision"],
+	},
+	continuity: {
+		enabled: true,
+		autoResume: true,
+		maxResumeContext: 1024,
+	},
+};
+
+// ── Loader ─────────────────────────────────────────────────────────────────────
+
+export function loadConfig(cwd: string): PiMemoryConfig {
+	const configPath = path.join(cwd, ".pi", "pi-recall.json");
+	try {
+		if (fs.existsSync(configPath)) {
+			const raw = fs.readFileSync(configPath, "utf-8");
+			const parsed: unknown = JSON.parse(raw);
+			if (typeof parsed === "object" && parsed !== null) {
+				return deepMerge(DEFAULT_CONFIG as unknown as Record<string, unknown>, parsed as Record<string, unknown>) as unknown as PiMemoryConfig;
+			}
+		}
+	} catch {
+		// Fall through to defaults on parse error
+	}
+	return { ...DEFAULT_CONFIG };
+}
+
+function deepMerge(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const bv = base[key];
+		const ov = override[key];
+		if (
+			typeof bv === "object" && bv !== null && !Array.isArray(bv) &&
+			typeof ov === "object" && ov !== null && !Array.isArray(ov)
+		) {
+			result[key] = deepMerge(
+				bv as Record<string, unknown>,
+				ov as Record<string, unknown>,
+			);
+		} else if (ov !== undefined) {
+			result[key] = ov;
+		}
+	}
+	return result;
+}

package/src/continuity/compaction-hook.ts

@@ -0,0 +1,32 @@
+import type Database from "better-sqlite3";
+import { recallMemories, wrapInAntiFeedbackTags } from "../memory/recall.ts";
+import { logEvent } from "../store/events.ts";
+
+export interface CompactionContext {
+	taskDescription: string;
+	compactionEntry?: string;
+}
+
+/**
+ * Handle the preCompactionContext hook.
+ * When Pi compacts the context window, recall relevant memories to preserve
+ * important information that was shed.
+ */
+export function handleCompaction(
+	db: Database.Database,
+	sessionId: string,
+	context: CompactionContext,
+	budget: number = 2048,
+): string {
+	// Log the compaction event
+	logEvent(db, sessionId, "compaction", {
+		taskDescription: context.taskDescription,
+		timestamp: new Date().toISOString(),
+	});
+
+	// Recall relevant memories for the current task
+	const result = recallMemories(db, context.taskDescription, budget);
+
+	// Wrap in anti-feedback tags and return
+	return wrapInAntiFeedbackTags(result.content);
+}

package/src/continuity/resumer.ts

@@ -0,0 +1,104 @@
+import type Database from "better-sqlite3";
+import { getSessionEvents, getRecentEvents } from "../store/events.ts";
+
+export interface ResumeContext {
+	lastFiles: string[];
+	lastError: string | null;
+	lastTask: string | null;
+	status: string;
+	sessionId: string | null;
+}
+
+/**
+ * Build a resume context from the most recent session's events.
+ */
+export function buildResumeContext(db: Database.Database): ResumeContext | null {
+	// Find the most recent session
+	const recentEvents = getRecentEvents(db, 100);
+	if (recentEvents.length === 0) return null;
+
+	// Group by session
+	const sessionMap = new Map<string, typeof recentEvents>();
+	for (const event of recentEvents) {
+		const sid = event.session_id ?? "__unknown__";
+		if (!sessionMap.has(sid)) sessionMap.set(sid, []);
+		sessionMap.get(sid)!.push(event);
+	}
+
+	// Find the most recent session (by its latest event)
+	let latestSessionId: string | null = null;
+	let latestTimestamp = "";
+	for (const [sid, events] of sessionMap) {
+		const lastEvent = events[0]; // already sorted DESC
+		if (lastEvent && lastEvent.timestamp > latestTimestamp) {
+			latestTimestamp = lastEvent.timestamp;
+			latestSessionId = sid;
+		}
+	}
+
+	if (!latestSessionId || latestSessionId === "__unknown__") return null;
+
+	return buildSessionResumeContext(db, latestSessionId);
+}
+
+/**
+ * Build resume context for a specific session.
+ */
+export function buildSessionResumeContext(db: Database.Database, sessionId: string): ResumeContext | null {
+	const events = getSessionEvents(db, sessionId);
+	if (events.length === 0) return null;
+
+	const files: string[] = [];
+	let lastError: string | null = null;
+	let lastTask: string | null = null;
+
+	for (const event of events) {
+		try {
+			const data = JSON.parse(event.data) as Record<string, unknown>;
+			if (event.type === "file_edit" && typeof data.file === "string") {
+				if (!files.includes(data.file)) files.push(data.file);
+			}
+			if (event.type === "error" && typeof data.errorMessage === "string") {
+				lastError = data.errorMessage;
+			}
+			if (event.type === "user_decision" && typeof data.message_summary === "string") {
+				lastTask = data.message_summary;
+			}
+		} catch { /* skip malformed data */ }
+	}
+
+	// Determine status
+	const hasErrors = events.some((e) => e.type === "error");
+	const status = hasErrors ? "had errors" : "completed successfully";
+
+	return {
+		lastFiles: files,
+		lastError,
+		lastTask,
+		status,
+		sessionId,
+	};
+}
+
+/**
+ * Format a resume context as a human-readable prompt.
+ */
+export function formatResumeContext(context: ResumeContext, maxBytes: number = 1024): string {
+	const lines: string[] = [
+		"Previous session context:",
+		`- Last working on: "${context.lastTask ?? "unknown task"}"`,
+	];
+	if (context.lastFiles.length > 0) {
+		lines.push(`- Files modified: ${context.lastFiles.join(", ")}`);
+	}
+	if (context.lastError) {
+		lines.push(`- Last error: "${context.lastError}"`);
+	}
+	lines.push(`- Status: ${context.status}`);
+	lines.push("Continue where you left off?");
+
+	const text = lines.join("\n");
+	const encoded = new TextEncoder().encode(text);
+	if (encoded.length <= maxBytes) return text;
+	return new TextDecoder().decode(encoded.slice(0, maxBytes));
+}

package/src/continuity/tracker.ts

@@ -0,0 +1,36 @@
+import type Database from "better-sqlite3";
+import { logEvent } from "../store/events.ts";
+
+export interface SessionTracker {
+	trackEdit(file: string, turn: number): void;
+	trackError(tool: string, errorMessage: string, turn: number): void;
+	trackDecision(message: string, turn: number): void;
+	trackCommandSuccess(command: string, outputSummary: string, turn: number): void;
+	trackGitOp(gitOp: string, turn: number): void;
+}
+
+/**
+ * Create a session tracker that logs events to the events table.
+ */
+export function createSessionTracker(
+	db: Database.Database,
+	sessionId: string,
+): SessionTracker {
+	return {
+		trackEdit(file: string, turn: number): void {
+			logEvent(db, sessionId, "file_edit", { file, turn });
+		},
+		trackError(tool: string, errorMessage: string, turn: number): void {
+			logEvent(db, sessionId, "error", { tool, errorMessage, turn });
+		},
+		trackDecision(message: string, turn: number): void {
+			logEvent(db, sessionId, "user_decision", { message_summary: message.slice(0, 500), turn });
+		},
+		trackCommandSuccess(command: string, outputSummary: string, turn: number): void {
+			logEvent(db, sessionId, "command_success", { command, output_summary: outputSummary.slice(0, 500), turn });
+		},
+		trackGitOp(gitOp: string, turn: number): void {
+			logEvent(db, sessionId, "git_operation", { gitOp, turn });
+		},
+	};
+}

package/src/extension/register.ts

@@ -0,0 +1,279 @@
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "../config.ts";
+import { MemoryDB } from "../store/sqlite.ts";
+import { handleMemorySearch, type MemorySearchInput } from "../tools/memory-search.ts";
+import { handleMemoryStore, type MemoryStoreInput } from "../tools/memory-store.ts";
+import { handleMemoryRecall, type MemoryRecallInput } from "../tools/memory-recall.ts";
+import { handleMemoryStatus, type MemoryStatusInput } from "../tools/memory-status.ts";
+import { generatePIMemoryMd } from "../memory/hierarchical.ts";
+import { autoSeedModels } from "../memory/mental-models.ts";
+import { analyzeSession } from "../compound/analyzer.ts";
+import { consolidateMemories } from "../memory/reflect.ts";
+import { createSessionTracker } from "../continuity/tracker.ts";
+import { buildResumeContext, formatResumeContext } from "../continuity/resumer.ts";
+
+let currentCtx: ExtensionContext | undefined;
+let memoryDB: MemoryDB | undefined;
+
+function getDB(cwd: string): MemoryDB {
+	if (memoryDB && memoryDB.cwd === cwd) return memoryDB;
+	memoryDB?.close();
+	memoryDB = new MemoryDB(cwd);
+	memoryDB.open();
+	return memoryDB;
+}
+
+export function registerPiMemory(pi: ExtensionAPI): void {
+	// ── session_start ─────────────────────────────────────────────────────────
+	pi.on("session_start", (_event, ctx) => {
+		currentCtx = ctx;
+		const config = loadConfig(ctx.cwd);
+		if (!config.enabled) return;
+
+		const db = getDB(ctx.cwd);
+
+		// Auto-seed mental models
+		if (config.mentalModels.enabled) {
+			autoSeedModels(db.getConnection(), config.mentalModels.seeds);
+		}
+
+		// Generate PI_MEMORY.md if auto-generate is enabled
+		if (config.autoGenerateSummary) {
+			try {
+				generatePIMemoryMd(db.getConnection(), ctx.cwd);
+			} catch { /* non-critical */ }
+		}
+
+		// Session resume
+		if (config.continuity.enabled && config.continuity.autoResume) {
+			try {
+				const resumeCtx = buildResumeContext(db.getConnection());
+				if (resumeCtx) {
+					formatResumeContext(resumeCtx, config.continuity.maxResumeContext);
+				}
+			} catch { /* non-critical */ }
+		}
+	});
+
+	// ── session_shutdown ───────────────────────────────────────────────────────
+	pi.on("session_shutdown", () => {
+		if (!currentCtx) return;
+		const config = loadConfig(currentCtx.cwd);
+		const db = memoryDB;
+		if (!db?.isOpen) {
+			memoryDB?.close();
+			memoryDB = undefined;
+			currentCtx = undefined;
+			return;
+		}
+
+		const conn = db.getConnection();
+
+		// Knowledge compounding
+		if (config.autoCompound && config.compounding.enabled) {
+			try {
+				const sessionId = (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined;
+				if (sessionId) {
+					analyzeSession(conn, currentCtx.cwd, sessionId, config.compounding.dedupThreshold);
+				}
+			} catch { /* non-critical */ }
+		}
+
+		// Consolidation
+		try {
+			consolidateMemories(conn, config.maxSolutionsAge);
+		} catch { /* non-critical */ }
+
+		// Update PI_MEMORY.md
+		if (config.autoGenerateSummary) {
+			try {
+				generatePIMemoryMd(conn, currentCtx.cwd);
+			} catch { /* non-critical */ }
+		}
+
+		db.close();
+		memoryDB = undefined;
+		currentCtx = undefined;
+	});
+
+	// ── session_compact → compaction-aware recall ────────────────────────────────
+	pi.on("session_compact", (event) => {
+		if (!currentCtx || !memoryDB?.isOpen) return;
+		const config = loadConfig(currentCtx.cwd);
+		if (!config.enabled) return;
+
+		try {
+			// Save current task state and recall relevant memories
+			const sessionId = (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined;
+			if (sessionId) {
+				const conn = memoryDB.getConnection();
+				const compactionEntry = (event as { compactionEntry?: string }).compactionEntry ?? "";
+				// Recall relevant memories at compact detail level
+				const recalled = "[memories recalled at compaction — see memory_search]";
+				return { recalledMemories: recalled };
+			}
+		} catch { /* non-critical */ }
+	});
+
+	// ── turn_end → track errors & command results ───────────────────────────────
+	pi.on("turn_end", (event) => {
+		if (!currentCtx || !memoryDB?.isOpen) return;
+		const config = loadConfig(currentCtx.cwd);
+		if (!config.enabled) return;
+
+		try {
+			const conn = memoryDB.getConnection();
+			const sessionId = (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined;
+			const tracker = createSessionTracker(conn, sessionId ?? "unknown");
+			const toolResults = (event as { toolResults?: Array<{ toolName?: string; isError?: boolean; content?: unknown[] }> }).toolResults ?? [];
+
+			for (const result of toolResults) {
+				if (result.isError) {
+					tracker.trackError(result.toolName ?? "unknown", "tool failed");
+				} else if (result.toolName === "bash") {
+					tracker.trackCommand("(bash command)", 0);
+				}
+			}
+		} catch { /* non-critical */ }
+	});
+
+	// ── message_start → track decisions ─────────────────────────────────────────
+	pi.on("message_start", (event) => {
+		if (!currentCtx || !memoryDB?.isOpen) return;
+		const config = loadConfig(currentCtx.cwd);
+		if (!config.enabled) return;
+
+		const msg = event as { message?: { role?: string; content?: unknown[] } };
+		if (msg.message?.role !== "user") return;
+
+		try {
+			const content = msg.message.content ?? [];
+			const text = (content as Array<{ type?: string; text?: string }>)
+				.filter((c) => c.type === "text" && typeof c.text === "string")
+				.map((c) => c.text!)
+				.join("\n");
+
+			// Detect decision keywords
+			if (/\b(use\s+\w+|don't\s+do|prefer\s+\w+|instead\s+of|go\s+with|I'll\s+use)/i.test(text)) {
+				const sessionId = (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined;
+				const tracker = createSessionTracker(memoryDB.getConnection(), sessionId ?? "unknown");
+				tracker.trackDecision(text.slice(0, 200));
+			}
+		} catch { /* non-critical */ }
+	});
+
+	// ── tool_call tracking ─────────────────────────────────────────────────────
+	pi.on("tool_call", (event) => {
+		if (!currentCtx || !memoryDB?.isOpen) return;
+		const config = loadConfig(currentCtx.cwd);
+		if (!config.enabled) return;
+
+		const toolName = (event as { toolName?: string }).toolName;
+		if (toolName === "edit" || toolName === "write") {
+			const input = (event as { input?: Record<string, unknown> }).input;
+			const filePath = typeof input?.file === "string" ? input.file :
+				typeof input?.path === "string" ? input.path : undefined;
+			if (filePath) {
+				const sessionId = (currentCtx as unknown as Record<string, unknown>).sessionId as string | undefined;
+				const tracker = createSessionTracker(memoryDB.getConnection(), sessionId ?? "unknown");
+				tracker.trackEdit(filePath, 0);
+			}
+		}
+	});
+
+	// ── resources_discover ─────────────────────────────────────────────────────
+	try {
+		pi.on("resources_discover", () => {
+			const extDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
+			if (fs.existsSync(extDir)) return { skillPaths: [extDir] };
+			return {};
+		});
+	} catch { /* older Pi without resources_discover */ }
+
+	// ── Register tools ─────────────────────────────────────────────────────────
+
+	const toolResult = (text: string) =>
+		({ content: [{ type: "text" as const, text }], details: {} });
+
+	const memorySearchTool: ToolDefinition = {
+		name: "memory_search",
+		label: "Memory Search",
+		description: "Search persistent memory for relevant knowledge, solutions, decisions, and patterns",
+		parameters: Type.Object({
+			query: Type.String({ description: "Natural language query" }),
+			maxResults: Type.Optional(Type.Number({ description: "Maximum results to return (default: 5)" })),
+			scope: Type.Optional(Type.String({ description: "Search scope filter: all, solutions, decisions, gotchas, conventions" })),
+			detail: Type.Optional(Type.String({ description: "Detail level: compact, medium, full" })),
+		}) as never,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const cwd = currentCtx?.cwd ?? process.cwd();
+			const db = getDB(cwd);
+			const text = handleMemorySearch(db.getConnection(), params as unknown as MemorySearchInput);
+			return toolResult(text);
+		},
+	};
+
+	const memoryStoreTool: ToolDefinition = {
+		name: "memory_store",
+		label: "Memory Store",
+		description: "Store knowledge in persistent memory (gotchas, conventions, decisions, patterns, architecture)",
+		parameters: Type.Object({
+			category: Type.String({ description: "Knowledge category: gotcha, convention, decision, pattern, architecture" }),
+			title: Type.String({ description: "Title for the stored knowledge" }),
+			content: Type.String({ description: "Content to store" }),
+			metadata: Type.Optional(Type.Object({
+				files: Type.Optional(Type.Array(Type.String())),
+				tags: Type.Optional(Type.Array(Type.String())),
+				severity: Type.Optional(Type.String()),
+			})),
+		}) as never,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const cwd = currentCtx?.cwd ?? process.cwd();
+			const db = getDB(cwd);
+			const text = handleMemoryStore(db.getConnection(), cwd, params as unknown as MemoryStoreInput);
+			return toolResult(text);
+		},
+	};
+
+	const memoryRecallTool: ToolDefinition = {
+		name: "memory_recall",
+		label: "Memory Recall",
+		description: "Recall relevant memories with progressive disclosure based on budget",
+		parameters: Type.Object({
+			context: Type.String({ description: "What context is needed" }),
+			budget: Type.Optional(Type.Number({ description: "Max bytes to return (default: 2048)" })),
+		}) as never,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const cwd = currentCtx?.cwd ?? process.cwd();
+			const db = getDB(cwd);
+			const text = handleMemoryRecall(db.getConnection(), params as unknown as MemoryRecallInput);
+			return toolResult(text);
+		},
+	};
+
+	const memoryStatusTool: ToolDefinition = {
+		name: "memory_status",
+		label: "Memory Status",
+		description: "Get memory status, stats, or manage the memory database",
+		parameters: Type.Object({
+			action: Type.String({ description: "Action to perform: status, stats, reindex, compact, export" }),
+			format: Type.Optional(Type.String({ description: "Output format: text, json" })),
+		}) as never,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const cwd = currentCtx?.cwd ?? process.cwd();
+			const db = getDB(cwd);
+			const text = handleMemoryStatus(db.getConnection(), db.dbPath, params as unknown as MemoryStatusInput);
+			return toolResult(text);
+		},
+	};
+
+	for (const tool of [memorySearchTool, memoryStoreTool, memoryRecallTool, memoryStatusTool]) {
+		try {
+			pi.registerTool(tool);
+		} catch { /* tool registration may not be available */ }
+	}
+}