@yandy0725/pi-memory 1.1.0 → 1.2.1

package/index.ts

@@ -2,13 +2,11 @@ import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { ensureAgentTypes } from "./src/agent-types";
 import { loadConfig, type MemoryConfig } from "./src/config";
 import { runDream } from "./src/dream";
 import { runExtract } from "./src/extract";
 import {
 	buildInjection,
-	buildSurfacingPrompt,
 	injectSurfacedContent,
 	loadIndexSnapshot,
 	runSideQuery,
@@ -19,9 +17,6 @@ import { readDreamMeta, shouldNudge, writeDreamMeta } from "./src/nudge";
 import { resolveMemoryDir } from "./src/paths";
 import { searchSessions } from "./src/session-search";
 
-// Register custom agent type on load (zero setup, auto-fallback on first session).
-ensureAgentTypes();
-
 export default function (pi: ExtensionAPI) {
 	let memoryDir: string | null = null;
 	let config: MemoryConfig | null = null;
@@ -57,30 +52,30 @@ export default function (pi: ExtensionAPI) {
 			if (nudge) {
 				const ok = await ctx.ui.confirm("Memory Consolidation", `${message}\n\nConsolidate memory files now?`);
 				if (ok) {
-					// Fire-and-forget: defers past the current macrotask so all
-					// session_start handlers (including pi-subagents') have completed.
-					// Does not block session_start.
+					// Fire-and-forget: does not block session_start. The headless
+					// dream agent runs independently; completion notifies the user.
 					const dreamModel = config.dream.model;
 					const dreamThinkLevel = config.dream.thinkLevel;
 					const dir = memoryDir;
 					ctx.ui.setStatus("dream", "Consolidating memory...");
-					setTimeout(async () => {
-						try {
-							const summary = await runDream({
-								model: dreamModel,
-								thinkLevel: dreamThinkLevel,
-								memoryDir: dir,
-								events: pi.events,
-							});
+					runDream({
+						model: dreamModel,
+						thinkLevel: dreamThinkLevel,
+						memoryDir: dir,
+						modelRegistry: ctx.modelRegistry,
+						parentModel: ctx.model,
+					})
+						.then(async (summary) => {
 							await writeDreamMeta(dir, sessions);
 							ctx.ui.notify(summary, "info");
-							// biome-ignore lint/suspicious/noExplicitAny: error catch
-						} catch (e: any) {
+						})
+						// biome-ignore lint/suspicious/noExplicitAny: error catch
+						.catch((e: any) => {
 							ctx.ui.notify(`Dream failed: ${e.message}`, "error");
-						} finally {
+						})
+						.finally(() => {
 							ctx.ui.setStatus("dream", undefined);
-						}
-					}, 0);
+						});
 				}
 			}
 		}
@@ -89,14 +84,12 @@ export default function (pi: ExtensionAPI) {
 	pi.on("before_agent_start", async (event, ctx) => {
 		if (!config?.enabled || !indexSnapshot || !memoryDir) return;
 
-		// Auto-surfacing: select relevant topic files via LLM side-query and inject as message.
-		// Skip for subagents: pi-subagents strips "subagent" from all children's
-		// tool sets, so its absence reliably identifies subagents. Without this guard,
-		// runSideQuery's subagent spawn → before_agent_start → re-enter here → OOM.
-		const agentTools = event.systemPromptOptions?.selectedTools;
-		const isSubagent = agentTools && !agentTools.includes("subagent");
-
 		const autoSurfacing = config.autoSurfacing;
+		// Skip auto-surfacing in subagent sessions: pi-subagents injects an
+		// <active_agent name="..."/> tag into every subagent's system prompt.
+		// Main sessions (including forks) never have this tag. Our own headless
+		// sessions use noExtensions (never bind), so they never reach here.
+		const isSubagent = event.systemPrompt?.includes("<active_agent name=\"");
 		// biome-ignore lint/suspicious/noExplicitAny: message injection result
 		let injectedMessage: any;
 		if (autoSurfacing?.enabled && event.prompt && !isSubagent) {
@@ -104,8 +97,17 @@ export default function (pi: ExtensionAPI) {
 				if (ctx.hasUI) ctx.ui.setStatus("surfacing", "Searching relevant memories…");
 				const manifest = await scanTopics(memoryDir);
 				if (manifest.length > 0) {
-					const queryPrompt = buildSurfacingPrompt(manifest, event.prompt.slice(0, 4000), injectedTopics);
-					const selected = await runSideQuery(queryPrompt, manifest, autoSurfacing.maxFiles, autoSurfacing.thinkLevel, pi.events);
+					const selected = await runSideQuery(
+						manifest,
+						event.prompt.slice(0, 4000),
+						injectedTopics,
+						autoSurfacing.maxFiles,
+						autoSurfacing.thinkLevel,
+						autoSurfacing.model,
+						ctx.modelRegistry,
+						ctx.model,
+						memoryDir,
+					);
 					if (selected.length > 0) {
 						const content = await injectSurfacedContent(
 							memoryDir,
@@ -114,9 +116,7 @@ export default function (pi: ExtensionAPI) {
 							autoSurfacing.maxInjectionBytes,
 						);
 						if (content) {
-							// Track injected topics for session-level dedup
 							for (const f of selected) injectedTopics.add(f);
-							// Inject as a custom message (NOT systemPrompt)
 							injectedMessage = { customType: "memory-auto-surfacing", content, display: false };
 						}
 					}
@@ -135,16 +135,17 @@ export default function (pi: ExtensionAPI) {
 		};
 	});
 
-	pi.on("agent_end", async (event) => {
+	pi.on("agent_end", async (event, ctx) => {
 		if (!config?.enabled || !memoryDir) return;
 		const extractConfig = config.extractMemories;
 		if (!extractConfig?.enabled) return;
 		if (!event.messages || event.messages.length === 0) return;
-		// Fire-and-forget: extract memories in background
 		runExtract({
 			model: extractConfig.model,
 			thinkLevel: extractConfig.thinkLevel,
 			memoryDir,
+			modelRegistry: ctx.modelRegistry,
+			parentModel: ctx.model,
 			messages: event.messages.map((m) => ({
 				// biome-ignore lint/suspicious/noExplicitAny: pi event message union type
 				role: String((m as any).role ?? ""),
@@ -202,24 +203,27 @@ export default function (pi: ExtensionAPI) {
 			}
 			const ok = await ctx.ui.confirm("Dream", "Consolidate all memory files? This rewrites them in-place.");
 			if (!ok) return;
+			const dir = memoryDir;
 			ctx.ui.setStatus("dream", "Consolidating memory...");
-			try {
-				const summary = await runDream({
-					model: config.dream.model,
-					thinkLevel: config.dream.thinkLevel,
-					memoryDir,
-					signal: ctx.signal,
-					events: pi.events,
-				});
-				const sessions = (await SessionManager.list(ctx.cwd)).length;
-				await writeDreamMeta(memoryDir, sessions);
-				ctx.ui.notify(summary, "info");
+			runDream({
+				model: config.dream.model,
+				thinkLevel: config.dream.thinkLevel,
+				memoryDir,
+				modelRegistry: ctx.modelRegistry,
+				parentModel: ctx.model,
+			})
+				.then(async (summary) => {
+					const sessions = (await SessionManager.list(ctx.cwd)).length;
+					await writeDreamMeta(dir, sessions);
+					ctx.ui.notify(summary, "info");
+				})
 				// biome-ignore lint/suspicious/noExplicitAny: command handler ctx
-			} catch (e: any) {
-				ctx.ui.notify(`Dream failed: ${e.message}`, "error");
-			} finally {
-				ctx.ui.setStatus("dream", undefined);
-			}
+				.catch((e: any) => {
+					ctx.ui.notify(`Dream failed: ${e.message}`, "error");
+				})
+				.finally(() => {
+					ctx.ui.setStatus("dream", undefined);
+				});
 		},
 	});
 }

package/package.json

@@ -3,7 +3,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "1.1.0",
+	"version": "1.2.1",
 	"description": "File-system driven persistent memory layer for pi coding agent",
 	"license": "MIT",
 	"repository": {
@@ -35,7 +35,6 @@
 		"@earendil-works/pi-ai": ">=0.80.2",
 		"@earendil-works/pi-coding-agent": ">=0.80.2",
 		"@earendil-works/pi-tui": ">=0.80.2",
-		"@yandy0725/pi-subagents": "*",
 		"typebox": "*"
 	},
 	"devDependencies": {

package/src/agent-config.ts

@@ -0,0 +1,2 @@
+/** Tools available to the headless memory-agent sub-session (file I/O only). */
+export const MEMORY_AGENT_TOOLS = ["read", "write", "edit", "ls"] as const;

package/src/agent-runner.ts

@@ -0,0 +1,121 @@
+import type { Model } from "@earendil-works/pi-ai";
+import {
+	type AgentSession,
+	type AgentSessionEvent,
+	createAgentSession,
+	DefaultResourceLoader,
+	getAgentDir,
+	SessionManager,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { MEMORY_AGENT_TOOLS } from "./agent-config";
+import type { ThinkLevel } from "./config";
+import { resolveModel } from "./model-resolver";
+
+export interface HeadlessAgentOpts {
+	task: string;
+	cwd: string;
+	modelRegistry: import("@earendil-works/pi-coding-agent").ModelRegistry;
+	model?: string;
+	parentModel?: Model<any>;
+	thinkLevel?: ThinkLevel;
+	maxTurns?: number;
+	signal?: AbortSignal;
+	timeoutMs?: number;
+}
+
+const GRACE_TURNS = 1;
+
+/**
+ * Run a headless memory-agent sub-session: create an in-memory, resource-free
+ * session, drive the turn loop, collect the assistant response text, and dispose.
+ *
+ * Does NOT call bindExtensions — no extension hooks fire in the sub-session,
+ * so pi-memory's own before_agent_start cannot recurse.
+ */
+export async function runHeadlessAgent(opts: HeadlessAgentOpts): Promise<string> {
+	// 1. Resolve model: undefined → parentModel; otherwise fuzzy resolve (fallback parent)
+	const resolvedModel = !opts.model
+		? opts.parentModel
+		: (resolveModel(opts.model, opts.modelRegistry) ?? opts.parentModel);
+
+	// 2. Build a pure resource loader (no extensions/skills/context files/etc.)
+	const settingsManager = SettingsManager.inMemory();
+	const loader = new DefaultResourceLoader({
+		cwd: opts.cwd,
+		agentDir: getAgentDir(),
+		settingsManager,
+		noExtensions: true,
+		noSkills: true,
+		noContextFiles: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await loader.reload();
+
+	// 3. Forward abort signal BEFORE createAgentSession (handle early abort)
+	let session: AgentSession | undefined;
+	const onAbort = (): void => {
+		void session?.abort();
+	};
+	opts.signal?.addEventListener("abort", onAbort, { once: true });
+
+	// 4. Create the in-memory session (no bindExtensions)
+	const created = await createAgentSession({
+		cwd: opts.cwd,
+		tools: [...MEMORY_AGENT_TOOLS],
+		model: resolvedModel as any,
+		thinkingLevel: opts.thinkLevel as any,
+		modelRegistry: opts.modelRegistry,
+		sessionManager: SessionManager.inMemory(opts.cwd),
+		settingsManager,
+		resourceLoader: loader,
+	});
+	session = created.session as AgentSession;
+
+	// 5. Collect response text + enforce turn limits
+	let text = "";
+	let turnCount = 0;
+	let softLimitReached = false;
+	const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+		if (event.type === "message_start") {
+			text = "";
+		} else if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+			text += event.assistantMessageEvent.delta;
+		} else if (event.type === "turn_end") {
+			turnCount++;
+			if (opts.maxTurns != null) {
+				if (!softLimitReached && turnCount >= opts.maxTurns) {
+					softLimitReached = true;
+					void session.steer("You have reached your turn limit. Finish now.");
+				} else if (softLimitReached && turnCount >= opts.maxTurns + GRACE_TURNS) {
+					void session.abort();
+				}
+			}
+		}
+	});
+
+	try {
+		// 6. Drive prompt (with optional timeout)
+		const promptPromise = session.prompt(opts.task);
+		if (opts.timeoutMs != null) {
+			let timeoutId: ReturnType<typeof setTimeout> | undefined;
+			const timeoutPromise = new Promise<never>((_, reject) => {
+				timeoutId = setTimeout(
+					() => reject(new Error(`headless agent timed out after ${opts.timeoutMs}ms`)),
+					opts.timeoutMs,
+				);
+			});
+			await Promise.race([promptPromise, timeoutPromise]).finally(() => {
+				if (timeoutId) clearTimeout(timeoutId);
+			});
+		} else {
+			await promptPromise;
+		}
+		return text || (session.getLastAssistantText() ?? "");
+	} finally {
+		opts.signal?.removeEventListener("abort", onAbort);
+		unsubscribe();
+		session.dispose?.();
+	}
+}

package/src/config.ts

@@ -7,7 +7,7 @@ export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
 
 export interface AutoSurfacingConfig {
 	enabled: boolean;
-	model: string;
+	model?: string;
 	thinkLevel: ThinkLevel;
 	maxFiles: number;
 	maxTopicBytes: number;
@@ -16,7 +16,7 @@ export interface AutoSurfacingConfig {
 
 export interface ExtractMemoriesConfig {
 	enabled: boolean;
-	model: string;
+	model?: string;
 	thinkLevel: ThinkLevel;
 	maxContextTokens: number;
 }
@@ -26,7 +26,7 @@ export interface MemoryConfig {
 	memoryDir: string;
 	memIndexMaxLines: number;
 	memIndexMaxBytes: number;
-	dream: { nudgeAfterSessions: number; nudgeAfterHours: number; model: string; thinkLevel: ThinkLevel };
+	dream: { nudgeAfterSessions: number; nudgeAfterHours: number; model?: string; thinkLevel: ThinkLevel };
 	sessionSearch: { maxSessions: number; maxMatches: number };
 	autoSurfacing: AutoSurfacingConfig;
 	extractMemories: ExtractMemoriesConfig;
@@ -37,11 +37,10 @@ export const DEFAULT_CONFIG: MemoryConfig = {
 	memoryDir: join(homedir(), CONFIG_DIR_NAME, "memory"),
 	memIndexMaxLines: 200,
 	memIndexMaxBytes: 25600,
-	dream: { nudgeAfterSessions: 5, nudgeAfterHours: 24, model: "auto", thinkLevel: "high" },
+	dream: { nudgeAfterSessions: 5, nudgeAfterHours: 24, thinkLevel: "high" },
 	sessionSearch: { maxSessions: 10, maxMatches: 5 },
 	autoSurfacing: {
 		enabled: true,
-		model: "auto",
 		thinkLevel: "off",
 		maxFiles: 5,
 		maxTopicBytes: 4096,
@@ -49,7 +48,6 @@ export const DEFAULT_CONFIG: MemoryConfig = {
 	},
 	extractMemories: {
 		enabled: true,
-		model: "auto",
 		thinkLevel: "high",
 		maxContextTokens: 2000,
 	},

package/src/dream.ts

@@ -1,11 +1,9 @@
-import { access } from "node:fs/promises";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { runHeadlessAgent } from "./agent-runner";
 import type { ThinkLevel } from "./config";
-import { getSubagentsService, type SubagentsService, type WorkspaceProvider } from "@yandy0725/pi-subagents";
 
-/** Build dream consolidation task.
- *  Session context strategy: cwd = memoryDir (via WorkspaceProvider).
- *  Dream agent sees only the memory files, no parent conversation history.
- *  Tool scope: full file read/write/edit (needed for consolidation). */
+/** Build dream consolidation task. (unchanged) */
 export function buildDreamTask(memoryDir: string, maxLines: number): string {
 	return `You are a memory consolidation agent. Your job is to read all memory files
 and consolidate them into a clean, deduplicated memory store.
@@ -53,80 +51,24 @@ CRITICAL for hooks and descriptions:
 }
 
 export interface RunDreamOpts {
-	model: string;
+	model?: string;
 	thinkLevel: ThinkLevel;
 	memoryDir: string;
-	signal?: AbortSignal;
-	// biome-ignore lint/suspicious/noExplicitAny: pi events API handler
-	events?: { on(channel: string, handler: (data: any) => void): () => void };
-	service?: SubagentsService;
+	modelRegistry: ModelRegistry;
+	parentModel?: Model<any>;
 }
 
+/** Run dream consolidation via a headless agent. Fire-and-forget (caller decides await). */
 export async function runDream(opts: RunDreamOpts): Promise<string> {
-	const service = opts.service ?? getSubagentsService();
-	if (!service) throw new Error("pi-subagents not available — install @yandy0725/pi-subagents");
-
-	const events = opts.events;
-	if (!events) throw new Error("events required for dream — pass pi.events");
-
-	const model = opts.model === "auto" ? undefined : opts.model;
 	const task = buildDreamTask(opts.memoryDir, 200);
-
-	// Register workspace provider so the subagent runs in memoryDir
-	const provider: WorkspaceProvider = {
-		async prepare(_ctx) {
-			await access(opts.memoryDir).catch(() => {
-				throw new Error(`Memory directory not found: ${opts.memoryDir}`);
-			});
-			return {
-				cwd: opts.memoryDir,
-				dispose: () => undefined,
-			};
-		},
-	};
-	const unregister = service.registerWorkspaceProvider(provider);
-
-	// Spawn the dream subagent
-	const agentId = service.spawn(
-		"memory-agent",
+	return runHeadlessAgent({
 		task,
-		model ? { model, thinkingLevel: opts.thinkLevel } : { thinkingLevel: opts.thinkLevel },
-	);
-
-	// Wait for completion/failure via pi-subagents events (abort-while-queued
-	// is handled: pi-subagents guarantees events fire for all terminal states).
-	return await new Promise<string>((resolve, reject) => {
-		let settled = false;
-
-		const cleanup = () => {
-			if (settled) return;
-			settled = true;
-			unsubCompleted();
-			unsubFailed();
-			unregister();
-			opts.signal?.removeEventListener("abort", onAbort);
-		};
-
-		const onCompleted = (data: { id: string }) => {
-			if (data.id !== agentId) return;
-			cleanup();
-			const record = service.getRecord(agentId);
-			resolve(record?.result ?? "Dream completed.");
-		};
-
-		const onFailed = (data: { id: string; error?: string }) => {
-			if (data.id !== agentId) return;
-			cleanup();
-			reject(new Error(data.error ?? "Dream agent failed"));
-		};
-
-		const onAbort = () => {
-			service.abort(agentId);
-		};
-
-		const unsubCompleted = events.on("subagents:completed", onCompleted);
-		const unsubFailed = events.on("subagents:failed", onFailed);
-
-		opts.signal?.addEventListener("abort", onAbort, { once: true });
+		cwd: opts.memoryDir,
+		modelRegistry: opts.modelRegistry,
+		model: opts.model,
+		parentModel: opts.parentModel,
+		thinkLevel: opts.thinkLevel,
+		maxTurns: undefined,
+		timeoutMs: 600_000,
 	});
 }

package/src/extract.ts

@@ -1,32 +1,29 @@
-import { access } from "node:fs/promises";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { runHeadlessAgent } from "./agent-runner";
 import type { ThinkLevel } from "./config";
-import { getSubagentsService, type SubagentsService, type WorkspaceProvider } from "@yandy0725/pi-subagents";
 
 export interface RunExtractOpts {
-	model: string;
+	model?: string;
 	thinkLevel: ThinkLevel;
 	memoryDir: string;
 	messages: Array<{ role: string; content: string }>;
 	maxContextTokens: number;
-	service?: SubagentsService;
+	modelRegistry: ModelRegistry;
+	parentModel?: Model<any>;
 }
 
-/** Build extraction task prompt.
- *  Session context strategy: only current turn (user + assistant messages).
- *  No conversation history — extraction is turn-scoped.
- *  Tool scope: file read/write only (cwd = memoryDir). */
+/** Build extraction task prompt. (unchanged) */
 export function buildExtractTask(
 	memoryDir: string,
 	messages: Array<{ role: string; content: string }>,
 	maxTokens: number,
 ): string {
-	// Find user and assistant messages for context
 	const fromUser = messages.find((m) => m.role === "user");
 	const fromAssistant = messages.findLast((m) => m.role === "assistant");
 	const userText = fromUser?.content ?? "";
 	const assistantText = fromAssistant?.content ?? "";
 
-	// Truncate by maxTokens (rough estimate: ~4 chars/token)
 	const maxChars = maxTokens * 4;
 	const truncatedUser = userText.slice(0, maxChars / 2);
 	const truncatedAssistant = assistantText.slice(0, maxChars / 2);
@@ -79,35 +76,21 @@ export function buildExtractTask(
 	].join("\n");
 }
 
+/** Fire-and-forget memory extraction. Does not await the headless agent. */
 export async function runExtract(opts: RunExtractOpts): Promise<void> {
 	if (opts.messages.length === 0) return;
-
-	const service = opts.service ?? getSubagentsService();
-	if (!service) return; // silently skip if no subagent service
-
-	const model = opts.model === "auto" ? undefined : opts.model;
-	const thinkLevel = opts.thinkLevel;
 	const task = buildExtractTask(opts.memoryDir, opts.messages, opts.maxContextTokens);
-
-	const provider: WorkspaceProvider = {
-		async prepare(_ctx) {
-			await access(opts.memoryDir).catch(() => {
-				throw new Error(`Memory directory not found: ${opts.memoryDir}`);
-			});
-			return {
-				cwd: opts.memoryDir,
-				dispose: () => undefined,
-			};
-		},
-	};
-	service.registerWorkspaceProvider(provider);
-
-	// Fire-and-forget spawn
-	service.spawn(
-		"memory-agent",
+	// fire-and-forget: runner disposes internally via finally
+	runHeadlessAgent({
 		task,
-		model
-			? { model, inheritContext: false, maxTurns: 5, thinkingLevel: thinkLevel }
-			: { inheritContext: false, maxTurns: 5, thinkingLevel: thinkLevel },
-	);
+		cwd: opts.memoryDir,
+		modelRegistry: opts.modelRegistry,
+		model: opts.model,
+		parentModel: opts.parentModel,
+		thinkLevel: opts.thinkLevel,
+		maxTurns: 5,
+		timeoutMs: 120_000,
+	}).catch(() => {
+		/* silently ignore extract errors */
+	});
 }

package/src/inject.ts

@@ -1,6 +1,9 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { getSubagentsService } from "@yandy0725/pi-subagents";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { runHeadlessAgent } from "./agent-runner";
+import type { ThinkLevel } from "./config";
 import { truncateForInjection } from "./index-file";
 import { parseFrontmatter } from "./topic-file";
 
@@ -57,25 +60,15 @@ export async function scanTopics(memoryDir: string): Promise<TopicManifest[]> {
 	return manifests.sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 
-export function buildSurfacingPrompt(
-	manifest: TopicManifest[],
-	userPrompt: string,
-	injectedTopics: Set<string>,
-): string {
+function buildSurfacingPrompt(manifest: TopicManifest[], userPrompt: string): string {
 	const lines = manifest.map((t) => {
-		const marker = injectedTopics.has(t.filename) ? " [already injected]" : "";
-		return `[${t.type}] ${t.filename} — ${t.description.slice(0, 80)}${marker}`;
+		return `[${t.type}] ${t.filename} — ${t.description.slice(0, 80)}`;
 	});
-	const alreadyInjected =
-		injectedTopics.size > 0
-			? `\n\nNote: ${injectedTopics.size} topic file(s) have already been injected in this session and are marked [already injected]. Prefer selecting uninjected topics.`
-			: "";
 
 	return [
 		"You are a memory relevance selector. Below is a list of memory topic files and a user message.",
 		"Select up to N topic files that are relevant to the user's current query.",
 		"Response format: JSON with a 'selected_files' array of filenames.",
-		alreadyInjected,
 		"",
 		"=== Topic Files ===",
 		...lines,
@@ -114,30 +107,9 @@ export async function injectSurfacedContent(
 	return `<relevant_memories>\n${blocks.join("\n\n")}\n</relevant_memories>`;
 }
 
-/** Run a lightweight LLM side-query to select relevant topic files.
- *  Uses pi-subagents spawn + Promise pattern (same as dream.ts).
- *  Falls back to keyword matching if subagent service is unavailable. */
-import type { ThinkLevel } from "./config";
-
-export async function runSideQuery(
-	prompt: string,
-	manifest: TopicManifest[],
-	maxFiles: number,
-	thinkLevel: ThinkLevel,
-	// biome-ignore lint/suspicious/noExplicitAny: pi events API handler
-	events?: { on(channel: string, handler: (data: any) => void): () => void },
-): Promise<string[]> {
-	// Filter to uninjected candidates only
-	const candidates = manifest.filter((t) => {
-		// already-injected topics are marked in the prompt, but we also
-		// filter here as a safety net
-		return !prompt.includes(`[already injected] ${t.filename}`);
-	});
-	if (candidates.length === 0) return [];
-
-	// Build a minimal selection prompt — only current user message + topic manifest.
-	// With prompt_mode=replace, this IS the entire system prompt (no inheritance).
-	const task = [
+/** Build the side-query task prompt. Extracted for testability. */
+export function buildSideQueryTask(prompt: string, maxFiles: number): string {
+	return [
 		"Respond with ONLY a JSON object.",
 		"",
 		"Below is a list of memory topic files and a user query.",
@@ -148,106 +120,51 @@ export async function runSideQuery(
 		"",
 		'Respond with EXACTLY: {"selected_files": [...]}',
 	].join("\n");
+}
 
-	const service = getSubagentsService();
-	if (!service) {
-		// Fallback: keyword matching when subagent service unavailable
-		return keywordMatch(candidates, prompt, maxFiles);
+/** Parse selected_files JSON from headless agent response. */
+function parseSelectedFiles(result: string, candidates: TopicManifest[], maxFiles: number): string[] {
+	try {
+		const jsonMatch = result.match(/\{[^}]*"selected_files"[^}]*\}/s);
+		if (!jsonMatch) return [];
+		const parsed = JSON.parse(jsonMatch[0]);
+		const files: string[] = parsed.selected_files ?? [];
+		return files.filter((f: string) => candidates.some((c) => c.filename === f)).slice(0, maxFiles);
+	} catch {
+		return [];
 	}
+}
 
-	const provider = {
-		// biome-ignore lint/suspicious/noExplicitAny: WorkspaceProvider prepare ctx
-		async prepare(_ctx: any) {
-			return { cwd: process.cwd(), dispose: () => undefined };
-		},
-	};
-	const unregister = service.registerWorkspaceProvider(provider);
-
+/** Run a lightweight headless side-query to select relevant topic files.
+ *  Returns [] on timeout/failure — no fallback. */
+export async function runSideQuery(
+	manifest: TopicManifest[],
+	userPrompt: string,
+	injectedTopics: Set<string>,
+	maxFiles: number,
+	thinkLevel: ThinkLevel,
+	model: string | undefined,
+	modelRegistry: ModelRegistry,
+	parentModel: Model<any> | undefined,
+	memoryDir: string,
+): Promise<string[]> {
+	const candidates = manifest.filter((t) => !injectedTopics.has(t.filename));
+	if (candidates.length === 0) return [];
+	const surfacingPrompt = buildSurfacingPrompt(candidates, userPrompt);
+	const task = buildSideQueryTask(surfacingPrompt, maxFiles);
 	try {
-		// Subscribe to events BEFORE spawn to prevent race: if the subagent
-		// completes between spawn and subscribe, the event is lost and
-		// the Promise never resolves except by timeout.
-		const result = await new Promise<string[]>((resolve) => {
-			const timeout = setTimeout(() => {
-				cleanup();
-				resolve(keywordMatch(candidates, prompt, maxFiles));
-			}, 30_000);
-
-			let settled = false;
-			const cleanup = () => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeout);
-				unsubCompleted();
-				unsubFailed();
-				unregister();
-			};
-
-			const onCompleted = (data: { id: string }) => {
-				if (data.id !== agentId) return;
-				cleanup();
-				const record = service.getRecord(agentId);
-				const result = record?.result ?? "";
-				try {
-					const jsonMatch = result.match(/\{[^}]*"selected_files"[^}]*\}/s);
-					if (jsonMatch) {
-						const parsed = JSON.parse(jsonMatch[0]);
-						const files: string[] = parsed.selected_files ?? [];
-						const valid = files.filter((f: string) => candidates.some((c) => c.filename === f)).slice(0, maxFiles);
-						resolve(valid);
-					} else {
-						resolve([]);
-					}
-				} catch {
-					resolve([]);
-				}
-			};
-
-			const onFailed = (data: { id: string }) => {
-				if (data.id !== agentId) return;
-				cleanup();
-				resolve(keywordMatch(candidates, prompt, maxFiles));
-			};
-
-			const unsubCompleted = events?.on("subagents:completed", onCompleted) ?? (() => {});
-			const unsubFailed = events?.on("subagents:failed", onFailed) ?? (() => {});
-
-			if (!events) {
-				cleanup();
-				resolve(keywordMatch(candidates, prompt, maxFiles));
-				return;
-			}
-
-			// Spawn AFTER subscriptions are active
-			const agentId = service.spawn("memory-agent", task, {
-				maxTurns: 1,
-				inheritContext: false,
-				thinkingLevel: thinkLevel,
-				foreground: true,
-				bypassQueue: true,
-			});
+		const result = await runHeadlessAgent({
+			task,
+			cwd: memoryDir,
+			modelRegistry,
+			model,
+			parentModel,
+			thinkLevel,
+			maxTurns: 1,
+			timeoutMs: 30_000,
 		});
-
-		return result;
+		return parseSelectedFiles(result, candidates, maxFiles);
 	} catch {
-		unregister();
-		return keywordMatch(candidates, prompt, maxFiles);
+		return [];
 	}
 }
-
-/** Keyword-matching fallback for topic selection (no LLM required). */
-function keywordMatch(manifest: TopicManifest[], userPrompt: string, maxFiles: number): string[] {
-	const words = userPrompt
-		.toLowerCase()
-		.split(/\W+/)
-		.filter((w) => w.length > 2);
-	const scored = manifest
-		.map((t) => {
-			const desc = `${t.description} ${t.name}`.toLowerCase();
-			const score = words.filter((w) => desc.includes(w)).length;
-			return { filename: t.filename, score };
-		})
-		.filter((t) => t.score > 0)
-		.sort((a, b) => b.score - a.score);
-	return scored.slice(0, maxFiles).map((t) => t.filename);
-}

package/src/memory-tool.ts

@@ -110,7 +110,10 @@ export async function doAdd(memoryDir: string, p: AddParams): Promise<ActionResu
 
 			// Build hook from all entries (comma-separated titles, trimmed to ~150 chars)
 			const allEntries = parseEntries(topicContent);
-			const hook = allEntries.map((e) => e.title).join("; ").slice(0, 150);
+			const hook = allEntries
+				.map((e) => e.title)
+				.join("; ")
+				.slice(0, 150);
 			next = updateHook(entries, topic, hook);
 			if (!checkCapacity(next, p.maxLines, p.maxBytes)) {
 				return {

package/src/model-resolver.ts

@@ -0,0 +1,69 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+interface ModelEntry {
+	id: string;
+	name: string;
+	provider: string;
+}
+
+/**
+ * Resolve a model string to a Model instance.
+ * Tries exact "provider/modelId" match (only available models), then fuzzy match.
+ * Returns the Model on success, or undefined on failure (caller falls back to parent model).
+ */
+export function resolveModel(input: string, registry: ModelRegistry): Model<any> | undefined {
+	if (!input) return undefined;
+	const all = (registry.getAvailable?.() ?? registry.getAll()) as ModelEntry[];
+	if (all.length === 0) return undefined;
+	const availableSet = new Set(all.map((m) => `${m.provider}/${m.id}`.toLowerCase()));
+
+	// 1. Exact match: "provider/modelId" — only if available (has auth)
+	const slashIdx = input.indexOf("/");
+	if (slashIdx !== -1) {
+		const provider = input.slice(0, slashIdx);
+		const modelId = input.slice(slashIdx + 1);
+		if (availableSet.has(input.toLowerCase())) {
+			const found = registry.find(provider, modelId);
+			if (found) return found;
+		}
+	}
+
+	// 2. Fuzzy match against available models
+	const query = input.toLowerCase();
+	let bestMatch: ModelEntry | undefined;
+	let bestScore = 0;
+
+	for (const m of all) {
+		const id = m.id.toLowerCase();
+		const name = m.name.toLowerCase();
+		const full = `${m.provider}/${m.id}`.toLowerCase();
+
+		let score = 0;
+		if (id === query || full === query) {
+			score = 100;
+		} else if (id.includes(query) || full.includes(query)) {
+			score = 60 + (query.length / id.length) * 30;
+		} else if (name.includes(query)) {
+			score = 40 + (query.length / name.length) * 20;
+		} else if (
+			query
+				.split(/[\s\-/]+/)
+				.every((part) => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))
+		) {
+			score = 20;
+		}
+
+		if (score > bestScore) {
+			bestScore = score;
+			bestMatch = m;
+		}
+	}
+
+	if (bestMatch && bestScore >= 20) {
+		const found = registry.find(bestMatch.provider, bestMatch.id);
+		if (found) return found;
+	}
+
+	return undefined;
+}

package/src/agent-types.ts

@@ -1,44 +0,0 @@
-/**
- * agent-types.ts — Register a single minimal agent type for pi-memory subagents.
- *
- * Writes `memory-agent.md` to ~/.pi/agent/agents/ so pi-subagents
- * picks it up as a custom agent type with restricted tools and replace-mode prompt.
- * Written during extension factory (before pi-subagents initializes its registry).
- *
- * One type serves three tasks:
- *   - side-query:    thinking=off,  maxTurns=1
- *   - extractMemories: thinking=high, maxTurns=5
- *   - dream:         thinking=high  (unlimited turns)
- *
- * On first install (before pi restart), pi-subagents auto-falls-back to
- * general-purpose. No manual action needed.
- */
-
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
-
-const AGENTS_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "agents");
-
-const DEFINITION = `---
-description: Memory maintenance agent — file read/write only (no bash/websearch)
-tools: read, write, edit, ls
-prompt_mode: replace
----
-`;
-
-export function ensureAgentTypes(): void {
-	try {
-		mkdirSync(AGENTS_DIR, { recursive: true });
-	} catch {
-		return;
-	}
-
-	const path = join(AGENTS_DIR, "memory-agent.md");
-	if (!existsSync(path)) {
-		try {
-			writeFileSync(path, DEFINITION, "utf8");
-		} catch {}
-	}
-}