@oh-my-pi/pi-coding-agent 15.9.0 → 15.9.3

package/src/slash-commands/types.ts

@@ -31,7 +31,11 @@ export interface ParsedSlashCommand {
 /**
  * Result returned by a slash-command handler.
  *
- * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `undefined` (and the implicit `void` return) — command was handled and
+ *   consumed; no further input. Handlers may simply omit a `return` rather than
+ *   building `{ consumed: true }`; `void` is accepted in the handler signatures
+ *   below so the contract typechecks under TypeScript 5.x (which does not
+ *   coerce `() => void` to `() => T | undefined`) as well as 6.x / tsgo.
  * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
  * - `{ prompt: string }` — command handled, pass `prompt` through as the new
  *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
@@ -100,20 +104,33 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
 	/**
 	 * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
 	 * and, via the TUI adapter, when no `handleTui` override is provided.
+	 *
+	 * Expressed as a union of two function types — one returning a
+	 * `SlashCommandResult`, one returning `void` — so handlers that simply
+	 * `return` (or omit the return) typecheck under TypeScript 5.x as well as
+	 * 6.x / tsgo. TS 5.x does not coerce a `() => void` value into a
+	 * `() => T | undefined` slot, so the two return shapes must be siblings
+	 * rather than a `T | void` union inside one function type (which Biome's
+	 * `noConfusingVoidType` also rejects).
 	 */
-	handle?: (
-		command: ParsedSlashCommand,
-		runtime: SlashCommandRuntime,
-	) => Promise<SlashCommandResult> | SlashCommandResult;
+	handle?:
+		| ((
+				command: ParsedSlashCommand,
+				runtime: SlashCommandRuntime,
+		  ) => SlashCommandResult | Promise<SlashCommandResult>)
+		| ((command: ParsedSlashCommand, runtime: SlashCommandRuntime) => void | Promise<void>);
 	/**
 	 * TUI-only handler that supersedes `handle` when both are present. Use for
 	 * selectors, wizards, dashboards, and anything else that requires
-	 * `InteractiveModeContext`.
+	 * `InteractiveModeContext`. See `handle` for the rationale behind the
+	 * function-type union shape.
 	 */
-	handleTui?: (
-		command: ParsedSlashCommand,
-		runtime: TuiSlashCommandRuntime,
-	) => Promise<SlashCommandResult> | SlashCommandResult;
+	handleTui?:
+		| ((
+				command: ParsedSlashCommand,
+				runtime: TuiSlashCommandRuntime,
+		  ) => SlashCommandResult | Promise<SlashCommandResult>)
+		| ((command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => void | Promise<void>);
 }
 
 /** Result returned by `executeAcpBuiltinSlashCommand`. */

package/src/task/executor.ts

@@ -531,7 +531,7 @@ function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 	});
 }
 
-function createSubagentSettings(baseSettings: Settings): Settings {
+function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>): Settings {
 	const snapshot: Partial<Record<SettingPath, unknown>> = {};
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
@@ -545,6 +545,7 @@ function createSubagentSettings(baseSettings: Settings): Settings {
 		// the parent task approval is the authorization boundary. Use yolo mode
 		// to preserve unattended subagent execution. User `tools.approval` policies still apply.
 		"tools.approvalMode": "yolo",
+		...overrides,
 	});
 }
 
@@ -619,7 +620,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const settings = options.settings ?? Settings.isolated();
-	const subagentSettings = createSubagentSettings(settings);
+	const subagentSettings = createSubagentSettings(
+		settings,
+		agent.readSummarize === false ? { "read.summarize.enabled": false } : undefined,
+	);
 	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
 	const maxRuntimeMs = Math.max(0, Math.trunc(Number(settings.get("task.maxRuntimeMs") ?? 0) || 0));
 	const parentDepth = options.taskDepth ?? 0;

package/src/task/index.ts

@@ -17,9 +17,8 @@ import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import { $env, prompt, Snowflake } from "@oh-my-pi/pi-utils";
+import { $env, logger, prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from "..";
-import { AsyncJobManager } from "../async";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import { MCPManager } from "../mcp/manager";
 import type { Theme } from "../modes/theme/theme";
@@ -343,12 +342,14 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			return this.#executeSync(_toolCallId, params, signal, onUpdate);
 		}
 
-		const manager = AsyncJobManager.instance();
+		const manager = this.session.asyncJobManager;
 		if (!manager) {
-			return {
-				content: [{ type: "text", text: "Async execution is enabled but no async job manager is available." }],
-				details: { projectAgentsDir: null, results: [], totalDurationMs: 0 },
-			};
+			// Async was requested but no manager is registered (e.g. an
+			// orphaned session whose host never wired one up). Falling back
+			// to the sync path keeps the tool usable; only background/job-poll
+			// semantics are lost.
+			logger.warn("task: async.enabled but no AsyncJobManager registered; falling back to sync execution");
+			return this.#executeSync(_toolCallId, params, signal, onUpdate);
 		}
 
 		const taskItems = params.tasks ?? [];

package/src/task/types.ts

@@ -174,6 +174,8 @@ export interface AgentDefinition {
 	output?: unknown;
 	blocking?: boolean;
 	autoloadSkills?: string[];
+	/** When `false`, the agent's `read` tool returns verbatim file content instead of structural summaries. */
+	readSummarize?: boolean;
 	source: AgentSource;
 	filePath?: string;
 }

package/src/tiny/text.ts

@@ -43,6 +43,116 @@ export function formatTitleUserMessage(message: string): string {
 	return `<user-message>\n${prepareTitleInput(message)}\n</user-message>`;
 }
 
+/**
+ * Greeting / acknowledgement / filler tokens. A first user message composed
+ * entirely of these (or of bare numbers / punctuation / emoji) carries no
+ * concrete task, so titling is deferred to a later message instead of latching
+ * onto "hi". See {@link isLowSignalTitleInput}.
+ */
+const FILLER_TITLE_TOKENS = new Set<string>([
+	// greetings
+	"hi",
+	"hii",
+	"hiii",
+	"hiya",
+	"hey",
+	"heya",
+	"hello",
+	"helo",
+	"hullo",
+	"yo",
+	"ya",
+	"sup",
+	"wassup",
+	"whatsup",
+	"howdy",
+	"greetings",
+	"hola",
+	"ciao",
+	"aloha",
+	"gm",
+	"gn",
+	"good",
+	"morning",
+	"afternoon",
+	"evening",
+	"night",
+	"day",
+	// politeness / acknowledgement
+	"thanks",
+	"thank",
+	"thx",
+	"ty",
+	"tysm",
+	"cheers",
+	"please",
+	"pls",
+	"plz",
+	"ok",
+	"okay",
+	"okey",
+	"k",
+	"kk",
+	"yep",
+	"yes",
+	"yeah",
+	"yup",
+	"nope",
+	"no",
+	"nah",
+	"sure",
+	"cool",
+	"nice",
+	"great",
+	"awesome",
+	"perfect",
+	"lol",
+	"lmao",
+	"haha",
+	"hehe",
+	// poking the agent / fillers
+	"test",
+	"tests",
+	"testing",
+	"ping",
+	"pong",
+	"there",
+	"you",
+	"u",
+	"hmm",
+	"hmmm",
+	"um",
+	"uh",
+	"so",
+	"well",
+	"anyway",
+]);
+
+const TITLE_WORD = /[\p{L}\p{N}]+/gu;
+
+/**
+ * True when a first user message is too low-signal to title (greeting, ack,
+ * bare number, or empty once code/punctuation/emoji are stripped).
+ *
+ * Deterministic pre-filter: the default tiny title model (~350M local) cannot
+ * reliably follow a "respond with none" instruction and tends to hallucinate a
+ * title for trivial input, so we never ask it — the caller defers titling to
+ * the next message instead.
+ */
+export function isLowSignalTitleInput(message: string): boolean {
+	const tokens = stripCodeBlocks(message).toLowerCase().match(TITLE_WORD);
+	if (!tokens) return true;
+	return tokens.every(token => FILLER_TITLE_TOKENS.has(token) || /^\d+$/.test(token));
+}
+
+/**
+ * Sentinel a capable title model may emit when a message carries no concrete
+ * task. Treated as "no title yet" so the caller can defer titling. Backstop for
+ * the deterministic {@link isLowSignalTitleInput} filter; kept in sync with the
+ * `none` instruction in `prompts/system/title-system.md`.
+ */
+export const NO_TITLE_SENTINEL = "none";
+
 export function normalizeGeneratedTitle(value: string | null | undefined): string | null {
 	const firstLine = value?.trim().split(/\r?\n/, 1)[0]?.trim();
 	if (!firstLine) return null;
@@ -50,5 +160,6 @@ export function normalizeGeneratedTitle(value: string | null | undefined): strin
 		.replace(/^["']|["']$/g, "")
 		.replace(/[.!?]$/, "")
 		.trim();
-	return title || null;
+	if (!title || title.toLowerCase() === NO_TITLE_SENTINEL) return null;
+	return title;
 }

package/src/tools/bash.ts

@@ -10,7 +10,6 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, TERMINAL } from "@oh-my-pi/pi-tui";
 import { getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { AsyncJobManager } from "../async";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
@@ -489,7 +488,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<BashToolDetails>;
 		startBackgrounded: boolean;
 	}): ManagedBashJobHandle {
-		const manager = AsyncJobManager.instance();
+		const manager = this.session.asyncJobManager;
 		if (!manager) {
 			throw new ToolError("Background job manager unavailable for this session.");
 		}
@@ -716,7 +715,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		if (timeoutClampNotice) pendingNotices.push(timeoutClampNotice);
 
 		if (asyncRequested) {
-			if (!AsyncJobManager.instance()) {
+			if (!this.session.asyncJobManager) {
 				throw new ToolError("Async job manager unavailable for this session.");
 			}
 			const job = this.#startManagedBashJob({
@@ -737,7 +736,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
-		const autoBgManager = AsyncJobManager.instance();
+		const autoBgManager = this.session.asyncJobManager;
 		if (this.#autoBackgroundEnabled && !pty && autoBgManager) {
 			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
 			const startBackgrounded = autoBackgroundWaitMs === 0;

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";
@@ -183,6 +184,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. */

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-recall.ts

@@ -38,7 +38,7 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 					throw new Error("Mnemopi backend is not initialised for this session.");
 				}
 				try {
-					const results = state.recallResultsScoped(params.query);
+					const results = await state.recallResultsScoped(params.query);
 					if (results.length === 0) {
 						return {
 							content: [{ type: "text", text: "No relevant memories found." }],

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 ".";
 
@@ -43,7 +43,7 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 					const query = params.context?.trim()
 						? `${params.query.trim()}\n\nAdditional context:\n${params.context.trim()}`
 						: params.query;
-					const results = state.recallResultsScoped(query);
+					const results = await state.recallResultsScoped(query);
 					if (results.length === 0) {
 						return {
 							content: [{ type: "text", text: "No relevant information found to reflect on." }],
@@ -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/search.ts

@@ -38,6 +38,8 @@ import {
 	type ResolvedSearchTarget,
 	resolveReadPath,
 	resolveToolSearchScope,
+	selectorLineRanges,
+	splitInternalUrlSel,
 	splitPathAndSel,
 } from "./path-utils";
 import {
@@ -109,6 +111,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 +276,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;

package/src/tools/ssh.ts

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 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 { SSHHost } from "../capability/ssh";
@@ -18,6 +17,7 @@ import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
+import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -230,12 +230,30 @@ interface SshRenderContext {
 	totalVisualLines?: number;
 }
 
+function formatSshCommandLines(command: string, uiTheme: Theme): string[] {
+	const sanitized = replaceTabs(command);
+	const rawLines = sanitized.length > 0 ? sanitized.split("\n") : ["…"];
+	const prefix = uiTheme.fg("dim", "$ ");
+	return rawLines.map((line, i) => (i === 0 ? `${prefix}${line}` : line));
+}
+
 export const sshToolRenderer = {
 	renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const host = args.host || "…";
-		const command = args.command || "…";
-		const text = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}] $ ${command}` }, uiTheme);
-		return new Text(text, 0, 0);
+		const command = args.command ?? "";
+		const header = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}]` }, uiTheme);
+		const cmdLines = formatSshCommandLines(command, uiTheme);
+		const outputBlock = new CachedOutputBlock();
+		return {
+			render: (width: number): string[] =>
+				outputBlock.render(
+					{ header, state: "pending", sections: [{ lines: cmdLines }], width, animate: true },
+					uiTheme,
+				),
+			invalidate: () => {
+				outputBlock.invalidate();
+			},
+		};
 	},
 
 	renderResult(
@@ -249,11 +267,9 @@ export const sshToolRenderer = {
 	): Component {
 		const details = result.details;
 		const host = args?.host || "…";
-		const command = args?.command || "…";
-		const header = renderStatusLine(
-			{ icon: "success", title: "SSH", description: `[${host}] $ ${command}` },
-			uiTheme,
-		);
+		const command = args?.command ?? "";
+		const header = renderStatusLine({ icon: "success", title: "SSH", description: `[${host}]` }, uiTheme);
+		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
 		const outputBlock = new CachedOutputBlock();
 
@@ -303,7 +319,7 @@ export const sshToolRenderer = {
 					{
 						header,
 						state: "success",
-						sections: [{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
+						sections: [{ lines: cmdLines }, { label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
 						width,
 					},
 					uiTheme,

package/src/tools/write.ts

@@ -135,6 +135,15 @@ function maybeWriteSnapshotHeader(session: ToolSession, absolutePath: string, co
 	return formatHashlineHeader(formatPathRelativeToCwd(absolutePath, session.cwd), tag);
 }
 
+function shouldRouteWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string): boolean {
+	if (isInternalUrlPath(requestedPath)) return false;
+
+	const state = session.getPlanModeState?.();
+	if (!state?.enabled || !isInternalUrlPath(state.planFilePath)) return true;
+
+	return absolutePath !== resolvePlanPath(session, state.planFilePath);
+}
+
 /**
  * Append a trailing note line to the first text block of a tool result.
  * Mutates `result` in place (the result object is owned by this call).
@@ -845,8 +854,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				await assertEditableFile(absolutePath, path);
 			}
 
-			// Try ACP bridge first — no disk write when client handles it
-			const bridgePromise = this.#routeWriteThroughBridge(absolutePath, cleanContent);
+			// Try ACP bridge first for editor-visible filesystem paths. Internal
+			// artifacts such as local:// plans are owned by OMP, not the editor.
+			const bridgePromise = shouldRouteWriteThroughBridge(this.session, path, absolutePath)
+				? this.#routeWriteThroughBridge(absolutePath, cleanContent)
+				: undefined;
 			if (bridgePromise !== undefined) {
 				try {
 					await bridgePromise;

package/src/tui/status-line.ts

@@ -15,22 +15,33 @@ export interface StatusLineOptions {
 	meta?: string[];
 }
 
+/**
+ * Flatten CR/LF runs in caller-supplied header fragments so a single newline
+ * embedded in `description` or `meta` cannot expand the status line into
+ * multiple rows — which would otherwise break the bordered output block the
+ * header sits on. Tab characters are left alone; tool renderers that need
+ * tab-safe text run `replaceTabs()` themselves.
+ */
+function flattenForHeader(text: string): string {
+	return text.replace(/\r\n?|\n/g, " ");
+}
+
 export function renderStatusLine(options: StatusLineOptions, theme: Theme): string {
 	const icon = options.icon ? formatStatusIcon(options.icon, theme, options.spinnerFrame) : "";
 	const titleColor = options.titleColor ?? "accent";
-	const title = theme.fg(titleColor, options.title);
+	const title = theme.fg(titleColor, flattenForHeader(options.title));
 	let line = icon ? `${icon} ${title}` : title;
 
 	if (options.description) {
-		line += `: ${theme.fg("muted", options.description)}`;
+		line += `: ${theme.fg("muted", flattenForHeader(options.description))}`;
 	}
 
 	if (options.badge) {
 		const { label, color } = options.badge;
-		line += ` ${theme.fg(color, `${theme.format.bracketLeft}${label}${theme.format.bracketRight}`)}`;
+		line += ` ${theme.fg(color, `${theme.format.bracketLeft}${flattenForHeader(label)}${theme.format.bracketRight}`)}`;
 	}
 
-	const meta = options.meta?.filter(value => value.trim().length > 0) ?? [];
+	const meta = options.meta?.map(flattenForHeader).filter(value => value.trim().length > 0) ?? [];
 	if (meta.length > 0) {
 		line += ` ${theme.fg("dim", meta.join(theme.sep.dot))}`;
 	}