@nghyane/arcane 0.1.16 → 0.1.18

package/src/session/session-index.ts

@@ -0,0 +1,329 @@
+import { Database, type Statement } from "bun:sqlite";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger, parseJsonlLenient } from "@nghyane/arcane-utils";
+import { getAgentDir } from "@nghyane/arcane-utils/dirs";
+
+export interface SessionIndexEntry {
+	sessionId: string;
+	title: string;
+	firstMessage: string;
+	files: string;
+	cwd: string;
+	createdAt: number;
+	messageCount: number;
+}
+
+export interface SessionSearchResult {
+	threadId: string;
+	title: string;
+	date: string;
+	messageCount: number;
+	snippet: string;
+}
+
+interface SearchRow {
+	session_id: string;
+	title: string;
+	created_at: number;
+	message_count: number;
+	snippet: string;
+}
+
+const FILE_PATH_PARAMS = new Set(["path", "file", "filePath", "glob", "pattern", "command_working_directory"]);
+
+export class SessionIndex {
+	#db: Database;
+	static #instance?: SessionIndex;
+
+	#upsertStmt: Statement;
+	#hasStmt: Statement;
+
+	private constructor(dbPath: string) {
+		const dir = path.dirname(dbPath);
+		fs.mkdirSync(dir, { recursive: true });
+
+		this.#db = new Database(dbPath);
+
+		this.#db.exec(`
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+PRAGMA busy_timeout=5000;
+
+CREATE TABLE IF NOT EXISTS session_index (
+    session_id TEXT PRIMARY KEY,
+    title TEXT,
+    first_message TEXT,
+    files TEXT,
+    cwd TEXT,
+    created_at INTEGER,
+    message_count INTEGER
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS session_fts USING fts5(
+    title, first_message, files,
+    content='session_index', content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS session_index_ai AFTER INSERT ON session_index BEGIN
+    INSERT INTO session_fts(rowid, title, first_message, files)
+    VALUES (new.rowid, new.title, new.first_message, new.files);
+END;
+
+CREATE TRIGGER IF NOT EXISTS session_index_ad AFTER DELETE ON session_index BEGIN
+    INSERT INTO session_fts(session_fts, rowid, title, first_message, files)
+    VALUES ('delete', old.rowid, old.title, old.first_message, old.files);
+END;
+
+CREATE TRIGGER IF NOT EXISTS session_index_au AFTER UPDATE ON session_index BEGIN
+    INSERT INTO session_fts(session_fts, rowid, title, first_message, files)
+    VALUES ('delete', old.rowid, old.title, old.first_message, old.files);
+    INSERT INTO session_fts(rowid, title, first_message, files)
+    VALUES (new.rowid, new.title, new.first_message, new.files);
+END;
+`);
+
+		this.#upsertStmt = this.#db.prepare(
+			"INSERT OR REPLACE INTO session_index (session_id, title, first_message, files, cwd, created_at, message_count) VALUES (?, ?, ?, ?, ?, ?, ?)",
+		);
+		this.#hasStmt = this.#db.prepare("SELECT 1 FROM session_index WHERE session_id = ?");
+	}
+
+	static open(dbPath: string = path.join(getAgentDir(), "session-index.db")): SessionIndex {
+		if (!SessionIndex.#instance) {
+			SessionIndex.#instance = new SessionIndex(dbPath);
+		}
+		return SessionIndex.#instance;
+	}
+
+	upsert(entry: SessionIndexEntry): void {
+		try {
+			this.#upsertStmt.run(
+				entry.sessionId,
+				entry.title,
+				entry.firstMessage,
+				entry.files,
+				entry.cwd,
+				entry.createdAt,
+				entry.messageCount,
+			);
+		} catch (error) {
+			logger.error("SessionIndex upsert failed", { error: String(error) });
+		}
+	}
+
+	has(sessionId: string): boolean {
+		return this.#hasStmt.get(sessionId) != null;
+	}
+
+	search(query: string, limit: number): SessionSearchResult[] {
+		const safeLimit = Math.min(Math.max(1, Math.floor(limit)), 50);
+		const { ftsQuery, afterTs, beforeTs } = this.#parseQuery(query);
+		if (!ftsQuery) return [];
+
+		const conditions = ["session_fts MATCH ?"];
+		const params: (string | number)[] = [ftsQuery];
+
+		if (afterTs != null) {
+			conditions.push("si.created_at >= ?");
+			params.push(afterTs);
+		}
+		if (beforeTs != null) {
+			conditions.push("si.created_at <= ?");
+			params.push(beforeTs);
+		}
+		params.push(safeLimit);
+
+		const sql = `SELECT si.session_id, si.title, si.created_at, si.message_count,
+       snippet(session_fts, -1, '<match>', '</match>', '...', 32) as snippet
+FROM session_fts f
+JOIN session_index si ON si.rowid = f.rowid
+WHERE ${conditions.join(" AND ")}
+ORDER BY si.created_at DESC
+LIMIT ?`;
+
+		try {
+			const rows = this.#db.prepare(sql).all(...params) as SearchRow[];
+			return rows.map(row => ({
+				threadId: row.session_id,
+				title: row.title || "Untitled",
+				date: new Date(row.created_at * 1000).toISOString().slice(0, 10),
+				messageCount: row.message_count,
+				snippet: row.snippet || "",
+			}));
+		} catch (error) {
+			logger.error("SessionIndex search failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	async indexSessionFile(filePath: string): Promise<void> {
+		try {
+			const content = await Bun.file(filePath).text();
+			const entries = parseJsonlLenient<Record<string, unknown>>(content);
+			if (entries.length === 0) return;
+
+			const header = entries.find(e => e.type === "session") as
+				| { type: string; id?: string; title?: string; cwd?: string; timestamp?: string }
+				| undefined;
+			if (!header?.id) return;
+
+			let firstMessage = "";
+			let messageCount = 0;
+			const fileSet = new Set<string>();
+
+			for (const entry of entries) {
+				if (entry.type !== "message") continue;
+				const msg = entry.message as { role?: string; content?: unknown } | undefined;
+				if (!msg?.role) continue;
+
+				messageCount++;
+
+				if (msg.role === "user" && !firstMessage) {
+					firstMessage = extractTextContent(msg.content);
+				}
+
+				if (msg.role === "assistant") {
+					extractFilePaths(msg.content, fileSet);
+				}
+			}
+
+			const title = header.title || firstMessage.slice(0, 100) || "Untitled";
+			const createdAt = header.timestamp ? Math.floor(new Date(header.timestamp).getTime() / 1000) : 0;
+
+			this.upsert({
+				sessionId: header.id,
+				title,
+				firstMessage: firstMessage.slice(0, 500),
+				files: [...fileSet].join(" "),
+				cwd: header.cwd || "",
+				createdAt,
+				messageCount,
+			});
+		} catch (error) {
+			logger.warn("SessionIndex indexSessionFile failed", { path: filePath, error: String(error) });
+		}
+	}
+
+	async indexAllSessions(sessionsDir?: string): Promise<void> {
+		const dir = sessionsDir ?? path.join(getAgentDir(), "sessions");
+		let subdirs: string[];
+		try {
+			subdirs = fs.readdirSync(dir);
+		} catch {
+			return;
+		}
+
+		for (const subdir of subdirs) {
+			const subdirPath = path.join(dir, subdir);
+			let stat: fs.Stats;
+			try {
+				stat = fs.statSync(subdirPath);
+			} catch {
+				continue;
+			}
+			if (!stat.isDirectory()) continue;
+
+			let files: string[];
+			try {
+				files = fs.readdirSync(subdirPath).filter(f => f.endsWith(".jsonl"));
+			} catch {
+				continue;
+			}
+
+			for (const file of files) {
+				const filePath = path.join(subdirPath, file);
+				try {
+					const firstLine = await Bun.file(filePath).text();
+					const headerLine = firstLine.split("\n")[0];
+					if (!headerLine) continue;
+					const header = JSON.parse(headerLine) as { id?: string };
+					if (!header.id) continue;
+					if (this.has(header.id)) continue;
+					await this.indexSessionFile(filePath);
+				} catch {}
+			}
+		}
+	}
+
+	#parseQuery(query: string): { ftsQuery: string | null; afterTs: number | null; beforeTs: number | null } {
+		let afterTs: number | null = null;
+		let beforeTs: number | null = null;
+
+		const remaining = query.replace(/\b(after|before):(\S+)/g, (_, dir: string, val: string) => {
+			const ts = this.#parseDate(val);
+			if (ts != null) {
+				if (dir === "after") afterTs = ts;
+				else beforeTs = ts;
+			}
+			return "";
+		});
+
+		const ftsQuery = this.#buildFtsQuery(remaining);
+		return { ftsQuery, afterTs, beforeTs };
+	}
+
+	#parseDate(value: string): number | null {
+		const relMatch = value.match(/^(\d+)([dwm])$/);
+		if (relMatch) {
+			const n = Number.parseInt(relMatch[1], 10);
+			const unit = relMatch[2];
+			const now = Date.now();
+			let ms = 0;
+			if (unit === "d") ms = n * 86400_000;
+			else if (unit === "w") ms = n * 7 * 86400_000;
+			else if (unit === "m") ms = n * 30 * 86400_000;
+			return Math.floor((now - ms) / 1000);
+		}
+
+		const d = new Date(value);
+		if (!Number.isNaN(d.getTime())) {
+			return Math.floor(d.getTime() / 1000);
+		}
+		return null;
+	}
+
+	#buildFtsQuery(query: string): string | null {
+		const tokens = query
+			.trim()
+			.split(/\s+/)
+			.map(t => t.trim())
+			.filter(Boolean);
+
+		if (tokens.length === 0) return null;
+
+		return tokens
+			.map(token => {
+				const escaped = token.replace(/"/g, '""');
+				return `"${escaped}"*`;
+			})
+			.join(" ");
+	}
+}
+
+function extractTextContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		for (const block of content) {
+			if (block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block) {
+				return String(block.text);
+			}
+		}
+	}
+	return "";
+}
+
+function extractFilePaths(content: unknown, fileSet: Set<string>): void {
+	if (!Array.isArray(content)) return;
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		if (!("type" in block) || block.type !== "toolCall") continue;
+		const args = "arguments" in block ? (block.arguments as Record<string, unknown>) : null;
+		if (!args) continue;
+		for (const [key, val] of Object.entries(args)) {
+			if (FILE_PATH_PARAMS.has(key) && typeof val === "string" && val.length > 0) {
+				fileSet.add(val);
+			}
+		}
+	}
+}

package/src/session/session-manager.ts

@@ -1581,36 +1581,6 @@ export class SessionManager {
 		await this.#rewriteFile();
 	}
 
-	/**
-	 * Rewrite tool call arguments in the most recent assistant message containing the toolCallId.
-	 * Returns true if a tool call was updated.
-	 */
-	async rewriteAssistantToolCallArgs(toolCallId: string, args: Record<string, unknown>): Promise<boolean> {
-		let updated = false;
-		for (let i = this.#fileEntries.length - 1; i >= 0; i--) {
-			const entry = this.#fileEntries[i];
-			if (entry.type !== "message" || entry.message.role !== "assistant") continue;
-			const message = entry.message as { content?: unknown };
-			if (!Array.isArray(message.content)) continue;
-			for (const block of message.content) {
-				if (typeof block !== "object" || block === null) continue;
-				if (!("type" in block) || (block as { type?: string }).type !== "toolCall") continue;
-				const toolCall = block as { id?: string; arguments?: Record<string, unknown> };
-				if (toolCall.id === toolCallId) {
-					toolCall.arguments = args;
-					updated = true;
-					break;
-				}
-			}
-			if (updated) break;
-		}
-
-		if (updated && this.persist && this.#sessionFile) {
-			await this.#rewriteFile();
-		}
-		return updated;
-	}
-
 	/**
 	 * Append a custom message entry (for extensions) that participates in LLM context.
 	 * @param customType Hook identifier for filtering on reload

package/src/session/streaming-edit.ts

@@ -1,13 +1,12 @@
 import * as fs from "node:fs";
 
 import type { Agent, AgentEvent } from "@nghyane/arcane-agent";
-import type { AssistantMessage, ToolCall } from "@nghyane/arcane-ai";
+import type { ToolCall } from "@nghyane/arcane-ai";
 import { isEnoent, logger } from "@nghyane/arcane-utils";
 import type { Settings } from "../config/settings";
 import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../patch";
 import type { SecretObfuscator } from "../secrets/obfuscator";
 import { resolveToCwd } from "../tools/path-utils";
-import type { SessionManager } from "./session-manager";
 
 /**
  * Mutable state for streaming edit abort detection.
@@ -222,37 +221,3 @@ async function checkPreviewPatchAsync(
 		agent.abort();
 	}
 }
-
-/**
- * Rewrite tool call arguments in agent state and persisted session history.
- */
-export async function rewriteToolCallArgs(
-	agent: Agent,
-	sessionManager: SessionManager,
-	toolCallId: string,
-	args: Record<string, unknown>,
-): Promise<void> {
-	let updated = false;
-	const messages = agent.state.messages;
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (msg.role !== "assistant") continue;
-		const assistantMsg = msg as AssistantMessage;
-		if (!Array.isArray(assistantMsg.content)) continue;
-		for (const block of assistantMsg.content) {
-			if (typeof block !== "object" || block === null) continue;
-			if (!("type" in block) || (block as { type?: string }).type !== "toolCall") continue;
-			const toolCall = block as { id?: string; arguments?: Record<string, unknown> };
-			if (toolCall.id === toolCallId) {
-				toolCall.arguments = args;
-				updated = true;
-				break;
-			}
-		}
-		if (updated) break;
-	}
-
-	if (updated) {
-		await sessionManager.rewriteAssistantToolCallArgs(toolCallId, args);
-	}
-}

package/src/slash-commands/builtin-registry.ts

@@ -349,22 +349,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
-	{
-		name: "memory",
-		description: "Inspect and operate memory maintenance",
-		subcommands: [
-			{ name: "view", description: "Show current memory injection payload" },
-			{ name: "clear", description: "Clear persisted memory data and artifacts" },
-			{ name: "reset", description: "Alias for clear" },
-			{ name: "enqueue", description: "Enqueue memory consolidation maintenance" },
-			{ name: "rebuild", description: "Alias for enqueue" },
-		],
-		allowArgs: true,
-		handle: async (command, runtime) => {
-			runtime.ctx.editor.setText("");
-			await runtime.ctx.handleMemoryCommand(command.text);
-		},
-	},
 	{
 		name: "move",
 		description: "Move session to a different working directory",

package/src/task/index.ts

@@ -189,7 +189,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				modelRegistry: this.session.subagentContext?.modelRegistry,
 				settings: this.session.settings,
 				mcpManager: this.session.subagentContext?.mcpManager,
-				contextFiles: this.session.contextFiles,
+				contextFiles: this.session.contextFiles?.filter(f => !f.path.endsWith("AGENTS.md")),
 				skills: this.session.skills,
 				promptTemplates: this.session.promptTemplates,
 			});

package/src/tools/ask.ts

@@ -111,14 +111,15 @@ interface UIContext {
 	select(
 		prompt: string,
 		options: string[],
-		options_?: { initialIndex?: number; timeout?: number; outline?: boolean },
+		options_?: { initialIndex?: number; timeout?: number; outline?: boolean; signal?: AbortSignal },
 	): Promise<string | undefined>;
-	input(prompt: string): Promise<string | undefined>;
+	input(prompt: string, placeholder?: string, options_?: { signal?: AbortSignal }): Promise<string | undefined>;
 }
 
 interface AskQuestionOptions {
 	/** Timeout in milliseconds, null/undefined to disable */
 	timeout?: number | null;
+	signal?: AbortSignal;
 }
 
 async function askSingleQuestion(
@@ -158,6 +159,7 @@ async function askSingleQuestion(
 				initialIndex: cursorIndex,
 				timeout: timeout ?? undefined,
 				outline: true,
+				signal: options?.signal,
 			});
 			const elapsed = Date.now() - selectionStart;
 			const timedOut = timeout != null && elapsed >= timeout;
@@ -166,7 +168,7 @@ async function askSingleQuestion(
 
 			if (choice === OTHER_OPTION) {
 				if (!timedOut) {
-					const input = await ui.input("Enter your response:");
+					const input = await ui.input("Enter your response:", undefined, { signal: options?.signal });
 					if (input) customInput = input;
 				}
 				break;
@@ -205,9 +207,10 @@ async function askSingleQuestion(
 			timeout: timeout ?? undefined,
 			initialIndex: recommended,
 			outline: true,
+			signal: options?.signal,
 		});
 		if (choice === OTHER_OPTION) {
-			const input = await ui.input("Enter your response:");
+			const input = await ui.input("Enter your response:", undefined, { signal: options?.signal });
 			if (input) customInput = input;
 		} else if (choice) {
 			selectedOptions = [stripRecommendedSuffix(choice)];
@@ -300,7 +303,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails, Them
 				optionLabels,
 				q.multi ?? false,
 				q.recommended,
-				{ timeout },
+				{ timeout, signal: _signal },
 			);
 
 			const details: AskToolDetails = {
@@ -335,7 +338,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails, Them
 				optionLabels,
 				q.multi ?? false,
 				q.recommended,
-				{ timeout },
+				{ timeout, signal: _signal },
 			);
 
 			results.push({

package/src/tools/bash-skill-urls.ts

@@ -9,9 +9,9 @@ const SKILL_URL_PATTERN = /'skill:\/\/[^'\s")`\\]+'|"skill:\/\/[^"\s')`\\]+"|ski
 
 /** Regex to find supported internal URL tokens in command text. */
 const INTERNAL_URL_PATTERN =
-	/'(?:skill|agent|artifact|plan|memory|rule):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|memory|rule):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|memory|rule):\/\/[^\s'")`\\]+/g;
+	/'(?:skill|agent|artifact|plan|rule):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|rule):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|rule):\/\/[^\s'")`\\]+/g;
 
-const SUPPORTED_INTERNAL_SCHEMES = ["skill", "agent", "artifact", "plan", "memory", "rule"] as const;
+const SUPPORTED_INTERNAL_SCHEMES = ["skill", "agent", "artifact", "plan", "rule"] as const;
 
 type SupportedInternalScheme = (typeof SUPPORTED_INTERNAL_SCHEMES)[number];
 
@@ -152,7 +152,7 @@ export function expandSkillUrls(command: string, skills: readonly Skill[]): stri
 
 /**
  * Expand supported internal URLs in a bash command string to shell-escaped absolute paths.
- * Supported schemes: skill://, agent://, artifact://, plan://, memory://, rule://
+ * Supported schemes: skill://, agent://, artifact://, plan://, rule://
  */
 export async function expandInternalUrls(command: string, options: InternalUrlExpansionOptions): Promise<string> {
 	if (!command.includes("://")) return command;

package/src/tools/bash.ts

@@ -55,7 +55,8 @@ function isInteractiveResult(result: BashResult | BashInteractiveResult): result
 export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails, Theme> {
 	readonly name = "bash";
 	readonly label = "Bash";
-	description = "Execute a shell command";
+	description =
+		"Execute a shell command. Use grep/find instead of shell grep/find, read instead of cat/head/tail, edit instead of sed/awk, write instead of echo/printf redirects.";
 	readonly parameters = bashSchema;
 	readonly concurrency = "exclusive";
 

package/src/tools/create-tools.ts

@@ -1,7 +1,5 @@
 import type { AgentTool } from "@nghyane/arcane-agent";
-import { $env, logger } from "@nghyane/arcane-utils";
-import { getPreludeDocs, warmPythonEnvironment } from "../ipy/executor";
-import { checkPythonKernelAvailability } from "../ipy/kernel";
+import { $env } from "@nghyane/arcane-utils";
 import { LspTool } from "../lsp";
 import { EditTool } from "../patch";
 import { TaskTool } from "../task";
@@ -13,6 +11,7 @@ import { BrowserTool } from "./browser";
 import { exploreConfig } from "./explore";
 import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
+import { FindThreadTool } from "./find-thread";
 import { GitHubTool } from "./github";
 import { GrepTool } from "./grep";
 import type { ToolSession } from "./index";
@@ -22,7 +21,10 @@ import { oracleConfig } from "./oracle";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
+import { ReadThreadTool } from "./read-thread";
+import { RenderMermaidTool } from "./render-mermaid";
 import { reviewerConfig } from "./reviewer-tool";
+import { SaveMemoryTool } from "./save-memory";
 import { SearchCodeTool } from "./search-code";
 import { loadSshTool } from "./ssh";
 import { SubagentTool } from "./subagent-tool";
@@ -38,6 +40,8 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	python: s => new PythonTool(s),
 	ssh: loadSshTool,
 	edit: s => new EditTool(s),
+	find_thread: s => new FindThreadTool(s),
+	read_thread: s => new ReadThreadTool(s),
 	find: s => new FindTool(s),
 	explore: s => new SubagentTool(s, exploreConfig),
 	github: s => new GitHubTool(s),
@@ -47,6 +51,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	notebook: s => new NotebookTool(s),
 	oracle: s => new SubagentTool(s, oracleConfig),
 	read: s => new ReadTool(s),
+	render_mermaid: s => new RenderMermaidTool(s),
 	browser: s => new BrowserTool(s),
 	task: TaskTool.create,
 	code_review: s => new SubagentTool(s, reviewerConfig),
@@ -55,6 +60,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	fetch: s => new FetchTool(s),
 	web_search: () => new SearchTool(),
 	search_code: () => new SearchCodeTool(),
+	save_memory: s => new SaveMemoryTool(s),
 	write: s => new WriteTool(s),
 };
 
@@ -98,37 +104,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
 	const pythonMode = getPythonModeFromEnv() ?? session.settings.get("python.toolMode");
-	const skipPythonPreflight = session.skipPythonPreflight === true;
-	let pythonAvailable = true;
-	const shouldCheckPython =
-		!skipPythonPreflight &&
-		pythonMode !== "bash-only" &&
-		(requestedTools === undefined || requestedTools.includes("python"));
-	const isTestEnv = Bun.env.BUN_ENV === "test" || Bun.env.NODE_ENV === "test";
-	const skipPythonWarm = isTestEnv || $env.ARCANE_PYTHON_SKIP_CHECK === "1";
-	if (shouldCheckPython) {
-		const availability = await checkPythonKernelAvailability(session.cwd);
-		time("createTools:pythonCheck");
-		pythonAvailable = availability.ok;
-		if (!availability.ok) {
-			logger.warn("Python kernel unavailable, falling back to bash", {
-				reason: availability.reason,
-			});
-		} else if (!skipPythonWarm && getPreludeDocs().length === 0) {
-			const sessionFile = session.getSessionFile?.() ?? undefined;
-			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
-			try {
-				await warmPythonEnvironment(session.cwd, warmSessionId, session.settings.get("python.sharedGateway"));
-				time("createTools:warmPython");
-			} catch (err) {
-				logger.warn("Failed to warm Python environment", {
-					error: err instanceof Error ? err.message : String(err),
-				});
-			}
-		}
-	}
 
-	const effectiveMode = pythonAvailable ? pythonMode : "bash-only";
+	const effectiveMode = pythonMode;
 	const allowBash = effectiveMode !== "ipy-only";
 	const allowPython = effectiveMode !== "bash-only";
 	if (
@@ -153,6 +130,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		if (name === "lsp") return session.settings.get("lsp.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
+		if (name === "render_mermaid") return session.settings.get("renderMermaid.enabled");
 		if (name === "librarian") return session.settings.get("librarian.enabled");
 		if (name === "oracle") return session.settings.get("oracle.enabled");
 		if (name === "github") return session.settings.get("github.enabled");
@@ -182,5 +160,22 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	);
 	const tools = results.filter((r): r is AgentTool => r !== null);
 
+	// Auto-include AST tools when their text-based counterparts are enabled
+	const toolNameSet = new Set(tools.map(t => t.name));
+	if (session.settings.get("astGrep.enabled") && toolNameSet.has("grep") && !toolNameSet.has("ast_grep")) {
+		const astGrepFactory = allTools.ast_grep;
+		if (astGrepFactory) {
+			const astGrepTool = await astGrepFactory(session);
+			if (astGrepTool) tools.push(wrapToolWithMetaNotice(astGrepTool));
+		}
+	}
+	if (session.settings.get("astEdit.enabled") && toolNameSet.has("edit") && !toolNameSet.has("ast_edit")) {
+		const astEditFactory = allTools.ast_edit;
+		if (astEditFactory) {
+			const astEditTool = await astEditFactory(session);
+			if (astEditTool) tools.push(wrapToolWithMetaNotice(astEditTool));
+		}
+	}
+
 	return tools;
 }

package/src/tools/fetch.ts

@@ -850,7 +850,7 @@ export interface FetchToolDetails {
 export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails, Theme> {
 	readonly name = "fetch";
 	readonly label = "Fetch";
-	description = "Fetch a URL and return its content";
+	description = "Fetch a URL and return its content. Do NOT use for localhost or local URLs; use bash curl instead.";
 	readonly parameters = fetchSchema;
 
 	constructor(private readonly session: ToolSession) {}