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

package/dist/types/session/compact-modes.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 declare const COMPACT_MODES: readonly CompactModeDef[];
+/** Resolve a subcommand token (case-insensitive) to its mode definition. */
+export declare function findCompactMode(name: string): CompactModeDef | undefined;
+/** 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 declare function parseCompactArgs(args: string): ParsedCompactArgs | {
+    error: string;
+};

package/dist/types/session/session-context.d.ts

@@ -17,6 +17,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. */
 export declare function getRestorableSessionModels(models: Readonly<Record<string, string>>, lastModelChangeRole: string | undefined): string[];

package/dist/types/session/session-dump-format.d.ts

@@ -21,6 +21,7 @@ export interface FormatSessionDumpTextOptions {
     model?: Model | null;
     thinkingLevel?: ThinkingLevel | string | null;
     tools?: readonly SessionDumpToolInfo[];
+    inlineToolDescriptors?: boolean;
 }
 /**
  * Format messages and session metadata as markdown/plain text (same as

package/dist/types/session/streaming-output.d.ts

@@ -163,8 +163,6 @@ export declare function truncateMiddle(content: string, options?: TruncationOpti
 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

package/dist/types/session/tool-choice-queue.d.ts

@@ -67,6 +67,20 @@ export declare class ToolChoiceQueue {
     get hasInFlight(): boolean;
     /** Return the in-flight directive's onInvoked handler and mark it when called. */
     peekInFlightInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Register (or replace by exact id) a non-forcing pending preview invoker. */
+    registerPendingInvoker(id: string, sourceToolName: string, onInvoked: (input: unknown) => Promise<unknown> | unknown): void;
+    /** Drop the pending invoker with this id (e.g. after it resolves). */
+    removePendingInvoker(id: string): void;
+    /** True when at least one non-forcing pending preview is registered. */
+    get hasPendingInvoker(): boolean;
+    /** The head (most-recently registered) pending invoker's handler, for resolve dispatch. */
+    peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** 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;
     /** Remove all directives with the given label. Rejects in-flight if it matches. */
     removeByLabel(label: string): void;
     /** Empty the queue and reject any in-flight yield. */

package/dist/types/system-prompt.d.ts

@@ -54,11 +54,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;

package/dist/types/tools/__tests__/json-tree.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -272,6 +272,10 @@ export interface ToolSession {
     }): void;
     /** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
     peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Peek the most-recently registered non-forcing pending preview invoker. The `resolve`
+     *  tool dispatches to it so a staged preview resolves WITHOUT forcing tool_choice — the
+     *  agent-loop's SoftToolRequirement lifecycle owns reminder injection and escalation. */
+    peekPendingInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     /** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
      *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
      *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */

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

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, CustomMessage } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -18,10 +18,13 @@ export interface ResolveToolDetails {
     sourceResultDetails?: unknown;
 }
 /**
- * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
- * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
- * callbacks into an onInvoked closure that matches the resolve schema, and
- * steers a preview reminder so the model understands why.
+ * Register a non-forcing resolve-protocol handler for a staged preview. Wraps the
+ * caller's apply/reject into an onInvoked closure (matching the resolve schema) and
+ * stores it on the tool-choice queue's pending-invoker registry under a UNIQUE id.
+ * The `resolve` tool dispatches to it; the agent-loop's SoftToolRequirement
+ * lifecycle injects the preview reminder and escalates to a forced `resolve` only
+ * if the model declines — so a compliant turn pays ZERO tool_choice change (no
+ * prompt-cache messages-cache invalidation).
  *
  * This is the canonical entry point for any tool that wants preview/apply
  * semantics. No session-level abstraction is needed: callers pass their
@@ -33,6 +36,13 @@ export declare function queueResolveHandler(session: ToolSession, options: {
     apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
     reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
 }): void;
+/**
+ * The canonical preview reminder. The resolve mechanism owns the wording; the
+ * agent-loop delivers it via the session's `SoftToolRequirement.reminder` (injected
+ * once per pending-preview head) instead of a host-side steer, so it lands as a
+ * stable mid-history append and never churns the cached prefix.
+ */
+export declare function buildResolveReminderMessage(sourceToolName: string): CustomMessage;
 /**
  * Shared invocation runner used by both queued (in-flight) handlers and
  * standing handlers (e.g. plan-mode approval). Discriminates on action,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.10",
+	"version": "16.1.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.0.10",
-		"@oh-my-pi/omp-stats": "16.0.10",
-		"@oh-my-pi/pi-agent-core": "16.0.10",
-		"@oh-my-pi/pi-ai": "16.0.10",
-		"@oh-my-pi/pi-catalog": "16.0.10",
-		"@oh-my-pi/pi-mnemopi": "16.0.10",
-		"@oh-my-pi/pi-natives": "16.0.10",
-		"@oh-my-pi/pi-tui": "16.0.10",
-		"@oh-my-pi/pi-utils": "16.0.10",
-		"@oh-my-pi/pi-wire": "16.0.10",
-		"@oh-my-pi/snapcompact": "16.0.10",
+		"@oh-my-pi/hashline": "16.1.0",
+		"@oh-my-pi/omp-stats": "16.1.0",
+		"@oh-my-pi/pi-agent-core": "16.1.0",
+		"@oh-my-pi/pi-ai": "16.1.0",
+		"@oh-my-pi/pi-catalog": "16.1.0",
+		"@oh-my-pi/pi-mnemopi": "16.1.0",
+		"@oh-my-pi/pi-natives": "16.1.0",
+		"@oh-my-pi/pi-tui": "16.1.0",
+		"@oh-my-pi/pi-utils": "16.1.0",
+		"@oh-my-pi/pi-wire": "16.1.0",
+		"@oh-my-pi/snapcompact": "16.1.0",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/index.ts

@@ -1,3 +1,4 @@
 export * from "./advise-tool";
 export * from "./runtime";
+export * from "./transcript-recorder";
 export * from "./watchdog";

package/src/advisor/transcript-recorder.ts

@@ -0,0 +1,136 @@
+import * as path from "node:path";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { Message, UserMessage } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { SessionManager } from "../session/session-manager";
+
+/**
+ * Reserved transcript stem for advisor session files. Chosen so it cannot
+ * collide with a task subagent's `<id>.jsonl` (task ids are reserved against
+ * this exact stem in {@link AgentOutputManager}).
+ */
+export const ADVISOR_TRANSCRIPT_STEM = "__advisor";
+export const ADVISOR_TRANSCRIPT_FILENAME = `${ADVISOR_TRANSCRIPT_STEM}.jsonl`;
+
+const JSONL_SUFFIX = ".jsonl";
+
+/**
+ * Append-only persister for an advisor agent's transcript.
+ *
+ * The advisor is a passive reviewer with its own model usage, so — like a task
+ * subagent — its turns are written to a JSONL inside the owning session's
+ * artifacts dir (`<session>/__advisor.jsonl`, `<session>/<SubId>/__advisor.jsonl`
+ * for subagent advisors). That single file gives the advisor model proper usage
+ * attribution in `omp stats` (the stats parser scans the session dir
+ * recursively) and a read-only transcript in the Agent Hub, without making the
+ * advisor a registered, messageable peer.
+ *
+ * The target is derived from the *session file* (`getSessionFile()`), never
+ * `getArtifactsDir()` — subagents adopt the parent's artifact manager, so the
+ * artifacts dir points at the parent root and every subagent advisor would
+ * collide. The file path is resolved synchronously when a message finalizes and
+ * captured for the queued write, so a `/new`, resume, or session switch in
+ * flight can never misattribute an old advisor turn into the new session's file.
+ * On such a switch the previous writer is closed and the new file opened on the
+ * next recorded turn. The recorder never truncates: the advisor's in-memory
+ * context resets/compacts independently, but every billed turn is appended here.
+ */
+export class AdvisorTranscriptRecorder {
+	#manager: SessionManager | undefined;
+	#file: string | undefined;
+	/** Serializes the async open/close against synchronous appends so records land in order. */
+	#queue: Promise<void>;
+
+	/**
+	 * @param after Optional barrier the queue starts behind — used on the advisor
+	 *   on→off→on toggle so a fresh recorder's first `open` waits for the prior
+	 *   recorder's `close` and the two never hold the same `__advisor.jsonl` at once.
+	 */
+	constructor(
+		private readonly resolveSessionFile: () => string | undefined,
+		private readonly resolveCwd: () => string,
+		after?: Promise<unknown>,
+	) {
+		this.#queue = after
+			? after.then(
+					() => {},
+					() => {},
+				)
+			: Promise.resolve();
+	}
+
+	/**
+	 * Persist one finalized advisor message. Assistant turns carry the usage the
+	 * stats parser reads; tool results round out the Hub transcript; user deltas
+	 * (the advisor's "session update" prompts) are persisted but flagged
+	 * `synthetic`/agent-attributed so they never inflate user-message metrics.
+	 * Non-conversational message kinds are skipped.
+	 */
+	record(message: AgentMessage): void {
+		let persisted: Message;
+		switch (message.role) {
+			case "assistant":
+			case "toolResult":
+				persisted = message;
+				break;
+			case "user":
+				// Clone so the live advisor message stays untouched; mark synthetic so
+				// stats' user-message metrics skip these agent-internal review prompts.
+				persisted = { ...(message as UserMessage), synthetic: true, attribution: "agent" };
+				break;
+			default:
+				return;
+		}
+		const sessionFile = this.resolveSessionFile();
+		if (!sessionFile?.endsWith(JSONL_SUFFIX)) return;
+		const file = path.join(sessionFile.slice(0, -JSONL_SUFFIX.length), ADVISOR_TRANSCRIPT_FILENAME);
+		const cwd = this.resolveCwd();
+		this.#enqueue(async () => {
+			if (file !== this.#file) {
+				await this.#closeManager();
+				this.#manager = await SessionManager.open(file, undefined, undefined, {
+					initialCwd: cwd,
+					suppressBreadcrumb: true,
+				});
+				this.#file = file;
+			}
+			this.#manager?.appendMessage(persisted);
+		});
+	}
+
+	/** Flush pending writes (best-effort). */
+	flush(): Promise<void> {
+		return this.#enqueueResult(async () => {
+			if (this.#manager) await this.#manager.flush();
+		});
+	}
+
+	/** Flush and close the writer, releasing the session file. */
+	close(): Promise<void> {
+		return this.#enqueueResult(() => this.#closeManager());
+	}
+
+	async #closeManager(): Promise<void> {
+		const manager = this.#manager;
+		this.#manager = undefined;
+		this.#file = undefined;
+		if (!manager) return;
+		try {
+			await manager.close();
+		} catch (err) {
+			logger.debug("advisor transcript close failed", { err: String(err) });
+		}
+	}
+
+	#enqueue(work: () => Promise<void>): void {
+		this.#queue = this.#queue.then(work, work).catch(err => {
+			logger.debug("advisor transcript record failed", { err: String(err) });
+		});
+	}
+
+	#enqueueResult(work: () => Promise<void>): Promise<void> {
+		const next = this.#queue.then(work, work);
+		this.#queue = next.catch(() => {});
+		return next;
+	}
+}

package/src/cli/stats-cli.ts

@@ -4,6 +4,7 @@
  * Handles `omp stats` subcommand for viewing AI usage statistics.
  */
 
+import { truncateToWidth } from "@oh-my-pi/pi-tui/utils";
 import { APP_NAME, formatDuration, formatNumber, formatPercent } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { openPath } from "../utils/open";
@@ -32,7 +33,7 @@ function createSyncProgressReporter(): {
 			const counter = chalk.cyan(`[${event.current}/${event.total}]`);
 			const line = `${counter} ${pct}%  ${label}`;
 			const columns = stream.columns ?? 120;
-			const trimmed = truncateToColumns(line, columns - 1);
+			const trimmed = truncateToWidth(line, columns - 1);
 			stream.write(`\r${trimmed.padEnd(lastWidth)}`);
 			lastWidth = trimmed.length;
 		},
@@ -50,16 +51,6 @@ function shortenSessionFile(p: string): string {
 	return idx >= 0 ? p.slice(idx + marker.length) : p;
 }
 
-function truncateToColumns(s: string, max: number): string {
-	if (max <= 0) return "";
-	const width = Bun.stringWidth(s, { countAnsiEscapeCodes: false });
-	if (width <= max) return s;
-	// Cheap right-trim with an ellipsis - we don't need ANSI-aware slicing
-	// because the colored prefix is short and the truncated tail is the
-	// dim filename, where dropping bytes is fine.
-	return `${s.slice(0, Math.max(0, max - 1))}\u2026`;
-}
-
 // =============================================================================
 // Types
 // =============================================================================

package/src/collab/host.ts

@@ -17,7 +17,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 import type { BusChannel, AgentEvent as WireAgentEvent, SessionEntry as WireSessionEntry } from "@oh-my-pi/pi-wire";
 import type { InteractiveModeContext } from "../modes/types";
 import { AgentLifecycleManager } from "../registry/agent-lifecycle";
-import { AgentRegistry } from "../registry/agent-registry";
+import { type AgentRef, AgentRegistry } from "../registry/agent-registry";
 import type { AgentSessionEvent } from "../session/agent-session";
 import { stripImagesFromMessage, USER_INTERRUPT_LABEL } from "../session/messages";
 import type { SessionEntry as StoredSessionEntry } from "../session/session-entries";
@@ -445,18 +445,24 @@ export class CollabHost {
 	}
 
 	#snapshotAgents(): AgentSnapshot[] {
-		return AgentRegistry.global()
-			.list()
-			.map(ref => ({
-				id: ref.id,
-				displayName: ref.displayName,
-				kind: ref.kind,
-				parentId: ref.parentId,
-				status: ref.status,
-				hasSessionFile: !!ref.sessionFile,
-				createdAt: ref.createdAt,
-				lastActivity: ref.lastActivity,
-			}));
+		return (
+			AgentRegistry.global()
+				.list()
+				// Advisor transcripts are local observability only; never mirror them to
+				// guests (the wire AgentSnapshot kind has no `advisor`, and guests must not
+				// be able to chat/kill/revive them).
+				.filter((ref): ref is AgentRef & { kind: "main" | "sub" } => ref.kind !== "advisor")
+				.map(ref => ({
+					id: ref.id,
+					displayName: ref.displayName,
+					kind: ref.kind,
+					parentId: ref.parentId,
+					status: ref.status,
+					hasSessionFile: !!ref.sessionFile,
+					createdAt: ref.createdAt,
+					lastActivity: ref.lastActivity,
+				}))
+		);
 	}
 
 	#scheduleAgentsBroadcast(): void {
@@ -472,6 +478,12 @@ export class CollabHost {
 			this.#rejectReadOnly("agent control", fromPeer);
 			return;
 		}
+		// Advisor refs are excluded from snapshots, but reject control by id defensively:
+		// a stale/malicious client must never chat/kill/revive a read-only advisor transcript.
+		if (AgentRegistry.global().get(agentId)?.kind === "advisor") {
+			this.#socket?.send({ t: "error", message: `agent ${agentId}: advisor transcripts are read-only` }, fromPeer);
+			return;
+		}
 		const fail = (err: unknown) => {
 			logger.warn("collab agent-cmd failed", { cmd, agentId, error: String(err) });
 			this.#socket?.send({ t: "error", message: `agent ${agentId}: ${String(err)}` }, fromPeer);

package/src/commit/agentic/agent.ts

@@ -1,7 +1,8 @@
-import { INTENT_FIELD, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { Markdown } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
+import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import chalk from "chalk";
 import typesDescriptionPrompt from "../../commit/prompts/types-description.md" with { type: "text" };
 import type { ModelRegistry } from "../../config/model-registry";

package/src/commit/agentic/tools/git-file-diff.ts

@@ -87,7 +87,7 @@ function truncateDiffContent(diff: string): { content: string; truncated: boolea
 	const truncatedCount = lines.length - KEEP_HEAD_LINES - KEEP_TAIL_LINES;
 
 	return {
-		content: [...head, `\n... (truncated ${truncatedCount} lines) ...\n`, ...tail].join("\n"),
+		content: [...head, `\n[…${truncatedCount}ln elided…]\n`, ...tail].join("\n"),
 		truncated: true,
 	};
 }
@@ -117,7 +117,7 @@ function processDiffs(files: string[], diffs: Map<string, string>): { result: st
 			}
 			content = truncated;
 			if (content.length > remaining) {
-				content = `${content.slice(0, remaining)}\n... (diff truncated due to size) ...`;
+				content = `${content.slice(0, remaining)}\n[…${content.length - remaining}ch elided…]`;
 				if (!truncatedFiles.includes(file)) {
 					truncatedFiles.push(file);
 				}

package/src/commit/changelog/index.ts

@@ -138,7 +138,7 @@ export async function applyChangelogProposals({
 
 function truncateDiff(diff: string, maxChars: number): string {
 	if (diff.length <= maxChars) return diff;
-	return `${diff.slice(0, maxChars)}\n... (truncated)`;
+	return `${diff.slice(0, maxChars)}\n[…${diff.length - maxChars}ch elided…]`;
 }
 
 function formatExistingEntries(entries: Record<string, string[]>): string {

package/src/commit/map-reduce/map-phase.ts

@@ -126,7 +126,7 @@ function generateContextHeader(files: FileDiff[], currentFile: string): string {
 	}
 
 	if (toShow.length < sorted.length) {
-		lines.push(`... and ${sorted.length - toShow.length} more files`);
+		lines.push(`[…${sorted.length - toShow.length} files elided…]`);
 	}
 
 	return lines.join("\n");

package/src/commit/map-reduce/utils.ts

@@ -5,5 +5,5 @@ export function estimateTokens(text: string): number {
 export function truncateToTokenLimit(text: string, maxTokens: number): string {
 	const maxChars = maxTokens * 4;
 	if (text.length <= maxChars) return text;
-	return `${text.slice(0, maxChars)}\n... (truncated)`;
+	return `${text.slice(0, maxChars)}\n[…${text.length - maxChars}ch elided…]`;
 }

package/src/config/settings-schema.ts

@@ -809,11 +809,6 @@ export const SETTINGS_SCHEMA = {
 			description: "Remove the 1-character horizontal padding from the left and right of the terminal output",
 		},
 	},
-	// Display rendering
-	"display.tabWidth": {
-		type: "number",
-		default: 3,
-	},
 
 	"display.shimmer": {
 		type: "enum",
@@ -854,6 +849,17 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"display.cacheMissMarker": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "appearance",
+			group: "Display",
+			label: "Cache Miss Marker",
+			description: "Show a divider above an assistant turn whose request lost (missed) the prompt cache",
+		},
+	},
+
 	showHardwareCursor: {
 		type: "boolean",
 		default: true, // will be computed based on platform if undefined
@@ -919,14 +925,15 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	repeatToolDescriptions: {
+	inlineToolDescriptors: {
 		type: "boolean",
-		default: false,
+		default: true,
 		ui: {
 			tab: "model",
 			group: "Prompt",
-			label: "Repeat Tool Descriptions",
-			description: "Render full tool descriptions in the system prompt instead of a tool name list",
+			label: "Inline Tool Descriptors",
+			description:
+				"Render full tool descriptors in the system prompt and strip top-level/nested descriptions from provider tool schemas so descriptor text is sent once",
 		},
 	},
 

package/src/config/settings.ts

@@ -22,7 +22,6 @@ import {
 	isEnoent,
 	logger,
 	procmgr,
-	setDefaultTabWidth,
 } from "@oh-my-pi/pi-utils";
 import { JSONC, YAML } from "bun";
 import { type Settings as SettingsCapabilityItem, settingsCapability } from "../capability/settings";
@@ -1103,11 +1102,6 @@ const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
 			});
 		}
 	},
-	"display.tabWidth": value => {
-		if (typeof value === "number") {
-			setDefaultTabWidth(value);
-		}
-	},
 	"provider.appendOnlyContext": value => {
 		if (typeof value === "string") {
 			appendOnlyModeSignal.fire(value);

package/src/debug/log-viewer.ts

@@ -866,21 +866,21 @@ export class DebugLogViewerComponent implements Component {
 	}
 
 	#frameTop(innerWidth: number): string {
-		return `${theme.boxSharp.topLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.topRight}`;
+		return `${theme.boxRound.topLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.topRight}`;
 	}
 
 	#frameSeparator(innerWidth: number): string {
-		return `${theme.boxSharp.teeRight}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.teeLeft}`;
+		return `${theme.boxRound.teeRight}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.teeLeft}`;
 	}
 
 	#frameBottom(innerWidth: number): string {
-		return `${theme.boxSharp.bottomLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.bottomRight}`;
+		return `${theme.boxRound.bottomLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.bottomRight}`;
 	}
 
 	#frameLine(content: string, innerWidth: number): string {
 		const truncated = truncateToWidth(content, innerWidth);
 		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
-		return `${theme.boxSharp.vertical}${truncated}${padding(remaining)}${theme.boxSharp.vertical}`;
+		return `${theme.boxRound.vertical}${truncated}${padding(remaining)}${theme.boxRound.vertical}`;
 	}
 
 	#copySelected() {

package/src/debug/raw-sse.ts

@@ -273,20 +273,20 @@ export class RawSseViewerComponent implements Component {
 	}
 
 	#frameTop(innerWidth: number): string {
-		return `${theme.boxSharp.topLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.topRight}`;
+		return `${theme.boxRound.topLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.topRight}`;
 	}
 
 	#frameSeparator(innerWidth: number): string {
-		return `${theme.boxSharp.teeRight}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.teeLeft}`;
+		return `${theme.boxRound.teeRight}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.teeLeft}`;
 	}
 
 	#frameBottom(innerWidth: number): string {
-		return `${theme.boxSharp.bottomLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.bottomRight}`;
+		return `${theme.boxRound.bottomLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.bottomRight}`;
 	}
 
 	#frameLine(content: string, innerWidth: number): string {
 		const truncated = truncateToWidth(content, innerWidth);
 		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
-		return `${theme.boxSharp.vertical}${truncated}${padding(remaining)}${theme.boxSharp.vertical}`;
+		return `${theme.boxRound.vertical}${truncated}${padding(remaining)}${theme.boxRound.vertical}`;
 	}
 }