@oh-my-pi/pi-coding-agent 14.9.5 → 14.9.8

package/src/modes/components/read-tool-group.ts

@@ -22,6 +22,7 @@ type ReadToolResultDetails = {
 		from?: string;
 		to?: string;
 	};
+	conflictCount?: number;
 };
 
 type ReadToolGroupOptions = {
@@ -41,6 +42,7 @@ type ReadEntry = {
 	status: "pending" | "success" | "warning" | "error";
 	correctedFrom?: string;
 	contentText?: string;
+	conflictCount?: number;
 };
 
 /** Number of code lines to show in collapsed preview mode */
@@ -91,6 +93,9 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		} else {
 			entry.correctedFrom = undefined;
 		}
+		const conflictCount =
+			typeof details?.conflictCount === "number" && details.conflictCount > 0 ? details.conflictCount : undefined;
+		entry.conflictCount = conflictCount;
 		entry.status = result.isError ? "error" : suffixResolution ? "warning" : "success";
 		// Store the text content for preview/expanded display
 		const textContent = result.content?.find(c => c.type === "text")?.text;
@@ -212,6 +217,10 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		if (entry.correctedFrom) {
 			pathDisplay += theme.fg("dim", ` (corrected from ${shortenPath(entry.correctedFrom)})`);
 		}
+		if (entry.conflictCount && entry.conflictCount > 0) {
+			const n = entry.conflictCount;
+			pathDisplay += ` ${theme.fg("warning", `(⚠ ${n} conflict${n === 1 ? "" : "s"})`)}`;
+		}
 		return pathDisplay;
 	}
 

package/src/modes/controllers/command-controller.ts

@@ -14,7 +14,6 @@ import { formatDuration, Snowflake, setProjectDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { reset as resetCapabilities } from "../../capability";
 import { clearClaudePluginRootsCache } from "../../discovery/helpers";
-import { getGatewayStatus } from "../../eval/py/gateway-coordinator";
 import { loadCustomShare } from "../../export/custom-share";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import {
@@ -402,28 +401,6 @@ export class CommandController {
 			}
 		}
 
-		const gateway = await getGatewayStatus();
-		info += `\n${theme.bold("Python Gateway")}\n`;
-		if (gateway.active) {
-			info += `${theme.fg("dim", "Status:")} ${theme.fg("success", "Active (Global)")}\n`;
-			info += `${theme.fg("dim", "URL:")} ${gateway.url}\n`;
-			info += `${theme.fg("dim", "PID:")} ${gateway.pid}\n`;
-			if (gateway.pythonPath) {
-				info += `${theme.fg("dim", "Python:")} ${gateway.pythonPath}\n`;
-			}
-			if (gateway.venvPath) {
-				info += `${theme.fg("dim", "Venv:")} ${gateway.venvPath}\n`;
-			}
-			if (gateway.uptime !== null) {
-				const uptimeSec = Math.floor(gateway.uptime / 1000);
-				const mins = Math.floor(uptimeSec / 60);
-				const secs = uptimeSec % 60;
-				info += `${theme.fg("dim", "Uptime:")} ${mins}m ${secs}s\n`;
-			}
-		} else {
-			info += `${theme.fg("dim", "Status:")} ${theme.fg("dim", "Inactive")}\n`;
-		}
-
 		if (this.ctx.lspServers && this.ctx.lspServers.length > 0) {
 			info += `\n${theme.bold("LSP Servers")}\n`;
 			for (const server of this.ctx.lspServers) {

package/src/prompts/tools/eval.md

@@ -1,23 +1,18 @@
 Run code in a persistent kernel using codeblock cells.
 
 <instruction>
-Each cell is wrapped between `*** Begin <LANG>` and `*** End <LANG>`:
+Each cell starts with a single header line and runs until the next header (or end of input):
 
 ```
-*** Begin PY
-*** Title: optional title
-*** Timeout: 10s
-*** Reset
+*** Cell py:"optional title" t:10s rst
 print("hi")
-*** End PY
 ```
 
-- **Language**: {{#if py}}`PY` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`JS` / `TS` for JavaScript{{/if}}. The opening `<LANG>` and closing `<LANG>` **MUST** match.
-- **Attributes** (optional, in any order, immediately after `*** Begin`):
-  - `*** Title: …` — cell title shown in the UI.
-  - `*** Timeout: <duration>` — per-cell timeout. Digits with optional `ms` / `s` / `m` units (e.g. `500ms`, `15s`, `2m`). Default 30s.
-  - `*** Reset` — wipe this cell's own language kernel before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
-- Anything between the last attribute and `*** End <LANG>` is the cell's code, verbatim.
+- **Language + title**: `<lang>:"<title>"` — {{#if py}}`py` for Python{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}`js` for JavaScript{{/if}}. Title may be empty (`py:""`).
+- **Attributes** (optional, in this order, after the language+title):
+  - `t:<duration>` — per-cell timeout. Digits with optional `ms` / `s` / `m` units (e.g. `500ms`, `15s`, `2m`). Default 30s.
+  - `rst` — wipe this cell's own language kernel before running.{{#ifAll py js}} Other languages are untouched.{{/ifAll}}
+- Anything after the header line, up to the next `*** Cell` header, is the cell's code, verbatim.
 - Stack multiple cells back-to-back; blank lines between cells are ignored.
 
 **Work incrementally:**
@@ -50,40 +45,32 @@ env(key?=None, value?=None) → str | None | dict
     No args → full environment as dict. One arg → value of `key`. Two args → set `key=value` and return value.
 output(*ids, format?="raw", query?=None, offset?=None, limit?=None) → str | dict | list[dict]
     Read task/agent output by ID. Single id returns text/dict; multiple ids return a list.
+tool.<name>(args) → unknown
+    Invoke any session tool by name. `args` is the tool's parameter object.
 ```
-
-{{#if js}}**JavaScript only:** `tool.<name>(args)` invokes any session tool directly (e.g. `await tool.read({ path: "src/foo.ts" })`).
-{{/if}}</prelude>
+</prelude>
 
 <output>
 Cells render like a Jupyter notebook. `display(value)` renders non-presentable data as an interactive JSON tree. Presentable values (figures, images, dataframes, etc.) use their native representation.
 </output>
 
 <caution>
-- In session mode, use `*** Reset` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `*** Reset` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
+- In session mode, use `rst` on a cell to wipe its language's kernel before running.{{#ifAll py js}} Reset is per-language: a python cell's `rst` does not touch the JavaScript kernel and vice versa.{{/ifAll}}
 {{#if js}}- **js**: the VM exposes a selective `process` subset, Web APIs, `Buffer`, `fs/promises`, and the `Bun` global.
 {{/if}}</caution>
 
 <example>
-{{#if py}}*** Begin PY
-*** Title: imports
-*** Timeout: 10s
+{{#if py}}*** Cell py:"imports" t:10s
 import json
 from pathlib import Path
-*** End PY
 
-*** Begin PY
-*** Title: load config
+*** Cell py:"load config"
 data = json.loads(read('package.json'))
 display(data)
-*** End PY
 {{/if}}{{#ifAll py js}}
-{{/ifAll}}{{#if js}}*** Begin JS
-*** Title: js summary
-*** Reset
+{{/ifAll}}{{#if js}}*** Cell js:"summary" rst
 const data = JSON.parse(await read('package.json'));
 display(data);
 return data.name;
-*** End JS
 {{/if}}
 </example>

package/src/prompts/tools/read.md

@@ -18,6 +18,7 @@ The `read` tool is multi-purpose and more capable than it looks — inspects fil
 |`:50+150`|Read 150 lines starting at line 50|
 |`:20+1`|Read exactly one line|
 |`:raw`|Read verbatim text without anchors or summarization|
+|`:conflicts`|Return a one-line-per-block index of every merge conflict in the file|
 
 # Filesystem
 - Reading a directory path returns a list of dirents.

package/src/session/agent-session.ts

@@ -6561,7 +6561,6 @@ export class AgentSession {
 				sessionId,
 				kernelOwnerId: this.#evalKernelOwnerId,
 				kernelMode: this.settings.get("python.kernelMode"),
-				useSharedGateway: this.settings.get("python.sharedGateway"),
 				onChunk,
 				signal: abortController.signal,
 			});

package/src/session/history-storage.ts

@@ -19,6 +19,12 @@ type HistoryRow = {
 
 const SQLITE_NOW_EPOCH = "CAST(strftime('%s','now') AS INTEGER)";
 
+// Escape LIKE wildcards so user input is treated as literal text.
+// Matches the `ESCAPE '\\'` clause used by substring-search statements.
+function escapeLikePattern(text: string): string {
+	return text.replace(/[\\%_]/g, "\\$&");
+}
+
 class AsyncDrain<T> {
 	#queue?: T[];
 	#promise = Promise.resolve();
@@ -63,6 +69,8 @@ export class HistoryStorage {
 	#recentStmt: Statement;
 	#searchStmt: Statement;
 	#lastPromptStmt: Statement;
+	// Cache substring-fallback prepared statements keyed by token count.
+	#substringStmts = new Map<number, Statement>();
 
 	// In-memory cache of last prompt to avoid sync DB reads on add
 	#lastPromptCache: string | null = null;
@@ -167,16 +175,53 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 		const safeLimit = this.#normalizeLimit(limit);
 		if (safeLimit === 0) return [];
 
-		const ftsQuery = this.#buildFtsQuery(query);
-		if (!ftsQuery) return [];
+		const tokens = this.#tokenize(query);
+		if (tokens.length === 0) return [];
 
+		// 1. FTS5 prefix match (token AND, prefix-wildcard per token).
+		//    Handles punctuation by tokenizing query the same way unicode61 tokenizer
+		//    indexed the stored text, so "git-commit" -> "git"* "commit"*.
+		const ftsQuery = tokens.map(tok => `"${tok.replace(/"/g, '""')}"*`).join(" ");
+		let ftsRows: HistoryRow[] = [];
 		try {
-			const rows = this.#searchStmt.all(ftsQuery, safeLimit) as HistoryRow[];
-			return rows.map(row => this.#toEntry(row));
+			ftsRows = this.#searchStmt.all(ftsQuery, safeLimit) as HistoryRow[];
 		} catch (error) {
-			logger.error("HistoryStorage search failed", { error: String(error) });
-			return [];
+			// Malformed FTS expression - fall through to substring path.
+			logger.debug("HistoryStorage FTS query failed, using substring only", { error: String(error) });
+		}
+
+		if (ftsRows.length >= safeLimit) {
+			return ftsRows.map(row => this.#toEntry(row));
+		}
+
+		// 2. Substring fallback (token-AND LIKE). Catches infix matches FTS5's
+		//    prefix-only wildcard cannot reach (e.g. "mit" -> "commit"). Bounded
+		//    by safeLimit, ordered by recency - no full-table load into JS.
+		let subRows: HistoryRow[] = [];
+		try {
+			subRows = this.#searchSubstring(tokens, safeLimit);
+		} catch (error) {
+			logger.error("HistoryStorage substring search failed", { error: String(error) });
+		}
+
+		if (ftsRows.length === 0) {
+			return subRows.map(row => this.#toEntry(row));
+		}
+
+		const seen = new Set<number>();
+		const merged: HistoryEntry[] = [];
+		for (const row of ftsRows) {
+			if (seen.has(row.id)) continue;
+			seen.add(row.id);
+			merged.push(this.#toEntry(row));
 		}
+		for (const row of subRows) {
+			if (merged.length >= safeLimit) break;
+			if (seen.has(row.id)) continue;
+			seen.add(row.id);
+			merged.push(this.#toEntry(row));
+		}
+		return merged;
 	}
 
 	#ensureDir(dbPath: string): void {
@@ -225,21 +270,34 @@ END;
 		return Math.min(clamped, 1000);
 	}
 
-	#buildFtsQuery(query: string): string | null {
-		const tokens = query
-			.trim()
-			.split(/\s+/)
-			.map(token => token.trim())
-			.filter(Boolean);
+	/**
+	 * Split on non-alphanumeric runs, mirroring FTS5's `unicode61` tokenizer so
+	 * query tokens align with how stored prompts were indexed. Lowercases for
+	 * stable substring matching.
+	 */
+	#tokenize(query: string): string[] {
+		return query
+			.toLowerCase()
+			.split(/[^\p{L}\p{N}]+/u)
+			.filter(tok => tok.length > 0);
+	}
 
-		if (tokens.length === 0) return null;
+	#searchSubstring(tokens: string[], limit: number): HistoryRow[] {
+		const stmt = this.#getSubstringStmt(tokens.length);
+		const params: unknown[] = tokens.map(tok => `%${escapeLikePattern(tok)}%`);
+		params.push(limit);
+		return stmt.all(...(params as [string, ...unknown[]])) as HistoryRow[];
+	}
 
-		return tokens
-			.map(token => {
-				const escaped = token.replace(/"/g, '""');
-				return `"${escaped}"*`;
-			})
-			.join(" ");
+	#getSubstringStmt(tokenCount: number): Statement {
+		let stmt = this.#substringStmts.get(tokenCount);
+		if (stmt) return stmt;
+		const whereClause = Array(tokenCount).fill("prompt LIKE ? ESCAPE '\\' COLLATE NOCASE").join(" AND ");
+		stmt = this.#db.prepare(
+			`SELECT id, prompt, created_at, cwd FROM history WHERE ${whereClause} ORDER BY created_at DESC, id DESC LIMIT ?`,
+		);
+		this.#substringStmts.set(tokenCount, stmt);
+		return stmt;
 	}
 
 	#toEntry(row: HistoryRow): HistoryEntry {

package/src/tools/browser/tab-protocol.ts

@@ -59,10 +59,13 @@ export type WorkerInitPayload =
 			dialogs?: "accept" | "dismiss";
 	  };
 
+export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunErrorPayload };
+
 export type WorkerInbound =
 	| { type: "init"; payload: WorkerInitPayload }
 	| { type: "run"; id: string; name: string; code: string; timeoutMs: number; session: SessionSnapshot }
 	| { type: "abort"; id: string }
+	| { type: "tool-reply"; id: string; reply: ToolReply }
 	| { type: "close" };
 
 export interface ReadyInfo {
@@ -91,6 +94,7 @@ export type WorkerOutbound =
 	| { type: "init-failed"; error: RunErrorPayload }
 	| { type: "result"; id: string; ok: true; payload: RunResultOk }
 	| { type: "result"; id: string; ok: false; error: RunErrorPayload }
+	| { type: "tool-call"; id: string; runId: string; name: string; args: unknown }
 	| { type: "log"; level: "debug" | "warn" | "error"; msg: string; meta?: Record<string, unknown> }
 	| { type: "closed" };
 

package/src/tools/browser/tab-supervisor.ts

@@ -1,5 +1,6 @@
 import { getPuppeteerDir, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import type { Page, Target } from "puppeteer-core";
+import { callSessionTool } from "../../eval/js/tool-bridge";
 import type { ToolSession } from "../../sdk";
 import { expandPath } from "../path-utils";
 import { ToolAbortError, ToolError } from "../tool-errors";
@@ -37,6 +38,14 @@ interface WorkerHandle {
 
 export type DialogPolicy = "accept" | "dismiss";
 
+export interface PendingRun {
+	resolve(result: RunResultOk): void;
+	reject(error: unknown): void;
+	session: ToolSession;
+	signal?: AbortSignal;
+	toolCalls: Map<string, AbortController>;
+}
+
 export interface TabSession {
 	name: string;
 	browser: BrowserHandle;
@@ -44,7 +53,7 @@ export interface TabSession {
 	worker: WorkerHandle;
 	state: "alive" | "dead";
 	info: ReadyInfo;
-	pending: Map<string, { resolve: (result: RunResultOk) => void; reject: (error: unknown) => void }>;
+	pending: Map<string, PendingRun>;
 	dialogPolicy?: DialogPolicy;
 	kindTag: BrowserKindTag;
 }
@@ -155,14 +164,14 @@ export async function acquireTab(
 export async function runInTab(name: string, opts: RunInTabOptions): Promise<RunResultOk> {
 	return await runInTabWithSnapshot(
 		name,
-		{ code: opts.code, timeoutMs: opts.timeoutMs, signal: opts.signal },
+		{ code: opts.code, timeoutMs: opts.timeoutMs, signal: opts.signal, session: opts.session },
 		{ cwd: opts.session.cwd, browserScreenshotDir: expandBrowserScreenshotDir(opts.session) },
 	);
 }
 
 async function runInTabWithSnapshot(
 	name: string,
-	opts: { code: string; timeoutMs: number; signal?: AbortSignal },
+	opts: { code: string; timeoutMs: number; signal?: AbortSignal; session?: ToolSession },
 	snapshot: SessionSnapshot,
 ): Promise<RunResultOk> {
 	const tab = tabs.get(name);
@@ -170,8 +179,18 @@ async function runInTabWithSnapshot(
 	if (tab.pending.size > 0) throw new ToolError(`Tab ${JSON.stringify(name)} is busy`);
 	const id = Snowflake.next();
 	const { promise, resolve, reject } = Promise.withResolvers<RunResultOk>();
-	tab.pending.set(id, { resolve, reject });
-	const abort = (): void => tab.worker.send({ type: "abort", id });
+	const pending: PendingRun = {
+		resolve,
+		reject,
+		session: opts.session ?? ({} as ToolSession),
+		signal: opts.signal,
+		toolCalls: new Map(),
+	};
+	tab.pending.set(id, pending);
+	const abort = (): void => {
+		tab.worker.send({ type: "abort", id });
+		for (const ctrl of pending.toolCalls.values()) ctrl.abort(opts.signal?.reason);
+	};
 	if (opts.signal?.aborted) abort();
 	else opts.signal?.addEventListener("abort", abort, { once: true });
 	try {
@@ -277,9 +296,71 @@ function handleTabMessage(tab: TabSession, msg: WorkerOutbound): void {
 		tab.info = msg.info;
 		return;
 	}
+	if (msg.type === "tool-call") {
+		void dispatchToolCall(tab, msg);
+		return;
+	}
 	if (msg.type === "log") logWorkerMessage(msg);
 }
 
+async function dispatchToolCall(tab: TabSession, msg: Extract<WorkerOutbound, { type: "tool-call" }>): Promise<void> {
+	const pending = tab.pending.get(msg.runId);
+	if (!pending?.session.cwd) {
+		safeSend(tab, {
+			type: "tool-reply",
+			id: msg.id,
+			reply: {
+				ok: false,
+				error: { name: "ToolError", message: "No active run for tool call", isToolError: true, isAbort: false },
+			},
+		});
+		return;
+	}
+	const ctrl = new AbortController();
+	pending.toolCalls.set(msg.id, ctrl);
+	const onParentAbort = (): void => ctrl.abort(pending.signal?.reason);
+	if (pending.signal?.aborted) onParentAbort();
+	else pending.signal?.addEventListener("abort", onParentAbort, { once: true });
+	try {
+		const value = await callSessionTool(msg.name, msg.args, {
+			session: pending.session,
+			signal: ctrl.signal,
+			emitStatus: () => {
+				// Status events from tool calls aren't piped back to user code yet; the worker
+				// already pushes its own helper status via the display channel.
+			},
+		});
+		safeSend(tab, { type: "tool-reply", id: msg.id, reply: { ok: true, value } });
+	} catch (error) {
+		safeSend(tab, { type: "tool-reply", id: msg.id, reply: { ok: false, error: toErrorPayload(error) } });
+	} finally {
+		pending.toolCalls.delete(msg.id);
+		pending.signal?.removeEventListener("abort", onParentAbort);
+	}
+}
+
+function safeSend(tab: TabSession, msg: WorkerInbound): void {
+	if (tab.state !== "alive") return;
+	try {
+		tab.worker.send(msg);
+	} catch (err) {
+		logger.debug("tab worker send failed", { error: err instanceof Error ? err.message : String(err) });
+	}
+}
+
+function toErrorPayload(error: unknown): RunErrorPayload {
+	if (error instanceof Error) {
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
+			isToolError: error instanceof ToolError || error.name === "ToolError",
+		};
+	}
+	return { name: "Error", message: String(error), isAbort: false, isToolError: false };
+}
+
 async function forceKillTab(name: string, reason: string): Promise<void> {
 	const tab = tabs.get(name);
 	if (!tab) return;