@oh-my-pi/pi-coding-agent 14.1.2 → 14.2.0

package/src/prompts/tools/task.md

@@ -5,28 +5,52 @@ Launches subagents to parallelize workflows.
 - Use the `poll` tool to wait until completion. You **MUST NOT** poll `read jobs://` in a loop.
 {{/if}}
 
+{{#if defaultMode}}
+Current input mode: `default`. Shared `context` and custom task-call `schema` are available.
+{{/if}}
+{{#if schemaFreeMode}}
+Current input mode: `schema-free`. Shared `context` is available; custom task-call `schema` is disabled. For structured output, rely on the agent definition or inherited session schema.
+{{/if}}
+{{#if independentMode}}
+Current input mode: `independent`. Shared `context` and custom `schema` are both disabled. Every assignment must stand on its own.
+{{/if}}
+
+{{#if contextEnabled}}
 Subagents lack your conversation history. Every decision, file content, and user requirement they need **MUST** be explicit in `context` or `assignment`.
+{{else}}
+Subagents lack your conversation history. Every decision, file content, and user requirement they need **MUST** be explicit in each task `assignment`.
+{{/if}}
 
 <parameters>
 - `agent`: Agent type for all tasks.
   - `.id`: CamelCase, max 32 chars
   - `.description`: UI display only — subagent never sees it
   - `.assignment`: Complete self-contained instructions. One-liners PROHIBITED; missing acceptance criteria = too vague.
+{{#if contextEnabled}}
 - `context`: Shared background prepended to every assignment. Session-specific info only.
+{{/if}}
+{{#if customSchemaEnabled}}
 - `schema`: JSON-encoded JTD schema for expected output. Format lives here — **MUST NOT** be duplicated in assignments.
+{{/if}}
 - `tasks`: Tasks to execute in parallel.
+{{#if isolationEnabled}}
 - `isolated`: Run in isolated environment; returns patches. Use when tasks edit overlapping files.
+{{/if}}
 </parameters>
 
 <critical>
+{{#if contextEnabled}}
 - **MUST NOT** duplicate shared constraints across assignments — put them in `context` once.
+{{else}}
+- Every `assignment` must repeat any constraints, reference paths, and acceptance criteria it needs — there is no shared `context` field.
+{{/if}}
 - **MUST NOT** tell tasks to run project-wide build/test/lint. Parallel agents share the working tree; each task edits, stops. Caller verifies after all complete.
-- For large payloads (traces, JSON blobs), write to `local://<path>` and pass the path in context.
-- Prefer `task` agents that investigate **and** edit in one pass. Only launch a dedicated read-only discovery step when the affected files are genuinely unknown and cannot be inferred from the task description.
+- For large payloads (traces, JSON blobs), write to `local://<path>` and pass the path in {{#if contextEnabled}}`context`{{else}}the relevant `assignment`{{/if}}.
+- Prefer `task` agents that investigate **and** edit in one pass. Launch a dedicated read-only discovery step only when affected files are genuinely unknown.
 </critical>
 
 <scope>
-Each task: **at most 3–5 files**. Globs in file paths, "update all", or package-wide scope = too broad. Enumerate files explicitly and fan out to a cluster of agents.
+Each task: **at most 3–5 files**. Globs, "update all", or package-wide scope = too broad. Enumerate files explicitly and fan out to a cluster of agents.
 </scope>
 
 <parallelization>
@@ -38,10 +62,12 @@ Each task: **at most 3–5 files**. Globs in file paths, "update all", or packag
 |API exports|Callers|Need signatures|
 |Core module|Dependents|Import dependency|
 |Schema/migration|App logic|Schema dependency|
+
 **Safe to parallelize:** independent modules, isolated file-scoped refactors, tests for existing code.
 </parallelization>
 
 <templates>
+{{#if contextEnabled}}
 **context:**
 ```
 ## Goal         ← one sentence: what the batch accomplishes
@@ -50,6 +76,9 @@ Each task: **at most 3–5 files**. Globs in file paths, "update all", or packag
 ## API Contract ← exact types/signatures if tasks share an interface (omit if N/A)
 ## Acceptance   ← definition of done; build/lint runs AFTER all tasks complete
 ```
+{{else}}
+No shared `context` field exists in this mode. Fold goal, non-goals, constraints, and acceptance criteria into each `assignment`.
+{{/if}}
 **assignment:**
 ```
 ## Target       ← exact file paths; named symbols; explicit non-goals
@@ -61,68 +90,75 @@ Each task: **at most 3–5 files**. Globs in file paths, "update all", or packag
 
 <checklist>
 Before invoking:
+{{#if contextEnabled}}
 - `context` contains only session-specific info
+{{else}}
+- Every `assignment` includes its own goal, constraints, and acceptance criteria (no shared context)
+{{/if}}
 - Every `assignment` follows the template; no one-liners; edge cases covered
 - Tasks are truly parallel — you can articulate why none depends on another's output
 - File paths are explicit; no globs
+{{#if customSchemaEnabled}}
 - `schema` is set if you expect structured output
+{{else}}
+- Do not pass a custom task-call `schema` in this mode
+{{/if}}
 </checklist>
 
+{{#if contextEnabled}}
 <example label="Rename exported symbol + update all call sites">
-Two tasks with non-overlapping file sets. Neither depends on the other's edits.
+Two tasks with non-overlapping file sets — demonstrates scope partitioning.
 
 <context>
 ## Goal
 Rename `parseConfig` → `loadConfig` in `src/config/parser.ts` and all callers.
 ## Non-goals
-Do not change function behavior, signature, or tests — rename only.
+No behavior or signature changes; rename only.
 ## Acceptance (global)
 Caller runs `bun check:ts` after both tasks complete. Tasks must NOT run it.
 </context>
 <tasks>
   <task name="RenameExport">
-    <description>Rename the export in parser.ts</description>
     <assignment>
 ## Target
-- File: `src/config/parser.ts`
-- Symbol: exported function `parseConfig`
+- `src/config/parser.ts`: function `parseConfig`
+- If `src/config/index.ts` re-exports it, update the re-export
 - Non-goals: do not touch callers or tests
 
 ## Change
-- Rename `parseConfig` → `loadConfig` (declaration + any JSDoc referencing it)
-- If `src/config/index.ts` re-exports `parseConfig`, update that re-export too
+- Rename `parseConfig` → `loadConfig` (declaration + any JSDoc references)
 
 ## Edge Cases
-- If the function is overloaded, rename all overload signatures
-- Internal helpers named `_parseConfigValue` or similar: leave untouched — different symbols
+- Rename all overload signatures if overloaded
+- Internal helpers like `_parseConfigValue` are different symbols — leave untouched
 - Do not add a backwards-compat alias
 
 ## Acceptance
-- `src/config/parser.ts` exports `loadConfig`; `parseConfig` no longer appears as a top-level export in that file
+- `parseConfig` no longer appears as a top-level export in `parser.ts`
     </assignment>
   </task>
   <task name="UpdateCallers">
-    <description>Update import and call sites in consuming modules</description>
     <assignment>
 ## Target
-- Files: `src/cli/init.ts`, `src/server/bootstrap.ts`, `src/worker/index.ts`
-- Non-goals: do not touch `src/config/parser.ts` or `src/config/index.ts` — handled by sibling task
+- `src/cli/init.ts`, `src/server/bootstrap.ts`, `src/worker/index.ts`
+- Non-goals: do not touch `src/config/parser.ts` or `src/config/index.ts`
 
 ## Change
-- In each file: replace `import { parseConfig }` → `import { loadConfig }` from its config path
+- Replace `import { parseConfig }` → `import { loadConfig }`
 - Replace every call site `parseConfig(` → `loadConfig(`
+- For `import * as cfg` users, update `cfg.parseConfig` property access
 
 ## Edge Cases
-- If a file spreads the import (`import * as cfg from "…"`) and calls `cfg.parseConfig(…)`, update the property access too
-- String literals containing "parseConfig" (log messages, comments) are documentation — leave them
-- If any file re-exports `parseConfig` to an external package boundary, keep the old name via `export { loadConfig as parseConfig }` and add a `// TODO: remove after next major` comment
+- String literals containing "parseConfig" (logs, comments) are documentation — leave them
+- If a file re-exports to an external package boundary, keep the old name via `export { loadConfig as parseConfig }` with a `// TODO: remove after next major` comment
 
 ## Acceptance
-- No bare reference to `parseConfig` (as identifier, not string) remains in the three target files
+- No bare `parseConfig` identifier remains in the three target files
     </assignment>
   </task>
 </tasks>
 </example>
+{{/if}}
 
 {{#list agents join="\n"}}
 ### Agent: {{name}}

package/src/prompts/tools/todo-write.md

@@ -1,13 +1,29 @@
-Manages a phased task list. Submit an `ops` array — each op mutates state incrementally.
-**Primary op: `update`.** Use it to mark tasks `in_progress` or `completed`. Only reach for other ops when the structure itself needs to change.
+Manages a phased task list. Each field is a verb — set the ones you need in a single call.
+The next pending task is auto-promoted to `in_progress` after completing the current one.
 
-<critical>
-You **MUST** call this tool twice per task:
-1. Before beginning — `{op: "update", id: "task-N", status: "in_progress"}`
-2. Immediately after finishing — `{op: "update", id: "task-N", status: "completed"}`
+<protocol>
+## Fields
 
-You **MUST** keep exactly one task `in_progress` at all times. Mark `completed` immediately — no batching.
-</critical>
+|Field|Type|When to use|
+|---|---|---|
+|`phases`|Phase[]|Initial setup, or full restructure when the plan changes significantly|
+|`complete`|string[]|Mark tasks done|
+|`start`|string|Jump to a specific task out of order|
+|`abandon`|string[]|Drop tasks intentionally|
+|`remove`|string[]|Remove tasks that are no longer relevant|
+|`add_notes`|{id, notes}[]|Append runtime observations to tasks|
+|`add_tasks`|{phase, content, details?}[]|Add tasks to a phase (by name or ID)|
+|`add_phase`|{name, tasks?}|Add a new phase of work discovered mid-task|
+
+## Task Anatomy
+- `content`: Short label (5-10 words). What is being done, not how.
+- `details`: File paths, implementation steps, edge cases. Shown only when the task is active.
+
+## Rules
+- Mark tasks completed immediately after finishing — never defer
+- Complete phases in order — do not skip ahead while earlier ones are pending
+- On blockers: add a new task describing the blocker
+</protocol>
 
 <conditions>
 Create a todo list when:
@@ -17,73 +33,35 @@ Create a todo list when:
 4. New instructions arrive mid-task — capture before proceeding
 </conditions>
 
-<protocol>
-## Operations
+<example name="initial-setup">
+{phases: [
+  {name: "Investigation", tasks: [{content: "Read source"}, {content: "Map callsites"}]},
+  {name: "Implementation", tasks: [{content: "Apply fix", details: "Update parser.ts to handle edge case in line 42"}, {content: "Run tests"}]}
+]}
+</example>
 
-|op|When to use|
-|---|---|
-|`update`|Mark a task in_progress / completed / abandoned, or edit content/notes|
-|`replace`|Initial setup, or full restructure when the plan changes significantly|
-|`add_phase`|Add a new phase of work discovered mid-task|
-|`add_task`|Add a task to an existing phase|
-|`remove_task`|Remove a task that is no longer relevant|
+<example name="complete">
+{complete: ["task-2", "task-3"]}
+</example>
 
-## Statuses
+<example name="add-notes">
+{add_notes: [{id: "task-3", notes: "Found edge case in parser — needs null check"}]}
+</example>
 
-|Status|Meaning|
-|---|---|
-|`pending`|Not started|
-|`in_progress`|Currently working — exactly one at a time|
-|`completed`|Fully done|
-|`abandoned`|Dropped intentionally|
+<example name="add-task">
+{add_tasks: [{phase: "Implementation", content: "Handle retries", details: "Cap exponential backoff in retry.ts"}]}
+</example>
 
-## Rules
-- You **MUST** mark `in_progress` **before** starting work, not after
-- You **MUST** mark `completed` **immediately** — never defer
-- You **MUST** keep exactly **one** task `in_progress`
-- You **MUST** complete phases in order — do not mark later tasks `completed` while earlier ones are `pending`
-- On blockers: keep `in_progress`, add a new task describing the blocker
-- Multiple ops can be batched in one call (e.g., complete current + start next)
-</protocol>
+<example name="add-phase">
+{add_phase: {name: "Cleanup", tasks: [{content: "Remove dead code"}]}}
+</example>
 
-## Task Anatomy
-- `content`: Short label (5-10 words). What is being done, not how.
-- `details`: File paths, implementation steps, edge cases. Shown only when task is active.
-- `notes`: Runtime observations added during execution.
+<example name="combined">
+{complete: ["task-2"], add_notes: [{id: "task-3", notes: "Needs extra validation"}]}
+</example>
 
 <avoid>
 - Single-step tasks — act directly
 - Conversational or informational requests
 - Tasks completable in under 3 trivial steps
 </avoid>
-
-<example name="start-task">
-Mark task-2 in_progress before beginning work:
-ops: [{op: "update", id: "task-2", status: "in_progress"}]
-</example>
-
-<example name="complete-and-advance">
-Finish task-2 and start task-3 in one call:
-ops: [
-  {op: "update", id: "task-2", status: "completed"},
-  {op: "update", id: "task-3", status: "in_progress"}
-]
-</example>
-
-<example name="add_task">
-Add a follow-up task with implementation specifics in `details`:
-ops: [{op: "add_task", phase: "Implementation", after: "task-2", task: {content: "Handle retries", details: "Update retry.ts to cap exponential backoff and preserve AbortSignal handling", status: "pending"}}]
-</example>
-
-<example name="initial-setup">
-Replace is for setup only. Prefer add_phase / add_task for incremental additions.
-ops: [{op: "replace", phases: [
-  {name: "Investigation", tasks: [{content: "Read source"}, {content: "Map callsites"}]},
-  {name: "Implementation", tasks: [{content: "Apply fix", details: "Update parser.ts to handle edge case in line 42"}, {content: "Run tests"}]}
-]}]
-</example>
-
-<example name="skip">
-User: "What does this function do?" / "Add a comment" / "Run npm install"
-→ Do it directly. No list needed.
-</example>

package/src/session/agent-session.ts

@@ -132,7 +132,7 @@ import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import type { CheckpointState } from "../tools/checkpoint";
 import { outputMeta } from "../tools/output-meta";
-import { resolveToCwd } from "../tools/path-utils";
+import { normalizeLocalScheme, resolveToCwd } from "../tools/path-utils";
 import { isAutoQaEnabled } from "../tools/report-tool-issue";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo-write";
 import { ToolError } from "../tools/tool-errors";
@@ -2445,8 +2445,8 @@ export class AgentSession {
 		const state = this.#planModeState;
 		if (!state?.enabled) return null;
 		const sessionPlanUrl = "local://PLAN.md";
-		const resolvedPlanPath = state.planFilePath.startsWith("local://")
-			? resolveLocalUrlToPath(state.planFilePath, {
+		const resolvedPlanPath = state.planFilePath.startsWith("local:")
+			? resolveLocalUrlToPath(normalizeLocalScheme(state.planFilePath), {
 					getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
 					getSessionId: () => this.sessionManager.getSessionId(),
 				})
@@ -2456,7 +2456,7 @@ export class AgentSession {
 			getSessionId: () => this.sessionManager.getSessionId(),
 		});
 		const displayPlanPath =
-			state.planFilePath.startsWith("local://") || resolvedPlanPath !== resolvedSessionPlan
+			state.planFilePath.startsWith("local:") || resolvedPlanPath !== resolvedSessionPlan
 				? state.planFilePath
 				: sessionPlanUrl;
 

package/src/session/session-manager.ts

@@ -286,6 +286,10 @@ export type ReadonlySessionManager = Pick<
 	| "putBlob"
 >;
 
+function createSessionId(): string {
+	return Bun.randomUUIDv7();
+}
+
 /** Generate a unique short ID (8 hex chars, collision-checked) */
 function generateId(byId: { has(id: string): boolean }): string {
 	for (let i = 0; i < 100; i++) {
@@ -1500,7 +1504,7 @@ export class SessionManager {
 		this.#fileEntries = await loadEntriesFromFile(this.#sessionFile, this.storage);
 		if (this.#fileEntries.length > 0) {
 			const header = this.#fileEntries.find(e => e.type === "session") as SessionHeader | undefined;
-			this.#sessionId = header?.id ?? Snowflake.next();
+			this.#sessionId = header?.id ?? createSessionId();
 			this.#sessionName = header?.title;
 			this.#titleSource = header?.titleSource;
 
@@ -1549,7 +1553,7 @@ export class SessionManager {
 		this.#persistErrorReported = false;
 
 		// Create new session ID and header
-		this.#sessionId = Snowflake.next();
+		this.#sessionId = createSessionId();
 		const timestamp = new Date().toISOString();
 		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 		this.#sessionFile = path.join(this.getSessionDir(), `${fileTimestamp}_${this.#sessionId}.jsonl`);
@@ -1680,7 +1684,7 @@ export class SessionManager {
 		this.#persistChain = Promise.resolve();
 		this.#persistError = undefined;
 		this.#persistErrorReported = false;
-		this.#sessionId = Snowflake.next();
+		this.#sessionId = createSessionId();
 		this.#sessionName = undefined;
 		this.#titleSource = undefined;
 		const timestamp = new Date().toISOString();
@@ -2036,14 +2040,18 @@ export class SessionManager {
 		if (this.#needsFullRewriteOnNextPersist || !this.#flushed) {
 			// Full flush: rewrite the entire file atomically to avoid
 			// duplicating entries if the file already exists (e.g. from ensureOnDisk).
-			void this.#rewriteFile();
+			// Errors are already surfaced through #persistChain/#persistError; the
+			// caller intentionally fires-and-forgets, so swallow the awaited rejection
+			// here to avoid an unhandled rejection when the persist dir races with
+			// test-level tempDir cleanup.
+			this.#rewriteFile().catch(() => {});
 		} else {
-			void this.#queuePersistTask(async () => {
+			this.#queuePersistTask(async () => {
 				const writer = this.#ensurePersistWriter();
 				if (!writer) return;
 				const persistedEntry = await prepareEntryForPersistence(entry, this.#blobStore);
 				await writer.write(persistedEntry);
-			});
+			}).catch(() => {});
 		}
 	}
 
@@ -2554,7 +2562,7 @@ export class SessionManager {
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
 		const pathWithoutLabels = branchPath.filter(e => e.type !== "label");
 
-		const newSessionId = Snowflake.next();
+		const newSessionId = createSessionId();
 		const timestamp = new Date().toISOString();
 		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 		const newSessionFile = path.join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);

package/src/session/streaming-output.ts

@@ -1,3 +1,4 @@
+import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { formatBytes } from "../tools/render-utils";
 import { sanitizeWithOptionalSixelPassthrough } from "../utils/sixel";
@@ -750,3 +751,26 @@ export function formatHeadTruncationNotice(
 	const notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use sel=L${nextOffset} to continue]`;
 	return `\n\n${notice}`;
 }
+
+// =============================================================================
+// Streaming tail update helper (shared by bash/ssh tools)
+// =============================================================================
+
+/**
+ * Build an onChunk handler that appends to a TailBuffer and emits a streaming
+ * update (when `onUpdate` is defined) with the buffer's current text.
+ */
+export function streamTailUpdates<TDetails, TInput = unknown>(
+	tailBuffer: TailBuffer,
+	onUpdate: AgentToolUpdateCallback<TDetails, TInput> | undefined,
+): (chunk: string) => void {
+	return chunk => {
+		tailBuffer.append(chunk);
+		if (onUpdate) {
+			onUpdate({
+				content: [{ type: "text", text: tailBuffer.text() }],
+				details: {} as TDetails,
+			});
+		}
+	};
+}

package/src/slash-commands/builtin-registry.ts

@@ -8,6 +8,7 @@ import type { SettingPath, SettingValue } from "../config/settings";
 import { settings } from "../config/settings";
 import {
 	clearClaudePluginRootsCache,
+	clearPluginRootsAndCaches,
 	resolveActiveProjectRegistryPath,
 	resolveOrDefaultProjectRegistryPath,
 } from "../discovery/helpers.js";
@@ -643,13 +644,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 				),
 				marketplacesCacheDir: getMarketplacesCacheDir(),
 				pluginsCacheDir: getPluginsCacheDir(),
-				clearPluginRootsCache: (extraPaths?: readonly string[]) => {
-					const home = os.homedir();
-					invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
-					invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
-					for (const p of extraPaths ?? []) invalidateFsCache(p);
-					clearClaudePluginRootsCache();
-				},
+				clearPluginRootsCache: clearPluginRootsAndCaches,
 			});
 
 			try {
@@ -837,13 +832,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 					),
 					marketplacesCacheDir: getMarketplacesCacheDir(),
 					pluginsCacheDir: getPluginsCacheDir(),
-					clearPluginRootsCache: (extraPaths?: readonly string[]) => {
-						const home = os.homedir();
-						invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
-						invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
-						for (const p of extraPaths ?? []) invalidateFsCache(p);
-						clearClaudePluginRootsCache();
-					},
+					clearPluginRootsCache: clearPluginRootsAndCaches,
 				});
 
 				switch (sub) {

package/src/task/executor.ts

@@ -14,6 +14,7 @@ import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import type { CustomTool } from "../extensibility/custom-tools/types";
+import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
 import type { Skill } from "../extensibility/skills";
 import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
@@ -24,7 +25,7 @@ import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
 import { SessionManager } from "../session/session-manager";
 import { type ContextFileEntry, truncateTail } from "../tools";
-import { jtdToJsonSchema } from "../tools/jtd-to-json-schema";
+import { jtdToJsonSchema, normalizeSchema } from "../tools/jtd-to-json-schema";
 import { ToolAbortError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice } from "../utils/tool-choice";
@@ -163,20 +164,8 @@ function parseStringifiedJson(value: unknown): unknown {
 	}
 }
 
-function normalizeOutputSchema(schema: unknown): { normalized?: unknown; error?: string } {
-	if (schema === undefined || schema === null) return {};
-	if (typeof schema === "string") {
-		try {
-			return { normalized: JSON.parse(schema) };
-		} catch (err) {
-			return { error: err instanceof Error ? err.message : String(err) };
-		}
-	}
-	return { normalized: schema };
-}
-
 function buildOutputValidator(schema: unknown): { validate?: ValidateFunction; error?: string } {
-	const { normalized, error } = normalizeOutputSchema(schema);
+	const { normalized, error } = normalizeSchema(schema);
 	if (error) return { error };
 	if (normalized === undefined) return {};
 	const jsonSchema = jtdToJsonSchema(normalized);
@@ -300,7 +289,7 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 		}
 	} else {
 		const allowFallback = exitCode === 0 && !doneAborted && !signalAborted;
-		const { normalized: normalizedSchema, error: schemaError } = normalizeOutputSchema(outputSchema);
+		const { normalized: normalizedSchema, error: schemaError } = normalizeSchema(outputSchema);
 		const hasOutputSchema = normalizedSchema !== undefined && !schemaError;
 		const fallback = allowFallback ? resolveFallbackCompletion(rawOutput, outputSchema) : null;
 		if (fallback) {
@@ -317,9 +306,14 @@ export function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): Fi
 			exitCode = 0;
 			stderr = "";
 		} else if (exitCode === 0) {
+			const hasRawOutput = rawOutput.trim().length > 0;
 			rawOutput = rawOutput
 				? `${SUBAGENT_WARNING_MISSING_SUBMIT_RESULT}\n\n${rawOutput}`
 				: SUBAGENT_WARNING_MISSING_SUBMIT_RESULT;
+			if (hasOutputSchema || !hasRawOutput) {
+				exitCode = 1;
+				stderr = SUBAGENT_WARNING_MISSING_SUBMIT_RESULT;
+			}
 		}
 	}
 
@@ -950,7 +944,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			const mcpProxyTools = options.mcpManager ? createMCPProxyTools(options.mcpManager) : [];
 			const enableMCP = !options.mcpManager;
 
-			const { normalized: normalizedOutputSchema } = normalizeOutputSchema(outputSchema);
+			const { normalized: normalizedOutputSchema } = normalizeSchema(outputSchema);
 
 			const { session } = await createAgentSession({
 				cwd: worktree ?? cwd,
@@ -1050,12 +1044,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						setActiveTools: (toolNames: string[]) =>
 							session.setActiveToolsByName(toolNames.filter(name => !parentOwnedToolNames.has(name))),
 						getCommands: () => [],
-						setModel: async model => {
-							const key = await session.modelRegistry.getApiKey(model);
-							if (!key) return false;
-							await session.setModel(model);
-							return true;
-						},
+						setModel: model => runExtensionSetModel(session, model),
 						getThinkingLevel: () => session.thinkingLevel,
 						setThinkingLevel: level => session.setThinkingLevel(level),
 						getSessionName: () => session.sessionManager.getSessionName(),
@@ -1071,14 +1060,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						shutdown: () => {},
 						getContextUsage: () => session.getContextUsage(),
 						getSystemPrompt: () => session.systemPrompt,
-						compact: async instructionsOrOptions => {
-							const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
-							const options =
-								instructionsOrOptions && typeof instructionsOrOptions === "object"
-									? instructionsOrOptions
-									: undefined;
-							await session.compact(instructions, options);
-						},
+						compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
 					},
 				);
 				extensionRunner.onError(err => {
@@ -1129,10 +1111,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			await session.waitForIdle();
 			if (!submitResultCalled && !abortSignal.aborted) {
-				aborted = true;
-				exitCode = 1;
-				abortReasonText ??= SUBAGENT_WARNING_MISSING_SUBMIT_RESULT;
-				error ??= SUBAGENT_WARNING_MISSING_SUBMIT_RESULT;
+				exitCode = 0;
 			}
 
 			const lastAssistant = session.getLastAssistantMessage();