@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

package/src/tools/find.ts

@@ -16,6 +16,7 @@ import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	expandDelimitedPathEntries,
 	formatPathRelativeToCwd,
 	hasGlobPathChars,
 	normalizePathLikeInput,
@@ -52,33 +53,6 @@ const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
 
-/**
- * Reject comma-separated path lists packed into a single array element
- * (`["a.py,b.py"]`). The schema is array-of-string; agents that pass a
- * single comma-joined element get silent no-matches otherwise.
- *
- * Commas inside brace expansion (`{a,b}`) are legitimate glob syntax and
- * must pass through.
- */
-export function validateFindPathInputs(paths: readonly string[]): void {
-	for (const entry of paths) {
-		let braceDepth = 0;
-		for (let i = 0; i < entry.length; i++) {
-			const ch = entry.charCodeAt(i);
-			if (ch === 0x5c /* \ */ && i + 1 < entry.length) {
-				i++;
-				continue;
-			}
-			if (ch === 0x7b /* { */) braceDepth++;
-			else if (ch === 0x7d /* } */) {
-				if (braceDepth > 0) braceDepth--;
-			} else if (ch === 0x2c /* , */ && braceDepth === 0) {
-				throw new ToolError(`paths is an array — pass ["a", "b"] not ["a,b"] (got ${JSON.stringify(entry)})`);
-			}
-		}
-	}
-}
-
 /**
  * Group find matches by their directory so the model doesn't pay repeated
  * tokens for shared path prefixes. Preserves the input order: groups appear in
@@ -180,8 +154,10 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			validateFindPathInputs(paths);
-			const rawPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const rawPatternInputs = this.#customOps
+				? paths
+				: await expandDelimitedPathEntries(paths, this.session.cwd, { splitter: parseFindPattern });
+			const rawPatterns = rawPatternInputs.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
 			for (const rawPattern of rawPatterns) {

package/src/tools/index.ts

@@ -1,7 +1,7 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
-import { $env, $flag, logger } from "@oh-my-pi/pi-utils";
+import { logger } from "@oh-my-pi/pi-utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
@@ -34,6 +34,7 @@ import { BrowserTool } from "./browser";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
+import { resolveEvalBackends } from "./eval-backends";
 import { FindTool } from "./find";
 import { GithubTool } from "./gh";
 import { InspectImageTool } from "./inspect-image";
@@ -74,6 +75,7 @@ export * from "./browser";
 export * from "./checkpoint";
 export * from "./debug";
 export * from "./eval";
+export * from "./eval-backends";
 export * from "./find";
 export * from "./gh";
 export * from "./image-gen";
@@ -157,7 +159,7 @@ export interface ToolSession {
 	getHindsightSessionState?: () => HindsightSessionState | undefined;
 	/** Get Mnemopi runtime state for this agent session. */
 	getMnemopiSessionState?: () => MnemopiSessionState | undefined;
-	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
+	/** Agent identity used for IRC routing. Returns the registry id (e.g. "Main", "AuthLoader"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
 	getToolByName?: (name: string) => AgentTool | undefined;
@@ -257,6 +259,10 @@ export interface ToolSession {
 	 *  by `getConflictHistory`. */
 	conflictHistory?: import("./conflict-detect").ConflictHistory;
 
+	/** Per-session ledger of post-edit LSP diagnostics already surfaced to the
+	 *  model for each file. Lazily initialized by `getDiagnosticsLedger`. */
+	diagnosticsLedger?: import("../lsp/diagnostics-ledger").DiagnosticsLedger;
+
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
 	/** Get the active OpenTelemetry config so subagent dispatch can forward
@@ -331,42 +337,6 @@ export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 
 export type ToolName = keyof typeof BUILTIN_TOOLS;
 
-export interface EvalBackendsAllowance {
-	python: boolean;
-	js: boolean;
-}
-
-/**
- * Parse PI_PY / PI_JS environment variables. Each is a boolean flag; unset
- * means "not specified, defer to settings". Returns null when neither is set
- * so the caller can fall through to `readEvalBackendsAllowance` per key.
- */
-function getEvalBackendsFromEnv(): EvalBackendsAllowance | null {
-	const pyEnv = $env.PI_PY;
-	const jsEnv = $env.PI_JS;
-	if (pyEnv === undefined && jsEnv === undefined) return null;
-	return {
-		python: pyEnv === undefined ? true : $flag("PI_PY"),
-		js: jsEnv === undefined ? true : $flag("PI_JS"),
-	};
-}
-
-/** Read per-backend allowance from settings (defaults true). */
-export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance {
-	return {
-		python: session.settings.get("eval.py") ?? true,
-		js: session.settings.get("eval.js") ?? true,
-	};
-}
-
-/**
- * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
- * override the per-key settings; otherwise settings (defaults true) win.
- */
-export function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance {
-	return getEvalBackendsFromEnv() ?? readEvalBackendsAllowance(session);
-}
-
 /**
  * Create tools from BUILTIN_TOOLS registry.
  */

package/src/tools/path-utils.ts

@@ -379,6 +379,145 @@ export function hasGlobPathChars(filePath: string): boolean {
 	return GLOB_PATH_CHARS.some(char => filePath.includes(char));
 }
 
+type PathEntrySplitter = (item: string) => { basePath: string };
+
+const TOP_LEVEL_WHITESPACE_RE = /\s/;
+
+type DelimitedPathSplitMode = "comma" | "semicolon" | "whitespace" | "mixed";
+
+function isDelimitedPathSeparator(ch: string, mode: DelimitedPathSplitMode): boolean {
+	if (mode === "comma") return ch === ",";
+	if (mode === "semicolon") return ch === ";";
+	if (mode === "whitespace") return TOP_LEVEL_WHITESPACE_RE.test(ch);
+	return ch === "," || ch === ";" || TOP_LEVEL_WHITESPACE_RE.test(ch);
+}
+
+function hasTopLevelPathDelimiter(entry: string): boolean {
+	let braceDepth = 0;
+	for (let i = 0; i < entry.length; i++) {
+		const ch = entry[i];
+		if (ch === "\\" && i + 1 < entry.length) {
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth++;
+			continue;
+		}
+		if (ch === "}") {
+			if (braceDepth > 0) braceDepth--;
+			continue;
+		}
+		if (braceDepth === 0 && (ch === "," || ch === ";" || TOP_LEVEL_WHITESPACE_RE.test(ch))) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function splitTopLevelDelimitedPath(entry: string, mode: DelimitedPathSplitMode): string[] {
+	const parts: string[] = [];
+	let braceDepth = 0;
+	let start = 0;
+	for (let i = 0; i < entry.length; i++) {
+		const ch = entry[i];
+		if (ch === "\\" && i + 1 < entry.length) {
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth++;
+			continue;
+		}
+		if (ch === "}") {
+			if (braceDepth > 0) braceDepth--;
+			continue;
+		}
+		if (braceDepth !== 0 || !isDelimitedPathSeparator(ch, mode)) continue;
+		parts.push(entry.slice(start, i));
+		start = i + 1;
+	}
+	parts.push(entry.slice(start));
+	return parts;
+}
+
+async function delimitedPathPartResolves(entry: string, cwd: string, splitter: PathEntrySplitter): Promise<boolean> {
+	if (isInternalUrlPath(entry)) return true;
+	const peeled = splitPathAndSel(entry).path;
+	const { basePath } = splitter(peeled);
+	const absoluteBasePath = resolveToCwd(basePath, cwd);
+	try {
+		await fs.promises.stat(absoluteBasePath);
+		return true;
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+async function tryDelimitedPathSplit(
+	entry: string,
+	cwd: string,
+	splitter: PathEntrySplitter,
+	mode: DelimitedPathSplitMode,
+	requireAllParts: boolean,
+): Promise<string[] | null> {
+	const rawParts = splitTopLevelDelimitedPath(entry, mode);
+	if (rawParts.length < 2) return null;
+
+	const parts = rawParts.map(normalizePathLikeInput).filter(part => part.length > 0);
+	if (parts.length === 0) return null;
+	if (parts.length < 2 && rawParts.length === parts.length) return null;
+
+	const resolved = await Promise.all(parts.map(part => delimitedPathPartResolves(part, cwd, splitter)));
+	const valid = requireAllParts ? resolved.every(Boolean) : resolved.some(Boolean);
+	return valid ? parts : null;
+}
+
+/**
+ * Split one path-like entry whose multiple targets were flattened into one
+ * string. Existing paths are kept intact, so real filenames containing spaces,
+ * commas, or semicolons win over delimiter recovery.
+ */
+export async function splitDelimitedPathEntry(
+	entry: string,
+	cwd: string,
+	options: { splitter?: PathEntrySplitter } = {},
+): Promise<string[] | null> {
+	const normalizedEntry = normalizePathLikeInput(entry);
+	if (!hasTopLevelPathDelimiter(normalizedEntry)) return null;
+	if (isInternalUrlPath(normalizedEntry)) return null;
+
+	const splitter = options.splitter ?? parseSearchPath;
+	const peeledEntry = splitPathAndSel(normalizedEntry).path;
+	if (!hasGlobPathChars(peeledEntry) && (await delimitedPathPartResolves(normalizedEntry, cwd, splitter))) {
+		return null;
+	}
+
+	return (
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "comma", false)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "semicolon", false)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "whitespace", true)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "mixed", true))
+	);
+}
+
+/** Expand delimited entries in-place while preserving unsplit entries. */
+export async function expandDelimitedPathEntries(
+	entries: readonly string[],
+	cwd: string,
+	options: { splitter?: PathEntrySplitter } = {},
+): Promise<string[]> {
+	const expanded: string[] = [];
+	for (const entry of entries) {
+		const normalizedEntry = normalizePathLikeInput(entry);
+		const split = await splitDelimitedPathEntry(normalizedEntry, cwd, options);
+		if (split) expanded.push(...split);
+		else expanded.push(normalizedEntry);
+	}
+	return expanded;
+}
+
 export interface ParsedSearchPath {
 	basePath: string;
 	glob?: string;
@@ -769,7 +908,11 @@ export interface ToolScopeResolution {
  */
 export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<ToolScopeResolution> {
 	const { rawPaths: inputs, cwd, internalUrlAction } = opts;
-	const rawPaths = inputs.map(normalizePathLikeInput);
+	const normalizedRawPaths = inputs.map(normalizePathLikeInput);
+	if (normalizedRawPaths.some(rawPath => rawPath.length === 0)) {
+		throw new ToolError("`paths` must contain non-empty paths or globs");
+	}
+	const rawPaths = await expandDelimitedPathEntries(normalizedRawPaths, cwd);
 	if (rawPaths.some(rawPath => rawPath.length === 0)) {
 		throw new ToolError("`paths` must contain non-empty paths or globs");
 	}

package/src/tools/read.ts

@@ -69,6 +69,7 @@ import {
 	type LineRange,
 	parseLineRanges,
 	resolveReadPath,
+	splitDelimitedPathEntry,
 	splitInternalUrlSel,
 	splitPathAndSel,
 } from "./path-utils";
@@ -693,6 +694,50 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		});
 	}
 
+	async #tryReadDelimitedPaths(
+		readPath: string,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<ReadToolDetails> | null> {
+		const parts = await splitDelimitedPathEntry(readPath, this.session.cwd);
+		if (!parts) return null;
+
+		const notice = `Note: interpreted as ${parts.length} paths: ${parts.join(", ")}`;
+		const notes = [notice];
+		const content: Array<TextContent | ImageContent> = [];
+		let pendingText = notice;
+		const flushText = () => {
+			if (pendingText.length === 0) return;
+			content.push({ type: "text", text: pendingText });
+			pendingText = "";
+		};
+		const appendText = (text: string) => {
+			pendingText = pendingText.length > 0 ? `${pendingText}\n\n${text}` : text;
+		};
+
+		for (const part of parts) {
+			try {
+				const result = await this.execute("read-delimited-part", { path: part }, signal);
+				for (const block of result.content) {
+					if (block.type === "text") {
+						appendText(block.text);
+						continue;
+					}
+					flushText();
+					content.push(block);
+				}
+			} catch (error) {
+				if (error instanceof ToolAbortError || signal?.aborted) throw error;
+				const message = error instanceof Error ? error.message : String(error);
+				const errorNote = `Could not read ${part}: ${message}`;
+				notes.push(errorNote);
+				appendText(`[${errorNote}]`);
+			}
+		}
+		flushText();
+
+		return toolResult<ReadToolDetails>({ notes }).content(content).done();
+	}
+
 	async #resolveArchiveReadPath(readPath: string, signal?: AbortSignal): Promise<ResolvedArchiveReadPath | null> {
 		const candidates = parseArchivePathCandidates(readPath);
 		for (const candidate of candidates) {
@@ -1596,6 +1641,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				}
 
 				if (!suffixResolution) {
+					const delimitedResult = await this.#tryReadDelimitedPaths(readPath, signal);
+					if (delimitedResult) return delimitedResult;
 					throw new ToolError(`Path '${localReadPath}' not found`);
 				}
 			} else {

package/src/tools/renderers.ts

@@ -17,7 +17,7 @@ import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
 import { browserToolRenderer } from "./browser/render";
 import { debugToolRenderer } from "./debug";
-import { evalToolRenderer } from "./eval";
+import { evalToolRenderer } from "./eval-render";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";

package/src/tools/search.ts

@@ -30,6 +30,7 @@ import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	expandDelimitedPathEntries,
 	hasGlobPathChars,
 	isLineInRanges,
 	type LineRange,
@@ -93,29 +94,6 @@ export const SINGLE_FILE_MATCHES = 200;
  * pagination headroom so the caller can see total file count. */
 const INTERNAL_TOTAL_CAP = 2000;
 
-/**
- * Detect a `,` that is not inside a `{…}` brace expansion. Used to catch
- * `paths: ["a,b"]` mistakes where the caller flattened multiple entries
- * into a single string instead of passing a JSON array of strings.
- */
-function containsTopLevelComma(entry: string): boolean {
-	let depth = 0;
-	for (let i = 0; i < entry.length; i++) {
-		const ch = entry[i];
-		if (ch === "\\" && i + 1 < entry.length) {
-			i++;
-			continue;
-		}
-		if (ch === "{") depth++;
-		else if (ch === "}") {
-			if (depth > 0) depth--;
-		} else if (ch === "," && depth === 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
 /**
  * Parsed `paths` entry — a path (possibly archive-shaped) plus an optional
  * line-range selector peeled off the trailing `:N-M` (or `:N+K`, `:N,M`, …)
@@ -146,9 +124,6 @@ function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
 			clean = split.path;
 			ranges = parsed;
 		}
-		if (containsTopLevelComma(clean)) {
-			throw new ToolError('paths is an array — pass ["a", "b"] not ["a,b"]');
-		}
 		specs.push({ original: entry, clean, ranges });
 	}
 	return specs;
@@ -663,7 +638,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
-			const rawEntries = toPathList(rawPaths);
+			const rawEntries = await expandDelimitedPathEntries(toPathList(rawPaths), this.session.cwd);
 			const pathSpecs = parsePathSpecs(rawEntries);
 			const paths = pathSpecs.map(spec => spec.clean);
 			const {

package/src/tools/sqlite-reader.ts

@@ -12,6 +12,15 @@ const MAX_QUERY_LIMIT = 500;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
 const MIN_COLUMN_WIDTH = 1;
+/**
+ * Upper bound on rows scanned when counting a table for the listing. SQLite has
+ * no stored row count, so `COUNT(*)` is a full b-tree scan — multi-second on a
+ * multi-GB database, and `bun:sqlite` runs it synchronously on the JS thread
+ * that also drives the TUI, freezing rendering and input. The listing instead
+ * trusts the planner's `sqlite_stat1` estimate for large tables and only counts
+ * exactly when a table is provably small, reading at most this many rows.
+ */
+const ROW_COUNT_PROBE_CAP = 50_000;
 
 type SqliteBinding = Exclude<SQLQueryBindings, Record<string, unknown>>;
 
@@ -26,6 +35,11 @@ interface SqliteCountRow {
 	count: number;
 }
 
+interface SqliteStat1Row {
+	tbl: string;
+	stat: string | null;
+}
+
 interface SqliteTableInfoRow {
 	cid: number;
 	name: string;
@@ -50,6 +64,23 @@ export type SqliteSelector =
 
 export type SqliteRowLookup = { kind: "pk"; column: string; type: string } | { kind: "rowid" };
 
+/**
+ * Row count for a table in the listing.
+ * - `exact`: counted in full (the table is small enough to count cheaply).
+ * - `estimate`: the planner's `sqlite_stat1` figure; the table is too large to
+ *   scan, so this may be stale.
+ * - `atLeast`: a lower bound; counting was capped before reaching the end.
+ */
+export type TableRowCount =
+	| { kind: "exact"; rows: number }
+	| { kind: "estimate"; rows: number }
+	| { kind: "atLeast"; rows: number };
+
+export interface SqliteTableSummary {
+	name: string;
+	count: TableRowCount;
+}
+
 function splitSqliteRemainder(remainder: string): { subPath: string; queryString: string } {
 	const queryIndex = remainder.indexOf("?");
 	if (queryIndex === -1) {
@@ -495,20 +526,61 @@ export function parseSqliteSelector(subPath: string, queryString: string): Sqlit
 	return { kind: "schema", table, sampleLimit: DEFAULT_SCHEMA_SAMPLE_LIMIT };
 }
 
-export function listTables(db: Database): { name: string; rowCount: number }[] {
+/**
+ * Reads the planner's per-table row estimate from `sqlite_stat1` (populated by
+ * `ANALYZE`). The first integer of each `stat` string is the number of rows in
+ * that index; for a full (non-partial) index it equals the table's row count,
+ * so the max across a table's entries is the table estimate. Returns an empty
+ * map when the database was never analyzed. One small indexed read — no scan.
+ */
+function loadRowEstimates(db: Database): Map<string, number> {
+	const estimates = new Map<string, number>();
+	const hasStat1 = db
+		.prepare<Pick<SqliteMasterRow, "name">, []>(
+			"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_stat1'",
+		)
+		.get();
+	if (!hasStat1) return estimates;
+
+	for (const { tbl, stat } of db.prepare<SqliteStat1Row, []>("SELECT tbl, stat FROM sqlite_stat1").all()) {
+		if (!stat) continue;
+		const rows = Number.parseInt(stat, 10);
+		if (!Number.isFinite(rows)) continue;
+		const prev = estimates.get(tbl);
+		if (prev === undefined || rows > prev) estimates.set(tbl, rows);
+	}
+	return estimates;
+}
+
+/**
+ * Counts a table while reading at most `cap + 1` rows. Returns an exact count
+ * when the table holds `cap` rows or fewer, otherwise a lower bound of `cap`.
+ * Bounds the worst-case scan so a stale or missing estimate can never trigger a
+ * full-table scan on the JS thread.
+ */
+function probeRowCount(db: Database, table: string, cap: number): TableRowCount {
+	const sql = `SELECT COUNT(*) AS count FROM (SELECT 1 FROM ${quoteSqliteIdentifier(table)} LIMIT ${cap + 1})`;
+	const counted = db.prepare<SqliteCountRow, []>(sql).get()?.count ?? 0;
+	return counted > cap ? { kind: "atLeast", rows: cap } : { kind: "exact", rows: counted };
+}
+
+export function listTables(db: Database, options: { probeCap?: number } = {}): SqliteTableSummary[] {
+	const cap = options.probeCap ?? ROW_COUNT_PROBE_CAP;
 	const names = db
 		.prepare<Pick<SqliteMasterRow, "name">, []>(
 			"SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name COLLATE NOCASE",
 		)
 		.all();
+	const estimates = loadRowEstimates(db);
 
 	return names.map(({ name }) => {
-		const countRow =
-			db.prepare<SqliteCountRow, []>(`SELECT COUNT(*) AS count FROM ${quoteSqliteIdentifier(name)}`).get() ?? null;
-		return {
-			name,
-			rowCount: countRow?.count ?? 0,
-		};
+		const estimate = estimates.get(name);
+		// Trust the planner only when it says the table is too large to count
+		// cheaply; otherwise count exactly (bounded), which also corrects a
+		// stale-low estimate without ever scanning more than `cap` rows.
+		const count: TableRowCount =
+			estimate !== undefined && estimate > cap ? { kind: "estimate", rows: estimate } : probeRowCount(db, name, cap);
+		return { name, count };
 	});
 }
 
@@ -679,13 +751,24 @@ export function deleteRowByRowId(db: Database, table: string, key: string): numb
 	return statement.run(binding).changes;
 }
 
-export function renderTableList(tables: { name: string; rowCount: number }[]): string {
+function formatRowCount(count: TableRowCount): string {
+	switch (count.kind) {
+		case "exact":
+			return `${count.rows} rows`;
+		case "estimate":
+			return `~${count.rows} rows`;
+		case "atLeast":
+			return `${count.rows}+ rows`;
+	}
+}
+
+export function renderTableList(tables: SqliteTableSummary[]): string {
 	if (tables.length === 0) {
 		return "(no tables)";
 	}
 
 	return tables
-		.map(table => truncateToWidth(replaceTabs(`${table.name} (${table.rowCount} rows)`), MAX_RENDER_WIDTH))
+		.map(table => truncateToWidth(replaceTabs(`${table.name} (${formatRowCount(table.count)})`), MAX_RENDER_WIDTH))
 		.join("\n");
 }
 

package/src/tools/write.ts

@@ -15,6 +15,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
+import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
@@ -278,8 +279,15 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		const enableLsp = session.enableLsp ?? true;
 		const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
 		const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnWrite");
+		const dedup = enableDiagnostics && session.settings.get("lsp.diagnosticsDeduplicate");
 		this.#writethrough = enableLsp
-			? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics })
+			? createLspWritethrough(session.cwd, {
+					enableFormat,
+					enableDiagnostics,
+					transformDiagnostics: dedup
+						? (path, result) => getDiagnosticsLedger(session).reduce(path, result)
+						: undefined,
+				})
 			: writethroughNoop;
 		this.description = prompt.render(writeDescription);
 	}

package/src/tui/output-block.ts

@@ -19,7 +19,7 @@ export interface OutputBlockOptions {
 	animate?: boolean;
 }
 
-const BORDER_SHIMMER_TICK_MS = 50;
+const BORDER_SHIMMER_TICK_MS = 16;
 /** Duration of one full left↔right↔left bounce of the bottom-edge segment, in
  * ms. Position is derived from the wall clock against this fixed cycle so a
  * resize only nudges the segment proportionally instead of teleporting it. */
@@ -28,9 +28,10 @@ const BORDER_BOUNCE_MS = 3000;
 const BORDER_SEGMENT_LEN = 8;
 
 /**
- * Monotonic frame counter for animated borders. Quantized coarse enough to
- * coalesce multiple render passes inside one frame, fine enough to advance on
- * every spinner interval so cached blocks re-render while the segment travels.
+ * Monotonic frame counter for animated borders, quantized to the TUI's ~16ms
+ * render cap so the cache key advances once per ~60fps frame — fine enough for a
+ * smooth segment sweep, coarse enough to coalesce multiple render passes that
+ * land inside the same frame.
  */
 export function borderShimmerTick(): number {
 	return Math.floor(Date.now() / BORDER_SHIMMER_TICK_MS);

package/src/utils/clipboard.ts

@@ -119,7 +119,7 @@ async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
 		if (!b64) return null;
 		const bytes = Buffer.from(b64, "base64");
 		if (bytes.byteLength === 0) return null;
-		return { data: new Uint8Array(bytes), mimeType: "image/png" };
+		return { data: bytes, mimeType: "image/png" };
 	} catch {
 		return null;
 	}
@@ -154,3 +154,40 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 
 	return (await native.readImageFromClipboard()) ?? null;
 }
+
+/**
+ * Read plain text from the system clipboard.
+ */
+export async function readTextFromClipboard(): Promise<string> {
+	try {
+		const p = process.platform;
+		if (p === "darwin") {
+			return execSync("pbpaste", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+		if (p === "win32") {
+			return execSync('powershell.exe -NoProfile -Command "Get-Clipboard"', {
+				encoding: "utf8",
+				timeout: 2000,
+			}).toString();
+		}
+		if (process.env.TERMUX_VERSION) {
+			return execSync("termux-clipboard-get", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+		const hasWaylandDisplay = Boolean(process.env.WAYLAND_DISPLAY);
+		const hasX11Display = Boolean(process.env.DISPLAY);
+		if (hasWaylandDisplay) {
+			try {
+				return execSync("wl-paste --type text/plain --no-newline", { encoding: "utf8", timeout: 2000 }).toString();
+			} catch {
+				if (hasX11Display) {
+					return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+				}
+			}
+		} else if (hasX11Display) {
+			return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+		}
+	} catch (error) {
+		logger.warn("clipboard: failed to read clipboard text", { error: String(error) });
+	}
+	return "";
+}