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

package/src/task/executor.ts

@@ -351,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 {
@@ -1927,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);
@@ -2016,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,
@@ -2048,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);
 					}
@@ -2084,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/title-generator.ts

@@ -4,7 +4,7 @@
 import * as path from "node:path";
 
 import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@oh-my-pi/pi-ai";
-import { logger, prompt } from "@oh-my-pi/pi-utils";
+import { isTerminalHeadless, logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 
 import { resolveRoleSelection } from "../config/model-resolver";
@@ -391,7 +391,7 @@ export function formatSessionTerminalTitle(sessionName: string | undefined, cwd?
  * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.
  */
 export function setTerminalTitle(title: string): void {
-	if (!process.stdout.isTTY) return;
+	if (!process.stdout.isTTY || isTerminalHeadless()) return;
 	process.stdout.write(`\x1b]0;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
 }
 
@@ -403,7 +403,7 @@ export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: s
  * Save the current terminal title on terminals that support xterm window ops.
  */
 export function pushTerminalTitle(): void {
-	if (!process.stdout.isTTY) return;
+	if (!process.stdout.isTTY || isTerminalHeadless()) return;
 	process.stdout.write("\x1b[22;2t");
 }
 
@@ -411,6 +411,6 @@ export function pushTerminalTitle(): void {
  * Restore the previously saved terminal title on terminals that support xterm window ops.
  */
 export function popTerminalTitle(): void {
-	if (!process.stdout.isTTY) return;
+	if (!process.stdout.isTTY || isTerminalHeadless()) return;
 	process.stdout.write("\x1b[23;2t");
 }

package/dist/types/tools/render-mermaid.d.ts

@@ -1,38 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { z } from "zod/v4";
-import type { ToolSession } from "./index";
-declare const renderMermaidSchema: z.ZodObject<{
-    mermaid: z.ZodString;
-    config: z.ZodOptional<z.ZodObject<{
-        useAscii: z.ZodOptional<z.ZodBoolean>;
-        paddingX: z.ZodOptional<z.ZodNumber>;
-        paddingY: z.ZodOptional<z.ZodNumber>;
-        boxBorderPadding: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type RenderMermaidParams = z.infer<typeof renderMermaidSchema>;
-export interface RenderMermaidToolDetails {
-    artifactId?: string;
-}
-export declare class RenderMermaidTool implements AgentTool<typeof renderMermaidSchema, RenderMermaidToolDetails> {
-    private readonly session;
-    readonly name = "render_mermaid";
-    readonly approval: "read";
-    readonly label = "RenderMermaid";
-    readonly summary = "Render a Mermaid diagram to an image";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        mermaid: z.ZodString;
-        config: z.ZodOptional<z.ZodObject<{
-            useAscii: z.ZodOptional<z.ZodBoolean>;
-            paddingX: z.ZodOptional<z.ZodNumber>;
-            paddingY: z.ZodOptional<z.ZodNumber>;
-            boxBorderPadding: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    constructor(session: ToolSession);
-    execute(_toolCallId: string, params: RenderMermaidParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<RenderMermaidToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<RenderMermaidToolDetails>>;
-}
-export {};

package/src/prompts/tools/render-mermaid.md

@@ -1,9 +0,0 @@
-Convert Mermaid graph source into ASCII diagram output.
-
-Parameters:
-- `mermaid` (required): Mermaid graph text to render.
-- `config` (optional): JSON render configuration (spacing and layout options).
-
-Behavior:
-- Returns ASCII diagram text.
-- Saves full output to `artifact://<id>`.

package/src/tools/render-mermaid.ts

@@ -1,69 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { type MermaidAsciiRenderOptions, prompt, renderMermaidAscii } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
-import renderMermaidDescription from "../prompts/tools/render-mermaid.md" with { type: "text" };
-import type { ToolSession } from "./index";
-
-const renderMermaidSchema = z.object({
-	mermaid: z.string().describe("mermaid source"),
-	config: z
-		.object({
-			useAscii: z.boolean().optional(),
-			paddingX: z.number().optional(),
-			paddingY: z.number().optional(),
-			boxBorderPadding: z.number().optional(),
-		})
-		.optional(),
-});
-
-type RenderMermaidParams = z.infer<typeof renderMermaidSchema>;
-
-function sanitizeRenderConfig(config: MermaidAsciiRenderOptions | undefined): MermaidAsciiRenderOptions | undefined {
-	if (!config) return undefined;
-	return {
-		useAscii: config.useAscii,
-		boxBorderPadding:
-			config.boxBorderPadding === undefined ? undefined : Math.max(0, Math.floor(config.boxBorderPadding)),
-		paddingX: config.paddingX === undefined ? undefined : Math.max(0, Math.floor(config.paddingX)),
-		paddingY: config.paddingY === undefined ? undefined : Math.max(0, Math.floor(config.paddingY)),
-	};
-}
-export interface RenderMermaidToolDetails {
-	artifactId?: string;
-}
-
-export class RenderMermaidTool implements AgentTool<typeof renderMermaidSchema, RenderMermaidToolDetails> {
-	readonly name = "render_mermaid";
-	readonly approval = "read" as const;
-	readonly label = "RenderMermaid";
-	readonly summary = "Render a Mermaid diagram to an image";
-	readonly description: string;
-	readonly parameters = renderMermaidSchema;
-	readonly strict = true;
-	readonly loadMode = "discoverable";
-
-	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(renderMermaidDescription);
-	}
-
-	async execute(
-		_toolCallId: string,
-		params: RenderMermaidParams,
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<RenderMermaidToolDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<RenderMermaidToolDetails>> {
-		const ascii = renderMermaidAscii(params.mermaid, sanitizeRenderConfig(params.config));
-		const { path: artifactPath, id: artifactId } =
-			(await this.session.allocateOutputArtifact?.("render_mermaid")) ?? {};
-		if (artifactPath) {
-			await Bun.write(artifactPath, ascii);
-		}
-
-		const artifactLine = artifactId ? `\n\nSaved artifact: artifact://${artifactId}` : "";
-		return {
-			content: [{ type: "text", text: `${ascii}${artifactLine}` }],
-			details: { artifactId },
-		};
-	}
-}