@oh-my-pi/pi-coding-agent 15.10.11 → 15.10.12

package/src/session/streaming-output.ts

@@ -11,6 +11,16 @@ export const DEFAULT_MAX_LINES = 3000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const DEFAULT_MAX_COLUMN = 512; // Max chars per grep match line
 
+/**
+ * Default artifact-on-disk cap for {@link OutputSink}.
+ *
+ * `0` means unbounded: by default, `artifact://<id>` references preserve the
+ * complete raw stream instead of a capped head/tail sample.
+ */
+export const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+/** Default head budget; the remainder becomes the rolling tail window. */
+export const ARTIFACT_DEFAULT_HEAD_BYTES = 3 * 1024 * 1024; // 3 MiB
+
 const NL = "\n";
 const ELLIPSIS = "…";
 
@@ -58,6 +68,20 @@ export interface OutputSinkOptions {
 	onChunk?: (chunk: string) => void;
 	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
 	chunkThrottleMs?: number;
+	/**
+	 * Optional cap on bytes written to the artifact-on-disk file. When the cap
+	 * is hit, the head window is preserved verbatim and subsequent output feeds
+	 * a rolling tail window; on close, the sink writes a single
+	 * `[ARTIFACT TRUNCATED: …]` notice between them. Default
+	 * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+	 */
+	artifactMaxBytes?: number;
+	/**
+	 * Bytes reserved for the head window of the capped artifact file. The
+	 * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
+	 * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+	 */
+	artifactHeadBytes?: number;
 }
 
 export interface TruncationResult {
@@ -676,6 +700,21 @@ export class OutputSink {
 	readonly #chunkThrottleMs: number;
 	readonly #maxColumns: number;
 
+	// Optional artifact-on-disk cap. When `#artifactMaxBytes > 0` the file sink
+	// owns a head budget + a rolling tail buffer; once the head is closed,
+	// subsequent chunks are diverted into `#artifactTailRing` (bounded by
+	// `#artifactTailBudget`). On `dump()` the tail is flushed back to the sink
+	// behind a `[ARTIFACT TRUNCATED: …]` notice. The default cap is disabled so
+	// advertised `artifact://<id>` captures are lossless.
+	readonly #artifactMaxBytes: number;
+	readonly #artifactHeadBudget: number;
+	readonly #artifactTailBudget: number;
+	#artifactHeadBytesWritten = 0;
+	#artifactHeadClosed = false;
+	#artifactTailRing = "";
+	#artifactTailRingBytes = 0;
+	#artifactTailIncomingBytes = 0;
+
 	constructor(options?: OutputSinkOptions) {
 		const {
 			artifactPath,
@@ -685,6 +724,8 @@ export class OutputSink {
 			maxColumns = 0,
 			onChunk,
 			chunkThrottleMs = 0,
+			artifactMaxBytes = ARTIFACT_DEFAULT_MAX_BYTES,
+			artifactHeadBytes = ARTIFACT_DEFAULT_HEAD_BYTES,
 		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
@@ -693,6 +734,9 @@ export class OutputSink {
 		this.#maxColumns = Math.max(0, maxColumns);
 		this.#onChunk = onChunk;
 		this.#chunkThrottleMs = chunkThrottleMs;
+		this.#artifactMaxBytes = Math.max(0, artifactMaxBytes);
+		this.#artifactHeadBudget = Math.max(0, Math.min(artifactHeadBytes, this.#artifactMaxBytes));
+		this.#artifactTailBudget = Math.max(0, this.#artifactMaxBytes - this.#artifactHeadBudget);
 	}
 
 	/**
@@ -865,14 +909,18 @@ export class OutputSink {
 	/**
 	 * Write a chunk to the artifact file. Handles the async file sink creation
 	 * by queuing writes until the sink is ready, then draining synchronously.
+	 * Once the sink is up, every byte flows through {@link #emitToSink} which
+	 * owns the head + tail cap so artifacts cannot grow beyond
+	 * `#artifactMaxBytes` on disk.
 	 */
 	#writeToFile(chunk: string): void {
 		if (this.#fileReady && this.#file) {
-			// Fast path: file sink exists, write synchronously
-			this.#file.sink.write(chunk);
+			this.#emitToSink(chunk);
 			return;
 		}
-		// File sink not yet created — queue this chunk and kick off creation
+		// File sink not yet created — queue this chunk and kick off creation.
+		// The queue is bounded only by how many chunks arrive before the open
+		// resolves (typically <2). The cap is enforced on drain.
 		if (!this.#pendingFileWrites) {
 			this.#pendingFileWrites = [chunk];
 			void this.#createFileSink();
@@ -881,31 +929,99 @@ export class OutputSink {
 		}
 	}
 
+	/**
+	 * Cap-aware sink writer. Bytes flow into the head window verbatim until the
+	 * budget is exhausted; subsequent bytes are diverted into a rolling tail
+	 * ring, evicted from the front so total RAM stays bounded by
+	 * `#artifactTailBudget`. `dump()` replays the ring behind a single notice
+	 * line before closing the sink.
+	 *
+	 * When the cap is disabled (`#artifactMaxBytes === 0`) this collapses to a
+	 * straight pass-through, preserving the historical "stream everything"
+	 * contract.
+	 */
+	#emitToSink(chunk: string): void {
+		if (!this.#file || chunk.length === 0) return;
+		if (this.#artifactMaxBytes === 0) {
+			this.#file.sink.write(chunk);
+			return;
+		}
+		const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+		const room = this.#artifactHeadClosed ? 0 : this.#artifactHeadBudget - this.#artifactHeadBytesWritten;
+		if (room >= chunkBytes) {
+			this.#file.sink.write(chunk);
+			this.#artifactHeadBytesWritten += chunkBytes;
+			return;
+		}
+		let overflow = chunk;
+		if (room > 0) {
+			const headSlice = truncateHeadBytes(chunk, room);
+			if (headSlice.bytes > 0) {
+				this.#file.sink.write(headSlice.text);
+				this.#artifactHeadBytesWritten += headSlice.bytes;
+			}
+			// Even when UTF-8 boundary safety leaves a few bytes of nominal room,
+			// this chunk has already overflowed the head window. Close it now so a
+			// later small ASCII chunk cannot be written before this overflow tail.
+			this.#artifactHeadClosed = true;
+			overflow = chunk.substring(headSlice.text.length);
+		}
+		if (overflow.length === 0 || this.#artifactTailBudget === 0) {
+			// No tail budget: count the dropped bytes so the notice reflects them.
+			if (overflow.length > 0) {
+				this.#artifactTailIncomingBytes += Buffer.byteLength(overflow, "utf-8");
+			}
+			return;
+		}
+		this.#pushArtifactTail(overflow);
+	}
+
+	#pushArtifactTail(chunk: string): void {
+		const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+		this.#artifactTailIncomingBytes += chunkBytes;
+		const budget = this.#artifactTailBudget;
+		if (chunkBytes >= budget) {
+			// Chunk alone dominates — keep only its tail slice.
+			const { text, bytes } = truncateTailBytes(chunk, budget);
+			this.#artifactTailRing = text;
+			this.#artifactTailRingBytes = bytes;
+			return;
+		}
+		this.#artifactTailRing += chunk;
+		this.#artifactTailRingBytes += chunkBytes;
+		if (this.#artifactTailRingBytes > budget) {
+			const { text, bytes } = truncateTailBytes(this.#artifactTailRing, budget);
+			this.#artifactTailRing = text;
+			this.#artifactTailRingBytes = bytes;
+		}
+	}
+
 	async #createFileSink(): Promise<void> {
 		if (!this.#artifactPath || this.#fileReady) return;
 		try {
 			const sink = Bun.file(this.#artifactPath).writer();
 			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
+			this.#fileReady = true;
 
 			// Head-retained bytes precede the rolling tail buffer in the capture.
+			// Route through #emitToSink so they count against the artifact head
+			// budget — a direct sink.write would let them escape the cap.
 			if (this.#head.length > 0) {
-				sink.write(this.#head);
+				this.#emitToSink(this.#head);
 			}
 
 			// Flush existing buffer to file BEFORE it gets trimmed further.
 			if (this.#buffer.length > 0) {
-				sink.write(this.#buffer);
+				this.#emitToSink(this.#buffer);
 			}
 
-			// Drain any chunks that arrived while the sink was being created
+			// Drain any chunks that arrived while the sink was being created.
 			if (this.#pendingFileWrites) {
 				for (const pending of this.#pendingFileWrites) {
-					sink.write(pending);
+					this.#emitToSink(pending);
 				}
 				this.#pendingFileWrites = undefined;
 			}
-
-			this.#fileReady = true;
 		} catch {
 			try {
 				await this.#file?.sink?.end();
@@ -914,6 +1030,7 @@ export class OutputSink {
 			}
 			this.#file = undefined;
 			this.#pendingFileWrites = undefined;
+			this.#fileReady = false;
 		}
 	}
 
@@ -961,6 +1078,42 @@ export class OutputSink {
 		this.#pendingChunk = "";
 	}
 
+	/**
+	 * Replay the rolling tail ring back into the artifact sink. When bytes
+	 * were actually dropped from the middle (the head budget was exhausted
+	 * *and* the tail ring evicted), a single `[ARTIFACT TRUNCATED: …]`
+	 * notice is injected between head and tail so a reader of
+	 * `artifact://<id>` understands the gap. When the total stream simply
+	 * spilled past the head budget but still fits below `artifactMaxBytes`,
+	 * `droppedBytes` is zero — head + tail together are the verbatim stream
+	 * and the notice is suppressed so we don't corrupt the artifact with a
+	 * misleading "0 B elided" marker (PR #2083 review by codex).
+	 *
+	 * No-op when the cap was never hit at all (head budget never exhausted,
+	 * tail ring empty).
+	 */
+	#flushArtifactTailIfCapped(): void {
+		if (!this.#file) return;
+		if (this.#artifactMaxBytes === 0) return;
+		const tailBytes = this.#artifactTailRingBytes;
+		const droppedBytes = Math.max(0, this.#artifactTailIncomingBytes - tailBytes);
+		if (tailBytes === 0 && droppedBytes === 0) return;
+
+		if (droppedBytes > 0) {
+			const headWritten = this.#artifactHeadBytesWritten;
+			const totalCapped = headWritten + this.#artifactTailIncomingBytes;
+			const headSep = headWritten > 0 ? "\n" : "";
+			const tailSep = tailBytes > 0 && !this.#artifactTailRing.startsWith("\n") ? "\n" : "";
+			const notice =
+				`${headSep}[ARTIFACT TRUNCATED: kept first ${formatBytes(headWritten)} + last ${formatBytes(tailBytes)} ` +
+				`of ${formatBytes(totalCapped)}; ${formatBytes(droppedBytes)} elided from the middle]${tailSep}`;
+			this.#file.sink.write(notice);
+		}
+		if (tailBytes > 0) {
+			this.#file.sink.write(this.#artifactTailRing);
+		}
+	}
+
 	async dump(notice?: string): Promise<OutputSummary> {
 		const noticeLine = notice ? `[${notice}]\n` : "";
 
@@ -973,7 +1126,10 @@ export class OutputSink {
 		}
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 
-		if (this.#file) await this.#file.sink.end();
+		if (this.#file) {
+			this.#flushArtifactTailIfCapped();
+			await this.#file.sink.end();
+		}
 
 		// Compose the visible output. With head retention, splice head + marker
 		// + tail when content was elided. Otherwise return the rolling buffer.

package/src/slash-commands/acp-builtins.ts

@@ -5,6 +5,30 @@ import type { AcpBuiltinSlashCommandResult, SlashCommandRuntime } from "./types"
 
 export type { AcpBuiltinSlashCommandResult } from "./types";
 
+/**
+ * All names (primary + aliases) that are reserved by ACP builtins. Used to
+ * filter out extension commands that would shadow a builtin or its alias at
+ * dispatch time (e.g. `models` is an alias for `/model`, so an extension
+ * registering `models` would appear in the palette but execute the builtin).
+ */
+export const ACP_BUILTIN_RESERVED_NAMES: ReadonlySet<string> = new Set(
+	BUILTIN_SLASH_COMMANDS_INTERNAL.filter(c => c.handle !== undefined).flatMap(c => [c.name, ...(c.aliases ?? [])]),
+);
+
+/**
+ * Whether an extension command named `name` would be captured by ACP builtin
+ * dispatch before reaching the extension handler. Beyond exact name/alias
+ * collisions, `parseSlashCommand` treats `:` as a name/args separator, so a
+ * colon-namespaced name whose prefix is a handled builtin (e.g. `model:foo`)
+ * executes the `/model` builtin with `foo` as args. Such names must not be
+ * advertised to ACP clients.
+ */
+export function isAcpBuiltinShadowedName(name: string): boolean {
+	if (ACP_BUILTIN_RESERVED_NAMES.has(name)) return true;
+	const colon = name.indexOf(":");
+	return colon !== -1 && ACP_BUILTIN_RESERVED_NAMES.has(name.slice(0, colon));
+}
+
 /**
  * Commands advertised to ACP clients. Entries without a text-mode `handle`
  * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't

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

@@ -82,6 +82,23 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "setup",
+		aliases: ["providers"],
+		description: "Open provider setup",
+		allowArgs: true,
+		subcommands: [{ name: "providers", description: "Configure sign-in and web search providers" }],
+		handleTui: async (command, runtime) => {
+			const args = command.args.trim().toLowerCase();
+			const opensProviders = args === "" || args === "providers";
+			if (opensProviders) {
+				await runtime.ctx.showProviderSetup();
+			} else {
+				runtime.ctx.showWarning(`Usage: /${command.name} [providers]`);
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "plan",
 		description: "Toggle plan mode (agent plans before executing)",
@@ -1697,10 +1714,13 @@ for (const command of BUILTIN_SLASH_COMMAND_REGISTRY) {
 	}
 }
 
+export const BUILTIN_SLASH_COMMAND_RESERVED_NAMES: ReadonlySet<string> = new Set(BUILTIN_SLASH_COMMAND_LOOKUP.keys());
+
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = BUILTIN_SLASH_COMMAND_REGISTRY.map(
 	command => ({
 		name: command.name,
+		aliases: command.aliases,
 		description: command.description,
 		subcommands: command.subcommands,
 		inlineHint: command.inlineHint,

package/src/slash-commands/types.ts

@@ -14,6 +14,7 @@ export interface SubcommandDef {
 /** Declarative builtin slash command metadata used by autocomplete and help UI. */
 export interface BuiltinSlashCommand {
 	name: string;
+	aliases?: string[];
 	description: string;
 	/** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
 	subcommands?: SubcommandDef[];
@@ -82,7 +83,6 @@ export interface TuiSlashCommandRuntime {
 
 /** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
 export interface SlashCommandSpec extends BuiltinSlashCommand {
-	aliases?: string[];
 	/** When false, the dispatcher refuses to handle invocations that include arguments. */
 	allowArgs?: boolean;
 	/**

package/src/system-prompt.ts

@@ -8,6 +8,7 @@ import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prom
 import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";
 import { systemPromptCapability } from "./capability/system-prompt";
+import { findConfigFile } from "./config";
 import type { SkillsSettings } from "./config/settings";
 import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "./discovery";
 import { expandAtImports } from "./discovery/at-imports";
@@ -208,6 +209,19 @@ async function getEnvironmentInfo(): Promise<Array<{ label: string; value: strin
 	return entries.filter((e): e is { label: string; value: string } => !!e.value);
 }
 
+/** Discover TITLE_SYSTEM.md file for automatic session-title prompt overrides */
+export function discoverTitleSystemPromptFile(cwd?: string): string | undefined {
+	const projectPath = findConfigFile("TITLE_SYSTEM.md", { user: false, cwd });
+	if (projectPath) {
+		return projectPath;
+	}
+	const globalPath = findConfigFile("TITLE_SYSTEM.md", { user: true, cwd });
+	if (globalPath) {
+		return globalPath;
+	}
+	return undefined;
+}
+
 /** Resolve input as file path or literal string */
 export async function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined> {
 	if (!input) {

package/src/task/executor.ts

@@ -162,6 +162,7 @@ export interface ExecutorOptions {
 	description?: string;
 	index: number;
 	id: string;
+	parentToolCallId?: string;
 	modelOverride?: string | string[];
 	/**
 	 * Active model selector of the parent session, used as an auth-aware fallback
@@ -840,6 +841,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agent: agent.name,
 				agentSource: agent.source,
 				task,
+				parentToolCallId: options.parentToolCallId,
 				assignment,
 				progress: { ...progress },
 				sessionFile: subtaskSessionFile,
@@ -922,20 +924,16 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		progress.recentOutput = [];
 	};
 
+	const emitSubagentEvent = (event: AgentSessionEvent) => {
+		if (!options.eventBus) return;
+		options.eventBus.emit(TASK_SUBAGENT_EVENT_CHANNEL, {
+			id,
+			event,
+		});
+	};
+
 	const processEvent = (event: AgentEvent) => {
 		if (resolved) return;
-
-		if (options.eventBus) {
-			options.eventBus.emit(TASK_SUBAGENT_EVENT_CHANNEL, {
-				index,
-				agent: agent.name,
-				agentSource: agent.source,
-				task,
-				assignment,
-				event,
-			});
-		}
-
 		const now = Date.now();
 		let flushProgress = false;
 
@@ -1354,6 +1352,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
 					id,
 					agent: agent.name,
+					parentToolCallId: options.parentToolCallId,
 					agentSource: agent.source,
 					description: options.description,
 					status: "started",
@@ -1452,6 +1451,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const MAX_YIELD_RETRIES = 3;
 			unsubscribe = session.subscribe(event => {
+				emitSubagentEvent(event);
 				if (event.type === "auto_retry_start") {
 					progress.retryState = {
 						attempt: event.attempt,
@@ -1704,6 +1704,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		options.eventBus.emit(TASK_SUBAGENT_LIFECYCLE_CHANNEL, {
 			id,
 			agent: agent.name,
+			parentToolCallId: options.parentToolCallId,
 			agentSource: agent.source,
 			description: options.description,
 			status: progress.status as "completed" | "failed" | "aborted",

package/src/task/index.ts

@@ -119,6 +119,7 @@ export type {
 	AgentDefinition,
 	AgentProgress,
 	SingleResult,
+	SubagentEventPayload,
 	SubagentLifecyclePayload,
 	SubagentProgressPayload,
 	TaskParams,
@@ -412,7 +413,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	}
 
 	async execute(
-		_toolCallId: string,
+		toolCallId: string,
 		rawParams: unknown,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
@@ -427,7 +428,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const asyncEnabled = this.session.settings.get("async.enabled");
 		const selectedAgent = this.#discoveredAgents.find(agent => agent.name === params.agent);
 		if (!asyncEnabled || selectedAgent?.blocking === true) {
-			return this.#executeSync(_toolCallId, params, signal, onUpdate);
+			return this.#executeSync(toolCallId, params, signal, onUpdate);
 		}
 
 		const manager = this.session.asyncJobManager;
@@ -437,12 +438,12 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			// 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);
+			return this.#executeSync(toolCallId, params, signal, onUpdate);
 		}
 
 		const taskItems = params.tasks ?? [];
 		if (taskItems.length === 0) {
-			return this.#executeSync(_toolCallId, params, signal, onUpdate);
+			return this.#executeSync(toolCallId, params, signal, onUpdate);
 		}
 
 		const taskIdProblem = validateTaskIds(taskItems);
@@ -552,9 +553,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							buildAsyncDetails("running", startedJobs[0]?.jobId ?? label) as unknown as Record<string, unknown>,
 						);
 						try {
-							const result = await this.#executeSync(_toolCallId, singleParams, runSignal, undefined, [
-								uniqueId,
-							]);
+							const result = await this.#executeSync(toolCallId, singleParams, runSignal, undefined, [uniqueId]);
 							const finalText = result.content.find(part => part.type === "text")?.text ?? "(no output)";
 							const singleResult = result.details?.results[0];
 							// A missing per-task result means #executeSync failed at the
@@ -707,7 +706,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	}
 
 	async #executeSync(
-		_toolCallId: string,
+		toolCallId: string,
 		params: TaskParams,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
@@ -1035,6 +1034,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						planReference,
 						description: task.description,
 						index,
+						parentToolCallId: toolCallId,
 						id: task.id,
 						taskDepth,
 						modelOverride,
@@ -1097,6 +1097,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						planReference,
 						description: task.description,
 						index,
+						parentToolCallId: toolCallId,
 						id: task.id,
 						taskDepth,
 						modelOverride,

package/src/task/render.ts

@@ -1072,6 +1072,20 @@ function renderAgentResult(
 	return lines;
 }
 
+/**
+ * Order live progress entries so finished agents render first and unfinished
+ * (pending/running) ones stay pinned at the bottom as tasks complete. Stable
+ * within each group, so agents keep their dispatch order.
+ */
+function orderProgressForDisplay(progress: readonly AgentProgress[]): AgentProgress[] {
+	const finished: AgentProgress[] = [];
+	const unfinished: AgentProgress[] = [];
+	for (const p of progress) {
+		(p.status === "pending" || p.status === "running" ? unfinished : finished).push(p);
+	}
+	return finished.concat(unfinished);
+}
+
 /**
  * Render the tool result.
  */
@@ -1140,7 +1154,7 @@ export function renderResult(
 		const shouldRenderProgress =
 			Boolean(details.progress && details.progress.length > 0) && (isPartial || details.results.length === 0);
 		if (shouldRenderProgress && details.progress) {
-			details.progress.forEach(progress => {
+			orderProgressForDisplay(details.progress).forEach(progress => {
 				lines.push(...renderAgentProgress(progress, "", "  ", expanded, theme, spinnerFrame));
 			});
 		} else if (details.results && details.results.length > 0) {
@@ -1269,8 +1283,9 @@ function renderNestedTaskTree(
 		}
 		const inflight = details.progress;
 		if (inflight && inflight.length > 0) {
-			inflight.forEach((prog, index) => {
-				const { prefix, continuePrefix } = nestedMarkers(index === inflight.length - 1, theme);
+			const ordered = orderProgressForDisplay(inflight);
+			ordered.forEach((prog, index) => {
+				const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
 				lines.push(...renderAgentProgress(prog, prefix, continuePrefix, expanded, theme, spinnerFrame));
 			});
 		}

package/src/task/types.ts

@@ -2,6 +2,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
+import type { AgentSessionEvent } from "../session/agent-session";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 
@@ -41,11 +42,18 @@ export interface SubagentProgressPayload {
 	agent: string;
 	agentSource: AgentSource;
 	task: string;
+	parentToolCallId?: string;
 	assignment?: string;
 	progress: AgentProgress;
 	sessionFile?: string;
 }
 
+/** Payload emitted on TASK_SUBAGENT_EVENT_CHANNEL */
+export interface SubagentEventPayload {
+	id: string;
+	event: AgentSessionEvent;
+}
+
 /** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
 export interface SubagentLifecyclePayload {
 	id: string;
@@ -54,6 +62,7 @@ export interface SubagentLifecyclePayload {
 	description?: string;
 	status: "started" | "completed" | "failed" | "aborted";
 	sessionFile?: string;
+	parentToolCallId?: string;
 	index: number;
 }
 

package/src/thinking.ts

@@ -71,6 +71,13 @@ export function toReasoningEffort(level: ThinkingLevel | undefined): Effort | un
 	return level;
 }
 
+/**
+ * True when a selector explicitly requests provider-side reasoning disablement.
+ */
+export function shouldDisableReasoning(level: ThinkingLevel | undefined): boolean {
+	return level === ThinkingLevel.Off;
+}
+
 /**
  * Resolves a selector against the current model while preserving explicit "off".
  */

package/src/tiny/title-client.ts

@@ -39,6 +39,17 @@ export interface TinyTitleDownloadOptions {
 	onProgress?: (event: TinyTitleProgressEvent) => void;
 }
 
+/**
+ * Per-request controls for {@link TinyTitleClient.generate}.
+ *
+ * Carries the optional abort signal and title-system-prompt override used by
+ * callers that customize automatic session-title generation.
+ */
+export interface TinyTitleGenerateOptions {
+	signal?: AbortSignal;
+	systemPrompt?: string;
+}
+
 // Cold-starting the worker subprocess from a compiled binary (decompress + module
 // graph load) is slow on contended CI runners — the macos-15-intel release smoke
 // blew past 5s while arm64/linux/win passed. The probe only needs to prove the
@@ -46,6 +57,14 @@ export interface TinyTitleDownloadOptions {
 // generous bound removes the flake without weakening the check.
 const SMOKE_TEST_TIMEOUT_MS = 30_000;
 
+function normalizeTinyTitleGenerateOptions(
+	options: AbortSignal | TinyTitleGenerateOptions | undefined,
+): TinyTitleGenerateOptions {
+	if (!options) return {};
+	if ("aborted" in options && "addEventListener" in options) return { signal: options };
+	return options;
+}
+
 /**
  * Hidden subcommand on the main CLI that boots the tiny-model worker in the
  * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
@@ -295,9 +314,16 @@ export class TinyTitleClient {
 		return () => this.#progressListeners.delete(listener);
 	}
 
-	async generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null> {
+	async generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
+	async generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
+	async generate(
+		modelKey: string,
+		message: string,
+		optionsOrSignal?: AbortSignal | TinyTitleGenerateOptions,
+	): Promise<string | null> {
+		const options = normalizeTinyTitleGenerateOptions(optionsOrSignal);
 		if (!isTinyTitleLocalModelKey(modelKey)) return null;
-		if (signal?.aborted) return null;
+		if (options.signal?.aborted) return null;
 
 		try {
 			const worker = this.#ensureWorker();
@@ -310,12 +336,15 @@ export class TinyTitleClient {
 				this.#pending.delete(id);
 				pending.resolve(null);
 			};
-			signal?.addEventListener("abort", abort, { once: true });
+			options.signal?.addEventListener("abort", abort, { once: true });
 			try {
-				worker.send({ type: "generate", id, modelKey, message });
+				const request: TinyTitleWorkerInbound = options.systemPrompt
+					? { type: "generate", id, modelKey, message, systemPrompt: options.systemPrompt }
+					: { type: "generate", id, modelKey, message };
+				worker.send(request);
 				return await promise;
 			} finally {
-				signal?.removeEventListener("abort", abort);
+				options.signal?.removeEventListener("abort", abort);
 				this.#pending.delete(id);
 			}
 		} catch (error) {