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

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

@@ -16,6 +16,17 @@ import type {
 	WorkerInitPayload,
 	WorkerOutbound,
 } from "./tab-protocol";
+// Imported with `type: "file"` so Bun's bundler statically discovers the
+// worker entry and embeds it inside `bun build --compile` single-file
+// binaries. Without this attribute the bundler cannot reach the entry through
+// a `new URL(..., import.meta.url)` literal stored in a local variable, and
+// the prebuilt binary surfaces `Timed out initializing browser tab worker`
+// (issue #1011) because `/$bunfs/root/tab-worker-entry.ts` is missing.
+// tsgo doesn't recognize Bun's `with { type: "file" }` attribute and treats
+// this as a normal TS source import, raising TS1192/TS5097. Bun's bundler
+// (and runtime) honors the attribute and returns the embedded file URL.
+// @ts-expect-error -- Bun file-URL import (see comment above).
+import tabWorkerEntryUrl from "./tab-worker-entry.ts" with { type: "file" };
 
 interface WorkerHandle {
 	send(msg: WorkerInbound, transferList?: Transferable[]): void;
@@ -364,8 +375,7 @@ async function raceWithTimeout<T>(
 
 async function spawnTabWorker(): Promise<WorkerHandle> {
 	try {
-		const url = new URL("./tab-worker-entry.ts", import.meta.url);
-		const worker = new Worker(url.href, { type: "module" });
+		const worker = new Worker(tabWorkerEntryUrl, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {
 		logger.warn("Bun Worker spawn failed; using inline tab worker (no sync-loop guard)", {

package/src/tools/eval.ts

@@ -4,11 +4,11 @@ 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 { type Static, Type } from "@sinclair/typebox";
-import { jsBackend, parseEvalInput, pythonBackend } from "../eval";
+import { jsBackend, parseEvalInput, pythonBackend, sniffEvalLanguage } from "../eval";
 import type { ExecutorBackend } from "../eval/backend";
 import evalGrammar from "../eval/eval.lark" with { type: "text" };
-import type { ParsedEvalCell } from "../eval/parse";
-import type { EvalCellResult, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
+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";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
@@ -26,7 +26,7 @@ export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
 export const evalSchema = Type.Object({
 	input: Type.String({
-		description: "eval input as a sequence of `===== <info> =====` cell headers followed by code",
+		description: "eval input as a sequence of `*** Begin <LANG>` cell headers followed by code",
 	}),
 });
 export type EvalToolParams = Static<typeof evalSchema>;
@@ -47,6 +47,38 @@ function formatJsonScalar(value: unknown): string {
 	return "[object]";
 }
 
+/** Cap per `display()` value sent back to the model. */
+const MAX_DISPLAY_TEXT_BYTES = 8000;
+
+function formatDisplayJsonForText(value: unknown): string {
+	let text: string;
+	try {
+		text = JSON.stringify(value, null, 2) ?? String(value);
+	} catch {
+		text = String(value);
+	}
+	if (text.length > MAX_DISPLAY_TEXT_BYTES) {
+		text = `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n… (${text.length - MAX_DISPLAY_TEXT_BYTES} chars truncated)`;
+	}
+	return text;
+}
+
+/**
+ * Format display() JSON values into text the model can see. Images are surfaced
+ * separately as ImageContent so the model can actually inspect them; this helper
+ * intentionally does not touch images.
+ */
+function formatDisplayOutputsForText(outputs: EvalDisplayOutput[]): string {
+	const chunks: string[] = [];
+	let displayIndex = 0;
+	for (const output of outputs) {
+		if (output.type !== "json") continue;
+		displayIndex++;
+		chunks.push(`display[${displayIndex}]:\n${formatDisplayJsonForText(output.data)}`);
+	}
+	return chunks.join("\n\n");
+}
+
 function renderJsonTree(value: unknown, theme: Theme, expanded: boolean, maxDepth = expanded ? 6 : 2): string[] {
 	const maxItems = expanded ? 20 : 5;
 
@@ -131,33 +163,6 @@ function timeoutSecondsFromMs(timeoutMs: number): number {
 	return clampTimeout("eval", timeoutMs / 1000);
 }
 
-/**
- * Best-effort language sniff for cells with no explicit `language`.
- *
- * Order:
- * 1. Shebang on first line (`#!/usr/bin/env python`, `#!/usr/bin/env node`, etc.)
- * 2. Strong syntactic markers unique to one language. We bias false negatives over
- *    false positives — anything ambiguous returns `undefined` and the caller falls
- *    back to the default-backend rules.
- */
-function sniffLanguage(code: string): EvalLanguage | undefined {
-	const stripped = code.replace(/^\s+/, "");
-	if (stripped.startsWith("#!")) {
-		const firstLine = stripped.split("\n", 1)[0]!.toLowerCase();
-		if (/(\bpython\d?\b|\bipython\b)/.test(firstLine)) return "python";
-		if (/(\bnode\b|\bbun\b|\bdeno\b|\bjavascript\b|\bjs\b)/.test(firstLine)) return "js";
-	}
-	const jsMarkers =
-		/(^|\n)\s*(const|let|var|async\s+function|function\s*\*?\s*[\w$]*\s*\(|import\s+[^\n]+\sfrom\s|export\s+(default|const|let|function|class|async)|require\s*\(|console\.\w+\s*\(|=>|;\s*$)/m;
-	const pyMarkers =
-		/(^|\n)\s*(def\s+\w+\s*\(|from\s+[\w.]+\s+import|import\s+\w+(\s+as\s+\w+)?\s*$|class\s+\w+\s*[(:]|print\s*\(|elif\s+[^\n]*:|with\s+[^\n]+:\s*$|@[\w.]+\s*$)/m;
-	const hasJs = jsMarkers.test(code);
-	const hasPy = pyMarkers.test(code);
-	if (hasJs && !hasPy) return "js";
-	if (hasPy && !hasJs) return "python";
-	return undefined;
-}
-
 async function resolveBackend(
 	session: ToolSession,
 	requested: EvalLanguage | undefined,
@@ -180,7 +185,7 @@ async function resolveBackend(
 		return { backend: jsBackend, fallback: false };
 	}
 	// Auto-detect.
-	const sniffed = sniffLanguage(code);
+	const sniffed = sniffEvalLanguage(code);
 	if (sniffed === "python" && allowPy && (await pythonBackend.isAvailable(session))) {
 		return { backend: pythonBackend, fallback: false };
 	}
@@ -397,13 +402,16 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 					const durationMs = Date.now() - startTime;
 
 					const cellStatusEvents: EvalStatusEvent[] = [];
+					const cellDisplayOutputs: EvalDisplayOutput[] = [];
 					let cellHasMarkdown = false;
 					for (const output of result.displayOutputs) {
 						if (output.type === "json") {
 							jsonOutputs.push(output.data);
+							cellDisplayOutputs.push(output);
 						}
 						if (output.type === "image") {
 							images.push({ type: "image", data: output.data, mimeType: output.mimeType });
+							cellDisplayOutputs.push(output);
 						}
 						if (output.type === "status") {
 							statusEvents.push(output.event);
@@ -414,7 +422,10 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						}
 					}
 
-					const cellOutput = result.output.trim();
+					const stdoutTrimmed = result.output.trim();
+					const displayText = formatDisplayOutputsForText(cellDisplayOutputs);
+					const cellOutput =
+						stdoutTrimmed && displayText ? `${stdoutTrimmed}\n\n${displayText}` : stdoutTrimmed || displayText;
 					cellResult.output = cellOutput;
 					cellResult.exitCode = result.exitCode;
 					cellResult.durationMs = durationMs;
@@ -446,10 +457,11 @@ 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;
+								: combinedOutput || errorMsg) + abortSuffix;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -457,14 +469,13 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 							languages,
 							cells: cellResults,
 							jsonOutputs: jsonOutputs.length > 0 ? jsonOutputs : undefined,
-							images: images.length > 0 ? images : undefined,
 							statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
 							isError: true,
 						};
 						if (notice) details.notice = notice;
 
 						return toolResult(details)
-							.text(outputText)
+							.content([{ type: "text", text: outputText }, ...images])
 							.truncationFromSummary(summaryForMeta, { direction: "tail" })
 							.done();
 					}
@@ -473,12 +484,13 @@ 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}`;
+									: `Command exited with code ${result.exitCode}`) + abortSuffix;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -486,14 +498,13 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 							languages,
 							cells: cellResults,
 							jsonOutputs: jsonOutputs.length > 0 ? jsonOutputs : undefined,
-							images: images.length > 0 ? images : undefined,
 							statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
 							isError: true,
 						};
 						if (notice) details.notice = notice;
 
 						return toolResult(details)
-							.text(outputText)
+							.content([{ type: "text", text: outputText }, ...images])
 							.truncationFromSummary(summaryForMeta, { direction: "tail" })
 							.done();
 					}
@@ -503,8 +514,13 @@ 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 || (jsonOutputs.length > 0 || images.length > 0 ? "(no text output)" : "(no output)");
+					(combinedOutput ||
+						(hasImages
+							? `(displayed ${images.length} image${images.length === 1 ? "" : "s"}; no text output)`
+							: "(no output)")) + abortSuffix;
 				const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 
 				const details: EvalToolDetails = {
@@ -512,13 +528,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 					languages,
 					cells: cellResults,
 					jsonOutputs: jsonOutputs.length > 0 ? jsonOutputs : undefined,
-					images: images.length > 0 ? images : undefined,
 					statusEvents: statusEvents.length > 0 ? statusEvents : undefined,
 				};
 				if (notice) details.notice = notice;
 
 				return toolResult(details)
-					.text(outputText)
+					.content([{ type: "text", text: outputText }, ...images])
 					.truncationFromSummary(summaryForMeta, { direction: "tail" })
 					.done();
 			} finally {

package/src/tools/fetch.ts

@@ -1352,7 +1352,7 @@ export function renderReadUrlCall(
 ): Component {
 	const url = args.path ?? args.url ?? "";
 	const domain = getDomain(url);
-	const path = truncate(url.replace(/^https?:\/\/[^/]+/, ""), 50, "\u2026");
+	const path = truncate(url.replace(/^https?:\/\/[^/]+/, ""), 50, "…");
 	const description = `${domain}${path ? ` ${path}` : ""}`.trim();
 	const meta: string[] = [];
 	if (args.raw) meta.push("raw");

package/src/tools/gh.ts

@@ -260,6 +260,27 @@ const githubSchema = Type.Object({
 			examples: ["is:open label:bug"],
 		}),
 	),
+	since: Type.Optional(
+		Type.String({
+			description:
+				"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.",
+			examples: ["3d", "2w", "2026-05-01"],
+		}),
+	),
+	until: Type.Optional(
+		Type.String({
+			description:
+				"upper-bound date in the same format as `since`. With both, builds a `field:since..until` range qualifier.",
+			examples: ["1d", "2026-05-09"],
+		}),
+	),
+	dateField: Type.Optional(
+		StringEnum(["created", "updated"], {
+			description:
+				"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`.",
+			default: "created",
+		}),
+	),
 	limit: Type.Optional(
 		Type.Number({
 			description: "max results (search_issues, search_prs, search_code, search_commits, search_repos)",
@@ -686,6 +707,110 @@ const SEARCH_FIELDS_BY_COMMAND: Record<"issues" | "prs" | "code" | "commits" | "
 	repos: GH_SEARCH_REPOS_FIELDS,
 };
 
+const RELATIVE_DURATION_PATTERN = /^(\d+)\s*(m|h|d|w|mo|y)$/i;
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const FIXED_UNIT_MS: Record<string, number> = {
+	m: 60_000,
+	h: 3_600_000,
+	d: 86_400_000,
+	w: 7 * 86_400_000,
+};
+
+/**
+ * Resolve a search date bound to a GitHub-search-compatible literal. Returns
+ * either a `YYYY-MM-DD` date (relative durations and date-only inputs) or a
+ * full ISO 8601 datetime string (datetime inputs), so the caller can drop it
+ * straight into a qualifier like `created:>=<value>`.
+ */
+export function parseSearchDateBound(raw: string, now: Date = new Date()): string {
+	const trimmed = raw.trim();
+	if (!trimmed) {
+		throw new ToolError("date bound must not be empty");
+	}
+
+	const relMatch = trimmed.match(RELATIVE_DURATION_PATTERN);
+	if (relMatch) {
+		const count = Number(relMatch[1]);
+		const unit = relMatch[2].toLowerCase();
+		const fixedMs = FIXED_UNIT_MS[unit];
+		let bound: Date;
+		if (fixedMs !== undefined) {
+			bound = new Date(now.getTime() - count * fixedMs);
+		} else {
+			bound = new Date(now);
+			if (unit === "mo") {
+				bound.setUTCMonth(bound.getUTCMonth() - count);
+			} else {
+				bound.setUTCFullYear(bound.getUTCFullYear() - count);
+			}
+		}
+		return bound.toISOString().slice(0, 10);
+	}
+
+	if (ISO_DATE_PATTERN.test(trimmed)) {
+		return trimmed;
+	}
+
+	const parsedMs = Date.parse(trimmed);
+	if (!Number.isNaN(parsedMs)) {
+		return new Date(parsedMs).toISOString();
+	}
+
+	throw new ToolError(
+		`invalid date bound: ${raw}. Expected a relative duration like "3d", "12h", "2w", an ISO date "YYYY-MM-DD", or an ISO datetime.`,
+	);
+}
+
+/**
+ * Build the GitHub-search qualifier (e.g. `created:>=2026-05-09`) for the
+ * provided bounds, or `undefined` if neither bound is set.
+ */
+export function buildSearchDateQualifier(
+	field: string,
+	since: string | undefined,
+	until: string | undefined,
+	now?: Date,
+): string | undefined {
+	const sinceVal = since ? parseSearchDateBound(since, now) : undefined;
+	const untilVal = until ? parseSearchDateBound(until, now) : undefined;
+	if (sinceVal && untilVal) {
+		return `${field}:${sinceVal}..${untilVal}`;
+	}
+	if (sinceVal) {
+		return `${field}:>=${sinceVal}`;
+	}
+	if (untilVal) {
+		return `${field}:<=${untilVal}`;
+	}
+	return undefined;
+}
+
+function resolveSearchDateField(
+	command: "issues" | "prs" | "commits" | "repos",
+	requested: "created" | "updated" | undefined,
+): string {
+	if (command === "commits") {
+		return "committer-date";
+	}
+	const dateField = requested ?? "created";
+	if (command === "repos" && dateField === "updated") {
+		return "pushed";
+	}
+	return dateField;
+}
+
+function composeSearchQuery(parts: ReadonlyArray<string | undefined>): string {
+	const cleaned: string[] = [];
+	for (const part of parts) {
+		const trimmed = part?.trim();
+		if (trimmed) cleaned.push(trimmed);
+	}
+	if (cleaned.length === 0) {
+		throw new ToolError("query is required (or pass since/until to filter by date)");
+	}
+	return cleaned.join(" ");
+}
+
 function buildGhSearchArgs(
 	command: "issues" | "prs" | "code" | "commits" | "repos",
 	query: string,
@@ -2636,9 +2761,11 @@ async function executeSearchIssues(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const query = requireNonEmpty(params.query, "query");
 	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
+	const dateField = resolveSearchDateField("issues", params.dateField);
+	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
+	const query = composeSearchQuery([params.query, dateQualifier]);
 	const args = buildGhSearchArgs("issues", query, limit, repo);
 
 	const items = await git.github.json<GhSearchResult[]>(session.cwd, args, signal, {
@@ -2652,9 +2779,11 @@ async function executeSearchPrs(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const query = requireNonEmpty(params.query, "query");
 	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
+	const dateField = resolveSearchDateField("prs", params.dateField);
+	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
+	const query = composeSearchQuery([params.query, dateQualifier]);
 	const args = buildGhSearchArgs("prs", query, limit, repo);
 
 	const items = await git.github.json<GhSearchResult[]>(session.cwd, args, signal, {
@@ -2669,6 +2798,9 @@ async function executeSearchCode(
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
 	const query = requireNonEmpty(params.query, "query");
+	if (params.since !== undefined || params.until !== undefined) {
+		throw new ToolError("search_code does not support since/until; GitHub code search has no date qualifier.");
+	}
 	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
 	const args = buildGhSearchArgs("code", query, limit, repo);
@@ -2684,9 +2816,11 @@ async function executeSearchCommits(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const query = requireNonEmpty(params.query, "query");
 	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
+	const dateField = resolveSearchDateField("commits", params.dateField);
+	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
+	const query = composeSearchQuery([params.query, dateQualifier]);
 	const args = buildGhSearchArgs("commits", query, limit, repo);
 
 	const items = await git.github.json<GhSearchCommitResult[]>(session.cwd, args, signal, {
@@ -2700,8 +2834,10 @@ async function executeSearchRepos(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const query = requireNonEmpty(params.query, "query");
 	const limit = resolveSearchLimit(params.limit);
+	const dateField = resolveSearchDateField("repos", params.dateField);
+	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
+	const query = composeSearchQuery([params.query, dateQualifier]);
 	const args = buildGhSearchArgs("repos", query, limit, undefined);
 
 	const items = await git.github.json<GhSearchRepoResult[]>(session.cwd, args, signal);

package/src/tools/index.ts

@@ -1,17 +1,16 @@
 import type { 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 type { AsyncJobManager } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
-import type { InternalUrlRouter } from "../internal-urls";
 import { LspTool } from "../lsp";
 import type { PlanModeState } from "../plan-mode/state";
-import type { AgentRegistry } from "../registry/agent-registry";
+import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
+import type { ArtifactManager } from "../session/artifacts";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
@@ -159,6 +158,8 @@ export interface ToolSession {
 	agentRegistry?: AgentRegistry;
 	/** Get artifacts directory for artifact:// URLs */
 	getArtifactsDir?: () => string | null;
+	/** Get the ArtifactManager backing this session (shared across parent + subagents). */
+	getArtifactManager?: () => ArtifactManager | null;
 	/** Allocate a new artifact path and ID for session-scoped truncated output. */
 	allocateOutputArtifact?: (toolType: string) => Promise<{ id?: string; path?: string }>;
 	/** Get session spawns */
@@ -171,14 +172,8 @@ export interface ToolSession {
 	authStorage?: import("../session/auth-storage").AuthStorage;
 	/** Model registry for passing to subagents (avoids re-discovery) */
 	modelRegistry?: import("../config/model-registry").ModelRegistry;
-	/** MCP manager for proxying MCP calls through parent */
-	mcpManager?: import("../mcp/manager").MCPManager;
-	/** Internal URL router for protocols like agent://, skill://, and mcp:// */
-	internalRouter?: InternalUrlRouter;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
-	/** Async background job manager for bash/task async execution */
-	asyncJobManager?: AsyncJobManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
 	/** Plan mode state (if active) */
@@ -282,7 +277,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	browser: s => new BrowserTool(s),
 	checkpoint: CheckpointTool.createIf,
 	rewind: RewindTool.createIf,
-	task: TaskTool.create,
+	task: s => TaskTool.create(s),
 	job: JobTool.createIf,
 	recipe: RecipeTool.createIf,
 	irc: IrcTool.createIf,
@@ -443,7 +438,13 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
-		if (name === "irc") return session.settings.get("irc.enabled");
+		if (name === "irc") {
+			if (!session.settings.get("irc.enabled")) return false;
+			// Main agent only needs `irc` when subagents may run concurrently (async).
+			// In sync mode main blocks on `task`, so peer messaging from main is dead weight.
+			if (!session.settings.get("async.enabled") && session.getAgentId?.() === MAIN_AGENT_ID) return false;
+			return true;
+		}
 		if (name === "recipe") return session.settings.get("recipe.enabled");
 		if (name === "retain" || name === "recall" || name === "reflect") {
 			return session.settings.get("memory.backend") === "hindsight";

package/src/tools/job.ts

@@ -3,7 +3,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { isBackgroundJobSupportEnabled } from "../async";
+import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
@@ -20,6 +20,7 @@ import {
 	type ToolUIColor,
 	type ToolUIStatus,
 } from "./render-utils";
+import { ToolError } from "./tool-errors";
 
 const jobSchema = Type.Object({
 	poll: Type.Optional(
@@ -34,6 +35,12 @@ const jobSchema = Type.Object({
 			examples: [["job-1234"]],
 		}),
 	),
+	list: Type.Optional(
+		Type.Boolean({
+			description:
+				"Return an immediate snapshot of every job spawned by this agent (running + completed within retention). Read-only \u2014 cannot be combined with `poll` or `cancel`.",
+		}),
+	),
 });
 
 type JobParams = Static<typeof jobSchema>;
@@ -97,7 +104,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<JobToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<JobToolDetails>> {
-		const manager = this.session.asyncJobManager;
+		const manager = AsyncJobManager.instance();
 		if (!manager) {
 			return {
 				content: [{ type: "text", text: "Async execution is disabled; no background jobs are available." }],
@@ -105,11 +112,24 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			};
 		}
 
+		// Scope every visible operation to the calling agent. Tests / SDK
+		// consumers without an agent id see everything (legacy behavior).
+		const ownerId = this.session.getAgentId?.() ?? undefined;
+		const ownerFilter = ownerId ? { ownerId } : undefined;
+
+		// `list` is a read-only snapshot mode. Replaces the legacy `jobs://` URL.
+		if (params.list) {
+			if (params.cancel?.length || params.poll?.length) {
+				throw new ToolError("`list` cannot be combined with `poll` or `cancel`.");
+			}
+			return this.#buildResult(manager, manager.getAllJobs(ownerFilter), []);
+		}
+
 		const cancelIds = params.cancel ?? [];
 		const cancelOutcomes: CancelOutcome[] = [];
 		for (const id of cancelIds) {
 			const existing = manager.getJob(id);
-			if (!existing) {
+			if (!existing || (ownerId && existing.ownerId !== ownerId)) {
 				cancelOutcomes.push({ id, status: "not_found", message: `Background job not found: ${id}` });
 				continue;
 			}
@@ -121,7 +141,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 				});
 				continue;
 			}
-			const cancelled = manager.cancel(id);
+			const cancelled = manager.cancel(id, ownerFilter);
 			cancelOutcomes.push(
 				cancelled
 					? { id, status: "cancelled", message: `Cancelled background job ${id}.` }
@@ -130,11 +150,11 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		}
 
 		const requestedPollIds = params.poll;
-		// If only `cancel` was provided (no `poll`), don't wait — return immediately.
+		// If only `cancel` was provided (no `poll`), don't wait \u2014 return immediately.
 		const shouldPoll = requestedPollIds !== undefined || cancelIds.length === 0;
 
 		if (!shouldPoll) {
-			const cancelledJobs = cancelIds.map(id => manager.getJob(id)).filter(j => j != null);
+			const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
 			return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
 		}
 
@@ -142,12 +162,12 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		// - If `poll` was passed explicitly, watch exactly those (filtered to existing).
 		// - If `poll` was omitted (and so was `cancel`), default to all running jobs.
 		const jobsToWatch = requestedPollIds
-			? requestedPollIds.map(id => manager.getJob(id)).filter(j => j != null)
-			: manager.getRunningJobs();
+			? this.#visibleJobs(manager, requestedPollIds, ownerId)
+			: manager.getRunningJobs(ownerFilter);
 
 		if (jobsToWatch.length === 0) {
 			if (cancelOutcomes.length > 0) {
-				const cancelledJobs = cancelIds.map(id => manager.getJob(id)).filter(j => j != null);
+				const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
 				return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
 			}
 			const message = requestedPollIds?.length
@@ -176,7 +196,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		const watchedJobIds = runningJobs.map(job => job.id);
 		manager.watchJobs(watchedJobIds);
 
-		const cancelledJobs = cancelIds.map(id => manager.getJob(id)).filter(j => j != null);
+		const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
 		const allTrackedJobs = [...cancelledJobs, ...jobsToWatch];
 
 		const PROGRESS_INTERVAL_MS = 500;
@@ -219,6 +239,22 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		return this.#buildResult(manager, allTrackedJobs, cancelOutcomes);
 	}
 
+	/**
+	 * Resolve a list of job ids to job records visible to the calling agent.
+	 * Drops missing ids and ids owned by other agents, so cross-agent inspection
+	 * via the `job` tool is impossible.
+	 */
+	#visibleJobs(manager: AsyncJobManager, ids: string[], ownerId: string | undefined): AsyncJob[] {
+		const out: AsyncJob[] = [];
+		for (const id of ids) {
+			const job = manager.getJob(id);
+			if (!job) continue;
+			if (ownerId && job.ownerId !== ownerId) continue;
+			out.push(job);
+		}
+		return out;
+	}
+
 	#snapshotJobs(
 		jobs: {
 			id: string;
@@ -232,7 +268,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	): JobSnapshot[] {
 		const now = Date.now();
 		return jobs.map(j => {
-			const current = this.session.asyncJobManager?.getJob(j.id);
+			const current = AsyncJobManager.instance()?.getJob(j.id);
 			const latest = current ?? j;
 			return {
 				id: latest.id,
@@ -247,7 +283,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	}
 
 	#buildResult(
-		manager: NonNullable<ToolSession["asyncJobManager"]>,
+		manager: AsyncJobManager,
 		jobs: {
 			id: string;
 			type: "bash" | "task";