@nghyane/arcane 0.1.15 → 0.1.17

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/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/create-tools.ts

@@ -13,6 +13,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 +23,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 +42,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 +53,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 +62,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),
 };
 
@@ -153,6 +161,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 +191,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/find-thread.ts

@@ -0,0 +1,120 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@nghyane/arcane-agent";
+import type { Component } from "@nghyane/arcane-tui";
+import { Text } from "@nghyane/arcane-tui";
+import { logger } from "@nghyane/arcane-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { SessionIndex, type SessionSearchResult } from "../session/session-index";
+import type { Theme } from "../theme/theme";
+import { renderStatusLine, renderTreeList } from "../tui";
+import { PREVIEW_LIMITS } from "../ui/render-utils";
+import type { ToolSession } from ".";
+
+const findThreadSchema = Type.Object({
+	query: Type.String({
+		description:
+			"Keywords to search past sessions. Supports bare words, quoted phrases, after:7d, before:2026-01-01 date filters.",
+	}),
+	limit: Type.Optional(Type.Number({ description: "Max results (default: 10)" })),
+});
+
+type FindThreadParams = Static<typeof findThreadSchema>;
+
+export interface FindThreadToolDetails {
+	results: SessionSearchResult[];
+	query: string;
+	indexed: boolean;
+}
+
+interface FindThreadRenderArgs {
+	query?: string;
+	limit?: number;
+}
+
+export class FindThreadTool implements AgentTool<typeof findThreadSchema, FindThreadToolDetails, Theme> {
+	readonly name = "find_thread";
+	readonly label = "Find Thread";
+	description = [
+		"Find past conversation threads by keyword search. Returns thread IDs, titles, dates, and matching snippets.",
+		"Use read_thread to get full content from a specific thread.",
+		"",
+		'Query syntax: bare keywords, "quoted phrases", after:7d, before:2026-01-01 date filters.',
+		"",
+		"When to use:",
+		"- User references past work or previous sessions",
+		"- Need context from earlier conversations",
+		"- Task may overlap with prior work",
+		"",
+		"When NOT to use: git history/blame, current session context, generic questions.",
+	].join("\n");
+	readonly parameters = findThreadSchema;
+	readonly concurrency = "shared" as const;
+
+	constructor(readonly _session: ToolSession) {}
+
+	async execute(
+		_toolCallId: string,
+		params: FindThreadParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<FindThreadToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<FindThreadToolDetails>> {
+		const index = SessionIndex.open();
+
+		try {
+			await index.indexAllSessions();
+		} catch (error) {
+			logger.warn("FindThread: indexing failed", { error: String(error) });
+		}
+
+		const limit = Math.min(Math.max(1, params.limit ?? 10), 50);
+		const results = index.search(params.query, limit);
+
+		const text =
+			results.length > 0 ? JSON.stringify(results, null, 2) : `No threads found matching "${params.query}".`;
+
+		return {
+			content: [{ type: "text", text }],
+			details: { results, query: params.query, indexed: true },
+		};
+	}
+
+	renderCall(args: FindThreadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const meta = args.query ? [`"${args.query}"`] : [];
+		const text = renderStatusLine({ icon: "pending", title: "Find Thread", meta }, uiTheme);
+		return new Text(text, 0, 0);
+	}
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: FindThreadToolDetails },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		_args?: FindThreadRenderArgs,
+	): Component {
+		const results = result.details?.results ?? [];
+		const header = renderStatusLine(
+			{ icon: "success", title: "Find Thread", meta: [`${results.length} results`] },
+			uiTheme,
+		);
+
+		if (results.length === 0) {
+			const fallback = result.content?.find(c => c.type === "text")?.text ?? "No results";
+			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
+		}
+
+		const { expanded } = options;
+		const treeLines = renderTreeList(
+			{
+				items: results,
+				expanded,
+				maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+				itemType: "thread",
+				renderItem: r =>
+					`${uiTheme.fg("accent", r.title)} ${uiTheme.fg("dim", r.date)} ${uiTheme.fg("dim", `(${r.messageCount} msgs)`)}`,
+			},
+			uiTheme,
+		);
+		const text = [header, ...treeLines].join("\n");
+		return new Text(text, 0, 0);
+	}
+}

package/src/tools/index.ts

@@ -26,6 +26,7 @@ export {
 	warmupLspServers,
 } from "../lsp";
 export { EditTool, type EditToolDetails } from "../patch";
+export { SessionIndex, type SessionIndexEntry, type SessionSearchResult } from "../session/session-index";
 export {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
@@ -70,6 +71,7 @@ export {
 	type FindToolInput,
 	type FindToolOptions,
 } from "./find";
+export { FindThreadTool, type FindThreadToolDetails } from "./find-thread";
 export { setPreferredImageProvider } from "./gemini-image";
 export { GitHubTool, type GitHubToolDetails } from "./github";
 export { GrepTool, type GrepToolDetails, type GrepToolInput } from "./grep";
@@ -82,7 +84,10 @@ export {
 	type PythonToolOptions,
 } from "./python";
 export { ReadTool, type ReadToolDetails, type ReadToolInput } from "./read";
+export { ReadThreadTool, type ReadThreadToolDetails } from "./read-thread";
+export { RenderMermaidTool, type RenderMermaidToolDetails } from "./render-mermaid";
 export { reviewerConfig } from "./reviewer-tool";
+export { SaveMemoryTool, type SaveMemoryToolDetails } from "./save-memory";
 export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
 export { type SubagentConfig, SubagentTool } from "./subagent-tool";
 export {