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

package/src/tools/eval.ts

@@ -2,13 +2,16 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 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 { formatNumber, prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
+import { settings } from "../config/settings";
 import { jsBackend, pythonBackend } from "../eval";
-import type { ExecutorBackend } from "../eval/backend";
+import type { ExecutorBackend, ExecutorBackendResult } from "../eval/backend";
+import { IdleTimeout } from "../eval/idle-timeout";
 import { defaultEvalSessionId } from "../eval/session-id";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { formatContextUsage } from "../modes/components/status-line/context-thresholds";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { shimmerEnabled } from "../modes/theme/shimmer";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
@@ -33,7 +36,16 @@ import {
 	resolveOutputSinkHeadBytes,
 	stripOutputNotice,
 } from "./output-meta";
-import { formatTitle, replaceTabs, shortenPath, truncateToWidth, wrapBrackets } from "./render-utils";
+import {
+	formatBadge,
+	formatDuration,
+	formatStatusIcon,
+	formatTitle,
+	replaceTabs,
+	shortenPath,
+	truncateToWidth,
+	wrapBrackets,
+} from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -335,12 +347,20 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				for (let i = 0; i < cells.length; i++) {
 					const cell = cells[i];
 					const backend = cell.resolved.backend;
-					const timeoutSec = timeoutSecondsFromMs(cell.timeoutMs);
-					const deadlineMs = Date.now() + timeoutSec * 1000;
-					const timeoutSignal = AbortSignal.timeout(Math.max(0, deadlineMs - Date.now()));
+					// The per-cell `timeout` is an *inactivity* budget, not a hard
+					// wall-clock cap: it bounds the gap between progress signals
+					// (status events — agent() updates, log()/phase(), tool-bridge
+					// activity), so a long fanout that keeps reporting progress runs to
+					// completion while a genuinely stalled cell (no progress for the
+					// whole window) is still interrupted. Raw stdout deliberately does
+					// NOT re-arm it, so pure-compute runaway loops stay bounded. The
+					// watchdog drives `combinedSignal`; we pass no wall-clock deadline
+					// downstream so the backends never arm a competing fixed timer.
+					const idleTimeoutMs = timeoutSecondsFromMs(cell.timeoutMs) * 1000;
+					const idle = new IdleTimeout(idleTimeoutMs);
 					const combinedSignal = signal
-						? AbortSignal.any([signal, timeoutSignal, sessionAbortController.signal])
-						: AbortSignal.any([timeoutSignal, sessionAbortController.signal]);
+						? AbortSignal.any([signal, idle.signal, sessionAbortController.signal])
+						: AbortSignal.any([idle.signal, sessionAbortController.signal]);
 
 					const cellResult = cellResults[i];
 					cellResult.status = "running";
@@ -351,21 +371,32 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 					pushUpdate();
 
 					const startTime = Date.now();
-					const result = await backend.execute(cell.code, {
-						cwd: session.cwd,
-						sessionId,
-						sessionFile: sessionFile ?? undefined,
-						kernelOwnerId,
-						signal: combinedSignal,
-						session,
-						deadlineMs,
-						reset: cell.reset,
-						artifactPath,
-						artifactId,
-						onChunk: chunk => {
-							outputSink!.push(chunk);
-						},
-					});
+					let result: ExecutorBackendResult;
+					try {
+						result = await backend.execute(cell.code, {
+							cwd: session.cwd,
+							sessionId,
+							sessionFile: sessionFile ?? undefined,
+							kernelOwnerId,
+							signal: combinedSignal,
+							session,
+							idleTimeoutMs,
+							reset: cell.reset,
+							artifactPath,
+							artifactId,
+							onChunk: chunk => {
+								outputSink!.push(chunk);
+							},
+							onStatus: event => {
+								idle.bump();
+								cellResult.statusEvents ??= [];
+								upsertStatusEvent(cellResult.statusEvents, event);
+								pushUpdate();
+							},
+						});
+					} finally {
+						idle.dispose();
+					}
 					const durationMs = Date.now() - startTime;
 
 					const cellStatusEvents: EvalStatusEvent[] = [];
@@ -400,8 +431,8 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 							}
 						}
 						if (output.type === "status") {
-							statusEvents.push(output.event);
-							cellStatusEvents.push(output.event);
+							upsertStatusEvent(statusEvents, output.event);
+							upsertStatusEvent(cellStatusEvents, output.event);
 						}
 						if (output.type === "markdown") {
 							cellHasMarkdown = true;
@@ -608,6 +639,137 @@ function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
 	return out;
 }
 
+type AgentEventStatus = "pending" | "running" | "completed" | "failed" | "aborted";
+
+/**
+ * Append or replace a status event. `agent` events are progress snapshots keyed
+ * by `id`, so they coalesce in place (preserving first-seen order); every other
+ * op is a discrete action and simply appends. Keeps the persisted event list
+ * bounded even when a subagent emits hundreds of throttled progress ticks.
+ */
+function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void {
+	if (event.op === "agent" && typeof event.id === "string") {
+		const id = event.id;
+		const idx = events.findIndex(e => e.op === "agent" && e.id === id);
+		if (idx >= 0) {
+			events[idx] = event;
+			return;
+		}
+	}
+	events.push(event);
+}
+
+function eventString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function eventNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function agentEventStatus(value: unknown): AgentEventStatus {
+	switch (value) {
+		case "pending":
+		case "running":
+		case "completed":
+		case "failed":
+		case "aborted":
+			return value;
+		default:
+			return "running";
+	}
+}
+
+/** Append the toolCount · context · cost · model stat run, mirroring the task tool. */
+function formatAgentStats(event: EvalStatusEvent, theme: Theme): string {
+	let line = "";
+	const toolCount = eventNumber(event.toolCount);
+	if (toolCount > 0) {
+		line += `${theme.sep.dot}${theme.fg("dim", `${formatNumber(toolCount)} ${theme.icon.extensionTool}`)}`;
+	}
+	const contextTokens = eventNumber(event.contextTokens);
+	if (contextTokens > 0) {
+		const contextWindow = eventNumber(event.contextWindow);
+		const ctx =
+			contextWindow > 0
+				? formatContextUsage((contextTokens / contextWindow) * 100, contextWindow)
+				: formatNumber(contextTokens);
+		line += `${theme.sep.dot}${theme.fg("dim", ctx)}`;
+	}
+	const cost = eventNumber(event.cost);
+	if (cost > 0) {
+		line += `${theme.sep.dot}${theme.fg("statusLineCost", `$${cost.toFixed(2)}`)}`;
+	}
+	const model = eventString(event.model);
+	if (model && settings.get("task.showResolvedModelBadge")) {
+		line += `${theme.sep.dot}${theme.fg("dim", truncateToWidth(replaceTabs(model), 30))}`;
+	}
+	return line;
+}
+
+/**
+ * Render coalesced `agent()` progress as a Task-tool-style tree, one entry per
+ * subagent: a status line (icon · id · stats) plus, while running, the current
+ * tool/intent. Drawn below the cell box so progress streams live.
+ */
+function renderAgentProgressEvents(events: EvalStatusEvent[], theme: Theme, spinnerFrame?: number): string[] {
+	const lines: string[] = [];
+	for (let i = 0; i < events.length; i++) {
+		const event = events[i];
+		const isLast = i === events.length - 1;
+		const prefix = theme.fg("dim", isLast ? theme.tree.last : theme.tree.branch);
+		const cont = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
+
+		const status = agentEventStatus(event.status);
+		const iconStatus =
+			status === "completed"
+				? "success"
+				: status === "failed"
+					? "error"
+					: status === "aborted"
+						? "aborted"
+						: status === "pending"
+							? "pending"
+							: "running";
+		const iconColor =
+			status === "completed" ? "success" : status === "failed" || status === "aborted" ? "error" : "accent";
+		const icon = formatStatusIcon(iconStatus, theme, status === "running" ? spinnerFrame : undefined);
+
+		const id = eventString(event.id) ?? "agent";
+		let line = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", theme.bold(id))}`;
+
+		if (status === "failed" || status === "aborted") {
+			line += ` ${formatBadge(status, iconColor, theme)}`;
+		}
+
+		const currentTool = eventString(event.currentTool);
+		const lastIntent = eventString(event.lastIntent);
+		if (status === "running" && !currentTool && !lastIntent) {
+			const preview = eventString(event.taskPreview);
+			if (preview) line += ` ${theme.fg("muted", truncateToWidth(replaceTabs(preview), 48))}`;
+		}
+
+		line += formatAgentStats(event, theme);
+		if (status === "completed" || status === "failed" || status === "aborted") {
+			const durationMs = eventNumber(event.durationMs);
+			if (durationMs > 0) line += `${theme.sep.dot}${theme.fg("dim", formatDuration(durationMs))}`;
+		}
+		lines.push(line);
+
+		if (status === "running") {
+			if (currentTool) {
+				let toolLine = `${cont}${theme.tree.hook} ${theme.fg("muted", currentTool)}`;
+				const detail = lastIntent ?? eventString(event.currentToolArgs);
+				if (detail) toolLine += `: ${theme.fg("dim", truncateToWidth(replaceTabs(detail), 48))}`;
+				lines.push(toolLine);
+			} else if (lastIntent) {
+				lines.push(`${cont}${theme.tree.hook} ${theme.fg("dim", truncateToWidth(replaceTabs(lastIntent), 48))}`);
+			}
+		}
+	}
+	return lines;
+}
+
 /** Format a status event as a single line for display. */
 function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 	const { op, ...data } = event;
@@ -636,6 +798,8 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		env: "icon.package",
 		batch: "icon.package",
 		llm: "icon.package",
+		log: "icon.package",
+		phase: "icon.package",
 	};
 
 	const iconKey = opIcons[op] ?? "icon.file";
@@ -716,6 +880,12 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme): string {
 		case "touch":
 			if (data.path) parts.push(shortenPath(String(data.path)));
 			break;
+		case "log":
+			parts.push(String(data.message ?? ""));
+			break;
+		case "phase":
+			parts.push(String(data.title ?? ""));
+			break;
 		default:
 			if (data.count !== undefined) {
 				parts.push(String(data.count));
@@ -963,7 +1133,10 @@ export const evalToolRenderer = {
 					const lines: string[] = [];
 					for (let i = 0; i < cellResults.length; i++) {
 						const cell = cellResults[i];
-						const statusLines = renderStatusEvents(cell.statusEvents ?? [], uiTheme, expanded);
+						const allEvents = cell.statusEvents ?? [];
+						const agentEvents = allEvents.filter(e => e.op === "agent");
+						const otherEvents = agentEvents.length > 0 ? allEvents.filter(e => e.op !== "agent") : allEvents;
+						const statusLines = renderStatusEvents(otherEvents, uiTheme, expanded);
 						const outputContent = formatCellOutputLines(cell, expanded, previewLines, uiTheme, width);
 						const outputLines = [...outputContent.lines];
 						if (!expanded && outputContent.hiddenCount > 0) {
@@ -997,6 +1170,9 @@ export const evalToolRenderer = {
 							uiTheme,
 						);
 						lines.push(...cellLines);
+						if (agentEvents.length > 0) {
+							lines.push(...renderAgentProgressEvents(agentEvents, uiTheme, options.spinnerFrame));
+						}
 						if (i < cellResults.length - 1) {
 							lines.push("");
 						}

package/src/tools/find.ts

@@ -192,7 +192,12 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				if (hasGlobPathChars(rawPattern)) {
 					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPattern}`);
 				}
-				const resource = await internalRouter.resolve(rawPattern);
+				const resource = await internalRouter.resolve(rawPattern, {
+					cwd: this.session.cwd,
+					settings: this.session.settings,
+					signal,
+					localProtocolOptions: this.session.localProtocolOptions,
+				});
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot find internal URL without a backing file: ${rawPattern}`);
 				}
@@ -443,10 +448,14 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 // =============================================================================
 
 interface FindRenderArgs {
-	paths?: string[];
+	paths?: string | string[];
 	limit?: number;
 }
 
+function formatFindRenderPaths(paths: FindRenderArgs["paths"]): string | undefined {
+	return Array.isArray(paths) ? paths.join(", ") : paths;
+}
+
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
 export const findToolRenderer = {
@@ -456,7 +465,7 @@ export const findToolRenderer = {
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
 		const text = renderStatusLine(
-			{ icon: "pending", title: "Find", description: args.paths?.join(", ") || "*", meta },
+			{ icon: "pending", title: "Find", description: formatFindRenderPaths(args.paths) || "*", meta },
 			uiTheme,
 		);
 		return new Text(text, 0, 0);
@@ -493,7 +502,7 @@ export const findToolRenderer = {
 				{
 					icon: "success",
 					title: "Find",
-					description: args?.paths?.join(", "),
+					description: formatFindRenderPaths(args?.paths),
 					meta: [formatCount("file", lines.length)],
 				},
 				uiTheme,
@@ -528,7 +537,7 @@ export const findToolRenderer = {
 
 		if (fileCount === 0) {
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Find", description: args?.paths?.join(", "), meta: ["0 files"] },
+				{ icon: "warning", title: "Find", description: formatFindRenderPaths(args?.paths), meta: ["0 files"] },
 				uiTheme,
 			);
 			const lines = [header, formatEmptyMessage("No files found", uiTheme)];
@@ -539,7 +548,12 @@ export const findToolRenderer = {
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const header = renderStatusLine(
-			{ icon: truncated ? "warning" : "success", title: "Find", description: args?.paths?.join(", "), meta },
+			{
+				icon: truncated ? "warning" : "success",
+				title: "Find",
+				description: formatFindRenderPaths(args?.paths),
+				meta,
+			},
 			uiTheme,
 		);
 

package/src/tools/gh.ts

@@ -75,6 +75,7 @@ const GH_PR_FIELDS = [
 	"labels",
 	"mergeStateStatus",
 	"number",
+	"reviews",
 	"reviewDecision",
 	"state",
 	"title",

package/src/tools/grouped-file-output.ts

@@ -1,5 +1,11 @@
 import path from "node:path";
 
+const URL_LIKE_PATH_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+function isUrlLikePath(filePath: string): boolean {
+	return URL_LIKE_PATH_RE.test(filePath);
+}
+
 /**
  * One file's contribution to a grouped file output. The header itself is generated
  * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
@@ -43,7 +49,7 @@ export function formatGroupedFiles(
 ): GroupedFilesOutput {
 	const filesByDirectory = new Map<string, string[]>();
 	for (const filePath of files) {
-		const directory = path.dirname(filePath).replace(/\\/g, "/");
+		const directory = isUrlLikePath(filePath) ? "." : path.dirname(filePath).replace(/\\/g, "/");
 		if (!filesByDirectory.has(directory)) {
 			filesByDirectory.set(directory, []);
 		}
@@ -66,7 +72,8 @@ export function formatGroupedFiles(
 				const section = renderFile(filePath);
 				if (section.skip) continue;
 				pushSeparatorIfNeeded();
-				const header = `# ${path.basename(filePath)}${section.headerSuffix ?? ""}`;
+				const headerName = isUrlLikePath(filePath) ? filePath : path.basename(filePath);
+				const header = `# ${headerName}${section.headerSuffix ?? ""}`;
 				model.push(header, ...section.modelLines);
 				display.push(header, ...(section.displayLines ?? section.modelLines));
 			}

package/src/tools/index.ts

@@ -10,8 +10,10 @@ import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
 import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
+import type { LocalProtocolOptions } from "../internal-urls";
 import { LspTool } from "../lsp";
-import type { MnemosyneSessionState } from "../mnemosyne/state";
+import type { MCPManager } from "../mcp";
+import type { MnemopiSessionState } from "../mnemopi/state";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import type { ArtifactManager } from "../session/artifacts";
@@ -153,8 +155,8 @@ export interface ToolSession {
 	getSessionId?: () => string | null;
 	/** Get Hindsight runtime state for this agent session. */
 	getHindsightSessionState?: () => HindsightSessionState | undefined;
-	/** Get Mnemosyne runtime state for this agent session. */
-	getMnemosyneSessionState?: () => MnemosyneSessionState | 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"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
@@ -179,6 +181,10 @@ export interface ToolSession {
 	modelRegistry?: import("../config/model-registry").ModelRegistry;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
+	/** MCP manager visible to subagents without relying on the process-global singleton. */
+	mcpManager?: MCPManager;
+	/** Local protocol root to propagate to nested subagents and eval-created agents. */
+	localProtocolOptions?: LocalProtocolOptions;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
 	/** Plan mode state (if active) */
@@ -187,6 +193,12 @@ export interface ToolSession {
 	getGoalModeState?: () => GoalModeState | undefined;
 	/** Goal runtime for the active agent session. */
 	getGoalRuntime?: () => GoalRuntime | undefined;
+	/** Get cumulative session usage statistics (input/output tokens, cost). */
+	getUsageStatistics?: () => import("../session/session-manager").UsageStatistics;
+	/** Current per-turn token budget {total, spent, hard} for the eval `budget` helper. */
+	getTurnBudget?: () => { total: number | null; spent: number; hard: boolean };
+	/** Record output tokens consumed by an eval-spawned subagent toward the current turn budget. */
+	recordEvalSubagentUsage?: (output: number) => void;
 	/** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
 	getClientBridge?: () => ClientBridge | undefined;
 	/** Get compact conversation context for subagents (excludes tool results, system prompts) */
@@ -413,7 +425,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		) {
 			requestedTools.push("ast_edit");
 		}
-		if (["hindsight", "mnemosyne"].includes(session.settings.get("memory.backend") ?? "")) {
+		if (["hindsight", "mnemopi"].includes(session.settings.get("memory.backend") ?? "")) {
 			for (const name of ["recall", "retain", "reflect"]) {
 				if (!requestedTools.includes(name)) requestedTools.push(name);
 			}
@@ -458,7 +470,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			return true;
 		}
 		if (name === "retain" || name === "recall" || name === "reflect") {
-			return ["hindsight", "mnemosyne"].includes(session.settings.get("memory.backend") ?? "");
+			return ["hindsight", "mnemopi"].includes(session.settings.get("memory.backend") ?? "");
 		}
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;

package/src/tools/memory-edit.ts

@@ -21,20 +21,20 @@ export class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
 	readonly parameters = memoryEditSchema;
 	readonly strict = true;
 	readonly loadMode = "discoverable";
-	readonly summary = "Update, forget, or invalidate Mnemosyne memories";
+	readonly summary = "Update, forget, or invalidate Mnemopi memories";
 
 	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): MemoryEditTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "mnemosyne") return null;
+		if (backend !== "mnemopi") return null;
 		return new MemoryEditTool(session);
 	}
 
 	async execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult> {
-		const state = this.session.getMnemosyneSessionState?.();
+		const state = this.session.getMnemopiSessionState?.();
 		if (!state) {
-			throw new Error("Mnemosyne backend is not initialised for this session.");
+			throw new Error("Mnemopi backend is not initialised for this session.");
 		}
 		if (params.op === "update" && params.content === undefined && params.importance === undefined) {
 			throw new Error("memory_edit update requires content or importance.");

package/src/tools/memory-recall.ts

@@ -25,17 +25,17 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 
 	static createIf(session: ToolSession): MemoryRecallTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		if (backend !== "hindsight" && backend !== "mnemopi") return null;
 		return new MemoryRecallTool(session);
 	}
 
 	async execute(_id: string, params: MemoryRecallParams, signal?: AbortSignal): Promise<AgentToolResult> {
 		return untilAborted(signal, async () => {
 			const backend = this.session.settings.get("memory.backend");
-			if (backend === "mnemosyne") {
-				const state = this.session.getMnemosyneSessionState?.();
+			if (backend === "mnemopi") {
+				const state = this.session.getMnemopiSessionState?.();
 				if (!state) {
-					throw new Error("Mnemosyne backend is not initialised for this session.");
+					throw new Error("Mnemopi backend is not initialised for this session.");
 				}
 				try {
 					const results = state.recallResultsScoped(params.query);
@@ -56,7 +56,7 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 						details: {},
 					};
 				} catch (err) {
-					logger.warn("recall failed", { backend: "mnemosyne", bank: state.config.bank, error: String(err) });
+					logger.warn("recall failed", { backend: "mnemopi", bank: state.config.bank, error: String(err) });
 					throw err instanceof Error ? err : new Error(String(err));
 				}
 			}

package/src/tools/memory-reflect.ts

@@ -26,17 +26,17 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 
 	static createIf(session: ToolSession): MemoryReflectTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		if (backend !== "hindsight" && backend !== "mnemopi") return null;
 		return new MemoryReflectTool(session);
 	}
 
 	async execute(_id: string, params: MemoryReflectParams, signal?: AbortSignal): Promise<AgentToolResult> {
 		return untilAborted(signal, async () => {
 			const backend = this.session.settings.get("memory.backend");
-			if (backend === "mnemosyne") {
-				const state = this.session.getMnemosyneSessionState?.();
+			if (backend === "mnemopi") {
+				const state = this.session.getMnemopiSessionState?.();
 				if (!state) {
-					throw new Error("Mnemosyne backend is not initialised for this session.");
+					throw new Error("Mnemopi backend is not initialised for this session.");
 				}
 
 				try {
@@ -56,7 +56,7 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 						details: {},
 					};
 				} catch (err) {
-					logger.warn("reflect failed", { backend: "mnemosyne", bank: state.config.bank, error: String(err) });
+					logger.warn("reflect failed", { backend: "mnemopi", bank: state.config.bank, error: String(err) });
 					throw err instanceof Error ? err : new Error(String(err));
 				}
 			}

package/src/tools/memory-retain.ts

@@ -30,16 +30,16 @@ export class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
 
 	static createIf(session: ToolSession): MemoryRetainTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		if (backend !== "hindsight" && backend !== "mnemopi") return null;
 		return new MemoryRetainTool(session);
 	}
 
 	async execute(_id: string, params: MemoryRetainParams): Promise<AgentToolResult> {
 		const backend = this.session.settings.get("memory.backend");
-		if (backend === "mnemosyne") {
-			const state = this.session.getMnemosyneSessionState?.();
+		if (backend === "mnemopi") {
+			const state = this.session.getMnemopiSessionState?.();
 			if (!state) {
-				throw new Error("Mnemosyne backend is not initialised for this session.");
+				throw new Error("Mnemopi backend is not initialised for this session.");
 			}
 
 			for (const item of params.items) {

package/src/tools/path-utils.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { InternalUrlRouter } from "../internal-urls";
+import { InternalUrlRouter, type LocalProtocolOptions } from "../internal-urls";
 import { ToolError } from "./tool-errors";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
@@ -740,6 +740,12 @@ export interface ToolScopeOptions {
 	surfaceExactFilePaths?: boolean;
 	/** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
 	multipathStatHint?: string;
+	/** Calling session's settings — forwarded to the internal-URL router so caller-aware handlers (issue://, pr://) honor it. */
+	settings?: unknown;
+	/** Caller's abort signal — forwarded to the internal-URL router. */
+	signal?: AbortSignal;
+	/** Calling session's `local://` root mapping — pins resolutions to the calling session. */
+	localProtocolOptions?: LocalProtocolOptions;
 }
 
 export interface ToolScopeResolution {
@@ -778,7 +784,12 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 		if (hasGlobPathChars(rawPath)) {
 			throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
 		}
-		const resource = await internalRouter.resolve(rawPath);
+		const resource = await internalRouter.resolve(rawPath, {
+			cwd,
+			settings: opts.settings,
+			signal: opts.signal,
+			localProtocolOptions: opts.localProtocolOptions,
+		});
 		if (!resource.sourcePath) {
 			throw new ToolError(`Cannot ${internalUrlAction} internal URL without a backing file: ${rawPath}`);
 		}

package/src/tools/read.ts

@@ -2141,6 +2141,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			cwd: this.session.cwd,
 			settings: this.session.settings,
 			signal,
+			localProtocolOptions: this.session.localProtocolOptions,
 		});
 		const details: ReadToolDetails = { resolvedPath: resource.sourcePath, contentType: resource.contentType };
 

package/src/tools/render-utils.ts

@@ -177,7 +177,8 @@ export function formatMeta(meta: string[], theme: Theme): string {
 
 export function formatErrorMessage(message: string | undefined, theme: Theme): string {
 	const clean = (message ?? "").replace(/^Error:\s*/, "").trim();
-	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${clean || "Unknown error"}`)}`;
+	const safe = clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
+	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${safe}`)}`;
 }
 
 export function formatEmptyMessage(message: string, theme: Theme): string {