@oh-my-pi/pi-coding-agent 15.9.1 → 15.9.5

package/src/tools/index.ts

@@ -2,6 +2,7 @@ import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
+import type { AsyncJobManager } from "../async/job-manager";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
@@ -22,6 +23,7 @@ import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
+import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import { WebSearchTool } from "../web/search";
@@ -183,6 +185,21 @@ export interface ToolSession {
 	modelRegistry?: import("../config/model-registry").ModelRegistry;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
+	/**
+	 * Async job manager scoped to this session.
+	 *
+	 * - Top-level session that constructed one: its own manager.
+	 * - Subagent (`parentTaskPrefix` set): the parent's manager, so background
+	 *   bash/task work and `onJobComplete` deliveries flow into the conversation
+	 *   that spawned it.
+	 * - Secondary in-process top-level session that found a singleton already
+	 *   installed (issue #1923): `undefined`. Tools refuse async work rather
+	 *   than silently route completions into the owning session's `yieldQueue`.
+	 *
+	 * Tools MUST use this instead of `AsyncJobManager.instance()` so a secondary
+	 * session never borrows the owning session's manager by accident.
+	 */
+	asyncJobManager?: AsyncJobManager;
 	/** 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. */
@@ -404,14 +421,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		}
 	}
 	// Resolve effective tool discovery mode.
-	// tools.discoveryMode takes precedence; mcp.discoveryMode is a back-compat alias for "mcp-only".
-	const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
-	const effectiveDiscoveryMode: "off" | "mcp-only" | "all" =
-		toolsDiscoveryMode !== "off"
-			? (toolsDiscoveryMode as "off" | "mcp-only" | "all")
-			: session.settings.get("mcp.discoveryMode")
-				? "mcp-only"
-				: "off";
+	// tools.discoveryMode controls the new modes; mcp.discoveryMode remains a back-compat alias for "mcp-only".
+	const effectiveDiscoveryMode = resolveEffectiveToolDiscoveryMode(
+		session.settings,
+		countToolsForAutoDiscovery(requestedTools ?? Object.keys(BUILTIN_TOOLS)),
+	);
 	const discoveryActive = effectiveDiscoveryMode !== "off";
 
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };

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 * as z from "zod/v4";
-import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
+import { type AsyncJob, type 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" };
@@ -90,7 +90,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<JobToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<JobToolDetails>> {
-		const manager = AsyncJobManager.instance();
+		const manager = this.session.asyncJobManager;
 		if (!manager) {
 			return {
 				content: [{ type: "text", text: "Async execution is disabled; no background jobs are available." }],
@@ -254,7 +254,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	): JobSnapshot[] {
 		const now = Date.now();
 		return jobs.map(j => {
-			const current = AsyncJobManager.instance()?.getJob(j.id);
+			const current = this.session.asyncJobManager?.getJob(j.id);
 			const latest = current ?? j;
 			return {
 				id: latest.id,

package/src/tools/memory-reflect.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { ensureBankMission } from "../hindsight/bank";
+import { ensureBankExists } from "../hindsight/bank";
 import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
 import type { ToolSession } from ".";
 
@@ -67,7 +67,7 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 			}
 
 			try {
-				await ensureBankMission(state.client, state.bankId, state.config, state.missionsSet);
+				await ensureBankExists(state.client, state.bankId, state.config, state.banksSet);
 				const response = await state.client.reflect(state.bankId, params.query, {
 					context: params.context,
 					budget: state.config.recallBudget,

package/src/tools/path-utils.ts

@@ -217,6 +217,27 @@ export function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null
 	return merged as [LineRange, ...LineRange[]];
 }
 
+/**
+ * Extract the line-range component from a read-tool selector that may also
+ * carry a verbatim/index display mode (`raw`, `conflicts`) — alone or compounded
+ * with a range (`raw:50-100`, `50-100:raw`). Returns the parsed ranges when the
+ * selector names any, otherwise `undefined` (pure `raw`/`conflicts`/none).
+ *
+ * Used by content search, which honors line ranges as a match filter but has no
+ * use for verbatim/conflict display modes — so those selectors are accepted and
+ * treated as an unfiltered, whole-resource search rather than rejected.
+ */
+export function selectorLineRanges(sel: string | undefined): [LineRange, ...LineRange[]] | undefined {
+	if (!sel) return undefined;
+	for (const chunk of sel.split(":")) {
+		const lower = chunk.toLowerCase();
+		if (lower === "raw" || lower === "conflicts") continue;
+		const ranges = parseLineRanges(chunk);
+		if (ranges) return ranges;
+	}
+	return undefined;
+}
+
 /** Return `true` when `lineNumber` (1-indexed) falls in any of the supplied ranges. */
 export function isLineInRanges(lineNumber: number, ranges: readonly LineRange[]): boolean {
 	for (const range of ranges) {

package/src/tools/read.ts

@@ -2316,6 +2316,49 @@ interface ReadRenderArgs {
 	raw?: boolean;
 }
 
+const INTERNAL_URL_LIKE_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+function splitReadRenderPath(rawPath: string): { path: string; sel?: string } {
+	if (INTERNAL_URL_LIKE_RE.test(rawPath)) {
+		const internal = splitInternalUrlSel(rawPath);
+		if (internal.sel) return internal;
+	}
+	return splitPathAndSel(rawPath);
+}
+
+function firstReadSelectorLine(sel: string | undefined): number | undefined {
+	if (!sel) return undefined;
+	try {
+		const parsed = parseSel(sel);
+		if (parsed.kind !== "lines") return undefined;
+		return parsed.ranges[0].startLine;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatReadPathLink(
+	rawPath: string,
+	options: {
+		resolvedPath?: string;
+		suffixResolution?: { from: string; to: string };
+		offset?: number;
+		fallbackLabel?: string;
+	},
+): string {
+	const split = splitReadRenderPath(rawPath);
+	const basePath = split.path || rawPath;
+	const selectorSuffix = split.sel ? `:${split.sel}` : "";
+	const plainDisplayPath = options.suffixResolution
+		? shortenPath(options.suffixResolution.to)
+		: shortenPath(basePath || options.resolvedPath || options.fallbackLabel || rawPath);
+	const target = options.resolvedPath ?? tryResolveInternalUrlSync(basePath);
+	const line = firstReadSelectorLine(split.sel) ?? options.offset;
+	const linkOptions = line !== undefined ? { line } : undefined;
+	const displayPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
+	return `${displayPath}${selectorSuffix}`;
+}
+
 export const readToolRenderer = {
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		if (isReadableUrlPath(args.file_path || args.path || "")) {
@@ -2323,13 +2366,10 @@ export const readToolRenderer = {
 		}
 
 		const rawPath = args.file_path || args.path || "";
-		const shortPath = shortenPath(rawPath);
-		const linkTarget = tryResolveInternalUrlSync(rawPath);
-		const filePath = linkTarget ? fileHyperlink(linkTarget, shortPath) : shortPath;
 		const offset = args.offset;
 		const limit = args.limit;
 
-		let pathDisplay = filePath || "…";
+		let pathDisplay = formatReadPathLink(rawPath, { offset, fallbackLabel: "…" }) || "…";
 		if (offset !== undefined || limit !== undefined) {
 			const startLine = offset ?? 1;
 			const endLine = limit !== undefined ? startLine + limit - 1 : "";
@@ -2363,7 +2403,7 @@ export const readToolRenderer = {
 			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
 			const rawPath = args?.file_path || args?.path || "";
-			const filePath = shortenPath(rawPath);
+			const filePath = formatReadPathLink(rawPath, { offset: args?.offset }) || shortenPath(rawPath);
 			let title = filePath ? `Read ${filePath}` : "Read";
 			if (args?.offset !== undefined || args?.limit !== undefined) {
 				const startLine = args.offset ?? 1;
@@ -2388,8 +2428,8 @@ export const readToolRenderer = {
 		const contentText = details?.displayContent?.text ?? stripOutputNotice(rawText, details?.meta);
 		const imageContent = result.content?.find(c => c.type === "image");
 		const rawPath = args?.file_path || args?.path || "";
-		const filePath = shortenPath(rawPath);
-		const lang = getLanguageFromPath(splitPathAndSel(rawPath).path);
+		const renderPath = splitReadRenderPath(rawPath);
+		const lang = getLanguageFromPath(renderPath.path);
 
 		const warningLines: string[] = [];
 		const truncation = details?.meta?.truncation;
@@ -2412,7 +2452,11 @@ export const readToolRenderer = {
 
 		if (imageContent) {
 			const suffix = details?.suffixResolution;
-			const displayPath = suffix ? shortenPath(suffix.to) : filePath || rawPath || "image";
+			const displayPath = formatReadPathLink(rawPath, {
+				resolvedPath: details?.resolvedPath,
+				suffixResolution: suffix,
+				fallbackLabel: "image",
+			});
 			const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
 			const header = renderStatusLine(
 				{ icon: suffix ? "warning" : "success", title: "Read", description: `${displayPath}${correction}` },
@@ -2442,13 +2486,15 @@ export const readToolRenderer = {
 		}
 
 		const suffix = details?.suffixResolution;
-		const plainDisplayPath = suffix ? shortenPath(suffix.to) : filePath;
 		// resolvedPath is the absolute fs path for fs-backed reads (regular files plus
 		// local:// / memory:// / skill:// / artifact:// resources). Fall back to a sync
 		// resolver for fs-backed internal URLs so the title is clickable even before the
 		// result lands or if the handler didn't populate resolvedPath.
-		const absForLink = details?.resolvedPath ?? tryResolveInternalUrlSync(rawPath);
-		const displayPath = absForLink ? fileHyperlink(absForLink, plainDisplayPath) : plainDisplayPath;
+		const displayPath = formatReadPathLink(rawPath, {
+			resolvedPath: details?.resolvedPath,
+			suffixResolution: suffix,
+			offset: args?.offset,
+		});
 		const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
 		let title = displayPath ? `Read ${displayPath}${correction}` : "Read";
 		if (args?.offset !== undefined || args?.limit !== undefined) {
@@ -2463,7 +2509,7 @@ export const readToolRenderer = {
 			const n = details.conflictCount;
 			title += ` ${uiTheme.fg("warning", `(⚠ ${n} conflict${n === 1 ? "" : "s"})`)}`;
 		}
-		const rawRequested = args?.raw === true || isRawSelector(parseSel(splitPathAndSel(rawPath).sel));
+		const rawRequested = args?.raw === true || isRawSelector(parseSel(renderPath.sel));
 		const isMarkdown = details?.contentType === "text/markdown" && !rawRequested;
 		let cachedWidth: number | undefined;
 		let cachedExpanded: boolean | undefined;

package/src/tools/search-tool-bm25.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
+import { resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
 import {
 	buildDiscoverableToolSearchIndex,
 	type DiscoverableTool,
@@ -198,12 +199,9 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): SearchToolBm25Tool | null {
-		// Active when new tools.discoveryMode is non-"off" or legacy mcp.discoveryMode is true
-		const toolsDiscoveryMode = session.settings.get("tools.discoveryMode");
-		const active =
-			(toolsDiscoveryMode !== undefined && toolsDiscoveryMode !== "off") ||
-			session.settings.get("mcp.discoveryMode") === true;
-		if (!active) return null;
+		// Direct createTools() calls do not know the final MCP/extension catalog yet, so
+		// auto mode is activated later by createAgentSession after the full registry exists.
+		if (resolveEffectiveToolDiscoveryMode(session.settings, 0) === "off") return null;
 		return supportsToolDiscoveryExecution(session) ? new SearchToolBm25Tool(session) : null;
 	}
 

package/src/tools/search.ts

@@ -16,7 +16,15 @@ import type { InternalResource, ResolveContext } from "../internal-urls/types";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "../session/streaming-output";
-import { Ellipsis, fileHyperlink, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import {
+	Ellipsis,
+	fileHyperlink,
+	renderStatusLine,
+	renderTreeList,
+	truncateToWidth,
+	tryResolveInternalUrlSync,
+	uriHyperlink,
+} from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import {
@@ -38,6 +46,8 @@ import {
 	type ResolvedSearchTarget,
 	resolveReadPath,
 	resolveToolSearchScope,
+	selectorLineRanges,
+	splitInternalUrlSel,
 	splitPathAndSel,
 } from "./path-utils";
 import {
@@ -109,6 +119,21 @@ interface SearchPathSpec {
 function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
 	const specs: SearchPathSpec[] = [];
 	for (const entry of rawEntries) {
+		// Internal URLs (`artifact://`, `skill://`, …) use the URL-aware splitter,
+		// which peels selector-shaped tails only for selector-capable schemes and
+		// leaves opaque ones (`mcp://`) intact. Unlike filesystem paths, their
+		// verbatim/index display modes (`raw`, `conflicts`) carry no meaning for
+		// content search, so we accept them — searching the whole resource — and
+		// still honor any embedded line range as a match filter.
+		const internalSplit = splitInternalUrlSel(entry);
+		if (internalSplit.sel !== undefined) {
+			specs.push({
+				original: entry,
+				clean: internalSplit.path,
+				ranges: selectorLineRanges(internalSplit.sel),
+			});
+			continue;
+		}
 		const split = splitPathAndSel(entry);
 		let clean = entry;
 		let ranges: [LineRange, ...LineRange[]] | undefined;
@@ -259,7 +284,7 @@ interface IndexedContentLines {
 }
 
 const INTERNAL_URL_DISPLAY_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
-const OMP_ROOT_URL_RE = /^omp:\/\/\/?$/i;
+const OMP_ROOT_URL_RE = /^omp:\/\/(?:\/?|docs\/?)$/i;
 
 function normalizeSearchLine(line: string): string {
 	return line.endsWith("\r") ? line.slice(0, -1) : line;
@@ -1145,6 +1170,26 @@ interface SearchRenderArgs {
 
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
+const SEARCH_CODE_FRAME_LINE_RE = /^\s*\*?(\d+)│/;
+
+function searchScopeMeta(details: SearchToolDetails | undefined): string | undefined {
+	if (!details?.scopePath) return undefined;
+	const label = details.searchPath ? fileHyperlink(details.searchPath, details.scopePath) : details.scopePath;
+	return `in ${label}`;
+}
+
+function linkUrlLikeSearchHeader(raw: string, styled: string): { line: string; absPath?: string } {
+	const resolvedPath = tryResolveInternalUrlSync(raw);
+	if (resolvedPath) return { line: fileHyperlink(resolvedPath, styled), absPath: resolvedPath };
+	return { line: uriHyperlink(raw, styled) };
+}
+
+function parseSearchDisplayLineNumber(line: string): number | undefined {
+	const match = SEARCH_CODE_FRAME_LINE_RE.exec(line);
+	if (!match) return undefined;
+	return Number.parseInt(match[1]!, 10);
+}
+
 export const searchToolRenderer = {
 	inline: true,
 	renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
@@ -1220,8 +1265,11 @@ export const searchToolRenderer = {
 				: undefined;
 
 		if (matchCount === 0) {
+			const meta = ["0 matches"];
+			const scopeMeta = searchScopeMeta(details);
+			if (scopeMeta) meta.push(scopeMeta);
 			const header = renderStatusLine(
-				{ icon: "warning", title: "Search", description: args?.pattern, meta: ["0 matches"] },
+				{ icon: "warning", title: "Search", description: args?.pattern, meta },
 				uiTheme,
 			);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
@@ -1231,7 +1279,8 @@ export const searchToolRenderer = {
 
 		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
 		const meta = [...summaryParts];
-		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
+		const scopeMeta = searchScopeMeta(details);
+		if (scopeMeta) meta.push(scopeMeta);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const description = args?.pattern ?? undefined;
 		const header = renderStatusLine(
@@ -1270,10 +1319,11 @@ export const searchToolRenderer = {
 						maxCollapsedLines: collapsedMatchLineBudget,
 						itemType: "match",
 						renderItem: group => {
-							// Track directory context within a group for ## file headers.
-							// `# foo/` is a directory header; `# foo.ts` is a root-level file
-							// from formatGroupedFiles (single-# when directory is `.`).
+							// Track directory/file context within a group so headers and code-frame
+							// lines link to the backing file, with line-specific links for matches.
 							let contextDir = searchBase ?? "";
+							const hasFileHeader = group.some(line => line.startsWith("# "));
+							let currentFilePath: string | undefined = hasFileHeader ? undefined : searchBase;
 							return group.map(line => {
 								if (line.startsWith("## ")) {
 									// Strip optional ` (suffix)` and `#hash` before resolving.
@@ -1283,6 +1333,7 @@ export const searchToolRenderer = {
 										.replace(/\s+\([^)]*\)\s*$/, "")
 										.replace(/#[0-9a-f]+$/, "");
 									const absPath = contextDir && fileName ? path.join(contextDir, fileName) : undefined;
+									currentFilePath = absPath;
 									const styled = uiTheme.fg("dim", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
 								}
@@ -1293,22 +1344,37 @@ export const searchToolRenderer = {
 										.replace(/\s+\([^)]*\)\s*$/, "");
 									if (INTERNAL_URL_DISPLAY_RE.test(raw)) {
 										contextDir = "";
-										return uiTheme.fg("accent", line);
+										const styled = uiTheme.fg("accent", line);
+										const linked = linkUrlLikeSearchHeader(raw, styled);
+										currentFilePath = linked.absPath;
+										return linked.line;
 									}
 									const isDirectory = raw.endsWith("/");
 									const name = isDirectory ? raw.replace(/\/$/, "") : raw.replace(/#[0-9a-f]+$/, "");
 									if (isDirectory) {
-										if (searchBase) {
-											contextDir = name === "." ? searchBase : path.join(searchBase, name);
+										const absPath = searchBase
+											? name === "."
+												? searchBase
+												: path.join(searchBase, name)
+											: undefined;
+										if (absPath) {
+											contextDir = absPath;
 										}
-										return uiTheme.fg("accent", line);
+										currentFilePath = undefined;
+										const styled = uiTheme.fg("accent", line);
+										return absPath ? fileHyperlink(absPath, styled) : styled;
 									}
 									// Root-level file emitted by formatGroupedFiles when the directory is `.`.
 									const absPath = searchBase && name ? path.join(searchBase, name) : undefined;
+									currentFilePath = absPath;
 									const styled = uiTheme.fg("accent", line);
 									return absPath ? fileHyperlink(absPath, styled) : styled;
 								}
-								return uiTheme.fg("toolOutput", line);
+								const styled = uiTheme.fg("toolOutput", line);
+								const lineNumber = parseSearchDisplayLineNumber(line);
+								return currentFilePath && lineNumber !== undefined
+									? fileHyperlink(currentFilePath, styled, { line: lineNumber })
+									: styled;
 							});
 						},
 					},

package/src/tui/hyperlink.ts

@@ -1,5 +1,5 @@
 /**
- * OSC 8 terminal hyperlink support for file paths.
+ * OSC 8 terminal hyperlink support for paths and URLs.
  *
  * Wraps display text in `ESC ] 8 ; id=HASH ; URI ESC \ TEXT ESC ] 8 ; ; ESC \`
  * sequences when the active terminal supports hyperlinks and the user setting
@@ -63,6 +63,46 @@ export function isHyperlinkEnabled(): boolean {
 	return TERMINAL.hyperlinks;
 }
 
+function safeHyperlinkUri(uri: string): string | undefined {
+	if (!uri || /[\x00-\x1f\x7f]/.test(uri)) return undefined;
+	return uri;
+}
+
+function wrapHyperlink(uri: string, displayText: string): string {
+	if (!isHyperlinkEnabled()) return displayText;
+	// Do not double-wrap if the text already embeds an OSC 8 sequence.
+	if (displayText.includes("\x1b]8;")) return displayText;
+	const safeUri = safeHyperlinkUri(uri);
+	if (!safeUri) return displayText;
+	const id = buildLinkId(safeUri);
+	return `${OSC}8;id=${id};${safeUri}${ST}${displayText}${OSC}8;;${ST}`;
+}
+
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at `uri`.
+ *
+ * Returns `displayText` unchanged when hyperlinks are disabled, `uri` contains
+ * terminal control bytes, or `displayText` already contains an OSC 8 sequence.
+ */
+export function uriHyperlink(uri: string, displayText: string): string {
+	return wrapHyperlink(uri, displayText);
+}
+
+/**
+ * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL.
+ * `www.example.com` inputs are linked as `https://www.example.com`.
+ */
+export function urlHyperlink(url: string, displayText: string): string {
+	const normalized = url.match(/^www\./i) ? `https://${url}` : url;
+	try {
+		const parsed = new URL(normalized);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return displayText;
+		return wrapHyperlink(parsed.href, displayText);
+	} catch {
+		return displayText;
+	}
+}
+
 /**
  * Wrap `displayText` in an OSC 8 hyperlink pointing at the given absolute file path.
  *
@@ -78,12 +118,7 @@ export function isHyperlinkEnabled(): boolean {
  * @param opts - Optional line/col position appended as `?line=N&col=M` query params
  */
 export function fileHyperlink(absPath: string, displayText: string, opts?: { line?: number; col?: number }): string {
-	if (!isHyperlinkEnabled()) return displayText;
-	// Do not double-wrap if the text already embeds an OSC 8 sequence.
-	if (displayText.includes("\x1b]8;")) return displayText;
-	const uri = buildFileUri(absPath, opts);
-	const id = buildLinkId(uri);
-	return `${OSC}8;id=${id};${uri}${ST}${displayText}${OSC}8;;${ST}`;
+	return wrapHyperlink(buildFileUri(absPath, opts), displayText);
 }
 
 /**

package/src/utils/file-mentions.ts

@@ -10,8 +10,6 @@ import path from "node:path";
 import { formatHashlineHeader, formatNumberedLines, type SnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { glob } from "@oh-my-pi/pi-natives";
-import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { formatAge, formatBytes, readImageMetadata } from "@oh-my-pi/pi-utils";
 import { normalizeToLF } from "../edit/normalize";
 import type { FileMentionMessage } from "../session/messages";
@@ -30,27 +28,6 @@ const LEADING_PUNCTUATION_REGEX = /^[`"'([{<]+/;
 const TRAILING_PUNCTUATION_REGEX = /[)\]}>.,;:!?"'`]+$/;
 const MENTION_BOUNDARY_REGEX = /[\s([{<"'`]/;
 const DEFAULT_DIR_LIMIT = 500;
-const MIN_FUZZY_QUERY_LENGTH = 5;
-const MAX_RESOLUTION_CANDIDATES = 20_000;
-const PATH_SEPARATOR_REGEX = /[/._\-\s]+/g;
-
-type MentionDiscoveryProfile = {
-	hidden: boolean;
-	gitignore: boolean;
-	includeNodeModules: boolean;
-	maxResults: number;
-	cache: boolean;
-};
-
-function getMentionCandidateDiscoveryProfile(): MentionDiscoveryProfile {
-	return {
-		hidden: true,
-		gitignore: true,
-		cache: true,
-		includeNodeModules: true,
-		maxResults: MAX_RESOLUTION_CANDIDATES,
-	};
-}
 
 // Avoid OOM when users @mention very large files. Above these limits we skip
 // auto-reading and only include the path in the message.
@@ -70,16 +47,6 @@ function sanitizeMentionPath(rawPath: string): string | null {
 	return cleaned.length > 0 ? cleaned : null;
 }
 
-type MentionCandidate = {
-	path: string;
-	pathLower: string;
-	normalizedPath: string;
-};
-
-function normalizeMentionQuery(query: string): string {
-	return query.toLowerCase().replace(PATH_SEPARATOR_REGEX, "");
-}
-
 async function pathExists(filePath: string): Promise<boolean> {
 	try {
 		await Bun.file(filePath).stat();
@@ -89,75 +56,13 @@ async function pathExists(filePath: string): Promise<boolean> {
 	}
 }
 
-async function listMentionCandidates(cwd: string): Promise<MentionCandidate[]> {
-	let entries: string[];
-	try {
-		const discoveryProfile = getMentionCandidateDiscoveryProfile();
-		const result = await glob({
-			pattern: "**/*",
-			path: cwd,
-			...discoveryProfile,
-		});
-		entries = result.matches.map(match => match.path);
-	} catch {
-		return [];
-	}
-
-	entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-	const candidates: MentionCandidate[] = [];
-	for (const entry of entries) {
-		const pathLower = entry.toLowerCase();
-		const normalizedPath = normalizeMentionQuery(entry);
-		if (normalizedPath.length === 0) {
-			continue;
-		}
-		candidates.push({ path: entry, pathLower, normalizedPath });
-	}
-	return candidates;
-}
-
-async function resolveMentionPath(
-	filePath: string,
-	cwd: string,
-	getMentionCandidates: () => Promise<MentionCandidate[]>,
-): Promise<string | null> {
+async function resolveMentionPath(filePath: string, cwd: string): Promise<string | null> {
+	// Exact resolution only. The TUI @-selector inserts the real, complete path, so a
+	// mention that does not resolve to an existing file or directory is prose, not a file
+	// reference. Fuzzy/prefix guessing here previously dragged in unrelated same-named
+	// files; that disambiguation belongs to the selector's display, not post-send.
 	const absolutePath = resolveReadPath(filePath, cwd);
-	if (await pathExists(absolutePath)) {
-		return filePath;
-	}
-
-	const queryLower = filePath.toLowerCase();
-	const candidates = await getMentionCandidates();
-	const prefixMatches = candidates.filter(candidate => candidate.pathLower.startsWith(queryLower));
-	if (prefixMatches.length === 1) {
-		return prefixMatches[0]?.path ?? null;
-	}
-	if (prefixMatches.length > 1) {
-		return null;
-	}
-
-	const normalizedQuery = normalizeMentionQuery(filePath);
-	if (normalizedQuery.length < MIN_FUZZY_QUERY_LENGTH) {
-		return null;
-	}
-
-	const scored = candidates
-		.map(candidate => ({ candidate, match: fuzzyMatch(normalizedQuery, candidate.normalizedPath) }))
-		.filter(entry => entry.match.matches)
-		.sort((a, b) => {
-			if (a.match.score !== b.match.score) {
-				return a.match.score - b.match.score;
-			}
-			return a.candidate.path.localeCompare(b.candidate.path);
-		});
-
-	if (scored.length === 0) {
-		return null;
-	}
-
-	const best = scored[0];
-
-	return best?.candidate.path ?? null;
+	return (await pathExists(absolutePath)) ? filePath : null;
 }
 
 function buildTextOutput(textContent: string): { output: string; lineCount: number } {
@@ -285,14 +190,9 @@ export async function generateFileMentionMessages(
 	const autoResizeImages = options?.autoResizeImages ?? true;
 
 	const files: FileMentionMessage["files"] = [];
-	let mentionCandidatesPromise: Promise<MentionCandidate[]> | null = null;
-	const getMentionCandidates = (): Promise<MentionCandidate[]> => {
-		mentionCandidatesPromise ??= listMentionCandidates(cwd);
-		return mentionCandidatesPromise;
-	};
 
 	for (const filePath of filePaths) {
-		const resolvedPath = await resolveMentionPath(filePath, cwd, getMentionCandidates);
+		const resolvedPath = await resolveMentionPath(filePath, cwd);
 		if (!resolvedPath) {
 			continue;
 		}