@oh-my-pi/pi-coding-agent 3.21.0 → 3.24.0

package/src/core/tools/index.ts

@@ -1,14 +1,14 @@
 export { type AskToolDetails, askTool, createAskTool } from "./ask";
-export { type BashToolDetails, bashTool, createBashTool } from "./bash";
-export { createEditTool, type EditToolOptions, editTool } from "./edit";
+export { type BashToolDetails, createBashTool } from "./bash";
+export { createEditTool } from "./edit";
 // Exa MCP tools (22 tools)
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
-export { createFindTool, type FindToolDetails, findTool } from "./find";
+export { createFindTool, type FindToolDetails } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
 export { createGitTool, type GitToolDetails, gitTool } from "./git";
-export { createGrepTool, type GrepToolDetails, grepTool } from "./grep";
-export { createLsTool, type LsToolDetails, lsTool } from "./ls";
+export { createGrepTool, type GrepToolDetails } from "./grep";
+export { createLsTool, type LsToolDetails } from "./ls";
 export {
 	createLspTool,
 	type FileDiagnosticsResult,
@@ -20,14 +20,14 @@ export {
 	lspTool,
 	warmupLspServers,
 } from "./lsp/index";
-export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook";
-export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
-export { createReadTool, type ReadToolDetails, type ReadToolOptions, readTool } from "./read";
-export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
-export { createRulebookTool, filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
+export { createNotebookTool, type NotebookToolDetails } from "./notebook";
+export { createOutputTool, type OutputToolDetails } from "./output";
+export { createReadTool, type ReadToolDetails } from "./read";
+export { reportFindingTool, submitReviewTool } from "./review";
+export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
-export { createWebFetchTool, type WebFetchToolDetails, webFetchCustomTool, webFetchTool } from "./web-fetch";
+export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
 export {
 	companyWebSearchTools,
 	createWebSearchTool,
@@ -47,247 +47,104 @@ export {
 	webSearchLinkedinTool,
 	webSearchTool,
 } from "./web-search/index";
-export { createWriteTool, type WriteToolDetails, type WriteToolOptions, writeTool } from "./write";
+export { createWriteTool, type WriteToolDetails } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { askTool, createAskTool } from "./ask";
-import { bashTool, createBashTool } from "./bash";
-import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
-import { createEditTool, editTool } from "./edit";
-import { createFindTool, findTool } from "./find";
-import { createGitTool, gitTool } from "./git";
-import { createGrepTool, grepTool } from "./grep";
-import { createLsTool, lsTool } from "./ls";
-import { createLspTool, createLspWritethrough, lspTool } from "./lsp/index";
-import { createNotebookTool, notebookTool } from "./notebook";
-import { createOutputTool, outputTool } from "./output";
-import { createReadTool, readTool } from "./read";
-import { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
-import { createTaskTool, taskTool } from "./task/index";
-import { createWebFetchTool, webFetchTool } from "./web-fetch";
-import { createWebSearchTool, webSearchTool } from "./web-search/index";
-import { createWriteTool, writeTool } from "./write";
+import type { Rule } from "../../capability/rule";
+import type { EventBus } from "../event-bus";
+import { createAskTool } from "./ask";
+import { createBashTool } from "./bash";
+import { createEditTool } from "./edit";
+import { createFindTool } from "./find";
+import { createGitTool } from "./git";
+import { createGrepTool } from "./grep";
+import { createLsTool } from "./ls";
+import { createLspTool } from "./lsp/index";
+import { createNotebookTool } from "./notebook";
+import { createOutputTool } from "./output";
+import { createReadTool } from "./read";
+import { reportFindingTool, submitReviewTool } from "./review";
+import { createRulebookTool } from "./rulebook";
+import { createTaskTool } from "./task/index";
+import { createWebFetchTool } from "./web-fetch";
+import { createWebSearchTool } from "./web-search/index";
+import { createWriteTool } from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
 export type Tool = AgentTool<any, any, any>;
 
-/** Context for tools that need session information */
-export interface SessionContext {
+/** Session context for tool factories */
+export interface ToolSession {
+	/** Current working directory */
+	cwd: string;
+	/** Whether UI is available */
+	hasUI: boolean;
+	/** Rulebook rules */
+	rulebookRules: Rule[];
+	/** Event bus for tool/extension communication */
+	eventBus?: EventBus;
+	/** Get session file */
 	getSessionFile: () => string | null;
+	/** Get session spawns */
+	getSessionSpawns: () => string | null;
+	/** Settings manager (optional) */
+	settings?: {
+		getImageAutoResize(): boolean;
+		getLspFormatOnWrite(): boolean;
+		getLspDiagnosticsOnWrite(): boolean;
+		getLspDiagnosticsOnEdit(): boolean;
+		getEditFuzzyMatch(): boolean;
+		getGitToolEnabled(): boolean;
+		getBashInterceptorEnabled(): boolean;
+	};
 }
 
-/** Options for creating coding tools */
-export interface CodingToolsOptions {
-	/** Whether to fetch LSP diagnostics after write tool writes files (default: true) */
-	lspDiagnosticsOnWrite?: boolean;
-	/** Whether to fetch LSP diagnostics after edit tool edits files (default: false) */
-	lspDiagnosticsOnEdit?: boolean;
-	/** Whether to format files using LSP after write tool writes (default: true) */
-	lspFormatOnWrite?: boolean;
-	/** Whether to accept high-confidence fuzzy matches in edit tool (default: true) */
-	editFuzzyMatch?: boolean;
-	/** Whether to auto-resize images to 2000x2000 max in read tool (default: true) */
-	readAutoResizeImages?: boolean;
-	/** Set of tool names available to the agent (for cross-tool awareness) */
-	availableTools?: Set<string>;
-}
-
-// Factory function type
-type ToolFactory = (cwd: string, sessionContext?: SessionContext, options?: CodingToolsOptions) => Tool | Promise<Tool>;
-
-// Tool definitions: static tools and their factory functions
-const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
-	ask: { tool: askTool, create: createAskTool },
-	read: {
-		tool: readTool,
-		create: (cwd, _ctx, options) => createReadTool(cwd, { autoResizeImages: options?.readAutoResizeImages ?? true }),
-	},
-	bash: { tool: bashTool, create: createBashTool },
-	edit: {
-		tool: editTool,
-		create: (cwd, _ctx, options) => {
-			const enableDiagnostics = options?.lspDiagnosticsOnEdit ?? false;
-			const enableFormat = options?.lspFormatOnWrite ?? true;
-			const writethrough = createLspWritethrough(cwd, {
-				enableFormat,
-				enableDiagnostics,
-			});
-			return createEditTool(cwd, { fuzzyMatch: options?.editFuzzyMatch ?? true, writethrough });
-		},
-	},
-	write: {
-		tool: writeTool,
-		create: (cwd, _ctx, options) => {
-			const enableFormat = options?.lspFormatOnWrite ?? true;
-			const enableDiagnostics = options?.lspDiagnosticsOnWrite ?? true;
-			const writethrough = createLspWritethrough(cwd, {
-				enableFormat,
-				enableDiagnostics,
-			});
-			return createWriteTool(cwd, { writethrough });
-		},
-	},
-	grep: { tool: grepTool, create: createGrepTool },
-	find: { tool: findTool, create: createFindTool },
-	git: { tool: gitTool, create: createGitTool },
-	ls: { tool: lsTool, create: createLsTool },
-	lsp: { tool: lspTool, create: createLspTool },
-	notebook: { tool: notebookTool, create: createNotebookTool },
-	output: { tool: outputTool, create: (cwd, ctx) => createOutputTool(cwd, ctx) },
-	task: { tool: taskTool, create: (cwd, ctx, opts) => createTaskTool(cwd, ctx, opts) },
-	web_fetch: { tool: webFetchTool, create: createWebFetchTool },
-	web_search: { tool: webSearchTool, create: createWebSearchTool },
-	report_finding: { tool: reportFindingTool, create: createReportFindingTool },
-	submit_review: { tool: submitReviewTool, create: createSubmitReviewTool },
+type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
+
+export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
+	ask: createAskTool,
+	bash: createBashTool,
+	edit: createEditTool,
+	find: createFindTool,
+	git: createGitTool,
+	grep: createGrepTool,
+	ls: createLsTool,
+	lsp: createLspTool,
+	notebook: createNotebookTool,
+	output: createOutputTool,
+	read: createReadTool,
+	rulebook: createRulebookTool,
+	task: createTaskTool,
+	web_fetch: createWebFetchTool,
+	web_search: createWebSearchTool,
+	write: createWriteTool,
 };
 
-export type ToolName = keyof typeof toolDefs;
-
-// Tools that require UI (excluded when hasUI is false)
-const uiToolNames: ToolName[] = ["ask"];
-
-// Tool sets defined by name (base sets, without UI-only tools)
-export const baseCodingToolNames: ToolName[] = [
-	"read",
-	"bash",
-	"edit",
-	"write",
-	"grep",
-	"find",
-	"git",
-	"ls",
-	"lsp",
-	"notebook",
-	"output",
-	"task",
-	"web_fetch",
-	"web_search",
-];
-const baseReadOnlyToolNames: ToolName[] = ["read", "grep", "find", "ls"];
-
-// Default tools for full access mode (using process.cwd(), no UI)
-export const codingTools: Tool[] = baseCodingToolNames.map((name) => toolDefs[name].tool);
-
-// Read-only tools for exploration without modification (using process.cwd(), no UI)
-export const readOnlyTools: Tool[] = baseReadOnlyToolNames.map((name) => toolDefs[name].tool);
-
-// All available tools (using process.cwd(), no UI)
-export const allTools = Object.fromEntries(Object.entries(toolDefs).map(([name, def]) => [name, def.tool])) as Record<
-	ToolName,
-	Tool
->;
-
-/**
- * Create coding tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param hasUI - Whether UI is available (includes ask tool if true)
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createCodingTools(
-	cwd: string,
-	hasUI = false,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Tool[]> {
-	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
-}
-
-/**
- * Create read-only tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param hasUI - Whether UI is available (includes ask tool if true)
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createReadOnlyTools(
-	cwd: string,
-	hasUI = false,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Tool[]> {
-	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
-}
-
-/**
- * Create all tools configured for a specific working directory.
- * @param cwd - Working directory for tools
- * @param sessionContext - Optional session context for tools that need it
- * @param options - Options for tool configuration
- */
-export async function createAllTools(
-	cwd: string,
-	sessionContext?: SessionContext,
-	options?: CodingToolsOptions,
-): Promise<Record<ToolName, Tool>> {
-	const names = Object.keys(toolDefs);
-	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	const entries = await Promise.all(
-		Object.entries(toolDefs).map(async ([name, def]) => [
-			name,
-			await def.create(cwd, sessionContext, optionsWithTools),
-		]),
-	);
-	return Object.fromEntries(entries) as Record<ToolName, Tool>;
-}
-
-/**
- * Wrap a bash tool with interception that redirects common patterns to specialized tools.
- * This helps prevent LLMs from falling back to shell commands when better tools exist.
- *
- * @param bashTool - The bash tool to wrap
- * @param availableTools - Set of tool names that are available (for context-aware blocking)
- * @returns Wrapped bash tool with interception
- */
-export function wrapBashWithInterception(bashTool: Tool, availableTools: Set<string>): Tool {
-	const originalExecute = bashTool.execute;
-
-	return {
-		...bashTool,
-		execute: async (toolCallId, params, signal, onUpdate, context) => {
-			const command = (params as { command: string }).command;
-
-			// Check for forbidden patterns
-			const interception = checkBashInterception(command, availableTools);
-			if (interception.block) {
-				throw new Error(interception.message);
-			}
+export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
+	report_finding: () => reportFindingTool,
+	submit_review: () => submitReviewTool,
+};
 
-			// Check for simple ls that should use ls tool
-			const lsInterception = checkSimpleLsInterception(command, availableTools);
-			if (lsInterception.block) {
-				throw new Error(lsInterception.message);
-			}
-
-			// Pass through to original bash tool
-			return originalExecute(toolCallId, params, signal, onUpdate, context);
-		},
-	};
-}
+export type ToolName = keyof typeof BUILTIN_TOOLS;
 
 /**
- * Apply bash interception to a set of tools.
- * Finds the bash tool and wraps it with interception based on other available tools.
- *
- * @param tools - Array of tools to process
- * @returns Tools with bash interception applied
+ * Create tools from BUILTIN_TOOLS registry.
  */
-export function applyBashInterception(tools: Tool[]): Tool[] {
-	const toolNames = new Set(tools.map((t) => t.name));
-
-	// If bash isn't in the tools, nothing to do
-	if (!toolNames.has("bash")) {
-		return tools;
+export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
+	const requestedTools = toolNames && toolNames.length > 0 ? toolNames : undefined;
+	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const entries = requestedTools
+		? requestedTools
+				.filter((name, index) => requestedTools.indexOf(name) === index && name in allTools)
+				.map((name) => [name, allTools[name]] as const)
+		: Object.entries(BUILTIN_TOOLS);
+	const results = await Promise.all(entries.map(([, factory]) => factory(session)));
+	const tools = results.filter((t): t is Tool => t !== null);
+
+	if (requestedTools) {
+		const allowed = new Set(requestedTools);
+		return tools.filter((tool) => allowed.has(tool.name));
 	}
 
-	return tools.map((tool) => {
-		if (tool.name === "bash") {
-			return wrapBashWithInterception(tool, toolNames);
-		}
-		return tool;
-	});
+	return tools;
 }

package/src/core/tools/ls.ts

@@ -7,6 +7,7 @@ import { Type } from "@sinclair/typebox";
 import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
+import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatAge,
@@ -37,7 +38,7 @@ export interface LsToolDetails {
 	entryLimitReached?: number;
 }
 
-export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
+export function createLsTool(session: ToolSession): AgentTool<typeof lsSchema> {
 	return {
 		name: "ls",
 		label: "Ls",
@@ -49,7 +50,7 @@ export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
 			signal?: AbortSignal,
 		) => {
 			return untilAborted(signal, async () => {
-				const dirPath = resolveToCwd(path || ".", cwd);
+				const dirPath = resolveToCwd(path || ".", session.cwd);
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
 
 				// Check if path exists
@@ -159,9 +160,6 @@ export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
 	};
 }
 
-/** Default ls tool using process.cwd() - for backwards compatibility */
-export const lsTool = createLsTool(process.cwd());
-
 // =============================================================================
 // TUI Renderer
 // =============================================================================
@@ -271,10 +269,7 @@ export const lsToolRenderer = {
 		}
 
 		if (hasTruncation) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-				"warning",
-				`truncated: ${truncationReasons.join(", ")}`,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)}`;
 		}
 
 		return new Text(text, 0, 0);

package/src/core/tools/lsp/index.ts

@@ -7,6 +7,7 @@ import { type Theme, theme } from "../../../modes/interactive/theme/theme";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import { logger } from "../../logger";
 import { once, untilAborted } from "../../utils";
+import type { ToolSession } from "../index";
 import { resolveToCwd } from "../path-utils";
 import {
 	ensureFileOpen,
@@ -687,7 +688,7 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 }
 
 /** Create an LSP tool */
-export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
+export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
 	return {
 		name: "lsp",
 		label: "LSP",
@@ -713,7 +714,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 				include_declaration,
 			} = params;
 
-			const config = await getConfig(cwd);
+			const config = await getConfig(session.cwd);
 
 			// Status action doesn't need a file
 			if (action === "status") {
@@ -730,7 +731,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 
 			// Workspace diagnostics - check entire project
 			if (action === "workspace_diagnostics") {
-				const result = await runWorkspaceDiagnostics(cwd, config);
+				const result = await runWorkspaceDiagnostics(session.cwd, config);
 				return {
 					content: [
 						{
@@ -757,7 +758,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 				const allServerNames = new Set<string>();
 
 				for (const target of targets) {
-					const resolved = resolveToCwd(target, cwd);
+					const resolved = resolveToCwd(target, session.cwd);
 					const servers = getServersForFile(config, resolved);
 					if (servers.length === 0) {
 						results.push(`${theme.status.error} ${target}: No language server found`);
@@ -765,7 +766,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 					}
 
 					const uri = fileToUri(resolved);
-					const relPath = path.relative(cwd, resolved);
+					const relPath = path.relative(session.cwd, resolved);
 					const allDiagnostics: Diagnostic[] = [];
 
 					// Query all applicable servers for this file
@@ -773,12 +774,12 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						allServerNames.add(serverName);
 						try {
 							if (serverConfig.createClient) {
-								const linterClient = getLinterClient(serverName, serverConfig, cwd);
+								const linterClient = getLinterClient(serverName, serverConfig, session.cwd);
 								const diagnostics = await linterClient.lint(resolved);
 								allDiagnostics.push(...diagnostics);
 								continue;
 							}
-							const client = await getOrCreateClient(serverConfig, cwd);
+							const client = await getOrCreateClient(serverConfig, session.cwd);
 							await refreshFile(client, resolved);
 							const diagnostics = await waitForDiagnostics(client, uri);
 							allDiagnostics.push(...diagnostics);
@@ -847,7 +848,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 				};
 			}
 
-			const resolvedFile = file ? resolveToCwd(file, cwd) : null;
+			const resolvedFile = file ? resolveToCwd(file, session.cwd) : null;
 			const serverInfo = resolvedFile
 				? getLspServerForFile(config, resolvedFile)
 				: getServerForWorkspaceAction(config, action);
@@ -862,10 +863,10 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 			const [serverName, serverConfig] = serverInfo;
 
 			try {
-				const client = await getOrCreateClient(serverConfig, cwd);
+				const client = await getOrCreateClient(serverConfig, session.cwd);
 				let targetFile = resolvedFile;
 				if (action === "runnables" && !targetFile) {
-					targetFile = findFileForServer(cwd, serverConfig);
+					targetFile = findFileForServer(session.cwd, serverConfig);
 					if (!targetFile) {
 						return {
 							content: [{ type: "text", text: "Error: no matching files found for runnables" }],
@@ -914,7 +915,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 								output = "No definition found";
 							} else {
 								output = `Found ${locations.length} definition(s):\n${locations
-									.map((loc) => `  ${formatLocation(loc, cwd)}`)
+									.map((loc) => `  ${formatLocation(loc, session.cwd)}`)
 									.join("\n")}`;
 							}
 						}
@@ -931,7 +932,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						if (!result || result.length === 0) {
 							output = "No references found";
 						} else {
-							const lines = result.map((loc) => `  ${formatLocation(loc, cwd)}`);
+							const lines = result.map((loc) => `  ${formatLocation(loc, session.cwd)}`);
 							output = `Found ${result.length} reference(s):\n${lines.join("\n")}`;
 						}
 						break;
@@ -964,7 +965,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 								details: { action, serverName, success: false },
 							};
 						} else {
-							const relPath = path.relative(cwd, targetFile);
+							const relPath = path.relative(session.cwd, targetFile);
 							// Check if hierarchical (DocumentSymbol) or flat (SymbolInformation)
 							if ("selectionRange" in result[0]) {
 								// Hierarchical
@@ -998,10 +999,8 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						if (!result || result.length === 0) {
 							output = `No symbols matching "${query}"`;
 						} else {
-							const lines = result.map((s) => formatSymbolInformation(s, cwd));
-							output = `Found ${result.length} symbol(s) matching "${query}":\n${lines
-								.map((l) => `  ${l}`)
-								.join("\n")}`;
+							const lines = result.map((s) => formatSymbolInformation(s, session.cwd));
+							output = `Found ${result.length} symbol(s) matching "${query}":\n${lines.map((l) => `  ${l}`).join("\n")}`;
 						}
 						break;
 					}
@@ -1025,10 +1024,10 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						} else {
 							const shouldApply = apply !== false;
 							if (shouldApply) {
-								const applied = await applyWorkspaceEdit(result, cwd);
+								const applied = await applyWorkspaceEdit(result, session.cwd);
 								output = `Applied rename:\n${applied.map((a) => `  ${a}`).join("\n")}`;
 							} else {
-								const preview = formatWorkspaceEdit(result, cwd);
+								const preview = formatWorkspaceEdit(result, session.cwd);
 								output = `Rename preview:\n${preview.map((p) => `  ${p}`).join("\n")}`;
 							}
 						}
@@ -1114,7 +1113,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 							}
 
 							if (isCodeAction(resolvedAction) && resolvedAction.edit) {
-								const applied = await applyWorkspaceEdit(resolvedAction.edit, cwd);
+								const applied = await applyWorkspaceEdit(resolvedAction.edit, session.cwd);
 								output = `Applied "${codeAction.title}":\n${applied.map((a) => `  ${a}`).join("\n")}`;
 							} else {
 								const commandPayload = getCommandPayload(resolvedAction);
@@ -1136,9 +1135,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 								}
 								return `  [${i}] ${actionItem.title}`;
 							});
-							output = `Available code actions:\n${lines.join(
-								"\n",
-							)}\n\nUse action_index parameter to apply a specific action.`;
+							output = `Available code actions:\n${lines.join("\n")}\n\nUse action_index parameter to apply a specific action.`;
 						}
 						break;
 					}
@@ -1169,7 +1166,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 								const lines = calls.map((call) => {
 									const loc = { uri: call.from.uri, range: call.from.selectionRange };
 									const detail = call.from.detail ? ` (${call.from.detail})` : "";
-									return `  ${call.from.name}${detail} @ ${formatLocation(loc, cwd)}`;
+									return `  ${call.from.name}${detail} @ ${formatLocation(loc, session.cwd)}`;
 								});
 								output = `Found ${calls.length} caller(s) of "${item.name}":\n${lines.join("\n")}`;
 							}
@@ -1184,7 +1181,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 								const lines = calls.map((call) => {
 									const loc = { uri: call.to.uri, range: call.to.selectionRange };
 									const detail = call.to.detail ? ` (${call.to.detail})` : "";
-									return `  ${call.to.name}${detail} @ ${formatLocation(loc, cwd)}`;
+									return `  ${call.to.name}${detail} @ ${formatLocation(loc, session.cwd)}`;
 								});
 								output = `"${item.name}" calls ${calls.length} function(s):\n${lines.join("\n")}`;
 							}
@@ -1207,7 +1204,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						await rustAnalyzer.flycheck(client, resolvedFile ?? undefined);
 						const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
 						for (const [diagUri, diags] of client.diagnostics.entries()) {
-							const relPath = path.relative(cwd, uriToFile(diagUri));
+							const relPath = path.relative(session.cwd, uriToFile(diagUri));
 							for (const diag of diags) {
 								collected.push({ filePath: relPath, diagnostic: diag });
 							}
@@ -1274,13 +1271,13 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 						const result = await rustAnalyzer.ssr(client, query, replacement, !shouldApply);
 
 						if (shouldApply) {
-							const applied = await applyWorkspaceEdit(result, cwd);
+							const applied = await applyWorkspaceEdit(result, session.cwd);
 							output =
 								applied.length > 0
 									? `Applied SSR:\n${applied.map((a) => `  ${a}`).join("\n")}`
 									: "SSR: no matches found";
 						} else {
-							const preview = formatWorkspaceEdit(result, cwd);
+							const preview = formatWorkspaceEdit(result, session.cwd);
 							output =
 								preview.length > 0
 									? `SSR preview:\n${preview.map((p) => `  ${p}`).join("\n")}`
@@ -1366,4 +1363,10 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 	};
 }
 
-export const lspTool = createLspTool(process.cwd());
+export const lspTool = createLspTool({
+	cwd: process.cwd(),
+	hasUI: false,
+	rulebookRules: [],
+	getSessionFile: () => null,
+	getSessionSpawns: () => null,
+});