@oh-my-pi/pi-coding-agent 15.1.2 → 15.1.3

package/src/task/types.ts

@@ -57,18 +57,13 @@ export interface SubagentLifecyclePayload {
 	index: number;
 }
 
-const assignmentDescriptionForContextEnabled =
-	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.";
-const assignmentDescriptionForContextDisabled =
-	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure, and include any background that would otherwise live in `context` since shared context is disabled in this mode.";
+const assignmentDescription = "per-task instructions; self-contained";
 
-const createTaskItemSchema = (contextEnabled: boolean) =>
+const createTaskItemSchema = (_contextEnabled: boolean) =>
 	z.object({
-		id: z.string().max(48).describe("CamelCase identifier, max 48 chars"),
-		description: z.string().describe("Short one-liner for UI display only — not seen by the subagent"),
-		assignment: z
-			.string()
-			.describe(contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled),
+		id: z.string().max(48).describe("camelcase identifier"),
+		description: z.string().describe("ui label, not seen by subagent"),
+		assignment: z.string().describe(assignmentDescription),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
@@ -80,44 +75,24 @@ const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: Task
 	const itemSchema = createTaskItemSchema(contextEnabled);
 
 	let schema = z.object({
-		agent: z.string().describe("Agent type for all tasks in this batch"),
-		tasks: z
-			.array(itemSchema)
-			.describe(
-				contextEnabled
-					? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
-					: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
-			),
+		agent: z.string().describe("agent type"),
+		tasks: z.array(itemSchema).describe("tasks to execute in parallel"),
 	});
-
 	if (contextEnabled) {
 		schema = schema.extend({
-			context: z
-				.string()
-				.optional()
-				.describe(
-					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
-				),
+			context: z.string().optional().describe("shared background prepended to each assignment"),
 		});
 	}
 
 	if (customSchemaEnabled) {
 		schema = schema.extend({
-			schema: z
-				.string()
-				.optional()
-				.describe(
-					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
-				),
+			schema: z.string().optional().describe("jtd schema for expected response shape"),
 		});
 	}
 
 	if (options.isolationEnabled) {
 		schema = schema.extend({
-			isolated: z
-				.boolean()
-				.optional()
-				.describe("Run in isolated environment; returns patches. Use when tasks edit overlapping files."),
+			isolated: z.boolean().optional().describe("run in isolated env; returns patches"),
 		});
 	}
 

package/src/tools/bash-interactive.ts

@@ -1,5 +1,5 @@
 import type { AgentToolContext } from "@oh-my-pi/pi-agent-core";
-import { type PtyRunResult, PtySession, sanitizeText } from "@oh-my-pi/pi-natives";
+import { type PtyRunResult, PtySession } from "@oh-my-pi/pi-natives";
 import {
 	type Component,
 	extractPrintableText,
@@ -10,6 +10,7 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Terminal as XtermTerminalType } from "@xterm/headless";
 import xterm from "@xterm/headless";
 import { Settings } from "../config/settings";
@@ -297,6 +298,7 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const settings = await Settings.init();
+	const { shell: resolvedShell } = settings.getShellConfig();
 	const sink = new OutputSink({
 		artifactPath: options.artifactPath,
 		artifactId: options.artifactId,
@@ -363,6 +365,7 @@ export async function runInteractiveBashPty(
 						signal: options.signal,
 						cols,
 						rows,
+						shell: resolvedShell,
 					},
 					(err, chunk) => {
 						if (finished || err || !chunk) return;

package/src/tools/bash-pty-selection.ts

@@ -9,6 +9,6 @@ export interface BashPtyContext {
 /** Return whether a bash tool call should use the local interactive PTY overlay. */
 export function canUseInteractiveBashPty(pty: boolean, ctx: BashPtyContext | undefined): boolean {
 	if (!pty) return false;
-	if (process.platform === "win32") return false;
-	return $env.PI_NO_PTY !== "1" && ctx?.hasUI === true && ctx.ui !== undefined;
+	if ($env.PI_NO_PTY === "1") return false;
+	return ctx?.hasUI === true && ctx.ui !== undefined;
 }

package/src/tools/browser.ts

@@ -18,19 +18,16 @@ export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 const DEFAULT_TAB_NAME = "main";
 
 const appSchema = z.object({
-	path: z.string().describe("absolute path to a binary to spawn (single-instance reuse)").optional(),
-	cdp_url: z.string().describe("existing CDP endpoint to connect to (e.g. http://127.0.0.1:9222)").optional(),
-	args: z.array(z.string()).describe("extra CLI args when spawning").optional(),
-	target: z.string().describe("substring matched against url+title to pick a BrowserWindow").optional(),
+	path: z.string().describe("binary path to spawn").optional(),
+	cdp_url: z.string().describe("existing cdp endpoint").optional(),
+	args: z.array(z.string()).describe("extra cli args").optional(),
+	target: z.string().describe("substring to pick a window").optional(),
 });
 
 const browserSchema = z.object({
-	action: z.enum(["open", "close", "run"] as const).describe("tab/browser operation"),
-	name: z
-		.string()
-		.describe("tab id; default 'main'. Multiple tabs can coexist; reusable across run() calls and subagents.")
-		.optional(),
-	url: z.string().describe("open: navigate after acquiring tab").optional(),
+	action: z.enum(["open", "close", "run"] as const).describe("operation"),
+	name: z.string().describe("tab id (default 'main')").optional(),
+	url: z.string().describe("url to open").optional(),
 	app: appSchema.optional(),
 	viewport: z
 		.object({
@@ -41,21 +38,16 @@ const browserSchema = z.object({
 		.optional(),
 	wait_until: z
 		.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"] as const)
-		.describe("navigation wait condition for url")
+		.describe("navigation wait condition")
 		.optional(),
 	dialogs: z
 		.enum(["accept", "dismiss"] as const)
-		.describe("open: auto-handle alert/confirm/beforeunload dialogs (default: leave for caller to handle)")
-		.optional(),
-	code: z
-		.string()
-		.describe(
-			"run: JS body executed with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. Treated as the body of an async function. Use `display(value)` to attach text/JSON/images; the function's return value is JSON-serialized as a final block.",
-		)
+		.describe("auto-handle dialogs")
 		.optional(),
+	code: z.string().describe("js body to run in tab").optional(),
 	timeout: z.number().default(30).describe("timeout in seconds").optional(),
-	all: z.boolean().describe("close: close every tab").optional(),
-	kill: z.boolean().describe("close: also kill spawned-app browsers (default: leave running)").optional(),
+	all: z.boolean().describe("close every tab").optional(),
+	kill: z.boolean().describe("also kill spawned-app browsers").optional(),
 });
 
 /** Input schema for the browser tool. */

package/src/tools/eval.ts

@@ -4,10 +4,8 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Markdown, Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { jsBackend, parseEvalInput, pythonBackend, sniffEvalLanguage } from "../eval";
+import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend } from "../eval/backend";
-import evalGrammar from "../eval/eval.lark" with { type: "text" };
-import { ABORT_WARNING, type ParsedEvalCell } from "../eval/parse";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
@@ -29,8 +27,27 @@ import { clampTimeout } from "./tool-timeouts";
 
 export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
+/**
+ * Per-cell input. Each cell runs in order; state persists within a language
+ * across cells and across tool calls.
+ */
+const evalCellSchema = z.object({
+	language: z.enum(["py", "js"]).describe('runtime: "py" for the IPython kernel, "js" for the persistent JS VM'),
+	code: z.string().describe("cell body, verbatim. Use top-level await freely."),
+	title: z.string().optional().describe('short label shown in transcript (e.g. "imports", "load config")'),
+	timeout: z.number().int().min(1).max(600).optional().describe("per-cell timeout in seconds (1-600, default 30)"),
+	reset: z
+		.boolean()
+		.optional()
+		.describe("wipe this cell's language kernel before running. Other languages are untouched."),
+});
+export type EvalCellInput = z.infer<typeof evalCellSchema>;
+
 export const evalSchema = z.object({
-	input: z.string().describe('eval input as a sequence of `*** Cell <lang>:"title"` cell headers followed by code'),
+	cells: z
+		.array(evalCellSchema)
+		.min(1)
+		.describe("cells executed in order. State persists within each language across cells and tool calls."),
 });
 export type EvalToolParams = z.infer<typeof evalSchema>;
 
@@ -134,7 +151,6 @@ export interface EvalToolOptions {
 
 interface ResolvedBackend {
 	backend: ExecutorBackend;
-	fallback: boolean;
 	notice?: string;
 }
 
@@ -166,51 +182,21 @@ function timeoutSecondsFromMs(timeoutMs: number): number {
 	return clampTimeout("eval", timeoutMs / 1000);
 }
 
-async function resolveBackend(
-	session: ToolSession,
-	requested: EvalLanguage | undefined,
-	code: string,
-): Promise<ResolvedBackend> {
+async function resolveBackend(session: ToolSession, language: EvalLanguage): Promise<ResolvedBackend> {
 	const allowPy = (session.settings.get("eval.py") as boolean | undefined) ?? true;
 	const allowJs = (session.settings.get("eval.js") as boolean | undefined) ?? true;
 
-	if (requested === "python") {
+	if (language === "python") {
 		if (!allowPy) throw new ToolError("Python backend is disabled (eval.py = false).");
 		if (!(await pythonBackend.isAvailable(session))) {
 			throw new ToolError(
 				'Python backend is unavailable in this session. Pass language: "js" or install the python kernel.',
 			);
 		}
-		return { backend: pythonBackend, fallback: false };
-	}
-	if (requested === "js") {
-		if (!allowJs) throw new ToolError("JavaScript backend is disabled (eval.js = false).");
-		return { backend: jsBackend, fallback: false };
-	}
-	// Auto-detect.
-	const sniffed = sniffEvalLanguage(code);
-	if (sniffed === "python" && allowPy && (await pythonBackend.isAvailable(session))) {
-		return { backend: pythonBackend, fallback: false };
-	}
-	if (sniffed === "js" && allowJs) {
-		return { backend: jsBackend, fallback: false };
+		return { backend: pythonBackend };
 	}
-
-	// Sniffer returned undefined or the preferred backend was disabled. Prefer
-	// python when its kernel is up, else fall back to js.
-	if (allowPy && (await pythonBackend.isAvailable(session))) {
-		const notice =
-			sniffed === "js" ? "JavaScript markers detected but eval.js is disabled; using Python." : undefined;
-		return { backend: pythonBackend, fallback: false, notice };
-	}
-	if (allowJs) {
-		const notice =
-			sniffed === "python"
-				? "Python markers detected but the python kernel is unavailable; using JavaScript."
-				: undefined;
-		return { backend: jsBackend, fallback: true, notice };
-	}
-	throw new ToolError("No eval backend is available; enable eval.py or eval.js.");
+	if (!allowJs) throw new ToolError("JavaScript backend is disabled (eval.js = false).");
+	return { backend: jsBackend };
 }
 
 export class EvalTool implements AgentTool<typeof evalSchema> {
@@ -227,20 +213,15 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 	readonly intent = (args: Partial<z.infer<typeof evalSchema>>): string | undefined => {
-		const input = args.input;
-		if (input) {
-			try {
-				const cells = parseEvalInput(input).cells;
-				return cells.map(cell => cell.title || `running ${cell.language}`).join("\n");
-			} catch {}
-		}
-		return "evaluating";
+		const cells = Array.isArray(args.cells) ? args.cells : [];
+		const first = cells.find(c => c && typeof c === "object");
+		if (!first) return "evaluating";
+		const title = typeof first.title === "string" ? first.title : undefined;
+		const language = typeof first.language === "string" ? first.language : "?";
+		const label = title || `running ${language}`;
+		return cells.length > 1 ? `${label} (+${cells.length - 1})` : label;
 	};
 
-	get customFormat(): { syntax: "lark"; definition: string } {
-		return { syntax: "lark", definition: evalGrammar };
-	}
-
 	readonly #proxyExecutor?: EvalProxyExecutor;
 
 	constructor(
@@ -266,19 +247,17 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		}
 		const session = this.session;
 
-		const parsedInput = parseEvalInput(params.input);
-		let previousRuntimeLanguage: EvalLanguage | undefined;
 		const cells: ResolvedEvalCell[] = [];
-		for (const cell of parsedInput.cells) {
-			const requested = cell.languageOrigin === "header" ? cell.language : (previousRuntimeLanguage ?? undefined);
-			const resolved = await resolveBackend(session, requested, cell.code);
-			previousRuntimeLanguage = resolved.backend.id;
+		for (let i = 0; i < params.cells.length; i++) {
+			const cell = params.cells[i];
+			const language: EvalLanguage = cell.language === "py" ? "python" : "js";
+			const resolved = await resolveBackend(session, language);
 			cells.push({
-				index: cell.index,
+				index: i,
 				title: cell.title,
 				code: cell.code,
-				timeoutMs: cell.timeoutMs,
-				reset: cell.reset,
+				timeoutMs: (cell.timeout ?? 30) * 1000,
+				reset: cell.reset ?? false,
 				resolved,
 			});
 		}
@@ -462,11 +441,10 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						pushUpdate();
 						const errorMsg = result.output || "Command aborted";
 						const combinedOutput = cellOutputs.join("\n\n");
-						const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 						const outputText =
-							(cells.length > 1
+							cells.length > 1
 								? `${combinedOutput}\n\nCell ${i + 1} aborted: ${errorMsg}`
-								: combinedOutput || errorMsg) + abortSuffix;
+								: combinedOutput || errorMsg;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -489,13 +467,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						cellResult.status = "error";
 						pushUpdate();
 						const combinedOutput = cellOutputs.join("\n\n");
-						const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 						const outputText =
-							(cells.length > 1
+							cells.length > 1
 								? `${combinedOutput}\n\nCell ${i + 1} failed (exit code ${result.exitCode}). Earlier cells succeeded—their state persists. Fix only cell ${i + 1}.`
 								: combinedOutput
 									? `${combinedOutput}\n\nCommand exited with code ${result.exitCode}`
-									: `Command exited with code ${result.exitCode}`) + abortSuffix;
+									: `Command exited with code ${result.exitCode}`;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -519,13 +496,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				}
 
 				const combinedOutput = cellOutputs.join("\n\n");
-				const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 				const hasImages = images.length > 0;
 				const outputText =
-					(combinedOutput ||
-						(hasImages
-							? `(displayed ${images.length} image${images.length === 1 ? "" : "s"}; no text output)`
-							: "(no output)")) + abortSuffix;
+					combinedOutput ||
+					(hasImages
+						? `(displayed ${images.length} image${images.length === 1 ? "" : "s"}; no text output)`
+						: "(no output)");
 				const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 
 				const details: EvalToolDetails = {
@@ -581,8 +557,14 @@ async function summarizeFinal(
 	};
 }
 
+interface EvalRenderCellArg {
+	language?: string;
+	code?: string;
+	title?: string;
+}
+
 interface EvalRenderArgs {
-	input?: string;
+	cells?: EvalRenderCellArg[];
 	__partialJson?: string;
 }
 
@@ -593,27 +575,30 @@ interface EvalRenderContext {
 	timeout?: number;
 }
 
-function decodePartialJsonStringFragment(fragment: string): string {
-	let text = fragment.replace(/\\u[0-9a-fA-F]{0,3}$/, "");
-	const trailingBackslashes = text.match(/\\+$/)?.[0].length ?? 0;
-	if (trailingBackslashes % 2 === 1) text = text.slice(0, -1);
-	try {
-		return JSON.parse(`"${text}"`) as string;
-	} catch {
-		return text;
-	}
+interface EvalRenderCell {
+	language: EvalLanguage;
+	code: string;
+	title?: string;
 }
 
-function extractPartialJsonString(partialJson: string | undefined, key: string): string | undefined {
-	if (!partialJson) return undefined;
-	const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)`, "u");
-	const match = pattern.exec(partialJson);
-	if (!match) return undefined;
-	return decodePartialJsonStringFragment(match[1]);
+function normalizeRenderLanguage(value: string | undefined): EvalLanguage {
+	return value === "js" ? "js" : "python";
 }
 
-function getRenderInput(args: EvalRenderArgs | undefined): string | undefined {
-	return args?.input ?? extractPartialJsonString(args?.__partialJson, "input");
+function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
+	const raw = args?.cells;
+	if (!Array.isArray(raw)) return [];
+	const out: EvalRenderCell[] = [];
+	for (const cell of raw) {
+		if (!cell || typeof cell !== "object") continue;
+		const code = typeof cell.code === "string" ? cell.code : "";
+		out.push({
+			language: normalizeRenderLanguage(typeof cell.language === "string" ? cell.language : undefined),
+			code,
+			title: typeof cell.title === "string" ? cell.title : undefined,
+		});
+	}
+	return out;
 }
 
 /** Format a status event as a single line for display. */
@@ -861,15 +846,7 @@ function formatCellOutputLines(
 
 export const evalToolRenderer = {
 	renderCall(args: EvalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const input = getRenderInput(args);
-		let cells: ParsedEvalCell[] = [];
-		if (input) {
-			try {
-				cells = parseEvalInput(input).cells;
-			} catch {
-				cells = [];
-			}
-		}
+		const cells = getRenderCells(args);
 
 		if (cells.length === 0) {
 			const promptSym = uiTheme.fg("accent", ">>>");
@@ -881,7 +858,7 @@ export const evalToolRenderer = {
 
 		return {
 			render: (width: number): string[] => {
-				const key = `${input?.length ?? 0}`;
+				const key = cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|");
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
 				}

package/src/tools/gh.ts

@@ -213,58 +213,34 @@ const githubSchema = z
 				"run_watch",
 			] as const)
 			.describe("github operation"),
-		repo: z.string().describe("owner/repo (any op)").optional(),
-		branch: z.string().describe("branch (repo_view, pr_push local branch, run_watch)").optional(),
+		repo: z.string().describe("owner/repo").optional(),
+		branch: z.string().describe("branch").optional(),
 		pr: z
 			.union([z.string(), z.array(z.string())])
-			.describe(
-				"pr number, url, or branch (pr_checkout); pass an array to batch-process multiple pull requests in one call",
-			)
-			.optional(),
-		force: z.boolean().describe("reset existing local branch (pr_checkout)").optional(),
-		forceWithLease: z.boolean().describe("force-with-lease push (pr_push)").optional(),
-		title: z.string().describe("PR title (pr_create)").optional(),
-		body: z.string().describe("PR body markdown (pr_create); mutually exclusive with fill").optional(),
-		base: z.string().describe("PR base branch (pr_create); defaults to repo default branch").optional(),
-		head: z.string().describe("PR head branch (pr_create); defaults to current branch").optional(),
-		draft: z.boolean().describe("open PR as draft (pr_create)").optional(),
-		fill: z
-			.boolean()
-			.describe("auto-fill PR title/body from commits (pr_create); mutually exclusive with title/body")
-			.optional(),
-		reviewer: z.array(z.string()).describe("reviewers to request (pr_create); accepts users or org/team").optional(),
-		assignee: z.array(z.string()).describe("assignees (pr_create); use @me for the authenticated user").optional(),
-		label: z.array(z.string()).describe("labels to apply (pr_create)").optional(),
-		query: z
-			.string()
-			.describe("search query (search_issues, search_prs, search_code, search_commits, search_repos)")
-			.optional(),
-		since: z
-			.string()
-			.describe(
-				"lower-bound date for search_issues/search_prs/search_commits/search_repos. Accepts a relative duration (`<n><unit>` with unit `m`/`h`/`d`/`w`/`mo`/`y`, e.g. `3d`, `12h`, `2w`) or an ISO date (`YYYY-MM-DD`) / datetime. Translated to a `created:>=…` (or `committer-date:`/`pushed:`) qualifier; not supported by search_code.",
-			)
-			.optional(),
-		until: z
-			.string()
-			.describe(
-				"upper-bound date in the same format as `since`. With both, builds a `field:since..until` range qualifier.",
-			)
+			.describe("pr number, url, or branch")
 			.optional(),
+		force: z.boolean().describe("reset existing local branch").optional(),
+		forceWithLease: z.boolean().describe("force-with-lease push").optional(),
+		title: z.string().describe("pr title").optional(),
+		body: z.string().describe("pr body markdown").optional(),
+		base: z.string().describe("pr base branch").optional(),
+		head: z.string().describe("pr head branch").optional(),
+		draft: z.boolean().describe("open pr as draft").optional(),
+		fill: z.boolean().describe("auto-fill pr title/body from commits").optional(),
+		reviewer: z.array(z.string()).describe("reviewers").optional(),
+		assignee: z.array(z.string()).describe("assignees").optional(),
+		label: z.array(z.string()).describe("labels").optional(),
+		query: z.string().describe("search query").optional(),
+		since: z.string().describe("lower-bound date filter").optional(),
+		until: z.string().describe("upper-bound date filter").optional(),
 		dateField: z
 			.enum(["created", "updated"] as const)
-			.describe(
-				"date field used by `since`/`until`. issues/prs: `created` (default) or `updated`. repos: `created` (default) or `updated` (mapped to GitHub's `pushed:`). commits: ignored — always uses `committer-date`.",
-			)
+			.describe("date field")
 			.default("created")
 			.optional(),
-		limit: z
-			.number()
-			.default(10)
-			.describe("max results (search_issues, search_prs, search_code, search_commits, search_repos)")
-			.optional(),
-		run: z.string().describe("actions run id or url (run_watch)").optional(),
-		tail: z.number().default(15).describe("log lines per failed job (run_watch)").optional(),
+		limit: z.number().default(10).describe("max results").optional(),
+		run: z.string().describe("actions run id or url").optional(),
+		tail: z.number().default(15).describe("log lines per failed job").optional(),
 	})
 	.strict();
 

package/src/tools/hindsight-recall.ts

@@ -6,7 +6,7 @@ import recallDescription from "../prompts/tools/recall.md" with { type: "text" }
 import type { ToolSession } from ".";
 
 const hindsightRecallSchema = z.object({
-	query: z.string().describe("Natural language search query. Be specific about what you need to know."),
+	query: z.string().describe("natural language search query"),
 });
 
 export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;

package/src/tools/hindsight-reflect.ts

@@ -6,8 +6,8 @@ import reflectDescription from "../prompts/tools/reflect.md" with { type: "text"
 import type { ToolSession } from ".";
 
 const hindsightReflectSchema = z.object({
-	query: z.string().describe("The question to answer using long-term memory."),
-	context: z.string().describe("Optional additional context to guide the reflection.").optional(),
+	query: z.string().describe("question to answer"),
+	context: z.string().describe("optional context").optional(),
 });
 
 export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;

package/src/tools/hindsight-retain.ts

@@ -7,16 +7,12 @@ const hindsightRetainSchema = z.object({
 	items: z
 		.array(
 			z.object({
-				content: z
-					.string()
-					.describe("The information to remember. Be specific and self-contained — include who, what, when, why."),
-				context: z.string().describe("Optional context describing where this information came from.").optional(),
+				content: z.string().describe("information to remember"),
+				context: z.string().describe("source context").optional(),
 			}),
 		)
 		.min(1)
-		.describe(
-			"One or more memories to retain. Batch related facts in a single call rather than calling retain repeatedly — they are deduplicated and consolidated together.",
-		),
+		.describe("memories to retain"),
 });
 
 export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;

package/src/tools/index.ts

@@ -514,7 +514,14 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	// Injected unconditionally into every agent, regardless of requested tool list.
 	const autoQA = isAutoQaEnabled(session.settings);
 	if (autoQA && !tools.some(t => t.name === "report_tool_issue")) {
-		const qaTool = await HIDDEN_TOOLS.report_tool_issue(session);
+		// Build the enum from tools we just constructed via BUILTIN_TOOLS / HIDDEN_TOOLS.
+		// Extension overrides (e.g. a user's custom `bash`) get added later by
+		// other code paths, so they're absent here — exactly what we want; MCP /
+		// extension tools never end up in the report enum.
+		const activeBuiltinNames = tools
+			.map(t => t.name)
+			.filter(name => (name in BUILTIN_TOOLS || name in HIDDEN_TOOLS) && name !== "report_tool_issue");
+		const qaTool = createReportToolIssueTool(session, activeBuiltinNames);
 		if (qaTool) {
 			tools.push(wrapToolWithMetaNotice(qaTool));
 		}

package/src/tools/inspect-image.ts

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
@@ -118,7 +119,8 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 			throw new ToolError("inspect_image only supports PNG, JPEG, GIF, and WEBP files detected by file content.");
 		}
 
-		const response = await this.completeImageRequest(
+		const telemetry = resolveTelemetry(this.session.getTelemetry?.(), this.session.getSessionId?.() ?? undefined);
+		const response = await instrumentedCompleteSimple(
 			model,
 			{
 				systemPrompt: [prompt.render(inspectImageSystemPromptTemplate)],
@@ -134,6 +136,7 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 				],
 			},
 			{ apiKey, signal },
+			{ telemetry, oneshotKind: "inspect_image", completeImpl: this.completeImageRequest },
 		);
 
 		if (response.stopReason === "error") {

package/src/tools/irc.ts

@@ -26,18 +26,10 @@ import type { AgentRef, AgentRegistry } from "../registry/agent-registry";
 import type { ToolSession } from ".";
 
 const ircSchema = z.object({
-	op: z
-		.union([
-			z.literal("send").describe("Send a message to one peer or to all peers"),
-			z.literal("list").describe("List currently visible peers"),
-		])
-		.describe("IRC operation"),
-	to: z.string().optional().describe('Recipient agent id (e.g. "0-Main", "0-AuthLoader") or "all" to broadcast'),
-	message: z.string().optional().describe("Message body to deliver"),
-	awaitReply: z
-		.boolean()
-		.optional()
-		.describe("Wait for the recipient's prose reply (default: true for DM, false for broadcast)"),
+	op: z.enum(["send", "list"]).describe("irc operation"),
+	to: z.string().optional().describe('recipient agent id or "all"'),
+	message: z.string().optional().describe("message body"),
+	awaitReply: z.boolean().optional().describe("wait for prose reply"),
 });
 
 type IrcParams = z.infer<typeof ircSchema>;