@oh-my-pi/pi-coding-agent 16.0.10 → 16.1.0

package/src/session/compact-modes.ts

@@ -0,0 +1,105 @@
+/**
+ * Manual `/compact` subcommands. Kept in a dependency-free leaf module so the
+ * slash-command registry, the interactive controllers, and `AgentSession`
+ * can all import the mode metadata + parser without pulling in the heavy
+ * `agent-session` module graph (which would form an import cycle through the
+ * slash-command registry) — same rationale as `shake-types.ts`.
+ *
+ * Each mode is a one-off override layered on top of the configured
+ * `compaction.*` settings for a single invocation; it never mutates settings.
+ * Adding a mode is a single entry here: the command surface (autocomplete +
+ * ACP hint), the parser, and the engine override all read this table.
+ */
+
+/** Subcommand selecting a one-off compaction mode for manual `/compact`. */
+export type CompactMode = "soft" | "remote" | "snapcompact";
+
+/**
+ * Per-invocation overrides merged over the configured `compaction.*` settings.
+ * Narrowed to the two knobs the modes actually flip; the result stays
+ * assignable to the full `CompactionSettings`.
+ */
+export interface CompactionOverride {
+	strategy?: "context-full" | "snapcompact";
+	remoteEnabled?: boolean;
+}
+
+export interface CompactModeDef {
+	readonly name: CompactMode;
+	/** One-line description surfaced in autocomplete + help. */
+	readonly description: string;
+	/** Settings overrides applied on top of `compaction.*` for this run. */
+	readonly overrides: CompactionOverride;
+	/**
+	 * When true, the mode produces no LLM summary, so trailing focus text is
+	 * meaningless and rejected by the parser (snapcompact archives history into
+	 * images without a directed summary).
+	 */
+	readonly rejectsFocus?: boolean;
+	/**
+	 * When true, the mode explicitly demands a remote path; the engine warns and
+	 * falls back to a local summary if neither a remote endpoint nor a
+	 * provider-native compaction path is available.
+	 */
+	readonly requiresRemote?: boolean;
+}
+
+export const COMPACT_MODES: readonly CompactModeDef[] = [
+	{
+		name: "soft",
+		description: "Summarize locally with the active model (skip remote endpoints)",
+		overrides: { strategy: "context-full", remoteEnabled: false },
+	},
+	{
+		name: "remote",
+		description: "Summarize via the remote endpoint / provider-native compaction",
+		overrides: { strategy: "context-full", remoteEnabled: true },
+		requiresRemote: true,
+	},
+	{
+		name: "snapcompact",
+		description: "Archive history onto dense bitmap images the model reads back (no LLM call)",
+		overrides: { strategy: "snapcompact" },
+		rejectsFocus: true,
+	},
+];
+
+/** Resolve a subcommand token (case-insensitive) to its mode definition. */
+export function findCompactMode(name: string): CompactModeDef | undefined {
+	const key = name.trim().toLowerCase();
+	return COMPACT_MODES.find(mode => mode.name === key);
+}
+
+/** Parsed `/compact` arguments: an optional mode plus optional focus text. */
+export interface ParsedCompactArgs {
+	mode?: CompactMode;
+	instructions?: string;
+}
+
+/**
+ * Split `/compact` args into a leading mode subcommand + focus instructions.
+ *
+ * Backward compatible: when the first token is not a known mode, the entire
+ * argument string is treated as focus instructions (the historical behavior).
+ * A recognized mode with `rejectsFocus` and trailing text is an error.
+ */
+export function parseCompactArgs(args: string): ParsedCompactArgs | { error: string } {
+	const trimmed = args.trim();
+	if (!trimmed) return {};
+
+	const spaceIndex = trimmed.search(/\s/);
+	const firstToken = spaceIndex === -1 ? trimmed : trimmed.slice(0, spaceIndex);
+	const mode = findCompactMode(firstToken);
+	if (!mode) {
+		// No recognized mode prefix — keep the whole thing as focus instructions.
+		return { instructions: trimmed };
+	}
+
+	const focus = spaceIndex === -1 ? "" : trimmed.slice(spaceIndex + 1).trim();
+	if (mode.rejectsFocus && focus) {
+		return {
+			error: `/compact ${mode.name} does not take focus instructions (it archives history without an LLM summary).`,
+		};
+	}
+	return { mode: mode.name, instructions: focus || undefined };
+}

package/src/session/messages.ts

@@ -204,16 +204,14 @@ function wrapSteeringUserMessage(message: UserMessage): UserMessage {
 }
 
 export function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[] {
-	const last = messages[messages.length - 1];
-	if (!isSteeringUserMessage(last)) return messages;
-
-	let firstSteer = messages.length - 1;
-	while (firstSteer > 0 && isSteeringUserMessage(messages[firstSteer - 1])) {
-		firstSteer--;
-	}
-
+	// Wrap EVERY steering message, not just a trailing run. The wire bytes of a
+	// steering message must be a pure function of the message itself, independent
+	// of its position in the array. When only the trailing steer was wrapped, the
+	// same persisted message was sent enveloped while it was the tail and raw once
+	// the assistant's reply buried it — rewriting already-cached prefix bytes and
+	// busting the provider prompt cache from that message onward on the next turn.
 	let wrappedMessages: AgentMessage[] | undefined;
-	for (let i = firstSteer; i < messages.length; i++) {
+	for (let i = 0; i < messages.length; i++) {
 		const message = messages[i];
 		if (!isSteeringUserMessage(message)) continue;
 		const wrappedMessage = wrapSteeringUserMessage(message);

package/src/session/session-context.ts

@@ -20,6 +20,13 @@ export interface SessionContext {
 	mode: string;
 	/** Mode-specific data from the last mode_change entry */
 	modeData?: Record<string, unknown>;
+	/**
+	 * Array parallel to messages, indicating which assistant turns should
+	 * have their prompt-cache misses suppressed/explained (because a model,
+	 * compaction, or plan-mode transition directly preceded them).
+	 * Only populated in transcript mode.
+	 */
+	cacheMissExplainedAt?: boolean[];
 }
 
 /** Lists session model strings to try when restoring, in fallback order. */
@@ -191,12 +198,45 @@ export function buildSessionContext(
 	// 2. Emit kept messages (from firstKeptEntryId up to compaction)
 	// 3. Emit messages after compaction
 	const messages: AgentMessage[] = [];
+	const cacheMissExplainedAt: boolean[] = [];
+	let pendingReset = false;
+	let currentMode = "none";
+	let lastAssistantModel: string | undefined;
+
+	const handleEntryResetTracking = (entry: SessionEntry) => {
+		if (entry.type === "compaction") {
+			pendingReset = true;
+		} else if (entry.type === "model_change") {
+			pendingReset = true;
+		} else if (entry.type === "mode_change") {
+			const isPlanTransition = (entry.mode === "plan") !== (currentMode === "plan");
+			if (isPlanTransition) {
+				pendingReset = true;
+			}
+			currentMode = entry.mode;
+		}
+	};
+
+	const pushMessage = (msg: AgentMessage) => {
+		messages.push(msg);
+		if (!options?.transcript) return;
+		if (msg.role === "assistant") {
+			const currentModel = `${msg.provider}/${msg.model}`;
+			const modelChanged = lastAssistantModel !== undefined && lastAssistantModel !== currentModel;
+			lastAssistantModel = currentModel;
+			cacheMissExplainedAt.push(pendingReset || modelChanged);
+			pendingReset = false;
+		} else {
+			cacheMissExplainedAt.push(false);
+		}
+	};
 
 	const appendMessage = (entry: SessionEntry) => {
+		handleEntryResetTracking(entry);
 		if (entry.type === "message") {
-			messages.push(entry.message);
+			pushMessage(entry.message);
 		} else if (entry.type === "custom_message") {
-			messages.push(
+			pushMessage(
 				createCustomMessage(
 					entry.customType,
 					entry.content,
@@ -207,7 +247,7 @@ export function buildSessionContext(
 				),
 			);
 		} else if (entry.type === "branch_summary" && entry.summary) {
-			messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+			pushMessage(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
 		}
 	};
 
@@ -217,16 +257,18 @@ export function buildSessionContext(
 		// TUI) at the point it fired, with any snapcompact frames re-attached so
 		// the component can report them.
 		for (const entry of path) {
+			handleEntryResetTracking(entry);
 			if (entry.type === "compaction") {
 				const snapcompactArchive = snapcompact.getPreservedArchive(entry.preserveData);
-				messages.push(
+				pushMessage(
 					createCompactionSummaryMessage(
 						entry.summary,
 						entry.tokensBefore,
 						entry.timestamp,
 						entry.shortSummary,
 						undefined,
-						snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
+						undefined,
+						snapcompactArchive ? snapcompact.historyBlocks(snapcompactArchive) : undefined,
 					),
 				);
 			} else {
@@ -251,14 +293,15 @@ export function buildSessionContext(
 		// Emit summary first; 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);
-		messages.push(
+		pushMessage(
 			createCompactionSummaryMessage(
 				compaction.summary,
 				compaction.tokensBefore,
 				compaction.timestamp,
 				compaction.shortSummary,
 				providerPayload,
-				snapcompactArchive ? snapcompact.images(snapcompactArchive) : undefined,
+				undefined,
+				snapcompactArchive ? snapcompact.historyBlocks(snapcompactArchive) : undefined,
 			),
 		);
 
@@ -333,6 +376,9 @@ export function buildSessionContext(
 			);
 		if (normalized.length === 0) {
 			messages.splice(i, 1);
+			if (options?.transcript) {
+				cacheMissExplainedAt.splice(i, 1);
+			}
 		} else {
 			messages[i] = { ...message, content: normalized };
 		}
@@ -340,6 +386,7 @@ export function buildSessionContext(
 
 	return {
 		messages,
+		cacheMissExplainedAt: options?.transcript ? cacheMissExplainedAt : undefined,
 		thinkingLevel,
 		serviceTier,
 		models,

package/src/session/session-dump-format.ts

@@ -7,9 +7,9 @@
  * args), `### Tool Result: <name>`, and the execution/summary sections.
  */
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model, ToolExample, TSchema } from "@oh-my-pi/pi-ai";
 import { renderDelimitedThinking, renderToolInventory } from "@oh-my-pi/pi-ai/dialect";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import { YAML } from "bun";
 import { canonicalizeMessage } from "../utils/thinking-display";
 import {
@@ -38,6 +38,7 @@ export interface FormatSessionDumpTextOptions {
 	model?: Model | null;
 	thinkingLevel?: ThinkingLevel | string | null;
 	tools?: readonly SessionDumpToolInfo[];
+	inlineToolDescriptors?: boolean;
 }
 
 interface InventoryTool {
@@ -78,7 +79,8 @@ function renderDumpHeader(options: FormatSessionDumpTextOptions, inventoryTools:
 	lines.push(`Thinking Level: ${options.thinkingLevel ?? ""}`);
 	lines.push("\n");
 
-	if (inventoryTools.length > 0) {
+	const hasSystemPromptToolInventory = options.inlineToolDescriptors === true;
+	if (inventoryTools.length > 0 && !hasSystemPromptToolInventory) {
 		lines.push("## Available Tools\n");
 		lines.push(renderToolInventory(inventoryTools, model?.id ?? ""));
 		lines.push("\n");

package/src/session/session-history-format.ts

@@ -7,8 +7,8 @@
  * as one-liners. No system prompt, no tool catalog, no config sections.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, ImageContent, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import type {
 	BashExecutionMessage,
 	BranchSummaryMessage,

package/src/session/snapcompact-inline.ts

@@ -46,8 +46,8 @@ export type SnapcompactSavingsSink = (
 // Per-provider image-count budgets live in @oh-my-pi/snapcompact
 // (`providerImageBudget`): snapcompact frames are 1568px (<2000px) so
 // dimension/size limits never bind; only COUNT does. Once the budget is
-// spent (e.g. OpenRouter's hard 8-image cap, already consumed by archive
-// frames), tool results ship verbatim as text.
+// spent by already-attached archive/system-prompt images, tool results ship
+// verbatim as text.
 const MAX_SYSTEM_PROMPT_FRAMES = 6;
 /** Tool results under this many tokens are never rasterized — the swap can't
  *  save enough to justify trading crisp text for an image. */

package/src/session/streaming-output.ts

@@ -495,8 +495,10 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
  * Returned without surrounding newlines so callers can position it freely.
  */
 export function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string {
-	const linesPart = `${elidedLines.toLocaleString()} line${elidedLines === 1 ? "" : "s"}`;
-	return `[… ${linesPart} elided (${formatBytes(elidedBytes)}) …]`;
+	// A 0/1-line elision (e.g. one giant single line) would read as
+	// "[…0ln elided…]"; fall back to a byte count there.
+	if (elidedLines <= 1) return `[…${elidedBytes}B elided…]`;
+	return `[…${elidedLines}ln elided…]`;
 }
 
 /**
@@ -578,8 +580,6 @@ export function truncateMiddle(content: string, options: TruncationOptions = {})
 export interface InlineByteCapOptions {
 	/** Inline byte budget. Defaults to {@link DEFAULT_MAX_BYTES}. */
 	maxBytes?: number;
-	/** What the text is, for the elision marker (e.g. "bash output"). */
-	label: string;
 	/**
 	 * Persist the full text as a session artifact. When an artifact id is
 	 * returned, a `[raw output: artifact://<id>]` footer is appended so the
@@ -619,7 +619,7 @@ export async function enforceInlineByteCap(text: string, options: InlineByteCapO
 	const head = trimHeadToLineBoundary(truncateHeadBytes(text, Math.floor(maxBytes * 0.6)).text);
 	const tail = trimTailToLineBoundary(truncateTailBytes(text, Math.floor(maxBytes * 0.25)).text);
 	const elidedBytes = Math.max(0, totalBytes - Buffer.byteLength(head, "utf-8") - Buffer.byteLength(tail, "utf-8"));
-	const marker = `[… elided ${elidedBytes} bytes of ${options.label} …]`;
+	const marker = `[…${elidedBytes}B elided…]`;
 	let composed = `${head}\n${marker}\n${tail}`;
 
 	const artifactId = await options.saveArtifact?.(text);

package/src/session/tool-choice-queue.ts

@@ -65,6 +65,20 @@ interface InFlight {
 	invoked: boolean;
 }
 
+/**
+ * A non-forcing pending preview invoker. Registered by `queueResolveHandler`
+ * (resolve previews) so the `resolve` tool can dispatch to a staged action
+ * WITHOUT this queue forcing `tool_choice`. The agent-loop's
+ * SoftToolRequirement lifecycle (remind-then-escalate) owns any forcing.
+ */
+interface PendingInvoker {
+	/** Unique id for this staged preview; never reused (never clobbered by label). */
+	id: string;
+	/** Source tool that staged the preview (e.g. "ast_edit"), for the reminder. */
+	sourceToolName: string;
+	onInvoked: (input: unknown) => Promise<unknown> | unknown;
+}
+
 // ── Queue ───────────────────────────────────────────────────────────────────
 
 export class ToolChoiceQueue {
@@ -75,6 +89,12 @@ export class ToolChoiceQueue {
 	 * Consumers (e.g. todo reminder suppression) read via consumeLastServedLabel().
 	 */
 	#lastResolvedLabel: string | undefined;
+	/**
+	 * Non-forcing pending preview invokers, stacked by UNIQUE id. The `resolve`
+	 * tool dispatches to the head; the agent-loop's soft-tool-requirement
+	 * lifecycle drives resolution without this queue forcing `tool_choice`.
+	 */
+	#pendingInvokers: PendingInvoker[] = [];
 
 	// ── Push ──────────────────────────────────────────────────────────────
 
@@ -190,6 +210,44 @@ export class ToolChoiceQueue {
 		};
 	}
 
+	// ── Non-forcing pending invokers ──────────────────────────────────────
+	// Preview producers (queueResolveHandler) register here so `resolve` can
+	// dispatch to a staged action WITHOUT a forced tool_choice (no messages-cache
+	// bust). Stacked by UNIQUE id: a re-register replaces only the same id, so
+	// concurrent/sequential previews each survive and resolve independently.
+
+	/** Register (or replace by exact id) a non-forcing pending preview invoker. */
+	registerPendingInvoker(
+		id: string,
+		sourceToolName: string,
+		onInvoked: (input: unknown) => Promise<unknown> | unknown,
+	): void {
+		this.removePendingInvoker(id);
+		this.#pendingInvokers.push({ id, sourceToolName, onInvoked });
+	}
+
+	/** Drop the pending invoker with this id (e.g. after it resolves). */
+	removePendingInvoker(id: string): void {
+		this.#pendingInvokers = this.#pendingInvokers.filter(p => p.id !== id);
+	}
+
+	/** True when at least one non-forcing pending preview is registered. */
+	get hasPendingInvoker(): boolean {
+		return this.#pendingInvokers.length > 0;
+	}
+
+	/** The head (most-recently registered) pending invoker's handler, for resolve dispatch. */
+	peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
+		return this.#pendingInvokers.at(-1)?.onInvoked;
+	}
+
+	/** The head pending preview's stable id + source tool, for building the agent-level
+	 *  SoftToolRequirement (the id drives reminder re-injection when the head changes). */
+	peekPendingHead(): { id: string; sourceToolName: string } | undefined {
+		const head = this.#pendingInvokers.at(-1);
+		return head ? { id: head.id, sourceToolName: head.sourceToolName } : undefined;
+	}
+
 	// ── Cleanup ───────────────────────────────────────────────────────────
 
 	/** Remove all directives with the given label. Rejects in-flight if it matches. */
@@ -206,6 +264,7 @@ export class ToolChoiceQueue {
 			this.reject("cleared");
 		}
 		this.#queue = [];
+		this.#pendingInvokers = [];
 		this.#lastResolvedLabel = undefined;
 	}
 

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

@@ -27,6 +27,7 @@ import { resolveMemoryBackend } from "../memory-backend";
 import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
 import type { AgentSession, FreshSessionResult } from "../session/agent-session";
+import { COMPACT_MODES, parseCompactArgs } from "../session/compact-modes";
 import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
 import { urlHyperlinkAlways } from "../tui";
 import { getChangelogPath, parseChangelog } from "../utils/changelog";
@@ -1257,13 +1258,20 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "compact",
 		description: "Manually compact the session context",
 		acpDescription: "Compact the conversation",
-		inlineHint: "[focus instructions]",
+		subcommands: COMPACT_MODES.map(mode => ({
+			name: mode.name,
+			description: mode.description,
+			usage: mode.rejectsFocus ? undefined : "[focus]",
+		})),
+		acpInputHint: `[${COMPACT_MODES.map(mode => mode.name).join("|")}] [focus]`,
 		allowArgs: true,
 		handle: async (command, runtime) => {
+			const parsed = parseCompactArgs(command.args);
+			if ("error" in parsed) return usage(parsed.error, runtime);
 			const before = runtime.session.getContextUsage?.();
 			const beforeTokens = before?.tokens;
 			try {
-				await runtime.session.compact(command.args || undefined);
+				await runtime.session.compact(parsed.instructions, parsed.mode ? { mode: parsed.mode } : undefined);
 			} catch (err) {
 				// Compaction precondition failures (no model, already compacted, too
 				// small) and provider errors propagate as plain Errors; surface them
@@ -1281,9 +1289,13 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			return commandConsumed();
 		},
 		handleTui: async (command, runtime) => {
-			const customInstructions = command.args || undefined;
+			const parsed = parseCompactArgs(command.args);
 			runtime.ctx.editor.setText("");
-			await runtime.ctx.handleCompactCommand(customInstructions);
+			if ("error" in parsed) {
+				runtime.ctx.showWarning(parsed.error);
+				return;
+			}
+			await runtime.ctx.handleCompactCommand(parsed.instructions, parsed.mode);
 		},
 	},
 	{

package/src/system-prompt.ts

@@ -373,11 +373,11 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
-	/** Repeat full tool descriptions in system prompt. Default: false */
-	repeatToolDescriptions?: boolean;
+	/** Inline full tool descriptors in the system prompt. Default: true */
+	inlineToolDescriptors?: boolean;
 	/**
 	 * Whether provider-native tool calling is active (no owned/in-band syntax).
-	 * When true and `repeatToolDescriptions` is false, the inventory renders as a
+	 * When true and `inlineToolDescriptors` is false, the inventory renders as a
 	 * compact tool-name list; otherwise it renders full `# Tool:` sections. Default: true
 	 */
 	nativeTools?: boolean;
@@ -433,7 +433,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
-		repeatToolDescriptions = false,
+		inlineToolDescriptors: providedInlineToolDescriptors,
 		nativeTools = true,
 		skillsSettings,
 		toolNames: providedToolNames,
@@ -454,6 +454,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		model,
 		personality = "default",
 	} = options;
+	const inlineToolDescriptors = providedInlineToolDescriptors ?? true;
 	const resolvedCwd = cwd ?? getProjectDir();
 
 	const prepDefaults = {
@@ -599,10 +600,10 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			examples: meta?.examples,
 		};
 	});
-	// List mode shows a compact tool-name list; it only applies when descriptions
-	// are not repeated AND native tool calling is active (the model already has the
-	// schemas). Otherwise render full `# Tool:` sections.
-	const toolListMode = !repeatToolDescriptions && nativeTools;
+	// List mode shows a compact tool-name list; it only applies when descriptors
+	// stay in provider-native tool schemas AND native tool calling is active.
+	// Otherwise render full `# Tool:` sections inline in the system prompt.
+	const toolListMode = !inlineToolDescriptors && nativeTools;
 	const toolInventory = toolListMode ? "" : renderToolInventory(inventoryTools, model ?? "");
 
 	// Filter skills for the rendered system prompt:
@@ -632,7 +633,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		tools: toolNames,
 		toolInfo,
 		toolInventory,
-		repeatToolDescriptions,
+		inlineToolDescriptors,
 		toolListMode,
 		toolRefs,
 		environment,

package/src/task/executor.ts

@@ -196,7 +196,7 @@ function installSubagentRetryFallbackChain(args: {
 function renderIrcPeerRoster(selfId: string): string {
 	const peers = AgentRegistry.global()
 		.list()
-		.filter(ref => ref.id !== selfId && ref.status !== "aborted");
+		.filter(ref => ref.id !== selfId && ref.status !== "aborted" && ref.kind !== "advisor");
 	if (peers.length === 0) return "- (no other agents)";
 	const lines = peers.map(
 		peer =>

package/src/task/output-manager.ts

@@ -11,6 +11,7 @@
  * collisions across repeated or nested task invocations.
  */
 import * as fs from "node:fs/promises";
+import { ADVISOR_TRANSCRIPT_STEM } from "../advisor/transcript-recorder";
 
 /**
  * Manages agent output ID allocation to ensure uniqueness.
@@ -29,6 +30,10 @@ export class AgentOutputManager {
 	constructor(getArtifactsDir: () => string | null, options?: { parentPrefix?: string }) {
 		this.#getArtifactsDir = getArtifactsDir;
 		this.#parentPrefix = options?.parentPrefix;
+		// Reserve the advisor transcript stem: a subagent allocated this id would
+		// write `<id>.jsonl`, clobbering the advisor's `__advisor.jsonl` in the same
+		// artifacts dir. Reserving bumps such a request to `__advisor-2`.
+		this.#taken.add(ADVISOR_TRANSCRIPT_STEM);
 	}
 
 	/**

package/src/tools/__tests__/json-tree.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
+import { formatArgsInline } from "../json-tree";
+
+describe("formatArgsInline", () => {
+	test("a trailing scalar grows into the available width instead of a fixed cap", () => {
+		// Regression: the value used to be hard-capped at 24 columns, so a long
+		// note was truncated even when the card had plenty of room (issue: advise
+		// preview cut to `note="Your “stric…"`).
+		const note = "x".repeat(200);
+		const narrow = formatArgsInline({ severity: "concern", note }, 40);
+		const wide = formatArgsInline({ severity: "concern", note }, 120);
+		expect(Bun.stringWidth(wide)).toBeGreaterThan(Bun.stringWidth(narrow) + 40);
+		// Both stay within their budget.
+		expect(Bun.stringWidth(narrow)).toBeLessThanOrEqual(40);
+		expect(Bun.stringWidth(wide)).toBeLessThanOrEqual(120);
+	});
+
+	test("every key stays visible even when a leading value is long", () => {
+		const out = formatArgsInline({ path: "x".repeat(200), pattern: "needle", limit: 5 }, 80);
+		expect(out).toContain("path=");
+		expect(out).toContain("pattern=");
+		expect(out).toContain("limit=");
+		expect(Bun.stringWidth(out)).toBeLessThanOrEqual(80);
+	});
+
+	test("short values render fully without truncation markers", () => {
+		expect(formatArgsInline({ a: "x", b: 5, c: true }, 80)).toBe('a="x", b=5, c=true');
+	});
+
+	test("hidden meta keys are skipped", () => {
+		const out = formatArgsInline({ [INTENT_FIELD]: "noise", __partialJson: "{}", path: "src/foo.ts" }, 80);
+		expect(out).toBe('path="src/foo.ts"');
+	});
+});

package/src/tools/approval.ts

@@ -159,7 +159,7 @@ export function requiresApproval(
 export function truncateForPrompt(value: string, maxChars = DEFAULT_PROMPT_TRUNCATE_CHARS): string {
 	if (value.length <= maxChars) return value;
 	const omitted = value.length - maxChars;
-	return `${value.slice(0, maxChars)}… (${omitted} chars truncated)`;
+	return `${value.slice(0, maxChars)}[…${omitted}ch elided…]`;
 }
 
 /**

package/src/tools/bash-interactive.ts

@@ -274,16 +274,16 @@ class BashInteractiveOverlayComponent implements Component {
 				: truncateToWidth(this.uiTheme.fg("dim", "session finished"), innerWidth);
 		const visibleLines = this.#readViewport(innerWidth, maxContentRows);
 		const content = visibleLines.length > 0 ? visibleLines : [padding(innerWidth)];
-		const borderHorizontal = this.uiTheme.fg("border", this.uiTheme.boxSharp.horizontal.repeat(innerWidth));
-		const borderVertical = this.uiTheme.fg("border", this.uiTheme.boxSharp.vertical);
+		const borderHorizontal = this.uiTheme.fg("border", this.uiTheme.boxRound.horizontal.repeat(innerWidth));
+		const borderVertical = this.uiTheme.fg("border", this.uiTheme.boxRound.vertical);
 		const boxLine = (line: string) =>
 			`${borderVertical}${line}${padding(Math.max(0, innerWidth - visibleWidth(line)))}${borderVertical}`;
 		return [
-			`${this.uiTheme.fg("border", this.uiTheme.boxSharp.topLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxSharp.topRight)}`,
+			`${this.uiTheme.fg("border", this.uiTheme.boxRound.topLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxRound.topRight)}`,
 			boxLine(header),
 			...content.map(boxLine),
 			boxLine(footer),
-			`${this.uiTheme.fg("border", this.uiTheme.boxSharp.bottomLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxSharp.bottomRight)}`,
+			`${this.uiTheme.fg("border", this.uiTheme.boxRound.bottomLeft)}${borderHorizontal}${this.uiTheme.fg("border", this.uiTheme.boxRound.bottomRight)}`,
 		];
 	}
 

package/src/tools/bash.ts

@@ -485,7 +485,6 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		// head-retention spill, minimizer miss) may emit more than
 		// ~DEFAULT_MAX_BYTES inline. No-op for already-bounded output.
 		const cappedOutputText = await enforceInlineByteCap(outputText, {
-			label: "bash output",
 			saveArtifact: full => saveBashOriginalArtifact(this.session, full),
 		});
 

package/src/tools/browser.ts

@@ -332,7 +332,6 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		// text inline; the full text stays recoverable via the artifact footer
 		// when allocation succeeds.
 		const cappedText = await enforceInlineByteCap(textOnly, {
-			label: "browser output",
 			saveArtifact: full => saveBrowserOutputArtifact(this.session, full),
 		});
 		details.result = cappedText;

package/src/tools/eval.ts

@@ -64,7 +64,7 @@ function formatDisplayJsonForText(value: unknown): string {
 		text = String(value);
 	}
 	if (text.length > MAX_DISPLAY_TEXT_BYTES) {
-		text = `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n… (${text.length - MAX_DISPLAY_TEXT_BYTES} chars truncated)`;
+		text = `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n[…${text.length - MAX_DISPLAY_TEXT_BYTES}ch elided…]`;
 	}
 	return text;
 }