@oh-my-pi/pi-coding-agent 17.0.0 → 17.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.0.0",
+	"version": "17.0.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.0.0",
-		"@oh-my-pi/omp-stats": "17.0.0",
-		"@oh-my-pi/pi-agent-core": "17.0.0",
-		"@oh-my-pi/pi-ai": "17.0.0",
-		"@oh-my-pi/pi-catalog": "17.0.0",
-		"@oh-my-pi/pi-mnemopi": "17.0.0",
-		"@oh-my-pi/pi-natives": "17.0.0",
-		"@oh-my-pi/pi-tui": "17.0.0",
-		"@oh-my-pi/pi-utils": "17.0.0",
-		"@oh-my-pi/pi-wire": "17.0.0",
-		"@oh-my-pi/snapcompact": "17.0.0",
+		"@oh-my-pi/hashline": "17.0.1",
+		"@oh-my-pi/omp-stats": "17.0.1",
+		"@oh-my-pi/pi-agent-core": "17.0.1",
+		"@oh-my-pi/pi-ai": "17.0.1",
+		"@oh-my-pi/pi-catalog": "17.0.1",
+		"@oh-my-pi/pi-mnemopi": "17.0.1",
+		"@oh-my-pi/pi-natives": "17.0.1",
+		"@oh-my-pi/pi-tui": "17.0.1",
+		"@oh-my-pi/pi-utils": "17.0.1",
+		"@oh-my-pi/pi-wire": "17.0.1",
+		"@oh-my-pi/snapcompact": "17.0.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.220.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -2568,18 +2568,28 @@ describe("advisor", () => {
 			}
 		});
 
-		it("preserves a late interrupting note when the primary already ended with a terminal answer", () => {
-			for (const severity of ["concern", "blocker"] as const) {
-				expect(
-					resolveAdvisorDeliveryChannel({
-						severity,
-						autoResumeSuppressed: false,
-						streaming: false,
-						aborting: false,
-						terminalAnswerNoQueuedWork: true,
-					}),
-				).toBe("preserve");
-			}
+		it("preserves a late concern when the primary already ended with a terminal answer", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "concern",
+					autoResumeSuppressed: false,
+					streaming: false,
+					aborting: false,
+					terminalAnswerNoQueuedWork: true,
+				}),
+			).toBe("preserve");
+		});
+
+		it("steers a late blocker after a terminal answer so the primary continues and acknowledges it (#5628)", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "blocker",
+					autoResumeSuppressed: false,
+					streaming: false,
+					aborting: false,
+					terminalAnswerNoQueuedWork: true,
+				}),
+			).toBe("steer");
 		});
 
 		it("routes interrupting notes to the aside queue during immune turns without overriding preservation", () => {

package/src/advisor/advise-tool.ts

@@ -106,8 +106,11 @@ export function isAdvisorInterruptImmuneTurnActive(opts: {
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
  *   advice is acted on immediately.
  * - If the primary tail is already a terminal text answer and there is no queued
- *   work, late interrupting advice is preserved as a visible card instead of
- *   waking the primary to restate completion.
+ *   work, a late `concern` is preserved as a visible card instead of waking the
+ *   primary to restate completion. A `blocker` is the exception: it means the
+ *   agent handed off broken or unexercised work, so it still steers a triggered
+ *   turn to force the primary to acknowledge and continue before the turn is
+ *   considered done (#5628) — deferring it to the next user turn is the bug.
  * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
  *   not auto-resume the stopped run. While the agent is idle — or still tearing
  *   the interrupted turn down (`aborting`) — the note is preserved as a visible
@@ -129,7 +132,8 @@ export function resolveAdvisorDeliveryChannel(opts: {
 }): AdvisorDeliveryChannel {
 	if (!isInterruptingSeverity(opts.severity)) return "aside";
 	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
-	if (opts.terminalAnswerNoQueuedWork && !opts.streaming && !opts.aborting) return "preserve";
+	if (opts.terminalAnswerNoQueuedWork && opts.severity !== "blocker" && !opts.streaming && !opts.aborting)
+		return "preserve";
 	if (opts.interruptImmuneTurnActive) return "aside";
 	return "steer";
 }

package/src/cli/bench-cli.ts

@@ -159,12 +159,14 @@ function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
 		case "text_end":
 		case "thinking_end":
 			return event.content.length > 0;
+		case "image_end":
+			return true;
 		default:
 			return false;
 	}
 }
 
-/** Final message carries visible output — non-empty text/thinking or a tool call. */
+/** Final message carries visible output — non-empty text/thinking, an image, or a tool call. */
 function hasVisibleFinalContent(message: AssistantMessage): boolean {
 	return message.content.some(block => {
 		switch (block.type) {
@@ -172,6 +174,7 @@ function hasVisibleFinalContent(message: AssistantMessage): boolean {
 				return block.text.length > 0;
 			case "thinking":
 				return block.thinking.length > 0;
+			case "image":
 			case "redactedThinking":
 			case "toolCall":
 				return true;

package/src/cli/grep-cli.ts

@@ -7,6 +7,7 @@ import * as path from "node:path";
 import { GrepOutputMode, grep } from "@oh-my-pi/pi-natives";
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { expandPath } from "../tools/path-utils";
 
 export interface GrepCommandArgs {
 	pattern: string;
@@ -73,7 +74,7 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 		process.exit(1);
 	}
 
-	const searchPath = path.resolve(cmd.path);
+	const searchPath = path.resolve(expandPath(cmd.path));
 	console.log(chalk.dim(`Searching in: ${searchPath}`));
 	console.log(chalk.dim(`Pattern: ${cmd.pattern}`));
 	console.log(

package/src/cli-commands.ts

@@ -46,31 +46,65 @@ export const commands: CommandEntry[] = [
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];
 
-// Documented-looking plugin-management verbs that are NOT registered top-level
-// commands. Without a guard `resolveCliArgv` rewrites e.g. `omp list` to
-// `omp launch list`, silently forwarding the bare verb to the model as a prompt
-// instead of managing plugins (#2935; same class as the `install` leak fixed in
-// #1496/#1498). A bare (single-arg) use gets a hint pointing at the real
-// `omp plugin <action>` command; multi-word invocations still fall through to
-// `launch`, so genuine prompts that merely begin with one of these words work.
-const RESERVED_TOP_LEVEL_WORDS = new Map<string, string>([
-	[
-		"extensions",
+// Documented-looking plugin/marketplace verbs that are NOT registered top-level
+// commands. Without a guard `resolveCliArgv` rewrites e.g. `omp marketplace add
+// xyz` to `omp launch marketplace add xyz`, silently forwarding the argv to the
+// model as a prompt instead of managing plugins (#4845; same class as the
+// `list`/`remove` leak fixed in #2935 and the `install` leak in #1496/#1498).
+// The real commands live under `omp plugin <action>`; each entry maps a verb to
+// a hint pointing there. See {@link reservedTopLevelWordMessage} for when a hint
+// fires vs. when the argv still falls through to `launch`.
+const RESERVED_TOP_LEVEL_WORDS: Record<string, string> = {
+	extensions:
 		'`omp extensions` is not a management command. Use `omp plugin list` / `omp plugin install`, or run `omp launch extensions` if you meant to send "extensions" as a prompt.',
-	],
-	[
-		"list",
-		'`omp list` is not a top-level command. Use `omp plugin list` to list installed plugins, or run `omp launch list` if you meant to send "list" as a prompt.',
-	],
-	[
-		"remove",
+	list: '`omp list` is not a top-level command. Use `omp plugin list` to list installed plugins, or run `omp launch list` if you meant to send "list" as a prompt.',
+	remove:
 		'`omp remove` is not a top-level command. Use `omp plugin uninstall <name>` to remove a plugin, or run `omp launch remove` if you meant to send "remove" as a prompt.',
-	],
-]);
+	uninstall:
+		'`omp uninstall` is not a top-level command. Use `omp plugin uninstall <name@marketplace>` to remove a plugin, or run `omp launch uninstall` if you meant to send "uninstall" as a prompt.',
+	marketplace:
+		'`omp marketplace` is not a top-level command. Use `omp plugin marketplace <add|remove|update|list>` to manage marketplaces, or run `omp launch marketplace` if you meant to send "marketplace" as a prompt.',
+	discover:
+		'`omp discover` is not a top-level command. Use `omp plugin discover [marketplace]` to browse available plugins, or run `omp launch discover` if you meant to send "discover" as a prompt.',
+	upgrade:
+		'`omp upgrade` is not a top-level command. Use `omp plugin upgrade [name@marketplace]` to upgrade plugins, or run `omp launch upgrade` if you meant to send "upgrade" as a prompt.',
+	enable:
+		'`omp enable` is not a top-level command. Use `omp plugin enable <name@marketplace>` to enable a plugin, or run `omp launch enable` if you meant to send "enable" as a prompt.',
+	disable:
+		'`omp disable` is not a top-level command. Use `omp plugin disable <name@marketplace>` to disable a plugin, or run `omp launch disable` if you meant to send "disable" as a prompt.',
+};
 
-export function reservedTopLevelWordMessage(first: string | undefined, argc = 1): string | undefined {
-	if (argc !== 1 || !first || first.startsWith("-") || first.startsWith("@")) return undefined;
-	return RESERVED_TOP_LEVEL_WORDS.get(first);
+// Sub-actions that make `omp marketplace <sub>` unambiguously a management
+// command even when multi-word (the reporter's `omp marketplace add xyz`,
+// #4845). Mirrors the switch in `handleMarketplace` (cli/plugin-cli.ts).
+const MARKETPLACE_SUBCOMMANDS: Record<string, true> = { add: true, remove: true, rm: true, update: true, list: true };
+
+/**
+ * Hint for a reserved plugin/marketplace verb used as a top-level command, or
+ * `undefined` when the argv should fall through to `launch`.
+ *
+ * A bare verb (`omp marketplace`) always hints. A multi-word invocation only
+ * hints when the arguments follow the documented plugin grammar — a marketplace
+ * sub-action (`omp marketplace add …`) or a `name@marketplace` plugin id
+ * (`omp uninstall foo@bar`) — so genuine prompts that merely begin with one of
+ * these words (`omp list all my files`, `omp upgrade the deps`) still launch.
+ *
+ * Flags (`-…`) and `@file` arguments in the verb slot are never management
+ * commands; those fall through to the default `launch` command.
+ */
+export function reservedTopLevelWordMessage(argv: readonly string[]): string | undefined {
+	const first = argv[0];
+	if (!first || first.startsWith("-") || first.startsWith("@")) return undefined;
+	const hint = RESERVED_TOP_LEVEL_WORDS[first];
+	if (!hint) return undefined;
+	const second = argv[1];
+	if (second === undefined) return hint;
+	if (first === "marketplace" && MARKETPLACE_SUBCOMMANDS[second]) return hint;
+	for (let index = 1; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (!arg.startsWith("-") && arg.includes("@")) return hint;
+	}
+	return undefined;
 }
 
 /**
@@ -112,7 +146,7 @@ function leadingSubcommandIndex(argv: string[]): number {
  */
 export function resolveCliArgv(argv: string[]): ResolvedCliArgv {
 	const first = argv[0];
-	const reservedMessage = reservedTopLevelWordMessage(first, argv.length);
+	const reservedMessage = reservedTopLevelWordMessage(argv);
 	if (reservedMessage) return { error: reservedMessage };
 	if (first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help") {
 		return { argv };

package/src/config/model-registry.ts

@@ -1993,6 +1993,15 @@ export class ModelRegistry {
 	getProviderBaseUrl(provider: string): string | undefined {
 		return this.#models.find(m => m.provider === provider && m.baseUrl)?.baseUrl;
 	}
+	/**
+	 * Get provider-level headers without including per-model overrides.
+	 */
+	getProviderHeaders(provider: string): Record<string, string> | undefined {
+		return createLiveConfigHeaders([
+			this.#providerOverrides.get(provider)?.headers,
+			this.#runtimeProviderOverrides.get(provider)?.headers,
+		]);
+	}
 
 	/**
 	 * Get API key for a model.

package/src/config/model-resolver.ts

@@ -623,11 +623,18 @@ function findExactModelReferenceMatch(modelReference: string, availableModels: M
  * 4. provider-scoped fuzzy match,
  * 5. substring match with the alias-vs-dated pick.
  * Returns the matched model or undefined if no match found.
+ *
+ * `exactOnly` stops after the exact phases (1-3), skipping the fuzzy/substring
+ * fallbacks (4-5). Callers use it to resolve the full selector exactly before
+ * a trailing `:<level>` thinking suffix is split off, so the suffix can never
+ * be fuzzily absorbed into a longer sibling id (e.g. `kimi-for-coding:high`
+ * must not match `kimi-for-coding-highspeed`).
  */
 function matchModel(
 	modelPattern: string,
 	availableModels: Model<Api>[],
 	context: ModelPreferenceContext,
+	options?: { exactOnly?: boolean },
 ): Model<Api> | undefined {
 	const exactRefMatch = findExactModelReferenceMatch(modelPattern, availableModels);
 	if (exactRefMatch) {
@@ -663,6 +670,14 @@ function matchModel(
 			return pickPreferredModel(preferred.length > 0 ? preferred : aliasMatches, context);
 		}
 	}
+
+	// Exact phases exhausted. Fuzzy/substring fallbacks (below) subsequence-match
+	// the whole pattern and would let a trailing `:<level>` thinking suffix bleed
+	// into a longer sibling id; callers that still hold an unstripped suffix ask
+	// for exact-only so the suffix is split off before any fuzzy attempt.
+	if (options?.exactOnly) {
+		return undefined;
+	}
 	// Check for provider/modelId format — fuzzy match within provider only.
 	const slashIndex = modelPattern.indexOf("/");
 	if (slashIndex !== -1) {
@@ -766,17 +781,33 @@ function parseModelPatternWithContext(
 	context: ModelPreferenceContext,
 	options?: { allowInvalidThinkingSelectorFallback?: boolean },
 ): ParsedModelResult {
-	// Try exact match first
-	const exactMatch = matchModel(pattern, availableModels, context);
+	// Exact match on the full pattern first (no fuzzy): a literal id that
+	// contains a colon (`coding-router:max`) wins over any suffix split.
+	const exactMatch = matchModel(pattern, availableModels, context, { exactOnly: true });
 	if (exactMatch) {
 		return { model: exactMatch, thinkingLevel: undefined, warning: undefined, explicitThinkingLevel: false };
 	}
 
-	// No match - try stripping a valid thinking suffix and recursing.
-	// `max` is accepted only after the full pattern failed, so literal model IDs
-	// ending in `:max` keep winning over the thinking suffix.
+	// Prefer a fuzzy match whose actual id ends in the suffix, preserving
+	// shorthand selectors for literal tier models such as `router:low`. Other
+	// fuzzy results (e.g. `kimi-for-coding-highspeed`) cannot absorb the suffix.
 	const { base, level } = splitThinkingSuffix(pattern, -1, MAX_THINKING_SUFFIX_OPTIONS);
 	if (level) {
+		const literalSuffixMatch = matchModel(pattern, availableModels, context);
+		if (literalSuffixMatch?.id.toLowerCase().endsWith(`:${level}`)) {
+			return {
+				model: literalSuffixMatch,
+				thinkingLevel: undefined,
+				warning: undefined,
+				explicitThinkingLevel: false,
+			};
+		}
+
+		// Strip a valid thinking suffix and recurse before accepting any other
+		// fuzzy match, so `:<level>` cannot be absorbed into a longer sibling
+		// id (e.g. `kimi-for-coding:high` must not match
+		// `kimi-for-coding-highspeed`). `max` is accepted only after the exact
+		// match above failed, so literal model IDs ending in `:max` keep winning.
 		const result = parseModelPatternWithContext(base, availableModels, context, options);
 		if (result.model) {
 			// Only use this thinking level if no warning from inner recursion
@@ -791,6 +822,13 @@ function parseModelPatternWithContext(
 		return result;
 	}
 
+	// No valid thinking suffix: fall back to fuzzy/substring matching on the
+	// whole pattern.
+	const fallbackMatch = matchModel(pattern, availableModels, context);
+	if (fallbackMatch) {
+		return { model: fallbackMatch, thinkingLevel: undefined, warning: undefined, explicitThinkingLevel: false };
+	}
+
 	const lastColonIndex = pattern.lastIndexOf(":");
 	if (lastColonIndex === -1) {
 		// No colons, pattern simply doesn't match any model

package/src/config/models-config-schema.ts

@@ -60,6 +60,7 @@ const OpenAICompatFields = {
 	"strictResponsesPairing?": "boolean",
 	"supportsImageDetailOriginal?": "boolean",
 	// anthropic-messages compat flags (same `compat` slot, per-api interpretation)
+	"supportsEagerToolInputStreaming?": "boolean",
 	"requiresToolResultId?": "boolean",
 	"replayUnsignedThinking?": "boolean",
 } as const;

package/src/config/settings-schema.ts

@@ -4479,7 +4479,8 @@ export const SETTINGS_SCHEMA = {
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Priority: GPT model image tool > Antigravity > xAI > OpenRouter > Gemini",
+					description:
+						"Priority: active session provider > GPT model image tool > Antigravity > xAI > OpenRouter > Gemini",
 				},
 				{ value: "openai", label: "OpenAI", description: "Uses the active GPT Responses/Codex model" },
 				{

package/src/discovery/codex.ts

@@ -37,6 +37,7 @@ import {
 	SOURCE_PATHS,
 	scanSkillsFromDir,
 } from "./helpers";
+import { resolvePluginStdioPaths } from "./substitute-plugin-root";
 
 const PROVIDER_ID = "codex";
 const DISPLAY_NAME = "OpenAI Codex";
@@ -87,7 +88,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 
 	const items: MCPServer[] = [];
 	if (userConfig) {
-		const servers = extractMCPServersFromToml(userConfig);
+		const servers = extractMCPServersFromToml(userConfig, path.dirname(userConfigPath));
 		for (const [name, config] of Object.entries(servers)) {
 			items.push({
 				name,
@@ -97,7 +98,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 		}
 	}
 	if (projectConfig) {
-		const servers = extractMCPServersFromToml(projectConfig);
+		const servers = extractMCPServersFromToml(projectConfig, path.dirname(projectConfigPath));
 		for (const [name, config] of Object.entries(servers)) {
 			items.push({
 				name,
@@ -139,7 +140,10 @@ interface CodexMCPConfig {
 	disabled_tools?: string[];
 }
 
-function extractMCPServersFromToml(toml: Record<string, unknown>): Record<string, Partial<MCPServer>> {
+function extractMCPServersFromToml(
+	toml: Record<string, unknown>,
+	configDir: string,
+): Record<string, Partial<MCPServer>> {
 	// Check for [mcp_servers.*] sections (Codex format)
 	if (!toml.mcp_servers || typeof toml.mcp_servers !== "object") {
 		return {};
@@ -149,10 +153,16 @@ function extractMCPServersFromToml(toml: Record<string, unknown>): Record<string
 	const result: Record<string, Partial<MCPServer>> = {};
 
 	for (const [name, config] of Object.entries(codexServers)) {
+		// Root relative cwd/command against the Codex config directory. Codex
+		// spawns the process with the resolved cwd, so a relative command is
+		// resolved by the OS from there — pass "cwd" so e.g. cwd="server",
+		// command="./bin/mcp" resolves to <configDir>/server/bin/mcp.
+		const rooted = resolvePluginStdioPaths({ command: config.command, cwd: config.cwd }, configDir, "cwd");
 		const server: Partial<MCPServer> = {
-			command: config.command,
+			...(rooted.command !== undefined && { command: rooted.command }),
 			args: config.args,
 			url: config.url,
+			...(rooted.cwd !== undefined && { cwd: rooted.cwd }),
 		};
 
 		// Build env by merging explicit env and forwarded env_vars

package/src/discovery/substitute-plugin-root.ts

@@ -31,23 +31,38 @@ export function substitutePluginRoot<T>(value: T, rootPath: string): T {
 }
 
 /**
- * Rebase relative filesystem values in a discovered plugin stdio config against
- * the directory of the `.mcp.json` that declared them.
+ * Where a relative, path-like `command` is rooted by {@link resolvePluginStdioPaths}.
  *
- * External plugin configs (bundled ChatGPT/Codex plugins, Claude marketplace
- * plugins) express `command`/`cwd` relative to their own config file, but MCP
- * stdio spawning roots relative values at the session cwd — so a plugin shipping
+ * - `"config-dir"` (default): the directory of the config file that declared the
+ *   server — the plugin package root for `.mcp.json`. A plugin can ship its
+ *   executable at the package root (`command: "./bin/server"`) yet run from a
+ *   data subdir (`cwd: "work"`); the command stays `<pkg>/bin/server`.
+ * - `"cwd"`: the rooted `cwd`, falling back to the config dir when no `cwd` is
+ *   set. This matches how the OS resolves a relative command against the
+ *   subprocess's working directory, which is the Codex `config.toml` contract:
+ *   `cwd = "server"`, `command = "./bin/mcp"` → `<configDir>/server/bin/mcp`.
+ */
+export type StdioCommandBase = "config-dir" | "cwd";
+
+/**
+ * Rebase relative filesystem values in a discovered stdio server config against
+ * the directory of the config file (`.mcp.json`/`config.toml`) that declared them.
+ *
+ * External configs (bundled ChatGPT/Codex plugins, Claude marketplace plugins)
+ * express `command`/`cwd` relative to their own config file, but MCP stdio
+ * spawning roots relative values at the session cwd — so a server shipping
  * `command: "./bin/server"`, `cwd: "."` launches from the wrong directory and
  * fails with ENOENT. This resolves those against `configDir` instead:
  *
  * - relative `cwd` → resolved against `configDir`;
  * - path-like `command` (`./`, `../`, or the Windows `.\`/`..\` forms) →
- *   resolved against `configDir`;
+ *   resolved against the base selected by `commandBase` (see {@link StdioCommandBase});
  * - bare executables (`npx`, `uvx`, …) and absolute paths are left untouched.
  */
 export function resolvePluginStdioPaths(
 	config: { command?: string; cwd?: string },
 	configDir: string,
+	commandBase: StdioCommandBase = "config-dir",
 ): { command?: string; cwd?: string } {
 	const resolved: { command?: string; cwd?: string } = {};
 	if (typeof config.cwd === "string") {
@@ -55,7 +70,8 @@ export function resolvePluginStdioPaths(
 	}
 	if (config.command !== undefined) {
 		const isPathLike = /^\.\.?[/\\]/.test(config.command);
-		resolved.command = isPathLike ? path.resolve(configDir, config.command) : config.command;
+		const base = commandBase === "cwd" ? (resolved.cwd ?? configDir) : configDir;
+		resolved.command = isPathLike ? path.resolve(base, config.command) : config.command;
 	}
 	return resolved;
 }

package/src/export/html/template.js

@@ -1082,6 +1082,8 @@
                   <div class="thinking-text">${escapeHtml(thinking)}</div>
                   <div class="thinking-collapsed">Thinking ...</div>
                 </div>`;
+              } else if (block.type === 'image') {
+                html += `<div class="message-images"><img src="data:${block.mimeType};base64,${block.data}" class="message-image" /></div>`;
               }
             }
             for (const block of msg.content) {

package/src/internal-urls/__tests__/agent-protocol-nested.test.ts

@@ -66,3 +66,76 @@ it("agent:// resolves a depth-2 subagent's .md output while its session is live
 	const resource = await new AgentProtocolHandler().resolve(new URL(`agent://${grandchildId}`) as never);
 	expect(resource.content).toBe("full report content");
 });
+
+it("agent:// slash form resolves a nested subagent child (hierarchy separator)", async () => {
+	const root = tempDir.path();
+	const rootSessionFile = path.join(root, "slash-session.jsonl");
+	const rootArtifactsDir = rootSessionFile.slice(0, -6);
+	await fs.mkdir(rootArtifactsDir, { recursive: true });
+	const sharedArtifactManager = new ArtifactManager(rootArtifactsDir);
+
+	// Parent subagent adopts the root ArtifactManager; its own children are
+	// written one level deeper under its sessionFile-derived dir, dot-qualified.
+	const parentSessionFile = path.join(rootArtifactsDir, "Parent.jsonl");
+	const parentOwnDir = parentSessionFile.slice(0, -6);
+	await fs.mkdir(parentOwnDir, { recursive: true });
+	await fs.writeFile(path.join(parentOwnDir, "Parent.Child.md"), "child capsule");
+	// Parent output may be in the root dir; the nested child must still win.
+	await fs.writeFile(path.join(rootArtifactsDir, "Parent.md"), JSON.stringify({ Child: "wrong base output" }));
+
+	const fakeSession = {
+		sessionManager: { getArtifactsDir: () => sharedArtifactManager.dir },
+	} as unknown as AgentSession;
+	const registry = AgentRegistry.global();
+	registry.register({
+		id: "Main",
+		displayName: "main",
+		kind: "main",
+		session: fakeSession,
+		sessionFile: rootSessionFile,
+	});
+	registry.register({
+		id: "Parent",
+		displayName: "sub",
+		kind: "sub",
+		parentId: "Main",
+		session: fakeSession,
+		sessionFile: parentSessionFile,
+	});
+
+	const handler = new AgentProtocolHandler();
+	// Slash form is a hierarchy hop, not a jq extraction.
+	const slash = await handler.resolve(new URL("agent://Parent/Child") as never);
+	expect(slash.content).toBe("child capsule");
+	expect(slash.contentType).toBe("text/markdown");
+	// The canonical dotted id resolves to the same output.
+	const dotted = await handler.resolve(new URL("agent://Parent.Child") as never);
+	expect(dotted.content).toBe("child capsule");
+});
+
+it("agent:// path form falls back to JSON extraction when no nested output matches", async () => {
+	const root = tempDir.path();
+	const rootSessionFile = path.join(root, "json-session.jsonl");
+	const rootArtifactsDir = rootSessionFile.slice(0, -6);
+	await fs.mkdir(rootArtifactsDir, { recursive: true });
+	const sharedArtifactManager = new ArtifactManager(rootArtifactsDir);
+	await fs.writeFile(path.join(rootArtifactsDir, "Worker.md"), JSON.stringify({ result: { ok: true } }));
+
+	const fakeSession = {
+		sessionManager: { getArtifactsDir: () => sharedArtifactManager.dir },
+	} as unknown as AgentSession;
+	const registry = AgentRegistry.global();
+	registry.register({
+		id: "Main",
+		displayName: "main",
+		kind: "main",
+		session: fakeSession,
+		sessionFile: rootSessionFile,
+	});
+
+	const handler = new AgentProtocolHandler();
+	// `result` names no nested output, so the path extracts JSON from Worker.md.
+	const extracted = await handler.resolve(new URL("agent://Worker/result") as never);
+	expect(extracted.contentType).toBe("application/json");
+	expect(JSON.parse(extracted.content)).toEqual({ ok: true });
+});