@oh-my-pi/pi-coding-agent 16.0.1 → 16.0.3

package/src/stt/stt-controller.ts

@@ -4,10 +4,11 @@ import * as path from "node:path";
 import { logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { settings } from "../config/settings";
 import { type SttStreamHandle, sttClient } from "./asr-client";
-import { ensureSTTDependencies } from "./downloader";
+import { downloadSttModel, isSttModelCached } from "./downloader";
 import { resolveSttModelSpec } from "./models";
 import {
 	detectRecorder,
+	ensureRecorder,
 	type RecordingHandle,
 	type StreamingRecordingHandle,
 	startRecording,
@@ -36,7 +37,7 @@ interface Editor {
 
 export class STTController {
 	#state: SttState = "idle";
-	#depsResolved = false;
+	#resolvedModelKey: string | null = null;
 	#toggling = false;
 	#stopAfterStart = false;
 	#disposed = false;
@@ -92,15 +93,39 @@ export class STTController {
 	}
 
 	async #ensureDeps(options: ToggleOptions): Promise<boolean> {
-		if (this.#depsResolved) return true;
+		const modelKey = resolveSttModelSpec(settings.get("stt.modelName") as string | undefined).key;
+		// Keyed on the model rather than a one-shot flag: switching stt.modelName
+		// mid-session must re-run preflight so an uncached new tier downloads here
+		// (with progress) instead of blocking silently at stop.
+		if (this.#resolvedModelKey === modelKey) return true;
 		try {
-			options.showStatus("Checking STT dependencies...");
-			await ensureSTTDependencies({
-				modelName: settings.get("stt.modelName") as string | undefined,
-				onProgress: p => options.showStatus(p.stage + (p.percent != null ? ` (${p.percent}%)` : "")),
-			});
-			options.showStatus("");
-			this.#depsResolved = true;
+			// Only clear the status line if we actually wrote to it: the cached
+			// fast path (recorder on PATH, model present) emits nothing, so an
+			// unconditional clear would be a stray write.
+			let wroteStatus = false;
+			const status = (msg: string): void => {
+				wroteStatus = true;
+				options.showStatus(msg);
+			};
+			// A recorder is required to capture audio; startRecording /
+			// startStreamingRecording only *detect* a recorder and throw when none
+			// exists, so provision one here. Instant when sox/ffmpeg/arecord is on
+			// PATH — only a first-run static-ffmpeg download actually blocks.
+			await ensureRecorder(p => status(p.stage + (p.percent != null ? ` (${p.percent}%)` : "")));
+			// Loading the multi-hundred-MB speech model into the worker is what made
+			// the old "Checking STT dependencies…" step slow. Don't pay it before
+			// recording: when the weights are already cached, start now and warm the
+			// model in the background — the stream/transcribe paths load it on demand
+			// (memoized in the worker) and it is hot by the time recording stops.
+			// Only a genuine first-use download blocks, with explicit progress, so we
+			// never record silently against missing weights.
+			if (await isSttModelCached(modelKey)) {
+				this.#warmModel(modelKey);
+			} else {
+				await downloadSttModel(modelKey, p => status(`Downloading speech model ${p.label} (${p.percent}%)`));
+			}
+			if (wroteStatus) options.showStatus("");
+			this.#resolvedModelKey = modelKey;
 			return true;
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : "Failed to setup STT dependencies";
@@ -110,6 +135,22 @@ export class STTController {
 		}
 	}
 
+	/** Warm the speech model in the worker without blocking recording. The worker
+	 *  memoizes the load, so the stream/transcribe path reuses it and the model is
+	 *  hot by the time recording stops. Only called when the weights are already
+	 *  cached, so no network fetch happens. On load failure (corrupt cache, OOM,
+	 *  runtime install) invalidate the resolved key so the next toggle re-runs
+	 *  preflight and retries instead of skipping it forever. */
+	#warmModel(modelKey: string): void {
+		void downloadSttModel(modelKey).catch(err => {
+			// Guard against a concurrent model switch clobbering a newer resolution.
+			if (!this.#disposed && this.#resolvedModelKey === modelKey) this.#resolvedModelKey = null;
+			logger.debug("stt: background model warmup failed", {
+				error: err instanceof Error ? err.message : String(err),
+			});
+		});
+	}
+
 	async #start(editor: Editor, options: ToggleOptions): Promise<void> {
 		if (!(await this.#ensureDeps(options))) return;
 		// Live transcription needs a recorder that can pipe PCM; the Windows
@@ -334,6 +375,6 @@ export class STTController {
 			this.#tempFile = null;
 		}
 		this.#state = "idle";
-		this.#depsResolved = false;
+		this.#resolvedModelKey = null;
 	}
 }

package/src/system-prompt.ts

@@ -615,7 +615,13 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		resolvedCustomPrompt,
 		resolvedAppendPrompt,
 	]);
-	const promptSources = [effectiveSystemPromptCustomization, resolvedCustomPrompt, resolvedAppendPrompt];
+	const contextPromptSources = contextFiles.map(file => file.content);
+	const promptSources = [
+		effectiveSystemPromptCustomization,
+		resolvedCustomPrompt,
+		resolvedAppendPrompt,
+		...contextPromptSources,
+	];
 	const injectedAlwaysApplyRules = dedupeAlwaysApplyRules(alwaysApplyRules, promptSources);
 
 	const environment = await logger.time("getEnvironmentInfo", getEnvironmentInfo);

package/src/task/executor.ts

@@ -7,11 +7,16 @@
 import path from "node:path";
 import type { AgentEvent, AgentIdentity, AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { recordHandoff, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
-import type { Usage } from "@oh-my-pi/pi-ai";
+import type { Api, Model, Usage } from "@oh-my-pi/pi-ai";
 import { logger, popLoopPhase, prompt, pushLoopPhase, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
-import { resolveModelOverrideWithAuthFallback } from "../config/model-resolver";
+import {
+	formatModelSelectorValue,
+	formatModelStringWithRouting,
+	resolveModelOverride,
+	resolveModelOverrideWithAuthFallback,
+} from "../config/model-resolver";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
@@ -120,6 +125,74 @@ function normalizeModelPatterns(value: string | string[] | undefined): string[]
 		.filter(Boolean);
 }
 
+const SUBAGENT_RETRY_FALLBACK_ROLE_PREFIX = "subagent:";
+
+interface SubagentRetryFallbackCandidate {
+	model: Model<Api>;
+	selector: string;
+}
+
+function resolveSubagentRetryFallbackCandidates(
+	modelPatterns: string[],
+	modelRegistry: ModelRegistry,
+	settings: Settings,
+): SubagentRetryFallbackCandidate[] {
+	const candidates: SubagentRetryFallbackCandidate[] = [];
+	const seen = new Set<string>();
+	for (const pattern of modelPatterns) {
+		const resolved = resolveModelOverride([pattern], modelRegistry, settings);
+		if (!resolved.model) continue;
+		const selector = resolved.explicitThinkingLevel
+			? formatModelSelectorValue(formatModelStringWithRouting(resolved.model), resolved.thinkingLevel)
+			: formatModelStringWithRouting(resolved.model);
+		if (seen.has(selector)) continue;
+		seen.add(selector);
+		candidates.push({ model: resolved.model, selector });
+	}
+	return candidates;
+}
+
+function installSubagentRetryFallbackChain(args: {
+	settings: Settings;
+	id: string;
+	candidates: SubagentRetryFallbackCandidate[];
+	model: Model<Api> | undefined;
+	authFallbackUsed: boolean;
+}): string | undefined {
+	const { settings, id, candidates, model, authFallbackUsed } = args;
+	if (!model || authFallbackUsed || candidates.length <= 1) return undefined;
+
+	const selectedIndex = candidates.findIndex(
+		candidate => candidate.model.provider === model.provider && candidate.model.id === model.id,
+	);
+	if (selectedIndex < 0) return undefined;
+	const fallbackSelectors = candidates.slice(selectedIndex + 1).map(candidate => candidate.selector);
+	if (fallbackSelectors.length === 0) return undefined;
+
+	const role = `${SUBAGENT_RETRY_FALLBACK_ROLE_PREFIX}${id}`;
+	const modelRoles: Record<string, string> = {};
+	const existingRoles = settings.getModelRoles();
+	for (const existingRole in existingRoles) {
+		const selector = existingRoles[existingRole];
+		if (selector) {
+			modelRoles[existingRole] = selector;
+		}
+	}
+	modelRoles[role] = candidates[selectedIndex].selector;
+	settings.override("modelRoles", modelRoles);
+	const fallbackChains: Record<string, string[]> = {
+		[role]: fallbackSelectors,
+	};
+	const existingFallbackChains = settings.get("retry.fallbackChains");
+	for (const existingRole in existingFallbackChains) {
+		if (existingRole !== role) {
+			fallbackChains[existingRole] = existingFallbackChains[existingRole];
+		}
+	}
+	settings.override("retry.fallbackChains", fallbackChains);
+	return role;
+}
+
 function renderIrcPeerRoster(selfId: string): string {
 	const peers = AgentRegistry.global()
 		.list()
@@ -278,6 +351,12 @@ export interface ExecutorOptions {
 	parentTelemetry?: AgentTelemetryConfig;
 	/** Skills to autoload via sendCustomMessage before the first prompt */
 	autoloadSkills?: Skill[];
+	/**
+	 * Registry id of the spawning agent, recorded as this subagent's parent.
+	 * Forwarded verbatim to the SDK; the executor never derives it (the spawner
+	 * passes its own `getAgentId()`).
+	 */
+	parentAgentId?: string;
 }
 
 function parseStringifiedJson(value: unknown): unknown {
@@ -1222,6 +1301,16 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 					popLoopPhase();
 				}
 			}
+			if (event.type === "retry_fallback_applied") {
+				progress.resolvedModel = event.to;
+				scheduleProgress(true);
+				return;
+			}
+			if (event.type === "retry_fallback_succeeded") {
+				progress.resolvedModel = event.model;
+				scheduleProgress(true);
+				return;
+			}
 		});
 
 	const captureSalvage = (session: AgentSession): void => {
@@ -1817,13 +1906,26 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					resolvedModel: model.id,
 				});
 			}
+			const retryFallbackRole = installSubagentRetryFallbackChain({
+				settings: subagentSettings,
+				id,
+				candidates: resolveSubagentRetryFallbackCandidates(modelPatterns, modelRegistry, settings),
+				model,
+				authFallbackUsed,
+			});
+			if (retryFallbackRole) {
+				logger.debug("Configured subagent runtime model fallback chain", {
+					role: retryFallbackRole,
+					requested: modelPatterns,
+				});
+			}
 			if (model?.contextWindow && model.contextWindow > 0) {
 				progress.contextWindow = model.contextWindow;
 			}
 			if (model) {
 				progress.resolvedModel = explicitThinkingLevel
-					? `${model.provider}/${model.id}:${resolvedThinkingLevel}`
-					: `${model.provider}/${model.id}`;
+					? formatModelSelectorValue(formatModelStringWithRouting(model), resolvedThinkingLevel)
+					: formatModelStringWithRouting(model);
 			}
 			const effectiveThinkingLevel = explicitThinkingLevel
 				? resolvedThinkingLevel
@@ -1831,7 +1933,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const effectiveCwd = worktree ?? cwd;
 			const sessionManager = sessionFile
-				? await awaitAbortable(SessionManager.open(sessionFile, undefined, undefined, { initialCwd: effectiveCwd }))
+				? await awaitAbortable(
+						SessionManager.open(sessionFile, undefined, undefined, {
+							initialCwd: effectiveCwd,
+							suppressBreadcrumb: true,
+						}),
+					)
 				: SessionManager.inMemory(effectiveCwd);
 			if (options.parentArtifactManager) {
 				sessionManager.adoptArtifactManager(options.parentArtifactManager);
@@ -1920,6 +2027,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				parentHindsightSessionState: options.parentHindsightSessionState,
 				parentMnemopiSessionState: options.parentMnemopiSessionState,
 				parentTaskPrefix: id,
+				parentAgentId: options.parentAgentId,
 				agentId: id,
 				agentDisplayName: subagentDisplayName,
 				enableLsp: lspEnabled,
@@ -1952,7 +2060,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				// (createAgentSession → agent.replaceMessages). Isolated runs are not
 				// resumable (worktree is merged + cleaned) and never get a reviver.
 				reviveSession = async () => {
-					const reopened = await SessionManager.open(sessionFile);
+					const reopened = await SessionManager.open(sessionFile, undefined, undefined, {
+						suppressBreadcrumb: true,
+					});
 					if (options.parentArtifactManager) {
 						reopened.adoptArtifactManager(options.parentArtifactManager);
 					}
@@ -1988,6 +2098,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				systemPrompt: session.agent.state.systemPrompt.join("\n\n"),
 				task,
 				tools: session.getActiveToolNames(),
+				spawns: spawnsEnv,
+				readSummarize: agent.readSummarize,
 				outputSchema,
 			});
 

package/src/task/index.ts

@@ -46,7 +46,7 @@ import "../tools/review";
 import type { AsyncJobManager } from "../async";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { loadOverallPlanReference } from "../plan-mode/plan-handoff";
-import { AgentRegistry } from "../registry/agent-registry";
+import { AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
 import { generateCommitMessage } from "../utils/commit-message-generator";
 import * as git from "../utils/git";
 import { type DiscoveryResult, discoverAgents, getAgent } from "./discovery";
@@ -156,7 +156,6 @@ export const READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
 	"reflect",
 	"retain",
 	"memory_edit",
-	"render_mermaid",
 	"inspect_image",
 	"checkpoint",
 	"rewind",
@@ -1301,6 +1300,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				parentMnemopiSessionState: this.session.getMnemopiSessionState?.(),
 				parentTelemetry: this.session.getTelemetry?.(),
 				parentEvalSessionId,
+				parentAgentId: this.session.getAgentId?.() ?? MAIN_AGENT_ID,
 			};
 
 			const runTask = async (): Promise<SingleResult> => {

package/src/task/persisted-revive.ts

@@ -0,0 +1,128 @@
+import * as fs from "node:fs/promises";
+
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import { MCPManager } from "../mcp/manager";
+import type { PersistedSubagentReviverFactory } from "../registry/agent-lifecycle";
+import { AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
+import { createAgentSession } from "../sdk";
+import type { AgentSession } from "../session/agent-session";
+import type { AuthStorage } from "../session/auth-storage";
+import { SessionManager } from "../session/session-manager";
+import { createMCPProxyTools, createSubagentSettings } from "./executor";
+
+/**
+ * Ambient context the reviver needs at revive time. The top-level session is
+ * kept LIVE (cwd / artifact manager read on demand) so a later `/new` or cwd
+ * move is followed rather than snapshotted; auth/models/settings are
+ * process-stable and captured by reference.
+ */
+export interface PersistedSubagentReviveContext {
+	session: AgentSession;
+	authStorage: AuthStorage;
+	modelRegistry: ModelRegistry;
+	settings: Settings;
+	/** LSP policy of the top-level session; revived subagents inherit it rather than defaulting on. */
+	enableLsp: boolean;
+}
+
+/**
+ * Build the factory the {@link AgentLifecycleManager} uses to cold-revive a
+ * `parked` subagent ref restored from disk (Agent Hub scan, collab mirror, or a
+ * resumed process). Such a ref carries a sessionFile but no in-memory adoption —
+ * the executor's live reviver closure died with the process/turn that spawned
+ * it — so `ensureLive` (IRC sends, hub focus) would otherwise refuse it.
+ *
+ * This rebuilds the subagent the same way `--resume` rebuilds a session: reopen
+ * the JSONL and replay it through {@link createAgentSession}. The catch is that
+ * resume restores only conversation/model from the file — the runtime contract
+ * (tools / system prompt / output schema / kind) is built from options, so a
+ * bare reopen would resurrect a wrong (top-level) session. We source that
+ * contract from the persisted `session_init` entry instead, and mirror the
+ * executor's subagent wiring (MCP proxy tools, depth-derived gating,
+ * yield-required, active-tool clamp, registry status sync).
+ */
+export function createPersistedSubagentReviverFactory(
+	ctx: PersistedSubagentReviveContext,
+): PersistedSubagentReviverFactory {
+	const registry = AgentRegistry.global();
+	return async ref => {
+		const sessionFile = ref.sessionFile;
+		if (!sessionFile) return undefined;
+		const peek = await SessionManager.peekSessionInit(sessionFile);
+		// No persisted contract (pre-session_init file) or the recorded workspace
+		// is gone (isolated/merged worktree, moved dir): leave it transcript-only
+		// (history://) rather than resurrect a wrong or broken session.
+		if (!peek?.init) return undefined;
+		try {
+			await fs.stat(peek.cwd);
+		} catch {
+			return undefined;
+		}
+		const init = peek.init;
+		// taskDepth drives real capability gating (task-spawn allowance, memory
+		// startup, …); derive it from the persisted parent chain rather than
+		// assuming a fixed level.
+		let taskDepth = 1;
+		let parentId = ref.parentId;
+		const seen = new Set<string>();
+		while (parentId && parentId !== MAIN_AGENT_ID && !seen.has(parentId)) {
+			seen.add(parentId);
+			taskDepth++;
+			parentId = registry.get(parentId)?.parentId;
+		}
+		return async () => {
+			// Re-open fresh on every revive: park closes the writer, so this takes
+			// the single-writer lock cleanly and restores the full message history.
+			const reopened = await SessionManager.open(sessionFile, undefined, undefined, {
+				suppressBreadcrumb: true,
+			});
+			const artifactManager = ctx.session.sessionManager.getArtifactManager();
+			if (artifactManager) reopened.adoptArtifactManager(artifactManager);
+			// Reuse the parent's live MCP connections via proxy tools (no
+			// re-discovery), exactly as the executor does for live subagents.
+			const mcpManager = MCPManager.instance();
+			const mcpProxyTools = mcpManager ? createMCPProxyTools(mcpManager) : [];
+			const { session } = await createAgentSession({
+				cwd: ctx.session.sessionManager.getCwd(),
+				authStorage: ctx.authStorage,
+				modelRegistry: ctx.modelRegistry,
+				settings: createSubagentSettings(
+					ctx.settings,
+					init.readSummarize === false ? { "read.summarize.enabled": false } : undefined,
+				),
+				sessionManager: reopened,
+				agentId: ref.id,
+				agentDisplayName: ref.displayName,
+				parentTaskPrefix: ref.id,
+				parentAgentId: ref.parentId,
+				taskDepth,
+				toolNames: init.tools,
+				outputSchema: init.outputSchema,
+				requireYieldTool: true,
+				systemPrompt: () => [init.systemPrompt],
+				// Old files predate persisted spawns: deny re-spawning rather than let
+				// createAgentSession default to wildcard ("*").
+				spawns: init.spawns ?? "",
+				hasUI: false,
+				enableLsp: ctx.enableLsp,
+				enableMCP: !mcpManager,
+				mcpManager,
+				customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+			});
+			// Clamp the active set to the persisted list: createAgentSession's
+			// `alwaysInclude` can re-add non-defaultInactive extension/custom tools
+			// the original run didn't carry. Unknown/missing names are ignored.
+			await session.setActiveToolsByName(init.tools);
+			// Cold revives must drive registry status themselves — createAgentSession
+			// doesn't wire this generically (the live path does it in the executor).
+			// Without it the idle-TTL timer never clears on a turn and the lifecycle
+			// could park the agent mid-run.
+			session.subscribe(event => {
+				if (event.type === "agent_start") registry.setStatus(ref.id, "running");
+				else if (event.type === "agent_end") registry.setStatus(ref.id, "idle");
+			});
+			return session;
+		};
+	};
+}

package/src/tiny/models.ts

@@ -10,6 +10,8 @@ export interface TinyTitleLocalModelSpec {
 	label: string;
 	description: string;
 	contextNote: string;
+	/** Model family emits hidden reasoning unless the chat template disables it. */
+	reasoning?: boolean;
 }
 
 export const TINY_TITLE_LOCAL_MODELS = [
@@ -28,6 +30,7 @@ export const TINY_TITLE_LOCAL_MODELS = [
 		label: "Qwen3 0.6B",
 		description: "Most robust local option; slower first load, about 500 MB cached.",
 		contextNote: "Use when title quality matters more than local startup cost.",
+		reasoning: true,
 	},
 	{
 		key: "gemma-270m",
@@ -122,6 +125,7 @@ export const TINY_MEMORY_LOCAL_MODELS = [
 		description:
 			"Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.",
 		contextNote: "Best single-model pick for memory from the local experiment.",
+		reasoning: true,
 	},
 	{
 		key: "gemma-3-1b",
@@ -196,6 +200,12 @@ export function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TI
 	return spec;
 }
 
+/** Return whether a memory local model may emit reasoning tokens before answers. */
+export function isTinyMemoryReasoningModelKey(key: TinyMemoryLocalModelKey): boolean {
+	const spec = getTinyMemoryModelSpec(key);
+	return "reasoning" in spec && spec.reasoning === true;
+}
+
 /** Any local model key (title or memory), used by the shared inference worker. */
 export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
 

package/src/tiny/worker.ts

@@ -31,7 +31,8 @@ const TITLE_PREFILL = "<title>";
 const TITLE_CLOSE = "</title>";
 const TITLE_MAX_NEW_TOKENS = 20;
 const STOP_DECODE_WINDOW_TOKENS = 32;
-const MEMORY_COMPLETION_MAX_NEW_TOKENS = 256;
+const MEMORY_COMPLETION_DEFAULT_MAX_NEW_TOKENS = 256;
+const COMPLETION_MAX_NEW_TOKENS = 1024;
 const TINY_TITLE_SYSTEM_PROMPT = prompt.render(tinyTitleSystemPrompt);
 const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
 const COMPILED_TRANSFORMERS_VERSION = process.env.PI_TINY_TRANSFORMERS_VERSION;
@@ -426,8 +427,8 @@ async function generateCompletion(
 ): Promise<string | null> {
 	const generator = await loadPipeline(modelKey, transport, requestId);
 	const text = buildCompletionPrompt(generator, promptText);
-	const requested = maxTokens ?? MEMORY_COMPLETION_MAX_NEW_TOKENS;
-	const maxNewTokens = Math.min(Math.max(1, requested), MEMORY_COMPLETION_MAX_NEW_TOKENS);
+	const requested = maxTokens ?? MEMORY_COMPLETION_DEFAULT_MAX_NEW_TOKENS;
+	const maxNewTokens = Math.min(Math.max(1, requested), COMPLETION_MAX_NEW_TOKENS);
 	const output = (await generator(text, {
 		max_new_tokens: maxNewTokens,
 		do_sample: false,

package/src/tools/builtin-names.ts

@@ -4,7 +4,6 @@ export const BUILTIN_TOOL_NAMES = [
 	"edit",
 	"ast_grep",
 	"ast_edit",
-	"render_mermaid",
 	"ask",
 	"debug",
 	"eval",

package/src/tools/index.ts

@@ -55,7 +55,6 @@ import { MemoryReflectTool } from "./memory-reflect";
 import { MemoryRetainTool } from "./memory-retain";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
-import { RenderMermaidTool } from "./render-mermaid";
 import { createReportToolIssueTool, isAutoQaEnabled } from "./report-tool-issue";
 import { ResolveTool } from "./resolve";
 import { reportFindingTool } from "./review";
@@ -94,7 +93,6 @@ export * from "./memory-recall";
 export * from "./memory-reflect";
 export * from "./memory-retain";
 export * from "./read";
-export * from "./render-mermaid";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
@@ -420,7 +418,6 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	edit: s => new EditTool(s),
 	ast_grep: s => new AstGrepTool(s),
 	ast_edit: s => new AstEditTool(s),
-	render_mermaid: s => new RenderMermaidTool(s),
 	ask: AskTool.createIf,
 	debug: DebugTool.createIf,
 	eval: s => new EvalTool(s),
@@ -563,7 +560,6 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "github") return session.settings.get("github.enabled");
 		if (name === "ast_grep") return session.settings.get("astGrep.enabled");
 		if (name === "ast_edit") return session.settings.get("astEdit.enabled");
-		if (name === "render_mermaid") return session.settings.get("renderMermaid.enabled");
 		if (name === "inspect_image") return session.settings.get("inspect_image.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.

package/src/tools/output-meta.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getDefault, type Settings } from "../config/settings";
 import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
@@ -616,9 +617,22 @@ async function spillLargeResultToArtifact(
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
 	if (totalBytes <= threshold) return result;
 
-	// Save full output as artifact
-	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
-	if (!artifactId) return result;
+	// Save the full output as an artifact so the elided bytes stay recoverable.
+	// In a persistent session this hits `Bun.write`, which can throw (disk full,
+	// permissions). The spill wraps arbitrary tools (built-in, MCP, extension,
+	// RPC-host); a save failure must never convert a successful call into an
+	// error, nor re-expose the full (possibly context-blowing) output. Mirror
+	// `enforceInlineByteCap`: always truncate past the threshold, and only
+	// attach the `artifact://` recovery link when the save actually succeeded.
+	let artifactId: string | undefined;
+	try {
+		artifactId = await sessionManager.saveArtifact(fullText, toolName);
+	} catch (error) {
+		logger.warn("Failed to spill large tool result to artifact", {
+			tool: toolName,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
 
 	// Truncate: middle elision when a head budget is configured, otherwise tail-only.
 	const useMiddle = headBytes > 0;

package/src/utils/lang-from-path.ts

@@ -66,6 +66,7 @@ const EXTENSION_LANG: Record<string, readonly [string, string]> = {
 	cljc: ["clojure", "clojure"],
 	cljs: ["clojure", "clojure"],
 	edn: ["clojure", "clojure"],
+	el: ["emacs-lisp", "emacs-lisp"],
 
 	// .NET
 	cs: ["csharp", "csharp"],
@@ -209,6 +210,7 @@ export function getLanguageFromPath(filePath: string): string | undefined {
 	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
 		return "dockerfile";
 	}
+	if (baseName === ".emacs") return "emacs-lisp";
 	if (baseName === "justfile") return "just";
 	if (baseName === "cmakelists.txt") return "cmake";
 
@@ -223,6 +225,9 @@ export function detectLanguageId(filePath: string): string {
 	if (baseName === "dockerfile" || baseName.startsWith("dockerfile.") || baseName === "containerfile") {
 		return "dockerfile";
 	}
+	if (baseName === ".emacs") {
+		return "emacs-lisp";
+	}
 	if (baseName === "makefile" || baseName === "gnumakefile") {
 		return "makefile";
 	}

package/src/utils/markit.ts

@@ -1,4 +1,4 @@
-import { untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Markit, StreamInfo } from "markit-ai";
 import { ToolAbortError } from "../tools/tool-errors";
 
@@ -8,6 +8,29 @@ export interface MarkitConversionResult {
 	error?: string;
 }
 
+interface MuPdfWasmModuleConfig {
+	print?: (...values: unknown[]) => void;
+	printErr?: (...values: unknown[]) => void;
+}
+
+declare global {
+	var $libmupdf_wasm_Module: MuPdfWasmModuleConfig | undefined;
+}
+
+function logMuPdfWasmOutput(stream: "stdout" | "stderr", values: unknown[]): void {
+	const message = values.length === 1 && typeof values[0] === "string" ? values[0] : values.map(String).join(" ");
+	logger.debug("mupdf wasm output", { stream, message });
+}
+
+function installMuPdfWasmLogger(): void {
+	const moduleConfig = globalThis.$libmupdf_wasm_Module ?? {};
+	moduleConfig.print = (...values) => logMuPdfWasmOutput("stdout", values);
+	moduleConfig.printErr = (...values) => logMuPdfWasmOutput("stderr", values);
+	globalThis.$libmupdf_wasm_Module = moduleConfig;
+}
+
+installMuPdfWasmLogger();
+
 let markit: () => Markit | Promise<Markit> = async () => {
 	const promise = import("markit-ai").then(({ Markit }) => {
 		const instance = new Markit();