@oh-my-pi/pi-coding-agent 16.2.12 → 16.3.0

package/src/session/exit-diagnostics.ts

@@ -0,0 +1,202 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { SessionEntry } from "./session-entries";
+
+export const TOOL_EXECUTION_START_CUSTOM_TYPE = "tool_execution_start";
+export const SESSION_EXIT_CUSTOM_TYPE = "session_exit";
+
+/**
+ * Compact projection of tool-call arguments persisted with the start marker.
+ * The assistant message already carries the full arguments; this exists only
+ * so `appendArgumentSummary` can name the command/path in resume warnings
+ * without duplicating whole argument payloads into the session JSONL.
+ */
+export interface ToolArgumentSummary {
+	command?: string;
+	path?: string;
+}
+
+/** Persisted marker written before a tool implementation starts running. */
+export interface ToolExecutionStartData {
+	toolCallId: string;
+	toolName: string;
+	args?: ToolArgumentSummary;
+	intent?: string;
+	startedAt: string;
+}
+
+/** Tool call left without a matching toolResult at the end of a branch. */
+export interface PendingToolCallDiagnostic {
+	toolCallId?: string;
+	toolName: string;
+	args?: unknown;
+	intent?: string;
+	assistantTimestamp?: number;
+	startedAt?: string;
+}
+
+/** Session shutdown marker written during normal and fatal process teardown. */
+export interface SessionExitData {
+	reason: string;
+	kind: "normal" | "signal" | "fatal" | "process_exit";
+	recordedAt: string;
+	pendingToolCalls?: PendingToolCallDiagnostic[];
+}
+
+interface PendingToolCallRecord extends PendingToolCallDiagnostic {
+	key: string;
+}
+
+interface ToolCallContent {
+	type: "toolCall";
+	id?: string;
+	name?: string;
+	arguments?: unknown;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	if (typeof value !== "object") return false;
+	return value !== null;
+}
+
+function isToolCallContent(value: unknown): value is ToolCallContent {
+	if (!isObject(value)) return false;
+	return value.type === "toolCall" && (typeof value.name === "string" || typeof value.id === "string");
+}
+
+/** Character cap for each summarized argument field. */
+const ARGUMENT_SUMMARY_MAX_CHARS = 200;
+
+function truncateSummaryField(value: string): string {
+	return value.length > ARGUMENT_SUMMARY_MAX_CHARS ? `${value.slice(0, ARGUMENT_SUMMARY_MAX_CHARS)}…` : value;
+}
+
+/**
+ * Project full tool-call arguments down to the fields the pending-tool-call
+ * resume warning actually renders (`command`/`path`), truncated. Returns
+ * `undefined` when the arguments carry neither, so callers can omit `args`
+ * entirely instead of persisting an empty object.
+ */
+export function summarizeToolArguments(args: unknown): ToolArgumentSummary | undefined {
+	if (!isObject(args)) return undefined;
+	const summary: ToolArgumentSummary = {};
+	if (typeof args.command === "string" && args.command.length > 0) {
+		summary.command = truncateSummaryField(args.command);
+	}
+	if (typeof args.path === "string" && args.path.length > 0) {
+		summary.path = truncateSummaryField(args.path);
+	}
+	return summary.command !== undefined || summary.path !== undefined ? summary : undefined;
+}
+
+function readToolExecutionStart(entry: SessionEntry): ToolExecutionStartData | undefined {
+	if (entry.type !== "custom" || entry.customType !== TOOL_EXECUTION_START_CUSTOM_TYPE) return undefined;
+	const data = entry.data;
+	if (!isObject(data)) return undefined;
+	if (typeof data.toolCallId !== "string" || typeof data.toolName !== "string") return undefined;
+	const startedAt = typeof data.startedAt === "string" ? data.startedAt : entry.timestamp;
+	const result: ToolExecutionStartData = {
+		toolCallId: data.toolCallId,
+		toolName: data.toolName,
+		startedAt,
+	};
+	// Legacy sessions persisted full argument objects; project them down.
+	if ("args" in data) {
+		const args = summarizeToolArguments(data.args);
+		if (args) result.args = args;
+	}
+	if (typeof data.intent === "string") result.intent = data.intent;
+	return result;
+}
+
+function appendAssistantToolCalls(pending: Map<string, PendingToolCallRecord>, message: AgentMessage): void {
+	if (message.role !== "assistant") return;
+	const content = Array.isArray(message.content) ? message.content : [];
+	const toolCalls: PendingToolCallRecord[] = [];
+	for (let index = 0; index < content.length; index++) {
+		const part = content[index];
+		if (!isToolCallContent(part)) continue;
+		const toolName = part.name ?? "unknown";
+		const key = part.id ?? `assistant:${message.timestamp ?? "unknown"}:${index}:${toolName}`;
+		const record: PendingToolCallRecord = {
+			key,
+			toolName,
+		};
+		if (typeof message.timestamp === "number") record.assistantTimestamp = message.timestamp;
+		if (part.id) record.toolCallId = part.id;
+		if ("arguments" in part) record.args = part.arguments;
+		toolCalls.push(record);
+	}
+	pending.clear();
+	for (const toolCall of toolCalls) pending.set(toolCall.key, toolCall);
+}
+
+function applyToolExecutionStart(pending: Map<string, PendingToolCallRecord>, marker: ToolExecutionStartData): void {
+	const existing = pending.get(marker.toolCallId);
+	if (existing) {
+		existing.startedAt = marker.startedAt;
+		// The assistant message carries the full arguments; the marker only has
+		// the command/path projection. Keep the richer copy when present.
+		existing.args ??= marker.args;
+		if (marker.intent) existing.intent = marker.intent;
+		return;
+	}
+	const record: PendingToolCallRecord = {
+		key: marker.toolCallId,
+		toolCallId: marker.toolCallId,
+		toolName: marker.toolName,
+		args: marker.args,
+		startedAt: marker.startedAt,
+	};
+	if (marker.intent) record.intent = marker.intent;
+	pending.set(marker.toolCallId, record);
+}
+
+function applyMessageEntry(pending: Map<string, PendingToolCallRecord>, message: AgentMessage): void {
+	if (message.role === "toolResult") {
+		const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
+		if (toolCallId) pending.delete(toolCallId);
+		return;
+	}
+	appendAssistantToolCalls(pending, message);
+}
+
+/** Finds tool calls left pending at the end of a session branch. */
+export function collectPendingToolCalls(entries: readonly SessionEntry[]): PendingToolCallDiagnostic[] {
+	const pending = new Map<string, PendingToolCallRecord>();
+	for (const entry of entries) {
+		if (entry.type === "message") {
+			applyMessageEntry(pending, entry.message);
+			continue;
+		}
+		const marker = readToolExecutionStart(entry);
+		if (marker) applyToolExecutionStart(pending, marker);
+	}
+	return [...pending.values()].map(({ key: _key, ...toolCall }) => toolCall);
+}
+
+function appendArgumentSummary(parts: string[], args: unknown): void {
+	if (!isObject(args)) return;
+	const command = args.command;
+	if (typeof command === "string" && command.length > 0) {
+		parts.push(`command \`${command}\``);
+		return;
+	}
+	const path = args.path;
+	if (typeof path === "string" && path.length > 0) parts.push(`path \`${path}\``);
+}
+
+function formatPendingToolCall(call: PendingToolCallDiagnostic): string {
+	const parts = [call.toolName];
+	if (call.toolCallId) parts.push(call.toolCallId);
+	appendArgumentSummary(parts, call.args);
+	return parts.join(" ");
+}
+
+/** Builds the resume warning shown when a prior branch ended mid-tool-call. */
+export function describePendingToolCalls(entries: readonly SessionEntry[]): string | undefined {
+	const pending = collectPendingToolCalls(entries);
+	if (pending.length === 0) return undefined;
+	const formatted = pending.map(formatPendingToolCall).join(", ");
+	const noun = pending.length === 1 ? "tool call" : "tool calls";
+	return `Previous session ended while ${pending.length} ${noun} remained pending: ${formatted}. The prior OMP process exited before recording tool result(s).`;
+}

package/src/session/session-context.ts

@@ -307,21 +307,23 @@ export function buildSessionContext(
 		})();
 		const remoteReplacementHistory = providerPayload?.items;
 
-		if (options?.transcript) handleEntryResetTracking(compaction);
-		// Emit summary first; re-attach any archived snapcompact frames so the
-		// model can keep reading the archived history after every context rebuild.
+		// Re-attach any archived snapcompact frames so the model can keep
+		// reading the archived history after every context rebuild.
 		const snapcompactArchive = snapcompact.getPreservedArchive(compaction.preserveData);
-		pushMessage(
-			createCompactionSummaryMessage(
-				compaction.summary,
-				compaction.tokensBefore,
-				compaction.timestamp,
-				compaction.shortSummary,
-				providerPayload,
-				undefined,
-				snapcompactHistoryBlocksForContext(snapcompactArchive, options),
-			),
+		const compactionSummaryMsg = createCompactionSummaryMessage(
+			compaction.summary,
+			compaction.tokensBefore,
+			compaction.timestamp,
+			compaction.shortSummary,
+			providerPayload,
+			undefined,
+			snapcompactHistoryBlocksForContext(snapcompactArchive, options),
 		);
+		// Agent context (non-transcript): summary first so the LLM sees the
+		// compacted context before recent messages.
+		if (!options?.transcript) {
+			pushMessage(compactionSummaryMsg);
+		}
 
 		// Find compaction index in path
 		const compactionIdx = path.findIndex(e => e.type === "compaction" && e.id === compaction.id);
@@ -345,6 +347,16 @@ export function buildSessionContext(
 			}
 		}
 
+		// Display transcript: emit the summary at the chronological compaction
+		// point (after kept messages, before post-compaction) so it stays in
+		// the live region where Ctrl+O can expand it. Reset tracking fires
+		// here so the first post-compaction assistant turn — not a kept
+		// pre-compaction one — is marked as a cache miss.
+		if (options?.transcript) handleEntryResetTracking(compaction);
+		if (options?.transcript) {
+			pushMessage(compactionSummaryMsg);
+		}
+
 		// Emit messages after compaction
 		for (let i = compactionIdx + 1; i < path.length; i++) {
 			const entry = path[i];

package/src/session/session-loader.ts

@@ -1,5 +1,3 @@
-import * as fs from "node:fs";
-import * as readline from "node:readline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { getBlobsDir, isEnoent, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import { BlobStore, isBlobRef, resolveImageData, resolveImageDataUrl } from "./blob-store";
@@ -103,40 +101,75 @@ function elideSupersededCompactionEntries(entries: FileEntry[]): void {
 	}
 }
 
-async function loadEntriesFromFileStream(filePath: string): Promise<{
+/** Exported for testing — the ≥8MiB streaming path (works on any file size). */
+export async function loadEntriesFromFileStream(filePath: string): Promise<{
 	entries: FileEntry[];
 	titleSlot: SessionTitleUpdate | undefined;
 }> {
 	const entries: FileEntry[] = [];
 	let titleSlot: SessionTitleUpdate | undefined;
-	let sawBodyLine = false;
-	const input = fs.createReadStream(filePath, { encoding: "utf8" });
-	const lines = readline.createInterface({ input, crlfDelay: Infinity });
+	let sawFirstLine = false;
+	// Byte buffer (NOT a decoded string): multibyte UTF-8 sequences that straddle
+	// a stream-chunk boundary stay intact, and Bun.JSONL.parseChunk accepts typed
+	// arrays directly. Only the unconsumed remainder is held (≤ one record + a
+	// chunk), so the ≥8MiB memory guard is preserved (the file is never fully
+	// loaded into memory).
+	let buffer: Uint8Array = new Uint8Array();
+	const decoder = new TextDecoder();
 
-	try {
-		for await (const rawLine of lines) {
-			const line = rawLine.trim();
-			if (!line) continue;
-			if (!sawBodyLine) {
-				const slot = parseTitleSlotLine(line);
-				if (slot) {
-					titleSlot = titleUpdateFromSlot(slot);
-					sawBodyLine = true;
-					continue;
-				}
-				sawBodyLine = true;
+	const drain = () => {
+		while (buffer.length > 0) {
+			const { values, error, read, done } = Bun.JSONL.parseChunk(buffer);
+			if (values.length > 0) {
+				for (const value of values) entries.push(value as FileEntry);
 			}
-
-			let entry: FileEntry;
-			try {
-				entry = JSON.parse(line) as FileEntry;
-			} catch {
+			if (error) {
+				// Malformed record: skip past the next newline and continue.
+				const nextNewline = buffer.indexOf(0x0a, read);
+				if (nextNewline === -1) break; // rest of the bad line not yet received
+				buffer = buffer.subarray(nextNewline + 1);
 				continue;
 			}
-			entries.push(entry);
+			if (read === 0) break; // incomplete record awaiting more data
+			buffer = buffer.subarray(read);
+			if (done) {
+				buffer = new Uint8Array();
+				break;
+			}
+		}
+	};
+
+	try {
+		for await (const chunk of Bun.file(filePath).stream()) {
+			buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk]);
+			// The optional fixed-width title slot is a physical first line that is
+			// NOT JSON; peel it before the parser would (correctly) reject it. The
+			// first line ends at a '\n' byte, so it is a complete UTF-8 sequence and
+			// safe to decode. A non-slot first line is a real entry and is left for
+			// the parser; a blank first line is left for the parser to skip.
+			if (!sawFirstLine) {
+				const newline = buffer.indexOf(0x0a);
+				if (newline !== -1) {
+					sawFirstLine = true;
+					const firstLine = decoder.decode(buffer.subarray(0, newline)).trim();
+					if (firstLine) {
+						const slot = parseTitleSlotLine(firstLine);
+						if (slot) {
+							titleSlot = titleUpdateFromSlot(slot);
+							buffer = buffer.subarray(newline + 1);
+						}
+					}
+				}
+			}
+			drain();
+		}
+		// A trailing record without a final newline: terminate it so the parser
+		// can complete it (readline yielded it; parseChunk needs the delimiter).
+		if (buffer.length > 0 && buffer[buffer.length - 1] !== 0x0a) {
+			buffer = Buffer.concat([buffer, new Uint8Array([0x0a])]);
 		}
+		drain();
 	} catch (err) {
-		input.destroy();
 		if (isEnoent(err)) return { entries: [], titleSlot: undefined };
 		throw err;
 	}

package/src/session/session-manager.ts

@@ -246,7 +246,6 @@ class SessionEntryIndex {
 			cursor = cursor.parentId ? this.#entriesById.get(cursor.parentId) : undefined;
 		}
 		branch.reverse();
-
 		return branch;
 	}
 

package/src/session/session-persistence.ts

@@ -59,9 +59,15 @@ function shouldExternalizeImagePayload(
 	return (key === TEXT_CONTENT_KEY && isImageBlock(value)) || key === "images";
 }
 
+/** True for a non-empty string — marks signature/encrypted fields whose block must persist verbatim. */
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0;
+}
+
 /**
  * Recursively truncate large strings in an object for session persistence.
- * - Truncates any oversized string fields (key-agnostic)
+ * - Truncates oversized string fields (key-agnostic), except signed/encrypted
+ *   blocks and signature keys, which persist verbatim
  * - Externalizes oversized image payloads to blob refs
  * - Updates lineCount when content is truncated
  * - Returns original object if no changes needed (structural sharing)
@@ -76,16 +82,36 @@ function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string
 	if (shouldExternalizeImagePayload(obj, key)) {
 		return { ...obj, data: externalizeImageDataSync(blobStore, obj.data, obj.mimeType) };
 	}
+	// Signed content is bound to its exact bytes: a truncated `thinking`/`text`/
+	// `arguments` no longer matches its signature and a truncated
+	// `redacted_thinking` blob is undecryptable, so the provider 400s the replay.
+	// Persist signed blocks verbatim — never truncate, externalize, or descend.
+	// Unsigned blocks (e.g. an interrupted stream) have no such binding and stay
+	// truncatable for size control.
+	if (typeof obj === "object" && "type" in obj) {
+		const signed =
+			(obj.type === "thinking" && "thinkingSignature" in obj && isNonEmptyString(obj.thinkingSignature)) ||
+			(obj.type === "text" && "textSignature" in obj && isNonEmptyString(obj.textSignature)) ||
+			(obj.type === "toolCall" && "thoughtSignature" in obj && isNonEmptyString(obj.thoughtSignature));
+		const redacted = obj.type === "redactedThinking" && "data" in obj && isNonEmptyString(obj.data);
+		// OpenAI Responses reasoning items (providerPayload.items) carry
+		// `encrypted_content`, server-validated on replay — atomic like signed blocks.
+		const encryptedReasoning =
+			obj.type === "reasoning" && "encrypted_content" in obj && isNonEmptyString(obj.encrypted_content);
+		if (signed || redacted || encryptedReasoning) return obj;
+	}
 
 	if (typeof obj === "string") {
 		if (key === "image_url" && isImageDataUrl(obj)) {
 			return externalizeImageDataUrlSync(blobStore, obj);
 		}
 		if (obj.length > MAX_PERSIST_CHARS) {
-			// Cryptographic signatures must be preserved exactly or cleared entirely — never truncated.
-			// Truncation would produce an invalid signature that the API rejects.
+			// Defensive: signature keys normally sit on blocks the guard above returns
+			// verbatim, but if one is reached here (unknown carrier shape), preserve it —
+			// truncation produces an invalid signature the API rejects, and clearing
+			// drops reasoning context the provider needs on replay.
 			if (key === "thinkingSignature" || key === "thoughtSignature" || key === "textSignature") {
-				return "";
+				return obj;
 			}
 			const limit = Math.max(0, MAX_PERSIST_CHARS - TRUNCATION_NOTICE.length);
 			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}`;

package/src/session/settings-stream-fn.ts

@@ -12,6 +12,7 @@
  */
 import type { StreamFn } from "@oh-my-pi/pi-agent-core";
 import { type SimpleStreamOptions, streamSimple } from "@oh-my-pi/pi-ai";
+import { isAnthropicFableOrMythosModel } from "@oh-my-pi/pi-catalog/identity";
 import { type Settings, validateProviderMaxInFlightRequests } from "../config/settings";
 
 function timeoutSecondsToMs(value: number): number | undefined {
@@ -38,6 +39,18 @@ export function createSettingsAwareStreamFn(settings: Settings, base: StreamFn =
 				: undefined;
 		const streamFirstEventTimeoutMs = timeoutSecondsToMs(settings.get("providers.streamFirstEventTimeoutSeconds"));
 		const streamIdleTimeoutMs = timeoutSecondsToMs(settings.get("providers.streamIdleTimeoutSeconds"));
+		// Server-side fallback (opt-in): when the user enables it AND the
+		// resolved model is a Claude Fable/Mythos on Anthropic's messages
+		// API, inject the `fallbacks: [{ model: "claude-opus-4-8" }]` chain.
+		// The provider layer picks it up, sends the beta header, and honors
+		// the response signals. Every other model / API is untouched.
+		const serverSideFallbackEnabled =
+			settings.get("providers.anthropic.serverSideFallback") &&
+			model.api === "anthropic-messages" &&
+			model.provider === "anthropic" &&
+			isAnthropicFableOrMythosModel(model.id);
+		const fallbacks =
+			streamOptions?.fallbacks ?? (serverSideFallbackEnabled ? [{ model: "claude-opus-4-8" }] : undefined);
 		const merged: SimpleStreamOptions = {
 			...streamOptions,
 			openrouterVariant: streamOptions?.openrouterVariant ?? openrouterVariant,
@@ -53,6 +66,7 @@ export function createSettingsAwareStreamFn(settings: Settings, base: StreamFn =
 				checkAssistantContent: settings.get("model.loopGuard.checkAssistantContent"),
 				...streamOptions?.loopGuard,
 			},
+			...(fallbacks !== undefined ? { fallbacks } : {}),
 		};
 		return base(model, context, merged);
 	};

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

@@ -27,6 +27,7 @@ import { resolveMemoryBackend } from "../memory-backend";
 import { describeLoopLimitRuntime } from "../modes/loop-limit";
 import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
+import { extractLastCodeBlock, extractLastCommand } from "../modes/utils/copy-targets";
 import type { AgentSession, FreshSessionResult } from "../session/agent-session";
 import { COMPACT_MODES, parseCompactArgs } from "../session/compact-modes";
 import { resolveResumableSession } from "../session/session-listing";
@@ -34,6 +35,7 @@ import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
 import { expandTilde, resolveToCwd } from "../tools/path-utils";
 import { urlHyperlinkAlways } from "../tui";
 import { getChangelogPath, parseChangelog } from "../utils/changelog";
+import { copyToClipboard } from "../utils/clipboard";
 import { CollabQrCodeComponent } from "./helpers/collab-qrcode";
 import { buildContextReportText } from "./helpers/context-report";
 import { formatDuration } from "./helpers/format";
@@ -69,7 +71,6 @@ export interface TuiBuiltinSlashCommand extends BuiltinSlashCommand {
 
 function refreshStatusLine(ctx: InteractiveModeContext): void {
 	ctx.statusLine.invalidate();
-	ctx.updateEditorTopBorder();
 	ctx.ui.requestRender();
 }
 
@@ -841,8 +842,39 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "copy",
 		description: "Pick text or code from the conversation to copy",
-		handleTui: (_command, runtime) => {
-			runtime.ctx.showCopySelector();
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (!arg) {
+				runtime.ctx.showCopySelector();
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "code") {
+				const block = extractLastCodeBlock(runtime.ctx.session.messages);
+				if (!block) {
+					runtime.ctx.showStatus("No code block to copy.");
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				await copyToClipboard(block.code);
+				runtime.ctx.showStatus("Copied code block to clipboard");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "cmd" || arg === "command") {
+				const lastCommand = extractLastCommand(runtime.ctx.session.messages);
+				if (!lastCommand) {
+					runtime.ctx.showStatus("No command to copy.");
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				await copyToClipboard(lastCommand.code);
+				runtime.ctx.showStatus(`Copied ${lastCommand.kind === "bash" ? "bash command" : "eval code"} to clipboard`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /copy [code|cmd]");
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/system-prompt.ts

@@ -249,6 +249,20 @@ async function getCachedGpu(): Promise<string | undefined> {
 	await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
 	return gpu ?? undefined;
 }
+/**
+ * Kernel identity for the workstation block. Prefers the uname build string
+ * from `os.version()`, but Bun on macOS 15+ (Darwin 24/25) returns the literal
+ * `"unknown"` when `uv_os_uname()`'s `version` field is empty — which surfaces
+ * `Kernel: unknown` in the system prompt and makes the model misidentify the
+ * host as Windows (#4141). Fall back to `<type> <release>` (uname -s + -r) so
+ * macOS is always tagged as `Darwin <release>` and Linux keeps its build info.
+ */
+function getKernelIdentity(): string {
+	const version = os.version()?.trim();
+	if (version && version.toLowerCase() !== "unknown") return version;
+	return `${os.type()} ${os.release()}`.trim();
+}
+
 function getEnvironmentInfo(gpu: string | undefined): Array<{ label: string; value: string }> {
 	let cpuModel: string | undefined;
 	try {
@@ -259,7 +273,7 @@ function getEnvironmentInfo(gpu: string | undefined): Array<{ label: string; val
 	const entries: Array<{ label: string; value: string | undefined }> = [
 		{ label: "OS", value: `${os.platform()} ${os.release()}` },
 		{ label: "Distro", value: os.type() },
-		{ label: "Kernel", value: os.version() },
+		{ label: "Kernel", value: getKernelIdentity() },
 		{ label: "Arch", value: os.arch() },
 		{ label: "CPU", value: cpuModel },
 		{ label: "GPU", value: gpu },

package/src/task/executor.ts

@@ -80,10 +80,12 @@ const MCP_CALL_TIMEOUT_MS = 60_000;
 
 /**
  * Soft per-agent request budgets (assistant requests per run). When a subagent
- * crosses its budget it receives ONE steering notice asking it to wrap up; at
- * 1.5x the budget the run is aborted gracefully so partial output is salvaged.
- * The `default` key applies to agents without an explicit entry and can be
- * overridden via the `task.softRequestBudget` setting (0 disables the guard).
+ * crosses its budget it can receive an optional steering notice asking it to
+ * wrap up; at 1.5x the budget the run is aborted gracefully so partial output is
+ * salvaged. The `default` key applies to agents without an explicit entry and
+ * can be overridden via the `task.softRequestBudget` setting (0 disables the
+ * guard). The notice is off by default and controlled separately by
+ * `task.softRequestBudgetNotice`.
  */
 export const SOFT_REQUEST_BUDGET: Record<string, number> = {
 	explore: 40,
@@ -91,7 +93,7 @@ export const SOFT_REQUEST_BUDGET: Record<string, number> = {
 	default: 90,
 };
 
-/** Steering notice injected once when a subagent crosses its soft request budget. */
+/** Optional steering notice injected when a subagent crosses its soft request budget. */
 export function buildBudgetNotice(requests: number): string {
 	return `[budget notice] You have used ${requests} requests in this run. Wrap up now: finish the current step and yield your final report.`;
 }
@@ -295,6 +297,11 @@ export interface ExecutorOptions {
 	parentActiveModelPattern?: string;
 	thinkingLevel?: ThinkingLevel;
 	outputSchema?: unknown;
+	/**
+	 * Caller supplied a schema that supersedes the agent's native output prompt.
+	 * Eval `agent(..., schema=...)` sets this so built-in agents ignore stale yield labels.
+	 */
+	outputSchemaOverridesAgent?: boolean;
 	/** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
 	taskDepth?: number;
 	/**
@@ -793,6 +800,8 @@ interface RunMonitorArgs {
 	sessionFile?: string;
 	/** Soft assistant-request budget; 0 disables the guard. */
 	softRequestBudget: number;
+	/** Whether crossing the soft budget injects a wrap-up steering notice. */
+	softRequestBudgetNotice: boolean;
 	/** Wall-clock cap in ms; 0 disables the timer. */
 	maxRuntimeMs: number;
 }
@@ -835,7 +844,18 @@ interface SubagentRunMonitor {
 }
 
 function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
-	const { index, id, agent, task, assignment, signal, onProgress, softRequestBudget, maxRuntimeMs } = args;
+	const {
+		index,
+		id,
+		agent,
+		task,
+		assignment,
+		signal,
+		onProgress,
+		softRequestBudget,
+		softRequestBudgetNotice,
+		maxRuntimeMs,
+	} = args;
 	const startTime = Date.now();
 
 	const progress: AgentProgress = {
@@ -1232,7 +1252,7 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 					if (softRequestBudget > 0 && !abortSent) {
 						if (progress.requests >= softRequestBudget * 1.5) {
 							requestAbort("budget");
-						} else if (!budgetSteerSent && progress.requests >= softRequestBudget) {
+						} else if (softRequestBudgetNotice && !budgetSteerSent && progress.requests >= softRequestBudget) {
 							budgetSteerSent = true;
 							const steerSession = activeSession;
 							if (steerSession) {
@@ -1868,6 +1888,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	);
 	const softRequestBudget =
 		configuredDefaultBudget === 0 ? 0 : (SOFT_REQUEST_BUDGET[agent.name] ?? configuredDefaultBudget);
+	const softRequestBudgetNotice = settings.get("task.softRequestBudgetNotice") ?? false;
 	const parentDepth = options.taskDepth ?? 0;
 	const childDepth = parentDepth + 1;
 	const atMaxDepth = maxRecursionDepth >= 0 && childDepth >= maxRecursionDepth;
@@ -1927,6 +1948,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		detached: options.detached,
 		sessionFile: subtaskSessionFile,
 		softRequestBudget,
+		softRequestBudgetNotice,
 		maxRuntimeMs,
 	});
 	const progress = monitor.progress;
@@ -2139,6 +2161,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						planReferencePath: options.planReference?.path ?? "",
 						worktree: worktree ?? "",
 						outputSchema: normalizedOutputSchema,
+						outputSchemaOverridesAgent: options.outputSchemaOverridesAgent === true,
 						ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
 						ircSelfId: ircEnabled ? id : "",
 					});
@@ -2313,7 +2336,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// Autoload skills via sendCustomMessage (same mechanic as /skill:<name>)
 			if (options.autoloadSkills?.length) {
 				for (const skill of options.autoloadSkills) {
-					const { message } = await buildSkillPromptMessage(skill, "");
+					const { message } = await buildSkillPromptMessage(skill, "", "autoload");
 					await session.sendCustomMessage(
 						{
 							customType: SKILL_PROMPT_MESSAGE_TYPE,