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

package/src/internal-urls/index.ts

@@ -1,28 +1,15 @@
 /**
- * Internal URL routing system for internal protocols like agent://, memory://, skill://, mcp://, and local://.
+ * Internal URL routing system for internal protocols like agent://, memory://,
+ * skill://, mcp://, and local://.
  *
- * This module provides a unified way to resolve internal URLs without
- * exposing filesystem paths to the agent.
- *
- * @example
- * ```ts
- * import { InternalUrlRouter, AgentProtocolHandler, MemoryProtocolHandler, SkillProtocolHandler } from './internal-urls';
- *
- * const router = new InternalUrlRouter();
- * router.register(new AgentProtocolHandler({ getArtifactsDir: () => sessionDir }));
- * router.register(new MemoryProtocolHandler({ getMemoryRoot: () => memoryRoot }));
- * router.register(new SkillProtocolHandler({ getSkills: () => skills }));
- *
- * if (router.canHandle('agent://reviewer_0')) {
- *   const resource = await router.resolve('agent://reviewer_0');
- *   console.log(resource.content);
- * }
- * ```
+ * One process-global `InternalUrlRouter` is shared across sessions. Handlers
+ * are stateless; they pull whatever they need (active skills/rules, active
+ * MCP/async managers, AgentRegistry-listed sessions) from the owning module
+ * on each resolve call.
  */
 
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
-export * from "./jobs-protocol";
 export * from "./json-query";
 export * from "./local-protocol";
 export * from "./mcp-protocol";

package/src/internal-urls/local-protocol.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
+import { AgentRegistry } from "../registry/agent-registry";
 import { parseInternalUrl } from "./parse";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
@@ -136,16 +137,60 @@ export function resolveLocalUrlToPath(input: string | InternalUrl, options: Loca
  * Protocol handler for local:// URLs.
  *
  * URL forms:
- * - local:// - Lists all session local files
- * - local://<path> - Reads a file under session local root
+ * - local:// - Lists files at the session local root
+ * - local://<path> - Reads a file under the session local root
  */
 export class LocalProtocolHandler implements ProtocolHandler {
 	readonly scheme = "local";
+	readonly immutable = false;
 
-	constructor(private readonly options: LocalProtocolOptions) {}
+	static #override: LocalProtocolOptions | undefined;
+
+	/**
+	 * Install a process-global override that wins over the AgentRegistry-based
+	 * derivation. Used by SDK consumers that wire `localProtocolOptions` on
+	 * `createAgentSession` and by subagents that share their parent's root.
+	 */
+	static setOverride(value: LocalProtocolOptions | undefined): void {
+		LocalProtocolHandler.#override = value;
+	}
+
+	/** Reset the process-global override. Test-only. */
+	static resetOverrideForTests(): void {
+		LocalProtocolHandler.#override = undefined;
+	}
+
+	/**
+	 * Returns the active local-protocol options.
+	 *
+	 * Resolution order:
+	 * 1. Explicit override installed via {@link setOverride} (used by subagents
+	 *    that share their parent's root and by SDK consumers with a custom
+	 *    artifacts/session id mapping).
+	 * 2. The main session in `AgentRegistry.global()`. Its `SessionManager`
+	 *    supplies both `getArtifactsDir` and `getSessionId`.
+	 */
+	static resolveOptions(): LocalProtocolOptions | undefined {
+		const override = LocalProtocolHandler.#override;
+		if (override) return override;
+		const main = AgentRegistry.global()
+			.list()
+			.find(ref => ref.kind === "main");
+		const sessionManager = main?.session?.sessionManager;
+		if (!sessionManager) return undefined;
+		return {
+			getArtifactsDir: () => sessionManager.getArtifactsDir(),
+			getSessionId: () => sessionManager.getSessionId(),
+		};
+	}
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const localRoot = path.resolve(resolveLocalRoot(this.options));
+		const opts = LocalProtocolHandler.resolveOptions();
+		if (!opts) {
+			throw new Error("No session - local:// unavailable");
+		}
+
+		const localRoot = path.resolve(resolveLocalRoot(opts));
 		await fs.mkdir(localRoot, { recursive: true });
 
 		let resolvedRoot: string;
@@ -171,9 +216,7 @@ export class LocalProtocolHandler implements ProtocolHandler {
 			const realParent = await fs.realpath(parentDir);
 			ensureWithinRoot(realParent, resolvedRoot);
 		} catch (error) {
-			if (!isEnoent(error)) {
-				throw error;
-			}
+			if (!isEnoent(error)) throw error;
 		}
 
 		let realTargetPath: string;

package/src/internal-urls/mcp-protocol.ts

@@ -1,11 +1,7 @@
-import type { MCPManager } from "../mcp/manager";
+import { MCPManager } from "../mcp/manager";
 import type { MCPResourceReadResult } from "../mcp/types";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-export interface McpProtocolOptions {
-	getMcpManager: () => MCPManager | undefined;
-}
-
 function escapeRegex(text: string): string {
 	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -106,11 +102,10 @@ function formatAvailableResources(mcpManager: MCPManager): string {
  */
 export class McpProtocolHandler implements ProtocolHandler {
 	readonly scheme = "mcp";
-
-	constructor(private readonly options: McpProtocolOptions) {}
+	readonly immutable = true;
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const mcpManager = this.options.getMcpManager();
+		const mcpManager = MCPManager.instance();
 		if (!mcpManager) {
 			throw new Error("No MCP manager available. MCP servers may not be configured.");
 		}

package/src/internal-urls/memory-protocol.ts

@@ -1,6 +1,8 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent } from "@oh-my-pi/pi-utils";
+import { getAgentDir, isEnoent } from "@oh-my-pi/pi-utils";
+import { getMemoryRoot } from "../memories";
+import { AgentRegistry } from "../registry/agent-registry";
 import { validateRelativePath } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
@@ -8,13 +10,20 @@ const DEFAULT_MEMORY_FILE = "memory_summary.md";
 const MEMORY_NAMESPACE = "root";
 
 /**
- * Options for the memory:// URL protocol.
+ * Snapshot of memory roots for every registered session, deduped.
+ * Each session has its own cwd (possibly a worktree), so subagents and main
+ * may see different roots.
  */
-export interface MemoryProtocolOptions {
-	/**
-	 * Returns the absolute path to the current project's memory root.
-	 */
-	getMemoryRoot: () => string;
+function memoryRootsFromRegistry(): string[] {
+	const agentDir = getAgentDir();
+	const roots: string[] = [];
+	for (const ref of AgentRegistry.global().list()) {
+		const sm = ref.session?.sessionManager;
+		if (!sm) continue;
+		const root = getMemoryRoot(agentDir, sm.getCwd());
+		if (root && !roots.includes(root)) roots.push(root);
+	}
+	return roots;
 }
 
 function ensureWithinRoot(targetPath: string, rootPath: string): void {
@@ -61,73 +70,95 @@ export function resolveMemoryUrlToPath(url: InternalUrl, memoryRoot: string): st
 	return path.resolve(memoryRoot, relativePath);
 }
 
+async function tryResolveInRoot(url: InternalUrl, memoryRoot: string): Promise<InternalResource | undefined> {
+	const resolved = path.resolve(memoryRoot);
+	let resolvedRoot: string;
+	try {
+		resolvedRoot = await fs.realpath(resolved);
+	} catch (error) {
+		if (isEnoent(error)) return undefined;
+		throw error;
+	}
+
+	const targetPath = resolveMemoryUrlToPath(url, resolvedRoot);
+	ensureWithinRoot(targetPath, resolvedRoot);
+
+	const parentDir = path.dirname(targetPath);
+	try {
+		const realParent = await fs.realpath(parentDir);
+		ensureWithinRoot(realParent, resolvedRoot);
+	} catch (error) {
+		if (!isEnoent(error)) throw error;
+	}
+
+	let realTargetPath: string;
+	try {
+		realTargetPath = await fs.realpath(targetPath);
+	} catch (error) {
+		if (isEnoent(error)) return undefined;
+		throw error;
+	}
+
+	ensureWithinRoot(realTargetPath, resolvedRoot);
+
+	const stat = await fs.stat(realTargetPath);
+	if (!stat.isFile()) {
+		throw new Error(`memory:// URL must resolve to a file: ${url.href}`);
+	}
+
+	const content = await Bun.file(realTargetPath).text();
+	const ext = path.extname(realTargetPath).toLowerCase();
+	const contentType: InternalResource["contentType"] = ext === ".md" ? "text/markdown" : "text/plain";
+
+	return {
+		url: url.href,
+		content,
+		contentType,
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: realTargetPath,
+		notes: [],
+	};
+}
+
 /**
  * Protocol handler for memory:// URLs.
  *
- * URL forms:
- * - memory://root - Reads memory_summary.md
- * - memory://root/<path> - Reads a relative file under memory root
+ * Walks every active session's memory root. Worktree-based subagents have
+ * their own root; first one containing the file wins. Parent and subagent
+ * sharing a cwd see the same file regardless of order.
  */
 export class MemoryProtocolHandler implements ProtocolHandler {
 	readonly scheme = "memory";
-
-	constructor(private readonly options: MemoryProtocolOptions) {}
+	readonly immutable = true;
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const memoryRoot = path.resolve(this.options.getMemoryRoot());
-		let resolvedRoot: string;
-		try {
-			resolvedRoot = await fs.realpath(memoryRoot);
-		} catch (error) {
-			if (isEnoent(error)) {
-				throw new Error(
-					"Memory artifacts are not available for this project yet. Run a session with memories enabled first.",
-				);
-			}
-			throw error;
-		}
-
-		const targetPath = resolveMemoryUrlToPath(url, resolvedRoot);
-		ensureWithinRoot(targetPath, resolvedRoot);
+		const roots = memoryRootsFromRegistry();
 
-		const parentDir = path.dirname(targetPath);
-		try {
-			const realParent = await fs.realpath(parentDir);
-			ensureWithinRoot(realParent, resolvedRoot);
-		} catch (error) {
-			if (!isEnoent(error)) {
-				throw error;
-			}
+		if (roots.length === 0) {
+			throw new Error(
+				"Memory artifacts are not available for this project yet. Run a session with memories enabled first.",
+			);
 		}
 
-		let realTargetPath: string;
-		try {
-			realTargetPath = await fs.realpath(targetPath);
-		} catch (error) {
-			if (isEnoent(error)) {
-				throw new Error(`Memory file not found: ${url.href}`);
+		let anyExists = false;
+		for (const root of roots) {
+			try {
+				await fs.stat(root);
+				anyExists = true;
+			} catch (error) {
+				if (isEnoent(error)) continue;
+				throw error;
 			}
-			throw error;
+			const result = await tryResolveInRoot(url, root);
+			if (result) return result;
 		}
 
-		ensureWithinRoot(realTargetPath, resolvedRoot);
-
-		const stat = await fs.stat(realTargetPath);
-		if (!stat.isFile()) {
-			throw new Error(`memory:// URL must resolve to a file: ${url.href}`);
+		if (!anyExists) {
+			throw new Error(
+				"Memory artifacts are not available for this project yet. Run a session with memories enabled first.",
+			);
 		}
 
-		const content = await Bun.file(realTargetPath).text();
-		const ext = path.extname(realTargetPath).toLowerCase();
-		const contentType: InternalResource["contentType"] = ext === ".md" ? "text/markdown" : "text/plain";
-
-		return {
-			url: url.href,
-			content,
-			contentType,
-			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: realTargetPath,
-			notes: [],
-		};
+		throw new Error(`Memory file not found: ${url.href}`);
 	}
 }

package/src/internal-urls/pi-protocol.ts

@@ -18,6 +18,7 @@ import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
  */
 export class PiProtocolHandler implements ProtocolHandler {
 	readonly scheme = "pi";
+	readonly immutable = true;
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
 		// Extract filename from host + path

package/src/internal-urls/router.ts

@@ -1,42 +1,58 @@
 /**
  * Internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://, mcp://, pi://, local://).
+ *
+ * One process-global router with one handler per scheme. Access via
+ * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and
+ * shared state lives in `./state.ts`.
  */
+import { AgentProtocolHandler } from "./agent-protocol";
+import { ArtifactProtocolHandler } from "./artifact-protocol";
+import { LocalProtocolHandler } from "./local-protocol";
+import { McpProtocolHandler } from "./mcp-protocol";
+import { MemoryProtocolHandler } from "./memory-protocol";
 import { parseInternalUrl } from "./parse";
+import { PiProtocolHandler } from "./pi-protocol";
+import { RuleProtocolHandler } from "./rule-protocol";
+import { SkillProtocolHandler } from "./skill-protocol";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-/**
- * Router for internal URL schemes.
- *
- * Dispatches URLs like `agent://output_id` or `memory://root/memory_summary.md` to
- * registered protocol handlers.
- */
 export class InternalUrlRouter {
+	static #instance: InternalUrlRouter | undefined;
+
 	#handlers = new Map<string, ProtocolHandler>();
 
-	/**
-	 * Register a protocol handler.
-	 * @param handler Handler to register (uses handler.scheme as key)
-	 */
+	constructor() {
+		this.register(new PiProtocolHandler());
+		this.register(new AgentProtocolHandler());
+		this.register(new ArtifactProtocolHandler());
+		this.register(new MemoryProtocolHandler());
+		this.register(new LocalProtocolHandler());
+		this.register(new SkillProtocolHandler());
+		this.register(new RuleProtocolHandler());
+		this.register(new McpProtocolHandler());
+	}
+
+	/** Process-global router instance. */
+	static instance(): InternalUrlRouter {
+		InternalUrlRouter.#instance ??= new InternalUrlRouter();
+		return InternalUrlRouter.#instance;
+	}
+
+	/** Reset the global instance in tests. */
+	static resetForTests(): void {
+		InternalUrlRouter.#instance = undefined;
+	}
+
 	register(handler: ProtocolHandler): void {
-		this.#handlers.set(handler.scheme, handler);
+		this.#handlers.set(handler.scheme.toLowerCase(), handler);
 	}
 
-	/**
-	 * Check if the router can handle a URL.
-	 * @param input URL string to check
-	 */
 	canHandle(input: string): boolean {
 		const match = input.match(/^([a-z][a-z0-9+.-]*):\/\//i);
 		if (!match) return false;
-		const scheme = match[1].toLowerCase();
-		return this.#handlers.has(scheme);
+		return this.#handlers.has(match[1].toLowerCase());
 	}
 
-	/**
-	 * Resolve an internal URL to its content.
-	 * @param input URL string (e.g., "agent://reviewer_0", "skill://notion-pages")
-	 * @throws Error if scheme is not registered or resolution fails
-	 */
 	async resolve(input: string): Promise<InternalResource> {
 		const parsed = parseInternalUrl(input);
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
@@ -49,6 +65,7 @@ export class InternalUrlRouter {
 			throw new Error(`Unknown protocol: ${scheme}://\nSupported: ${available || "none"}`);
 		}
 
-		return handler.resolve(parsed as InternalUrl);
+		const resource = await handler.resolve(parsed as InternalUrl);
+		return { ...resource, immutable: resource.immutable ?? handler.immutable };
 	}
 }

package/src/internal-urls/rule-protocol.ts

@@ -1,41 +1,24 @@
 /**
  * Protocol handler for rule:// URLs.
  *
- * Resolves rule names to their content files.
- *
  * URL forms:
  * - rule://<name> - Reads rule content
  */
-import type { Rule } from "../capability/rule";
+import { getActiveRules } from "../capability/rule";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-export interface RuleProtocolOptions {
-	/**
-	 * Returns the currently loaded rules.
-	 */
-	getRules: () => readonly Rule[];
-}
-
-/**
- * Handler for rule:// URLs.
- *
- * Resolves rule names to their content.
- */
 export class RuleProtocolHandler implements ProtocolHandler {
 	readonly scheme = "rule";
-
-	constructor(private readonly options: RuleProtocolOptions) {}
+	readonly immutable = true;
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const rules = this.options.getRules();
+		const rules = getActiveRules();
 
-		// Extract rule name from host
 		const ruleName = url.rawHost || url.hostname;
 		if (!ruleName) {
 			throw new Error("rule:// URL requires a rule name: rule://<name>");
 		}
 
-		// Find the rule
 		const rule = rules.find(r => r.name === ruleName);
 		if (!rule) {
 			const available = rules.map(r => r.name);

package/src/internal-urls/skill-protocol.ts

@@ -8,19 +8,9 @@
  * - skill://<name>/<path> - Reads relative path within skill's baseDir
  */
 import * as path from "node:path";
-import type { Skill } from "../extensibility/skills";
+import { getActiveSkills } from "../extensibility/skills";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-export interface SkillProtocolOptions {
-	/**
-	 * Returns the currently loaded skills.
-	 */
-	getSkills: () => readonly Skill[];
-}
-
-/**
- * Get content type based on file extension.
- */
 function getContentType(filePath: string): InternalResource["contentType"] {
 	const ext = path.extname(filePath).toLowerCase();
 	if (ext === ".md") return "text/markdown";
@@ -43,24 +33,19 @@ export function validateRelativePath(relativePath: string): void {
 
 /**
  * Handler for skill:// URLs.
- *
- * Resolves skill names to their content files.
  */
 export class SkillProtocolHandler implements ProtocolHandler {
 	readonly scheme = "skill";
-
-	constructor(private readonly options: SkillProtocolOptions) {}
+	readonly immutable = true;
 
 	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const skills = this.options.getSkills();
+		const skills = getActiveSkills();
 
-		// Extract skill name from host
 		const skillName = url.rawHost || url.hostname;
 		if (!skillName) {
 			throw new Error("skill:// URL requires a skill name: skill://<name>");
 		}
 
-		// Find the skill
 		const skill = skills.find(s => s.name === skillName);
 		if (!skill) {
 			const available = skills.map(s => s.name);
@@ -68,41 +53,34 @@ export class SkillProtocolHandler implements ProtocolHandler {
 			throw new Error(`Unknown skill: ${skillName}\nAvailable: ${availableStr}`);
 		}
 
-		// Determine the file to read
 		let targetPath: string;
 		const urlPath = url.pathname;
 		const hasRelativePath = urlPath && urlPath !== "/" && urlPath !== "";
 
 		if (hasRelativePath) {
-			// Read relative path within skill's baseDir
-			const relativePath = decodeURIComponent(urlPath.slice(1)); // Remove leading /
+			const relativePath = decodeURIComponent(urlPath.slice(1));
 			validateRelativePath(relativePath);
 			targetPath = path.join(skill.baseDir, relativePath);
 
-			// Verify the resolved path is still within baseDir
 			const resolvedPath = path.resolve(targetPath);
 			const resolvedBaseDir = path.resolve(skill.baseDir);
 			if (!resolvedPath.startsWith(resolvedBaseDir + path.sep) && resolvedPath !== resolvedBaseDir) {
 				throw new Error("Path traversal is not allowed");
 			}
 		} else {
-			// Read SKILL.md
 			targetPath = skill.filePath;
 		}
 
-		// Read the file
 		const file = Bun.file(targetPath);
 		if (!(await file.exists())) {
 			throw new Error(`File not found: ${targetPath}`);
 		}
 
 		const content = await file.text();
-		const contentType = getContentType(targetPath);
-
 		return {
 			url: url.href,
 			content,
-			contentType,
+			contentType: getContentType(targetPath),
 			size: Buffer.byteLength(content, "utf-8"),
 			sourcePath: targetPath,
 			notes: [],

package/src/internal-urls/types.ts

@@ -6,7 +6,9 @@
  */
 
 /**
- * Resolved internal resource returned by protocol handlers.
+ * Raw resource payload returned by protocol handlers. The `immutable` flag is
+ * applied by the router from {@link ProtocolHandler.immutable}, so handlers do
+ * not need to set it themselves.
  */
 export interface InternalResource {
 	/** Canonical URL that was resolved */
@@ -21,6 +23,13 @@ export interface InternalResource {
 	sourcePath?: string;
 	/** Additional notes about resolution */
 	notes?: string[];
+	/**
+	 * True when the resolved content cannot be edited by the agent (e.g. sealed
+	 * artifacts, harness docs, machine-generated memory summaries). Hashline
+	 * anchors and similar edit affordances are suppressed for immutable
+	 * resources. Mutable resources (e.g. local://) behave like editable files.
+	 */
+	immutable?: boolean;
 }
 
 /**
@@ -44,7 +53,14 @@ export interface ProtocolHandler {
 	/** The scheme this handler processes (without trailing ://) */
 	readonly scheme: string;
 	/**
-	 * Resolve an internal URL to its content.
+	 * Whether resources produced by this handler are immutable (cannot be
+	 * edited by the agent). When true, callers suppress hashline anchors and
+	 * other edit affordances. When false, resources behave like editable files.
+	 */
+	readonly immutable: boolean;
+	/**
+	 * Resolve an internal URL to its content. The router stamps the
+	 * {@link InternalResource.immutable} flag from {@link ProtocolHandler.immutable}.
 	 * @param url Parsed URL object
 	 * @throws Error with user-friendly message if resolution fails
 	 */

package/src/main.ts

@@ -765,7 +765,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 					await mgr.upgradeAllPlugins();
 					logger.debug(`Auto-upgraded ${updates.length} marketplace plugin(s)`);
 				} else {
-					logger.debug(`${updates.length} marketplace plugin update(s) available \u2014 /marketplace upgrade`);
+					logger.debug(`${updates.length} marketplace plugin update(s) available — /marketplace upgrade`);
 				}
 			} catch {
 				// Silently ignore — network failure, corrupt data, offline.

package/src/mcp/manager.ts

@@ -132,6 +132,23 @@ export interface MCPDiscoverOptions {
  * Manages connections to MCP servers and provides tools to the agent.
  */
 export class MCPManager {
+	static #instance: MCPManager | undefined;
+
+	/** Process-global instance shared by internal URL protocol handlers and tools. */
+	static instance(): MCPManager | undefined {
+		return MCPManager.#instance;
+	}
+
+	/** Install or clear the process-global instance. */
+	static setInstance(value: MCPManager | undefined): void {
+		MCPManager.#instance = value;
+	}
+
+	/** Reset the process-global instance. Test-only. */
+	static resetForTests(): void {
+		MCPManager.#instance = undefined;
+	}
+
 	#connections = new Map<string, MCPServerConnection>();
 	#tools: CustomTool<TSchema, MCPToolDetails>[] = [];
 	#pendingConnections = new Map<string, Promise<MCPServerConnection>>();

package/src/modes/components/session-observer-overlay.ts

@@ -192,7 +192,7 @@ export class SessionObserverOverlayComponent extends Container {
 		const statsLine = this.#buildStatsLine(session);
 		if (statsLine) this.#viewerFooterLines.push(statsLine);
 		this.#viewerFooterLines.push(
-			theme.fg("dim", "j/k:scroll  Enter:expand  [/]/\u2190\u2192:cycle agents  Esc/Ctrl+S:close  g/G:top/bottom"),
+			theme.fg("dim", "j/k:scroll  Enter:expand  [/]/←→:cycle agents  Esc/Ctrl+S:close  g/G:top/bottom"),
 		);
 
 		// Auto-scroll to bottom if we were at bottom
@@ -452,7 +452,7 @@ export class SessionObserverOverlayComponent extends Container {
 
 		// Tool call header
 		const intentStr = call.intent ? theme.fg("dim", ` ${sanitizeLine(call.intent, TRUNCATE_LENGTHS.SHORT)}`) : "";
-		lines.push(`${cursor} ${theme.fg("accent", "\u25B8")} ${theme.bold(theme.fg("muted", call.name))}${intentStr}`);
+		lines.push(`${cursor} ${theme.fg("accent", "▸")} ${theme.bold(theme.fg("muted", call.name))}${intentStr}`);
 
 		// Key arguments
 		const argSummary = this.#formatToolArgs(call.name, call.arguments);

package/src/modes/components/tool-execution.ts

@@ -665,6 +665,12 @@ export class ToolExecutionComponent extends Container {
 					context.perFileDiffPreview = previews;
 				}
 			}
+			if (!previews?.some(preview => preview.diff)) {
+				const editMode = this.#editMode;
+				const strategy = editMode ? EDIT_MODE_STRATEGIES[editMode] : undefined;
+				const fallback = strategy?.renderStreamingFallback(this.#args, theme);
+				if (fallback) context.editStreamingFallback = fallback;
+			}
 			context.renderDiff = renderDiff;
 		}