@oh-my-pi/pi-coding-agent 17.0.2 → 17.0.4

package/dist/types/task/types.d.ts

@@ -5,6 +5,32 @@ import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { NestedRepoPatch } from "./worktree.js";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
+/**
+ * Enforcement policy for a structured subagent output schema.
+ *
+ * `permissive` preserves legacy retry-budget overrides; `strict` turns every
+ * invalid final payload, including an exhausted retry override, into a failed
+ * `schema_violation` result.
+ */
+export type StructuredSubagentSchemaMode = "permissive" | "strict";
+/** Origin of the schema selected for a structured subagent invocation. */
+export type StructuredSubagentSchemaSource = "caller" | "agent" | "session" | "none";
+/** Final validation state of a structured subagent invocation. */
+export type StructuredSubagentValidationStatus = "valid" | "invalid" | "unavailable";
+/**
+ * Parsed structured completion and its schema-validation metadata.
+ *
+ * `data` is present whenever a payload could be assembled or parsed, even when
+ * strict validation rejects it. `error` explains unavailable or invalid
+ * validation without requiring consumers to parse presentation text.
+ */
+export interface StructuredSubagentOutput {
+    source: StructuredSubagentSchemaSource;
+    mode: StructuredSubagentSchemaMode;
+    status: StructuredSubagentValidationStatus;
+    data?: unknown;
+    error?: string;
+}
 /** Maximum output bytes per agent */
 export declare const MAX_OUTPUT_BYTES: number;
 /** Maximum output lines per agent */
@@ -57,6 +83,8 @@ export declare const taskItemSchema: import("arktype/internal/variants/object.ts
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: string | boolean | object | null | undefined;
+    schemaMode?: "permissive" | "strict" | undefined;
 }, {}>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
 export interface TaskItem {
@@ -66,6 +94,10 @@ export interface TaskItem {
     agent?: string;
     /** The work; required by the schema. */
     task?: string;
+    /** Caller-provided output schema; its presence overrides the selected agent's schema. */
+    outputSchema?: unknown;
+    /** Validation behavior for a caller-provided or inherited output schema. */
+    schemaMode?: "permissive" | "strict";
     /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
     isolated?: boolean;
 }
@@ -73,23 +105,31 @@ export declare const taskSchema: import("arktype/internal/variants/object.ts").O
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: string | boolean | object | null | undefined;
+    schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>;
 declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/object.ts").ObjectType<{
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: string | boolean | object | null | undefined;
+    schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
+    outputSchema?: string | boolean | object | null | undefined;
+    schemaMode?: "permissive" | "strict" | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     context: string;
     tasks: {
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        outputSchema?: string | boolean | object | null | undefined;
+        schemaMode?: "permissive" | "strict" | undefined;
         isolated?: boolean | undefined;
     }[];
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
@@ -98,6 +138,8 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
+        outputSchema?: string | boolean | object | null | undefined;
+        schemaMode?: "permissive" | "strict" | undefined;
     }[];
 }, {}>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
@@ -126,6 +168,10 @@ export interface TaskParams {
     agent?: string;
     /** The work (flat form). */
     task?: string;
+    /** Caller-provided output schema; its presence overrides the selected agent's schema. */
+    outputSchema?: unknown;
+    /** Validation behavior for a caller-provided or inherited output schema. */
+    schemaMode?: "permissive" | "strict";
     /** Batch form (`task.batch`): one subagent per item. */
     tasks?: TaskItem[];
     /** Batch form: shared background prepended to every assignment; required by the batch schema. */
@@ -294,6 +340,11 @@ export interface SingleResult {
     output: string;
     stderr: string;
     truncated: boolean;
+    /**
+     * Parsed structured completion and validation metadata, when this invocation
+     * selected an output schema or strict schema mode.
+     */
+    structuredOutput?: StructuredSubagentOutput;
     durationMs: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;

package/dist/types/tools/fetch.d.ts

@@ -53,22 +53,21 @@ export interface ReadUrlToolDetails {
     notes: string[];
     meta?: OutputMeta;
 }
-interface ReadUrlCacheEntry {
+interface ReadUrlEntry {
     artifactId?: string;
     artifactPath?: string;
-    contentPath?: string;
     details: ReadUrlToolDetails;
     image?: FetchImagePayload;
     output: string;
     content: string;
 }
-export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
+/** Fetch and render a URL for a read or search operation. */
+export declare function fetchReadUrl(session: ToolSession, params: {
     path: string;
     raw?: boolean;
 }, signal?: AbortSignal, options?: {
     ensureArtifact?: boolean;
-    preferCached?: boolean;
-}): Promise<ReadUrlCacheEntry>;
+}): Promise<ReadUrlEntry>;
 /** Materialize rendered URL body text to a local file for tools that require filesystem paths. */
 export declare function materializeReadUrlToFile(session: ToolSession, params: {
     path: string;

package/dist/types/tools/hub/messaging.d.ts

@@ -32,7 +32,11 @@ export declare function resolveMessageTimeoutMs(settings: Settings, explicit?: n
 export declare function drainPendingInbox(registry: AgentRegistry, senderId: string, from?: string): IrcMessage | undefined;
 /** `wait` result carrying a consumed message. */
 export declare function messageResult(senderId: string, waited: IrcMessage): AgentToolResult<CoordinationDetails>;
-export declare function executeList(registry: AgentRegistry, senderId: string): AgentToolResult<CoordinationDetails>;
+/**
+ * List every addressable peer, restoring parked refs from disk when a resumed
+ * session has no in-memory roster.
+ */
+export declare function executeList(registry: AgentRegistry, senderId: string): Promise<AgentToolResult<CoordinationDetails>>;
 export interface HubSendParams {
     to?: string;
     message?: string;

package/dist/types/tools/index.d.ts

@@ -20,6 +20,7 @@ import type { CustomMessage } from "../session/messages.js";
 import type { UsageStatistics } from "../session/session-entries.js";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue.js";
 import type { AgentOutputManager } from "../task/output-manager.js";
+import { type StructuredSubagentSchemaMode } from "../task/types.js";
 import type { EventBus } from "../utils/event-bus.js";
 import type { WorkspaceTree } from "../workspace-tree.js";
 import { type BuiltinToolName, type HiddenToolName } from "./builtin-names.js";
@@ -144,17 +145,31 @@ export interface ToolSession {
     customToolPaths?: ToolPathWithSource[];
     /** Whether LSP integrations are enabled */
     enableLsp?: boolean;
+    /** Whether this invocation may expose IRC. `false` removes it even for subagents. */
+    enableIrc?: boolean;
+    /**
+     * Whether MCP capabilities may be forwarded to child sessions. `false`
+     * prohibits inherited-manager and process-global MCP fallback.
+     */
+    enableMCP?: boolean;
     /** Whether an edit-capable tool is available in this session (controls hashline output) */
     hasEditTool?: boolean;
     /** Event bus for tool/extension communication */
     eventBus?: EventBus;
-    /** Output schema for structured completion (subagents) */
+    /** Output schema for structured completion (subagents). */
     outputSchema?: unknown;
+    /** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
+    outputSchemaMode?: StructuredSubagentSchemaMode;
     /** Whether to include the yield tool by default */
     requireYieldTool?: boolean;
     /** Session starts with a prewalk hand-off armed. Keeps `todo` in yield-gated
      *  (subagent) registries: the prewalk plan nudge + todo gate need it. */
     prewalkArmed?: boolean;
+    /**
+     * Constrain the active set to the caller's explicit built-in names (plus a
+     * required yield tool). Suppresses automatic tool-set expansion.
+     */
+    restrictToolNames?: boolean;
     /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
     /** Get shared eval executor session ID. Subagents inherit this to share JS/Python/Ruby/Julia state. */

package/dist/types/tools/todo.d.ts

@@ -57,6 +57,35 @@ export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]):
  * the contained side.
  */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
+/** Result of {@link selectCollapsedTodos}: the rows to render plus an optional
+ *  summary line (empty string ⇒ no summary row). */
+export interface CollapsedTodoSelection<T> {
+    items: T[];
+    summary: string;
+}
+/**
+ * Walking-viewport selection for a phase's collapsed todo preview (#5873).
+ *
+ * Policy, applied to `tasks` in todo order:
+ * 1. While the phase has open work, completed/abandoned tasks are omitted. A
+ *    phase with no open tasks left falls back to its closed tasks so the sticky
+ *    HUD's closed-todo persistence still has something to render.
+ * 2. Every active task (in-progress, or pending matched to a live subagent) is
+ *    placed at the head in stable todo order — never dropped for lying outside
+ *    an ordinary window.
+ * 3. Remaining rows up to `cap` are filled with the pending tasks that follow
+ *    the first active one, in todo order (falling back to leading pending tasks
+ *    when no active task exists), so a freshly-promoted task leads the preview.
+ * 4. When active tasks alone exceed `cap`, only the first `cap` active tasks are
+ *    shown and the summary counts the hidden *active* todos, never replacing
+ *    them with unrelated pending rows.
+ *
+ * The summary otherwise counts the remaining tasks in the display base. Returns
+ * the whole base with an empty summary when it already fits.
+ */
+export declare function selectCollapsedTodos<T extends {
+    status: TodoStatus;
+}>(tasks: T[], isMatched: (task: T) => boolean, cap: number): CollapsedTodoSelection<T>;
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
 export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams[]): {
     phases: TodoPhase[];
@@ -111,6 +140,8 @@ export declare function formatPhaseDisplayName(name: string, oneBasedIndex: numb
 export declare const TODO_STRIKE_HOLD_FRAMES = 2;
 export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
+/** Wire the live-subagent description source for {@link todoToolRenderer}. */
+export declare function setActiveTodoDescriptionsProvider(provider: () => readonly string[]): void;
 export declare const todoToolRenderer: {
     renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {

package/dist/types/tui/tree-list.d.ts

@@ -13,6 +13,13 @@ export interface TreeListOptions<T> {
     maxCollapsedLines?: number;
     itemType?: string;
     truncateFrom?: "start" | "end";
+    /** Caller-supplied trailing summary line. When set (and not expanded),
+     *  `renderTreeList` renders exactly the provided `items` (the caller has
+     *  already applied its own selection/cap) and appends this text as the
+     *  final `└` row, with the last item using `├`. Empty string renders the
+     *  items with no summary. Bypasses the built-in truncation/`maxCollapsed`
+     *  path. */
+    trailingSummary?: string;
     /** Called once per item with `isLast: false` during budget calculation;
      *  line count MUST NOT vary based on `isLast`. */
     renderItem: (item: T, context: TreeContext) => string | string[];

package/dist/types/utils/markit.d.ts

@@ -1,4 +1,15 @@
 import { type MarkitConversionCacheStatus } from "./markit-cache.js";
+/**
+ * File extensions markit can actually convert to markdown — one per registered
+ * converter in `src/markit/registry.ts` (pdf, docx, pptx, xlsx, epub). This is
+ * the single source of truth shared by the read, fetch, and CLI file tools so
+ * the advertised set never drifts from the converters that back it. Legacy
+ * binary formats (`.doc`, `.ppt`, `.xls`, `.rtf`) are intentionally absent:
+ * markit has no converter for them, so routing them here only produced an
+ * `Unsupported format` error instead of letting them fall through to the
+ * binary-file handling.
+ */
+export declare const CONVERTIBLE_EXTENSIONS: ReadonlySet<string>;
 export interface MarkitConversionResult {
     content: string;
     ok: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.0.2",
+	"version": "17.0.4",
 	"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.2",
-		"@oh-my-pi/omp-stats": "17.0.2",
-		"@oh-my-pi/pi-agent-core": "17.0.2",
-		"@oh-my-pi/pi-ai": "17.0.2",
-		"@oh-my-pi/pi-catalog": "17.0.2",
-		"@oh-my-pi/pi-mnemopi": "17.0.2",
-		"@oh-my-pi/pi-natives": "17.0.2",
-		"@oh-my-pi/pi-tui": "17.0.2",
-		"@oh-my-pi/pi-utils": "17.0.2",
-		"@oh-my-pi/pi-wire": "17.0.2",
-		"@oh-my-pi/snapcompact": "17.0.2",
+		"@oh-my-pi/hashline": "17.0.4",
+		"@oh-my-pi/omp-stats": "17.0.4",
+		"@oh-my-pi/pi-agent-core": "17.0.4",
+		"@oh-my-pi/pi-ai": "17.0.4",
+		"@oh-my-pi/pi-catalog": "17.0.4",
+		"@oh-my-pi/pi-mnemopi": "17.0.4",
+		"@oh-my-pi/pi-natives": "17.0.4",
+		"@oh-my-pi/pi-tui": "17.0.4",
+		"@oh-my-pi/pi-utils": "17.0.4",
+		"@oh-my-pi/pi-wire": "17.0.4",
+		"@oh-my-pi/snapcompact": "17.0.4",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/cli/file-processor.ts

@@ -9,13 +9,12 @@ import chalk from "chalk";
 import { resolveReadPath } from "../tools/path-utils";
 import { formatBytes } from "../tools/render-utils";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
-import { convertFileWithMarkit } from "../utils/markit";
+import { CONVERTIBLE_EXTENSIONS, convertFileWithMarkit } from "../utils/markit";
 
 // Keep CLI startup responsive and avoid OOM when users pass huge files.
 // If a file exceeds these limits, we include it as a path-only <file/> block.
 const MAX_CLI_TEXT_BYTES = 5 * 1024 * 1024; // 5MB
 const MAX_CLI_IMAGE_BYTES = 25 * 1024 * 1024; // 25MB
-const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
 
 export interface ProcessedFiles {
 	text: string;

package/src/config/settings-schema.ts

@@ -4748,14 +4748,15 @@ export const SETTINGS_SCHEMA = {
 
 	"providers.kimiApiFormat": {
 		type: "enum",
-		values: ["openai", "anthropic"] as const,
-		default: "anthropic",
+		values: ["auto", "openai", "anthropic"] as const,
+		default: "auto",
 		ui: {
 			tab: "providers",
 			group: "Protocol",
 			label: "Kimi API Format",
-			description: "API format for Kimi Code provider",
+			description: "API format for Kimi Code provider (auto follows live model metadata)",
 			options: [
+				{ value: "auto", label: "Auto", description: "Use the model's server-declared protocol" },
 				{ value: "openai", label: "OpenAI", description: "api.kimi.com" },
 				{ value: "anthropic", label: "Anthropic", description: "api.moonshot.ai" },
 			],

package/src/eval/__tests__/agent-bridge.test.ts

@@ -13,9 +13,9 @@ import type { ExecutorOptions } from "../../task/executor";
 import * as taskExecutor from "../../task/executor";
 import * as isolationRunner from "../../task/isolation-runner";
 import { AgentOutputManager } from "../../task/output-manager";
-import type { AgentDefinition, AgentProgress, SingleResult } from "../../task/types";
+import type { AgentDefinition, AgentProgress, SingleResult, StructuredSubagentOutput } from "../../task/types";
 import type { ToolSession } from "../../tools";
-import { EVAL_AGENT_MAX_DEPTH, runEvalAgent } from "../agent-bridge";
+import { runEvalAgent } from "../agent-bridge";
 import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../bridge-timeout";
 import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
@@ -51,6 +51,7 @@ interface SessionOptions {
 	settings?: Settings;
 	outputManager?: AgentOutputManager;
 	planMode?: boolean;
+	outputSchema?: unknown;
 }
 
 function makeSession(options: SessionOptions = {}): ToolSession {
@@ -76,6 +77,7 @@ function makeSession(options: SessionOptions = {}): ToolSession {
 		getArtifactsDir: () => artifactsDir,
 		getSessionId: () => "test-session",
 		getEvalSessionId: () => "test-eval-session",
+		outputSchema: options.outputSchema,
 		getPlanModeState: options.planMode
 			? () =>
 					({
@@ -189,7 +191,7 @@ describe("runEvalAgent", () => {
 		);
 	});
 
-	it("enforces spawn restrictions and the eval recursion cap", async () => {
+	it("enforces shared spawn restrictions", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 
@@ -199,9 +201,6 @@ describe("runEvalAgent", () => {
 		await expect(
 			runEvalAgent({ prompt: "hello", agent: "task" }, { session: makeSession({ spawns: "reviewer" }) }),
 		).rejects.toThrow("Allowed: reviewer");
-		await expect(
-			runEvalAgent({ prompt: "hello" }, { session: makeSession({ depth: EVAL_AGENT_MAX_DEPTH }) }),
-		).rejects.toThrow("maximum depth");
 		expect(runSpy).not.toHaveBeenCalled();
 	});
 
@@ -219,12 +218,10 @@ describe("runEvalAgent", () => {
 		expect(runSpy.mock.calls[0]?.[0].agent.name).toBe("reviewer");
 	});
 
-	it("honors task.maxRecursionDepth on top of the hard eval ceiling", async () => {
+	it("honors task.maxRecursionDepth without an eval-specific ceiling", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 
-		// task.maxRecursionDepth=0 means "no spawning at all" — even depth 0 (the
-		// top-level agent) must be blocked, matching canSpawnAtDepth().
 		await expect(
 			runEvalAgent(
 				{ prompt: "hello" },
@@ -240,35 +237,38 @@ describe("runEvalAgent", () => {
 			),
 		).rejects.toThrow("maximum depth is 0");
 
-		// task.maxRecursionDepth=1 ("Single") lets the top spawn but a depth-1
-		// subagent cannot spawn further — even though the hard ceiling is 3.
-		await expect(
-			runEvalAgent(
-				{ prompt: "hello" },
-				{
-					session: makeSession({
-						depth: 1,
-						settings: Settings.isolated({
-							"async.enabled": false,
-							"task.isolation.mode": "none",
-							"task.maxRecursionDepth": 1,
-						}),
+		await runEvalAgent(
+			{ prompt: "hello" },
+			{
+				session: makeSession({
+					depth: 3,
+					settings: Settings.isolated({
+						"async.enabled": false,
+						"task.isolation.mode": "none",
+						"task.maxRecursionDepth": -1,
 					}),
-				},
-			),
-		).rejects.toThrow("maximum depth is 1");
-
-		expect(runSpy).not.toHaveBeenCalled();
+				}),
+			},
+		);
+		expect(runSpy).toHaveBeenCalledTimes(1);
 	});
 
-	it("throws instead of spawning from plan mode", async () => {
-		mockAgents();
+	it("runs plan-mode eval agents with an attenuated policy", async () => {
+		mockAgents([{ ...taskAgent, tools: ["ast_grep", "write"] }]);
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 
-		await expect(runEvalAgent({ prompt: "hello" }, { session: makeSession({ planMode: true }) })).rejects.toThrow(
-			"unavailable in plan mode",
-		);
-		expect(runSpy).not.toHaveBeenCalled();
+		await expect(
+			runEvalAgent({ prompt: "hello" }, { session: makeSession({ planMode: true }) }),
+		).resolves.toMatchObject({
+			text: "ok",
+		});
+		expect(runSpy).toHaveBeenCalledTimes(1);
+		expect(runSpy.mock.calls[0]?.[0].agent.tools).toEqual(["read", "grep", "glob", "web_search", "ast_grep"]);
+		expect(runSpy.mock.calls[0]?.[0].agent.spawns).toBeUndefined();
+		await expect(
+			runEvalAgent({ prompt: "unsafe", isolated: true }, { session: makeSession({ planMode: true }) }),
+		).rejects.toThrow("isolation, apply, and merge controls are unavailable in plan mode");
+		expect(runSpy).toHaveBeenCalledTimes(1);
 	});
 
 	it("passes parent execution options and only sets outputSchema when schema is supplied", async () => {
@@ -310,8 +310,52 @@ describe("runEvalAgent", () => {
 		expect(secondOptions.outputSchema).toBeUndefined();
 		expect(secondOptions.outputSchemaOverridesAgent).toBeUndefined();
 	});
+	it("returns host-parsed data for caller, agent, and inherited schemas", async () => {
+		const agentSchema = { type: "object" };
+		const sessionSchema = { type: "object" };
+		const callerSchema = { type: "object" };
+		const frontmatterAgent = { ...reviewerAgent, name: "structured", output: agentSchema };
+		mockAgents([taskAgent, frontmatterAgent]);
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			const source = options.outputSchemaOverridesAgent
+				? "caller"
+				: options.agent.name === "structured"
+					? "agent"
+					: "session";
+			const structuredOutput: StructuredSubagentOutput = {
+				source,
+				mode: options.outputSchemaMode ?? "permissive",
+				status: "valid",
+				data: { source },
+			};
+			return singleResult(options, { output: "not JSON", structuredOutput });
+		});
+
+		const caller = await runEvalAgent(
+			{ prompt: "caller", schema: callerSchema, schemaMode: "strict" },
+			{ session: makeSession({ outputSchema: sessionSchema }) },
+		);
+		const frontmatter = await runEvalAgent(
+			{ prompt: "agent", agent: "structured" },
+			{ session: makeSession({ outputSchema: sessionSchema }) },
+		);
+		const inherited = await runEvalAgent(
+			{ prompt: "session" },
+			{ session: makeSession({ outputSchema: sessionSchema }) },
+		);
 
-	it("forces LSP off for bridge subagents even when task.enableLsp is on", async () => {
+		expect(caller.data).toEqual({ source: "caller" });
+		expect(caller.details).toMatchObject({ schemaSource: "caller", schemaMode: "strict", schemaStatus: "valid" });
+		expect(frontmatter.data).toEqual({ source: "agent" });
+		expect(inherited.data).toEqual({ source: "session" });
+		expect(runSpy.mock.calls.map(([options]) => options.outputSchema)).toEqual([
+			callerSchema,
+			agentSchema,
+			sessionSchema,
+		]);
+	});
+
+	it("inherits non-plan LSP and IRC policy for bridge subagents", async () => {
 		mockAgents();
 		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => singleResult(options));
 		// makeSession() defaults to enableLsp: true and task.enableLsp: true.
@@ -321,7 +365,8 @@ describe("runEvalAgent", () => {
 
 		const options = runSpy.mock.calls[0]?.[0];
 		if (!options) throw new Error("runSubprocess was not called");
-		expect(options.enableLsp).toBe(false);
+		expect(options.enableLsp).toBe(true);
+		expect(options.enableIrc).toBe(true);
 		expect(options.keepAlive).toBe(false);
 	});
 
@@ -485,16 +530,30 @@ describe("agent() through eval runtimes", () => {
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
 			singleResult(options, {
 				output: options.outputSchema ? '{"ok":true,"n":3}' : "hello from agent",
+				...(options.outputSchema
+					? {
+							structuredOutput: {
+								source: "caller",
+								mode: options.outputSchemaMode ?? "permissive",
+								status: "valid",
+								data: { ok: true, n: 3 },
+							} satisfies StructuredSubagentOutput,
+						}
+					: {}),
 			}),
 		);
 
 		const result = await executeJs(
-			'const text = await agent("hi"); const data = await agent("json", { schema: { type: "object" } }); return JSON.stringify([text, data]);',
+			'const text = await agent("hi"); const data = await agent("json", { schema: { type: "object" } }); const node = await agent("handle", { schema: { type: "object" }, handle: true }); return JSON.stringify({ text, data, node });',
 			{ cwd: tempDir.path(), sessionId: sharedJsSessionId, session, sessionFile },
 		);
 
 		expect(result.exitCode).toBe(0);
-		expect(JSON.parse(result.output.trim())).toEqual(["hello from agent", { ok: true, n: 3 }]);
+		const output = JSON.parse(result.output.trim());
+		expect(output.text).toBe("hello from agent");
+		expect(output.data).toEqual({ ok: true, n: 3 });
+		expect(output.node.data).toEqual({ ok: true, n: 3 });
+		expect(output.node.handle).toBe(`agent://${output.node.id}`);
 	});
 
 	it("bounds JavaScript parallel() by the task.maxConcurrency setting while preserving order", async () => {
@@ -547,23 +606,43 @@ describe("agent() through eval runtimes", () => {
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent");
 		mockAgents();
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options =>
-			singleResult(options, { output: "hello from python" }),
+			singleResult(options, {
+				output: options.outputSchema ? "not JSON" : "hello from python",
+				...(options.outputSchema
+					? {
+							structuredOutput: {
+								source: "caller",
+								mode: options.outputSchemaMode ?? "permissive",
+								status: "valid",
+								data: { ok: true },
+							} satisfies StructuredSubagentOutput,
+						}
+					: {}),
+			}),
 		);
 
-		const result = await executePython('print(agent("hi"))', {
-			cwd: tempDir.path(),
-			sessionId,
-			sessionFile,
-			kernelMode: "per-call",
-			toolSession: session,
-		});
+		const result = await executePython(
+			'import json\nprint(agent("hi"))\nprint(json.dumps(agent("structured", schema={"type": "object"})))\nnode = agent("handle", schema={"type": "object"}, handle=True)\nprint(json.dumps({"data": node["data"], "handle": node["handle"], "id": node["id"]}))',
+			{
+				cwd: tempDir.path(),
+				sessionId,
+				sessionFile,
+				kernelMode: "per-call",
+				toolSession: session,
+			},
+		);
 		if (result.exitCode === undefined && result.cancelled) {
 			expect(result.output).toBe("");
 			return; // kernel unavailable in this environment
 		}
 
 		expect(result.exitCode).toBe(0);
-		expect(result.output.trim()).toBe("hello from python");
+		const lines = result.output.trim().split("\n");
+		expect(lines[0]).toBe("hello from python");
+		expect(JSON.parse(lines[1] ?? "")).toEqual({ ok: true });
+		const node = JSON.parse(lines[2] ?? "");
+		expect(node.data).toEqual({ ok: true });
+		expect(node.handle).toBe(`agent://${node.id}`);
 	});
 
 	it("bounds Python parallel() by the task.maxConcurrency setting while preserving order", async () => {
@@ -772,7 +851,11 @@ describe("agent() through eval runtimes", () => {
 
 	it("pauses the idle watchdog while a quiet agent() runs past the budget", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-timeout-pause-");
-		const { session } = makeEvalSession(tempDir, "js-agent-timeout-pause");
+		const { session } = makeEvalSession(
+			tempDir,
+			"js-agent-timeout-pause",
+			Settings.isolated({ "task.maxRuntimeMs": 1 }),
+		);
 		mockAgents();
 
 		// runSubprocess runs far past the eval timeout budget and emits NO progress
@@ -788,7 +871,9 @@ describe("agent() through eval runtimes", () => {
 		const inFlight = new Promise<void>(resolve => {
 			markInFlight = resolve;
 		});
+		let observedMaxRuntimeMs: number | undefined;
 		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			observedMaxRuntimeMs = options.maxRuntimeMs;
 			markInFlight?.();
 			await released;
 			return singleResult(options, { output: "done" });
@@ -812,6 +897,7 @@ describe("agent() through eval runtimes", () => {
 
 		// The bridge paused the watchdog; the subprocess is now blocked in flight.
 		await inFlight;
+		expect(observedMaxRuntimeMs).toBe(0);
 		// Burn far more than the 20ms budget while paused: the watchdog stays armed-off.
 		vi.advanceTimersByTime(1_000);
 		expect(idle.signal.aborted).toBe(false);