@oh-my-pi/pi-coding-agent 15.10.7 → 15.10.9

package/src/modes/components/assistant-message.ts

@@ -5,7 +5,16 @@ import { settings } from "../../config/settings";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { resolveAbortLabel, shouldRenderAbortReason } from "../../session/messages";
-import { resolveImageOptions } from "../../tools/render-utils";
+import { getPreviewLines, resolveImageOptions, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+
+/**
+ * Max lines of a turn-ending provider error rendered inline in the transcript.
+ * Bounds pathological error bodies — e.g. a proxy 502 whose body is a full HTML
+ * page — so they can't flood the scrollback. Blank lines are dropped and each
+ * line is width-truncated by {@link getPreviewLines}. Full text is still kept in
+ * the persisted session.
+ */
+const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
 /**
  * Component that renders a complete assistant message
@@ -78,6 +87,22 @@ export class AssistantMessageComponent extends Container {
 		this.#transcriptBlockFinalized = true;
 	}
 
+	/**
+	 * Render a turn-ending provider error inline. Drops blank lines, clamps the
+	 * line count to {@link MAX_TRANSCRIPT_ERROR_LINES}, and width-truncates each
+	 * line so a pathological body — e.g. the HTML page a proxy returns on a 502 —
+	 * can't flood the transcript. Mirrors {@link ErrorBannerComponent}.
+	 */
+	#appendErrorBlock(message: string): void {
+		const lines = getPreviewLines(message, MAX_TRANSCRIPT_ERROR_LINES, TRUNCATE_LENGTHS.LINE);
+		if (lines.length === 0) lines.push("Unknown error");
+		this.#contentContainer.addChild(new Spacer(1));
+		this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${lines[0]}`), 1, 0));
+		for (const line of lines.slice(1)) {
+			this.#contentContainer.addChild(new Text(theme.fg("error", `  ${line}`), 1, 0));
+		}
+	}
+
 	setToolResultImages(toolCallId: string, images: ImageContent[]): void {
 		if (!toolCallId) return;
 		const validImages = images.filter(img => img.type === "image" && img.data && img.mimeType);
@@ -249,9 +274,7 @@ export class AssistantMessageComponent extends Container {
 				}
 				this.#contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
 			} else if (message.stopReason === "error" && !this.#errorPinned) {
-				const errorMsg = message.errorMessage || "Unknown error";
-				this.#contentContainer.addChild(new Spacer(1));
-				this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
+				this.#appendErrorBlock(message.errorMessage || "Unknown error");
 			}
 		}
 		if (
@@ -260,8 +283,7 @@ export class AssistantMessageComponent extends Container {
 			message.stopReason !== "aborted" &&
 			message.stopReason !== "error"
 		) {
-			this.#contentContainer.addChild(new Spacer(1));
-			this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${message.errorMessage}`), 1, 0));
+			this.#appendErrorBlock(message.errorMessage);
 		}
 
 		// Token usage metadata

package/src/modes/components/custom-editor.ts

@@ -58,16 +58,72 @@ function buildMatchKeys(keys: readonly KeyId[]): Set<string> {
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_IMAGE_PATH_REGEX = /\.(?:png|jpe?g|gif|webp)$/i;
+const BRACKETED_IMAGE_PATH_BOUNDARY_REGEX = /\.(?:png|jpe?g|gif|webp)(?=$|["']?\s)/gi;
+const SHELL_ESCAPED_PATH_CHAR_REGEX = /\\([\\\s'"()[\]{}&;<>|?*!$`])/g;
 
-export function extractBracketedImagePastePath(data: string): string | undefined {
+function isPastedPathSeparator(char: string | undefined): boolean {
+	return char === undefined || char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+
+function imagePathBoundaryEnd(payload: string, segmentStart: number, extensionEnd: number): number | undefined {
+	const quote = payload[segmentStart];
+	const afterExtension = payload[extensionEnd];
+	if (quote === '"' || quote === "'") {
+		return afterExtension === quote && isPastedPathSeparator(payload[extensionEnd + 1])
+			? extensionEnd + 1
+			: undefined;
+	}
+	if (isPastedPathSeparator(afterExtension)) return extensionEnd;
+	return undefined;
+}
+
+function normalizePastedImagePath(path: string): string {
+	const trimmed = path.trim();
+	const first = trimmed[0];
+	const last = trimmed[trimmed.length - 1];
+	const unquoted =
+		trimmed.length > 1 && (first === '"' || first === "'") && last === first ? trimmed.slice(1, -1) : trimmed;
+	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");
+}
+
+export function extractBracketedImagePastePaths(data: string): string[] | undefined {
 	if (!data.startsWith(BRACKETED_PASTE_START)) return undefined;
 	const endIndex = data.indexOf(BRACKETED_PASTE_END, BRACKETED_PASTE_START.length);
 	if (endIndex === -1 || endIndex + BRACKETED_PASTE_END.length !== data.length) return undefined;
 
 	const pasted = data.slice(BRACKETED_PASTE_START.length, endIndex).trim();
-	if (!pasted || /[\r\n]/.test(pasted)) return undefined;
-	if (!BRACKETED_IMAGE_PATH_REGEX.test(pasted)) return undefined;
-	return pasted;
+	if (!pasted) return undefined;
+
+	const paths: string[] = [];
+	let segmentStart = 0;
+	BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = 0;
+	for (
+		let match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted);
+		match;
+		match = BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.exec(pasted)
+	) {
+		const extensionEnd = match.index + match[0].length;
+		const boundaryEnd = imagePathBoundaryEnd(pasted, segmentStart, extensionEnd);
+		if (boundaryEnd === undefined) continue;
+
+		const path = normalizePastedImagePath(pasted.slice(segmentStart, boundaryEnd));
+		if (!path || !BRACKETED_IMAGE_PATH_REGEX.test(path)) return undefined;
+		paths.push(path);
+
+		segmentStart = boundaryEnd;
+		while (segmentStart < pasted.length && isPastedPathSeparator(pasted[segmentStart])) {
+			segmentStart++;
+		}
+		BRACKETED_IMAGE_PATH_BOUNDARY_REGEX.lastIndex = segmentStart;
+	}
+
+	if (paths.length === 0 || segmentStart !== pasted.length) return undefined;
+	return paths;
+}
+
+export function extractBracketedImagePastePath(data: string): string | undefined {
+	const paths = extractBracketedImagePastePaths(data);
+	return paths?.length === 1 ? paths[0] : undefined;
 }
 
 /**
@@ -111,8 +167,8 @@ export class CustomEditor extends Editor {
 	onCopyPrompt?: () => void;
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
-	/** Called when a bracketed paste contains exactly one image-file path. */
-	onPasteImagePath?: (path: string) => void;
+	/** Called when a bracketed paste contains one or more image-file paths. */
+	onPasteImagePath?: (path: string) => void | Promise<void>;
 	/** Called when the configured raw text-paste shortcut is pressed. */
 	onPasteTextRaw?: () => void;
 	/** Called when the configured dequeue shortcut is pressed. */
@@ -188,9 +244,13 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		const pastedImagePath = extractBracketedImagePastePath(data);
-		if (pastedImagePath && this.onPasteImagePath) {
-			this.onPasteImagePath(pastedImagePath);
+		const pastedImagePaths = extractBracketedImagePastePaths(data);
+		if (pastedImagePaths && this.onPasteImagePath) {
+			void (async () => {
+				for (const path of pastedImagePaths) {
+					await this.onPasteImagePath?.(path);
+				}
+			})();
 			return;
 		}
 

package/src/modes/components/transcript-container.ts

@@ -7,7 +7,11 @@ interface FrozenRender {
 	lines: string[];
 	generation: number;
 	appendOnly: boolean;
-	volatile: boolean;
+	/**
+	 * Frames remaining until a block that rewrote an interior row may re-earn
+	 * append-only status. `0` means the block is not under rewrite suspicion.
+	 */
+	volatileCooldown: number;
 }
 
 interface SnapshotCarrier {
@@ -51,10 +55,41 @@ function stripPlainBlankEdges(lines: string[]): string[] {
 
 interface LiveCommitState {
 	appendOnly: boolean;
-	volatile: boolean;
+	volatileCooldown: number;
 	safeLength: number;
 }
 
+/**
+ * Render frames a block must stay clean (static or append-shaped) after an
+ * interior rewrite before its rows become committable again. A one-off
+ * re-layout (a codespan finalizing across a wrap boundary, a paragraph
+ * re-parsed as a heading) only suspends commits briefly — the pinned emitter
+ * appends from the stalled high-water mark, so the gap backfills contiguously
+ * once the block re-earns append-only. Periodic animations (a spinner rewrites
+ * its row every few frames) keep resetting the countdown and never re-earn it,
+ * so genuinely volatile blocks stay deferred. Frames arrive at most at the
+ * TUI's 30 Hz render cadence, so 30 frames ≈ 1s of clean streaming.
+ */
+const VOLATILE_REARM_FRAMES = 30;
+
+/**
+ * Visible-content form of a row: SGR/OSC bytes and trailing pad spaces are
+ * write framing, not content. A styled line's closing escape moves when the
+ * line stops being the last of its span (a wrapped thinking paragraph growing
+ * by one row), and width-padded rows shift their trailing spaces as text
+ * grows; both leave the on-screen cells identical and must not count as a
+ * rewrite of a committed-candidate row. Committed scrollback rows are written
+ * with a full SGR/OSC reset terminator, so escape-placement drift between
+ * visually identical renders cannot bleed styles across rows.
+ */
+function normalizeRow(line: string): string {
+	return Bun.stripANSI(line).trimEnd();
+}
+
+function rowsVisiblyEqual(prev: string, cur: string): boolean {
+	return prev === cur || normalizeRow(prev) === normalizeRow(cur);
+}
+
 function hasValidSnapshot(
 	snapshot: FrozenRender | undefined,
 	width: number,
@@ -66,14 +101,14 @@ function hasValidSnapshot(
 function commonPrefixLength(prev: string[], cur: string[]): number {
 	const limit = Math.min(prev.length, cur.length);
 	let i = 0;
-	while (i < limit && prev[i] === cur[i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[i]!, cur[i]!)) i++;
 	return i;
 }
 
 function commonSuffixLength(prev: string[], cur: string[], prefixLength: number): number {
 	const limit = Math.min(prev.length - prefixLength, cur.length - prefixLength);
 	let i = 0;
-	while (i < limit && prev[prev.length - 1 - i] === cur[cur.length - 1 - i]) i++;
+	while (i < limit && rowsVisiblyEqual(prev[prev.length - 1 - i]!, cur[cur.length - 1 - i]!)) i++;
 	return i;
 }
 
@@ -84,42 +119,56 @@ function deriveLiveCommitState(
 	generation: number,
 ): LiveCommitState {
 	let appendOnly = false;
-	let volatile = false;
+	let volatileCooldown = 0;
 	if (hasValidSnapshot(previous, width, generation)) {
 		appendOnly = previous.appendOnly;
-		volatile = previous.volatile;
+		volatileCooldown = previous.volatileCooldown;
 
 		const prefixLength = commonPrefixLength(previous.lines, current);
 		const staticRender = prefixLength === previous.lines.length && prefixLength === current.length;
+		let cleanFrame = true;
 		if (!staticRender) {
 			const suffixLength = commonSuffixLength(previous.lines, current, prefixLength);
 			// Append-only growth never rewrites a row that may already have scrolled
-			// into native scrollback; it only grows the block at/near its tail. Three
+			// into native scrollback; it only grows the block at/near its tail. Four
 			// shapes qualify: a pure bottom append, an insertion above stable trailing
-			// chrome (a streaming tool's footer/border), and an in-place extension of
-			// the current line by one streamed token (line count unchanged). The first
-			// two preserve every previous row across a matching prefix + suffix; the
-			// last leaves a single divergent previous row that the current row merely
-			// lengthens. A divergent interior row that is genuinely rewritten means the
-			// block re-laid-out committed content — volatile, and never committed.
+			// chrome (a streaming tool's footer/border), an in-place extension of the
+			// current line by one streamed token (line count unchanged), and a
+			// wrap-shrink of the current line where its last word grew past the wrap
+			// column and moved down onto an appended row. The first two preserve every
+			// previous row across a matching prefix + suffix; the last two leave a
+			// single divergent previous row — the block's in-flight bottom line, which
+			// cannot have been committed (commits stop at the viewport top and the
+			// bottom line is by definition on screen). Any other divergent interior
+			// row means the block re-laid-out committed-candidate content — a rewrite,
+			// which suspends commits until the block re-earns append-only.
 			const preservedEveryRow = prefixLength + suffixLength >= previous.lines.length;
-			const tailExtendedInPlace =
+			let tailExtendedInPlace = false;
+			if (
+				!preservedEveryRow &&
 				prefixLength + suffixLength === previous.lines.length - 1 &&
-				prefixLength < current.length &&
-				current[prefixLength]!.startsWith(previous.lines[prefixLength]!);
-			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length && !volatile) {
-				appendOnly = true;
-			} else if (!preservedEveryRow && !tailExtendedInPlace) {
-				volatile = true;
+				prefixLength < current.length
+			) {
+				const prevTail = normalizeRow(previous.lines[prefixLength]!);
+				const curTail = normalizeRow(current[prefixLength]!);
+				tailExtendedInPlace =
+					curTail.startsWith(prevTail) || (current.length > previous.lines.length && prevTail.startsWith(curTail));
+			}
+			if ((preservedEveryRow || tailExtendedInPlace) && current.length >= previous.lines.length) {
+				if (volatileCooldown === 0) appendOnly = true;
+			} else {
+				cleanFrame = false;
 				appendOnly = false;
+				volatileCooldown = VOLATILE_REARM_FRAMES;
 			}
 		}
+		if (cleanFrame && volatileCooldown > 0) volatileCooldown--;
 	}
 
 	return {
 		appendOnly,
-		volatile,
-		safeLength: volatile ? 0 : appendOnly ? current.length : 0,
+		volatileCooldown,
+		safeLength: appendOnly ? current.length : 0,
 	};
 }
 
@@ -163,8 +212,11 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	#nativeScrollbackLiveRegionStart: number | undefined;
 	// Local line index up to which the leading run of live blocks is safe to
 	// commit. Finalized blocks contribute their full frozen body; still-live
-	// blocks contribute only after their stripped render has been observed
-	// growing without changing a previously rendered interior row.
+	// blocks contribute only while their render has been observed growing
+	// without visibly rewriting a previously rendered interior row (escape
+	// placement and pad drift are ignored). A rewrite suspends the block's
+	// contribution until it re-earns append-only via VOLATILE_REARM_FRAMES
+	// clean frames; the pinned emitter then backfills the stalled gap.
 	#nativeScrollbackCommitSafeEnd: number | undefined;
 
 	override invalidate(): void {
@@ -265,7 +317,7 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 						lines: contribution,
 						generation: this.#generation,
 						appendOnly: liveCommitState?.appendOnly ?? false,
-						volatile: liveCommitState?.volatile ?? false,
+						volatileCooldown: liveCommitState?.volatileCooldown ?? 0,
 					};
 				}
 			}

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

@@ -191,7 +191,7 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
 		);
 		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
-		this.ctx.editor.onPasteImagePath = path => void this.handleImagePathPaste(path);
+		this.ctx.editor.onPasteImagePath = path => this.handleImagePathPaste(path);
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteTextRaw",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteTextRaw"),

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

@@ -36,7 +36,7 @@ import {
 import type { MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
 import type { OAuthCredential } from "../../session/auth-storage";
 import { shortenPath } from "../../tools/render-utils";
-import { urlHyperlink } from "../../tui";
+import { urlHyperlinkAlways } from "../../tui";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -63,7 +63,7 @@ export class MCPAuthorizationLinkPrompt implements Component {
 	invalidate(): void {}
 
 	render(_width: number): string[] {
-		const link = urlHyperlink(this.#url, "Click here to authorize");
+		const link = urlHyperlinkAlways(this.#url, "Click here to authorize");
 		return [
 			` ${theme.fg("success", "Open authorization URL:")}`,
 			` ${theme.fg("accent", link)}`,

package/src/sdk.ts

@@ -62,10 +62,11 @@ import {
 	type LoadedCustomCommand,
 	loadCustomCommands as loadCustomCommandsInternal,
 } from "./extensibility/custom-commands";
-import { discoverAndLoadCustomTools } from "./extensibility/custom-tools";
+import { discoverCustomToolPaths, loadCustomTools, type ToolPathWithSource } from "./extensibility/custom-tools";
 import type { CustomTool, CustomToolContext, CustomToolSessionEvent } from "./extensibility/custom-tools/types";
 import {
 	discoverAndLoadExtensions,
+	discoverExtensionPaths,
 	type ExtensionContext,
 	type ExtensionFactory,
 	ExtensionRunner,
@@ -337,10 +338,41 @@ export interface CreateAgentSessionOptions {
 	/** Disable extension discovery (explicit paths still load). */
 	disableExtensionDiscovery?: boolean;
 	/**
-	 * Pre-loaded extensions (skips file discovery).
-	 * @internal Used by CLI when extensions are loaded early to parse custom flags.
+	 * Pre-loaded extensions (skips file discovery and the per-session factory
+	 * call). Used by the CLI when extensions are loaded early to parse custom
+	 * flags — the same process owns the returned instances, so reusing them is
+	 * safe.
+	 *
+	 * NEVER pass this across session boundaries (e.g. parent → subagent).
+	 * `Extension` instances close over a parent-bound `ExtensionAPI` (cwd,
+	 * eventBus, runtime), and reusing them would route tools/handlers/commands
+	 * back through the parent. For subagents, forward
+	 * {@link preloadedExtensionPaths} instead.
+	 *
+	 * @internal
 	 */
 	preloadedExtensions?: LoadExtensionsResult;
+	/**
+	 * Pre-discovered extension source paths. When provided, the filesystem-scan
+	 * inside `discoverExtensionPaths()` is skipped — the session still calls
+	 * `loadExtensions()` itself so each `Extension` is bound to THIS session's
+	 * `ExtensionAPI` (cwd, eventBus, runtime).
+	 *
+	 * This is the safe pass-through for parent → subagent forwarding.
+	 */
+	preloadedExtensionPaths?: string[];
+	/**
+	 * Pre-discovered custom-tool source paths from `.omp/tools/`, `.claude/tools/`,
+	 * plugins, etc. When provided, the filesystem-scan inside
+	 * `discoverCustomToolPaths()` is skipped — subagents inherit the parent's
+	 * scan result and call `loadCustomTools()` themselves so each session binds
+	 * tools to its OWN `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+	 *
+	 * Forwarding the loaded `LoadedCustomTool[]` instances directly would reuse
+	 * the parent's session-bound API and route tool execution back through the
+	 * parent — wrong for isolated tasks and for pending-action routing.
+	 */
+	preloadedCustomToolPaths?: ToolPathWithSource[];
 
 	/** Shared event bus for tool/extension communication. Default: creates new bus. */
 	eventBus?: EventBus;
@@ -565,6 +597,26 @@ export async function discoverExtensions(cwd?: string): Promise<LoadExtensionsRe
 	return discoverAndLoadExtensions([], resolvedCwd);
 }
 
+/**
+ * Path-only counterpart of {@link loadSessionExtensions}: the FS-heavy scan
+ * without the per-session module load. Subagents reuse the parent's path list
+ * (cached on {@link ToolSession.extensionPaths}) and rebuild Extension
+ * instances themselves so each session's `ExtensionAPI` (cwd, eventBus,
+ * runtime) is its own.
+ */
+export async function discoverSessionExtensionPaths(
+	options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">,
+	cwd: string,
+	settings: Settings,
+): Promise<string[]> {
+	if (options.disableExtensionDiscovery) {
+		return options.additionalExtensionPaths ?? [];
+	}
+	const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
+	const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
+	return discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds);
+}
+
 /**
  * Load the discovered/configured extensions for a session — everything {@link
  * createAgentSession} would load except the inline factory extensions it appends
@@ -580,23 +632,8 @@ export async function loadSessionExtensions(
 	settings: Settings,
 	eventBus: EventBus,
 ): Promise<LoadExtensionsResult> {
-	let result: LoadExtensionsResult;
-	if (options.disableExtensionDiscovery) {
-		const configuredPaths = options.additionalExtensionPaths ?? [];
-		result = await logger.time("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
-	} else {
-		// Merge CLI extension paths with settings extension paths.
-		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
-		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
-		result = await logger.time(
-			"discoverAndLoadExtensions",
-			discoverAndLoadExtensions,
-			configuredPaths,
-			cwd,
-			eventBus,
-			disabledExtensionIds,
-		);
-	}
+	const paths = await discoverSessionExtensionPaths(options, cwd, settings);
+	const result = await logger.time("loadExtensions", loadExtensions, paths, cwd, eventBus);
 	for (const { path, error } of result.errors) {
 		logger.error("Failed to load extension", { path, error });
 	}
@@ -1193,23 +1230,26 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 
 	// Discover rules and bucket them in one pass to avoid repeated scans over large rule sets.
-	const { ttsrManager, rulebookRules, alwaysApplyRules } = await logger.time("discoverTtsrRules", async () => {
-		const { TtsrManager } = await import("./export/ttsr");
-		const ttsrSettings = settings.getGroup("ttsr");
-		const ttsrManager = new TtsrManager(ttsrSettings);
-		const rulesResult =
-			options.rules !== undefined
-				? { items: options.rules, warnings: undefined }
-				: await loadCapability<Rule>(ruleCapability.id, { cwd });
-		const { rulebookRules, alwaysApplyRules } = bucketRules(rulesResult.items, ttsrManager, {
-			builtinRules: ttsrSettings.builtinRules,
-			disabledRules: ttsrSettings.disabledRules,
-		});
-		if (existingSession.injectedTtsrRules.length > 0) {
-			ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
-		}
-		return { ttsrManager, rulebookRules, alwaysApplyRules };
-	});
+	const { ttsrManager, rulebookRules, alwaysApplyRules, allRules } = await logger.time(
+		"discoverTtsrRules",
+		async () => {
+			const { TtsrManager } = await import("./export/ttsr");
+			const ttsrSettings = settings.getGroup("ttsr");
+			const ttsrManager = new TtsrManager(ttsrSettings);
+			const rulesResult =
+				options.rules !== undefined
+					? { items: options.rules, warnings: undefined }
+					: await loadCapability<Rule>(ruleCapability.id, { cwd });
+			const { rulebookRules, alwaysApplyRules } = bucketRules(rulesResult.items, ttsrManager, {
+				builtinRules: ttsrSettings.builtinRules,
+				disabledRules: ttsrSettings.disabledRules,
+			});
+			if (existingSession.injectedTtsrRules.length > 0) {
+				ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
+			}
+			return { ttsrManager, rulebookRules, alwaysApplyRules, allRules: rulesResult.items };
+		},
+	);
 
 	// Resolve contextFiles up-front (it's needed before tool creation). The
 	// workspace tree scan is slow on large repos and we MUST NOT block startup on
@@ -1331,6 +1371,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			contextFiles,
 			workspaceTree: resolvedWorkspaceTree,
 			skills,
+			rules: allRules,
 			eventBus,
 			outputSchema: options.outputSchema,
 			requireYieldTool: options.requireYieldTool,
@@ -1514,22 +1555,29 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			customTools.push(...getSearchTools());
 		}
 
-		// Discover and load custom tools from .omp/tools/, .claude/tools/, etc.
+		// Discover custom tools from `.omp/tools/`, `.claude/tools/`, plugins, etc.
+		// Subagents reuse the parent's scan via `preloadedCustomToolPaths` to skip
+		// the FS walk, but ALWAYS re-call `loadCustomTools` here so factories bind
+		// to THIS session's `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
+		// Forwarding the parent's `LoadedCustomTool[]` directly would route tool
+		// execution back through the parent — wrong for isolated tasks and for
+		// pending-action queueing.
 		const builtInToolNames = builtinTools.map(t => t.name);
-		const discoveredCustomTools = await logger.time(
-			"discoverAndLoadCustomTools",
-			discoverAndLoadCustomTools,
-			[],
-			cwd,
-			builtInToolNames,
-			action => queueResolveHandler(toolSession, action),
+		const customToolPaths: ToolPathWithSource[] =
+			options.preloadedCustomToolPaths ??
+			(await logger.time("discoverCustomToolPaths", () => discoverCustomToolPaths([], cwd)));
+		const customToolsLoadResult = await logger.time("loadCustomTools", () =>
+			loadCustomTools(customToolPaths, cwd, builtInToolNames, action => queueResolveHandler(toolSession, action)),
 		);
-		for (const { path, error } of discoveredCustomTools.errors) {
+		for (const { path, error } of customToolsLoadResult.errors) {
 			logger.error("Custom tool load failed", { path, error });
 		}
-		if (discoveredCustomTools.tools.length > 0) {
-			customTools.push(...discoveredCustomTools.tools.map(loaded => loaded.tool));
+		if (customToolsLoadResult.tools.length > 0) {
+			customTools.push(...customToolsLoadResult.tools.map(loaded => loaded.tool));
 		}
+		// Forward the path list (NOT the loaded tools) to subagents so they
+		// re-bind under their own `CustomToolAPI` while skipping the FS scan.
+		toolSession.customToolPaths = customToolPaths;
 
 		const inlineExtensions: ExtensionFactory[] = options.extensions ? [...options.extensions] : [];
 		inlineExtensions.push((await import("./autoresearch")).createAutoresearchExtension);
@@ -1537,14 +1585,48 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			inlineExtensions.push(createCustomToolsExtension(customTools));
 		}
 
-		// Load extensions. A preloaded result (e.g. resolved by the CLI before
-		// session creation so it can classify `@file` args extension-aware without
-		// a session/breadcrumb existing yet) is reused as-is; otherwise discover now
-		// through the shared helper. Preloaded wins over `disableExtensionDiscovery`
-		// because the preloaded result already reflects that choice — re-running the
-		// loader here would double-load.
-		const extensionsResult: LoadExtensionsResult =
-			options.preloadedExtensions ?? (await loadSessionExtensions(options, cwd, settings, eventBus));
+		// Load extensions. Three paths:
+		//   1. `preloadedExtensions` (CLI): caller already loaded — reuse the
+		//      Extension instances. Shallow-clone `extensions` so the inline
+		//      push below cannot mutate the caller's array. `runtime` is shared
+		//      so flag values set pre-creation flow into the live session.
+		//   2. `preloadedExtensionPaths` (subagent): caller resolved paths;
+		//      skip the FS scan but always re-call `loadExtensions` here so
+		//      each `Extension` binds to THIS session's `ExtensionAPI`
+		//      (cwd, eventBus, runtime).
+		//   3. No preload: run the full session discovery.
+		// `disableExtensionDiscovery` is honored implicitly: a caller that set
+		// the flag and pre-resolved the result already reflects that choice.
+		let extensionPaths: string[];
+		let extensionsResult: LoadExtensionsResult;
+		if (options.preloadedExtensions) {
+			extensionsResult = {
+				...options.preloadedExtensions,
+				extensions: [...options.preloadedExtensions.extensions],
+			};
+			// Capture paths for downstream forwarding; filter inline-factory
+			// entries (`<inline-N>`) — those are per-session, not source paths.
+			extensionPaths = extensionsResult.extensions
+				.map(ext => ext.resolvedPath)
+				.filter(p => !p.startsWith("<inline"));
+		} else if (options.preloadedExtensionPaths) {
+			extensionPaths = options.preloadedExtensionPaths;
+			extensionsResult = await logger.time("loadExtensions", loadExtensions, extensionPaths, cwd, eventBus);
+			for (const { path, error } of extensionsResult.errors) {
+				logger.error("Failed to load extension", { path, error });
+			}
+		} else {
+			extensionPaths = await logger.time("discoverSessionExtensionPaths", () =>
+				discoverSessionExtensionPaths(options, cwd, settings),
+			);
+			extensionsResult = await logger.time("loadExtensions", loadExtensions, extensionPaths, cwd, eventBus);
+			for (const { path, error } of extensionsResult.errors) {
+				logger.error("Failed to load extension", { path, error });
+			}
+		}
+		// Forward the source-path list (NOT the loaded instances) so subagents
+		// rebuild their own session-scoped extensions.
+		toolSession.extensionPaths = extensionPaths;
 
 		// Load inline extensions from factories
 		if (inlineExtensions.length > 0) {