@oh-my-pi/pi-coding-agent 15.9.1 → 15.9.5

package/src/session/blob-store.ts

@@ -5,19 +5,90 @@ import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 
 const BLOB_PREFIX = "blob:sha256:";
 
+export interface BlobPutOptions {
+	/** Optional file extension for a sidecar hardlink/copy that OS openers can type-detect. */
+	extension?: string;
+}
+
 export interface BlobPutResult {
 	hash: string;
+	/** Canonical content-addressed path, always `<dir>/<sha256-hex>`. */
 	path: string;
+	/** Path with the requested extension when supplied, otherwise the canonical path. */
+	displayPath: string;
 	get ref(): string;
 }
 
 /**
  * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
  *
- * Files are stored at `<dir>/<sha256-hex>` with no extension. The SHA-256 hash is computed
- * over the raw binary data (not base64). Content-addressing makes writes idempotent and
- * provides automatic deduplication across sessions.
+ * Files are stored canonically at `<dir>/<sha256-hex>`. Callers may also request
+ * a typed sidecar path (`<dir>/<sha256-hex>.<ext>`) for `file://` links and OS
+ * image viewers; blob refs and reads still address the extensionless hash path.
+ * The SHA-256 hash is computed over the raw binary data (not base64).
+ * Content-addressing makes writes idempotent and provides automatic deduplication
+ * across sessions.
  */
+
+const IMAGE_EXTENSION_BY_MIME: Record<string, string> = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/jpg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/svg+xml": "svg",
+};
+
+function normalizeBlobExtension(extension: string | undefined): string | undefined {
+	if (!extension) return undefined;
+	const normalized = extension.startsWith(".") ? extension.slice(1) : extension;
+	if (normalized.length === 0 || normalized.length > 32) return undefined;
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(normalized)) return undefined;
+	return normalized.toLowerCase();
+}
+
+async function ensureDisplayPath(blobPath: string, displayPath: string, data: Buffer): Promise<void> {
+	if (displayPath === blobPath) return;
+	try {
+		await fsp.link(blobPath, displayPath);
+		return;
+	} catch (err) {
+		if (typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST") return;
+		logger.debug("Blob display hardlink failed; falling back to copy", {
+			blobPath,
+			displayPath,
+			error: err instanceof Error ? err.message : String(err),
+		});
+	}
+	await Bun.write(displayPath, data);
+}
+
+function ensureDisplayPathSync(blobPath: string, displayPath: string, data: Buffer): void {
+	if (displayPath === blobPath) return;
+	try {
+		fs.linkSync(blobPath, displayPath);
+		return;
+	} catch (err) {
+		if (typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST") return;
+		logger.debug("Blob display hardlink failed; falling back to copy", {
+			blobPath,
+			displayPath,
+			error: err instanceof Error ? err.message : String(err),
+		});
+	}
+	fs.writeFileSync(displayPath, data);
+}
+
+export function blobExtensionForImageMimeType(mimeType: string | undefined): string | undefined {
+	if (!mimeType) return undefined;
+	const lower = mimeType.toLowerCase();
+	const known = IMAGE_EXTENSION_BY_MIME[lower];
+	if (known) return known;
+	if (!lower.startsWith("image/")) return undefined;
+	const subtype = lower.slice("image/".length).split(";")[0]?.split("+")[0];
+	return normalizeBlobExtension(subtype);
+}
+
 export class BlobStore {
 	constructor(readonly dir: string) {}
 
@@ -25,18 +96,22 @@ export class BlobStore {
 	 * Write binary data to the blob store.
 	 * @returns SHA-256 hex hash of the data
 	 */
-	async put(data: Buffer): Promise<BlobPutResult> {
+	async put(data: Buffer, options?: BlobPutOptions): Promise<BlobPutResult> {
 		const hash = new Bun.SHA256().update(data).digest("hex");
 		const blobPath = path.join(this.dir, hash);
+		const extension = normalizeBlobExtension(options?.extension);
+		const displayPath = extension ? `${blobPath}.${extension}` : blobPath;
 		const result = {
 			hash,
 			path: blobPath,
+			displayPath,
 			get ref() {
 				return `${BLOB_PREFIX}${hash}`;
 			},
 		};
 
 		await Bun.write(blobPath, data);
+		await ensureDisplayPath(blobPath, displayPath, data);
 		return result;
 	}
 
@@ -45,18 +120,22 @@ export class BlobStore {
 	 * cannot afford the microtask hops of the async version (e.g. OOM-safe session writes).
 	 * Returns once the bytes are in the kernel page cache.
 	 */
-	putSync(data: Buffer): BlobPutResult {
+	putSync(data: Buffer, options?: BlobPutOptions): BlobPutResult {
 		const hash = new Bun.SHA256().update(data).digest("hex");
 		const blobPath = path.join(this.dir, hash);
+		const extension = normalizeBlobExtension(options?.extension);
+		const displayPath = extension ? `${blobPath}.${extension}` : blobPath;
 		const result = {
 			hash,
 			path: blobPath,
+			displayPath,
 			get ref() {
 				return `${BLOB_PREFIX}${hash}`;
 			},
 		};
 		fs.mkdirSync(this.dir, { recursive: true });
 		fs.writeFileSync(blobPath, data);
+		ensureDisplayPathSync(blobPath, displayPath, data);
 		return result;
 	}
 
@@ -120,17 +199,25 @@ export function externalizeImageDataUrlSync(blobStore: BlobStore, dataUrl: strin
  * Externalize an image's base64 data to the blob store, returning a blob reference.
  * If the data is already a blob reference, returns it unchanged.
  */
-export async function externalizeImageData(blobStore: BlobStore, base64Data: string): Promise<string> {
+export async function externalizeImageData(
+	blobStore: BlobStore,
+	base64Data: string,
+	mimeType?: string,
+): Promise<string> {
 	if (isBlobRef(base64Data)) return base64Data;
 	const buffer = Buffer.from(base64Data, "base64");
-	const { ref } = await blobStore.put(buffer);
+	const { ref } = await blobStore.put(buffer, {
+		extension: blobExtensionForImageMimeType(mimeType),
+	});
 	return ref;
 }
 
 /** Synchronous variant of {@link externalizeImageData}. */
-export function externalizeImageDataSync(blobStore: BlobStore, base64Data: string): string {
+export function externalizeImageDataSync(blobStore: BlobStore, base64Data: string, mimeType?: string): string {
 	if (isBlobRef(base64Data)) return base64Data;
-	return blobStore.putSync(Buffer.from(base64Data, "base64")).ref;
+	return blobStore.putSync(Buffer.from(base64Data, "base64"), {
+		extension: blobExtensionForImageMimeType(mimeType),
+	}).ref;
 }
 
 /**

package/src/session/session-manager.ts

@@ -29,6 +29,7 @@ import {
 } from "@oh-my-pi/pi-utils";
 import { ArtifactManager } from "./artifacts";
 import {
+	type BlobPutOptions,
 	type BlobPutResult,
 	BlobStore,
 	externalizeImageData,
@@ -336,6 +337,7 @@ export type ReadonlySessionManager = Pick<
 	| "getTree"
 	| "getUsageStatistics"
 	| "putBlob"
+	| "putBlobSync"
 >;
 
 function createSessionId(): string {
@@ -1219,7 +1221,7 @@ async function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?:
 				if (key === TEXT_CONTENT_KEY && isImageBlock(item)) {
 					if (!isBlobRef(item.data) && item.data.length >= BLOB_EXTERNALIZE_THRESHOLD) {
 						changed = true;
-						const blobRef = await externalizeImageData(blobStore, item.data);
+						const blobRef = await externalizeImageData(blobStore, item.data, item.mimeType);
 						return { ...item, data: blobRef };
 					}
 				}
@@ -1313,13 +1315,15 @@ function truncateForPersistenceSync(obj: unknown, blobStore: BlobStore, key?: st
 		const result: unknown[] = new Array(obj.length);
 		for (let i = 0; i < obj.length; i++) {
 			const item = obj[i];
-			if (key === TEXT_CONTENT_KEY && isImageBlock(item)) {
-				if (!isBlobRef(item.data) && item.data.length >= BLOB_EXTERNALIZE_THRESHOLD) {
-					changed = true;
-					const blobRef = externalizeImageDataSync(blobStore, item.data);
-					result[i] = { ...item, data: blobRef };
-					continue;
-				}
+			if (
+				key === TEXT_CONTENT_KEY &&
+				isImageBlock(item) &&
+				!isBlobRef(item.data) &&
+				item.data.length >= BLOB_EXTERNALIZE_THRESHOLD
+			) {
+				changed = true;
+				result[i] = { ...item, data: externalizeImageDataSync(blobStore, item.data, item.mimeType) };
+				continue;
 			}
 			const newItem = truncateForPersistenceSync(item, blobStore, key);
 			if (newItem !== item) changed = true;
@@ -1978,8 +1982,13 @@ export class SessionManager {
 	}
 
 	/** Puts a binary blob into the blob store and returns the blob reference */
-	async putBlob(data: Buffer): Promise<BlobPutResult> {
-		return this.#blobStore.put(data);
+	async putBlob(data: Buffer, options?: BlobPutOptions): Promise<BlobPutResult> {
+		return this.#blobStore.put(data, options);
+	}
+
+	/** Synchronous variant of {@link putBlob} for rebuild-only render paths. */
+	putBlobSync(data: Buffer, options?: BlobPutOptions): BlobPutResult {
+		return this.#blobStore.putSync(data, options);
 	}
 
 	captureState(): SessionManagerStateSnapshot {

package/src/system-prompt.ts

@@ -363,6 +363,8 @@ export interface BuildSystemPromptOptions {
 	workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
 	/** Whether the local memory://root summary is active. */
 	memoryRootEnabled?: boolean;
+	/** Active model identifier (e.g. "anthropic/claude-opus-4") surfaced to the agent. */
+	model?: string;
 }
 
 /** Result of building provider-facing system prompt messages. */
@@ -396,6 +398,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		secretsEnabled = false,
 		workspaceTree: providedWorkspaceTree,
 		memoryRootEnabled = false,
+		model,
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 
@@ -566,6 +569,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		date,
 		dateTime,
 		cwd: promptCwd,
+		model: model ?? "",
 		intentTracing: !!intentField,
 		intentField: intentField ?? "",
 		mcpDiscoveryMode,

package/src/task/executor.ts

@@ -531,7 +531,7 @@ function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 	});
 }
 
-function createSubagentSettings(baseSettings: Settings): Settings {
+function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>): Settings {
 	const snapshot: Partial<Record<SettingPath, unknown>> = {};
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
@@ -545,6 +545,7 @@ function createSubagentSettings(baseSettings: Settings): Settings {
 		// the parent task approval is the authorization boundary. Use yolo mode
 		// to preserve unattended subagent execution. User `tools.approval` policies still apply.
 		"tools.approvalMode": "yolo",
+		...overrides,
 	});
 }
 
@@ -619,7 +620,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const settings = options.settings ?? Settings.isolated();
-	const subagentSettings = createSubagentSettings(settings);
+	const subagentSettings = createSubagentSettings(
+		settings,
+		agent.readSummarize === false ? { "read.summarize.enabled": false } : undefined,
+	);
 	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
 	const maxRuntimeMs = Math.max(0, Math.trunc(Number(settings.get("task.maxRuntimeMs") ?? 0) || 0));
 	const parentDepth = options.taskDepth ?? 0;

package/src/task/index.ts

@@ -17,9 +17,8 @@ import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import { $env, prompt, Snowflake } from "@oh-my-pi/pi-utils";
+import { $env, logger, prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from "..";
-import { AsyncJobManager } from "../async";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import { MCPManager } from "../mcp/manager";
 import type { Theme } from "../modes/theme/theme";
@@ -343,12 +342,14 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			return this.#executeSync(_toolCallId, params, signal, onUpdate);
 		}
 
-		const manager = AsyncJobManager.instance();
+		const manager = this.session.asyncJobManager;
 		if (!manager) {
-			return {
-				content: [{ type: "text", text: "Async execution is enabled but no async job manager is available." }],
-				details: { projectAgentsDir: null, results: [], totalDurationMs: 0 },
-			};
+			// Async was requested but no manager is registered (e.g. an
+			// orphaned session whose host never wired one up). Falling back
+			// to the sync path keeps the tool usable; only background/job-poll
+			// semantics are lost.
+			logger.warn("task: async.enabled but no AsyncJobManager registered; falling back to sync execution");
+			return this.#executeSync(_toolCallId, params, signal, onUpdate);
 		}
 
 		const taskItems = params.tasks ?? [];

package/src/task/types.ts

@@ -174,6 +174,8 @@ export interface AgentDefinition {
 	output?: unknown;
 	blocking?: boolean;
 	autoloadSkills?: string[];
+	/** When `false`, the agent's `read` tool returns verbatim file content instead of structural summaries. */
+	readSummarize?: boolean;
 	source: AgentSource;
 	filePath?: string;
 }

package/src/tiny/title-client.ts

@@ -261,6 +261,11 @@ export class TinyTitleClient {
 	#pending = new Map<string, PendingRequest>();
 	#progressListeners = new Set<(event: TinyTitleProgressEvent) => void>();
 	#nextRequestId = 0;
+	#spawnWorker: () => WorkerHandle;
+
+	constructor(spawnWorker: () => WorkerHandle = spawnTinyTitleWorker) {
+		this.#spawnWorker = spawnWorker;
+	}
 
 	onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void {
 		this.#progressListeners.add(listener);
@@ -392,7 +397,7 @@ export class TinyTitleClient {
 
 	#ensureWorker(): WorkerHandle {
 		if (this.#worker) return this.#worker;
-		const worker = spawnTinyTitleWorker();
+		const worker = this.#spawnWorker();
 		this.#worker = worker;
 		this.#unsubscribeMessage = worker.onMessage(message => this.#handleMessage(message));
 		this.#unsubscribeError = worker.onError(error => this.#handleWorkerError(error));
@@ -429,6 +434,7 @@ export class TinyTitleClient {
 		this.#emitProgress({ modelKey: pending.modelKey, status: "error" });
 		if (pending.kind === "generate" || pending.kind === "complete") pending.resolve(null);
 		else pending.resolve(false);
+		void this.terminate();
 	}
 
 	#emitProgress(event: TinyTitleProgressEvent): void {

package/src/tool-discovery/mode.ts

@@ -0,0 +1,24 @@
+import type { Settings } from "../config/settings";
+import type { SettingValue } from "../config/settings-schema";
+
+export const TOOL_DISCOVERY_AUTO_THRESHOLD = 40;
+export const TOOL_DISCOVERY_SEARCH_TOOL_NAME = "search_tool_bm25";
+
+export type ToolDiscoveryModeSetting = SettingValue<"tools.discoveryMode">;
+export type EffectiveToolDiscoveryMode = Exclude<ToolDiscoveryModeSetting, "auto">;
+
+export function countToolsForAutoDiscovery(toolNames: Iterable<string>): number {
+	let count = 0;
+	for (const name of toolNames) {
+		if (name !== TOOL_DISCOVERY_SEARCH_TOOL_NAME) count++;
+	}
+	return count;
+}
+
+export function resolveEffectiveToolDiscoveryMode(settings: Settings, toolCount: number): EffectiveToolDiscoveryMode {
+	const configuredMode = settings.get("tools.discoveryMode");
+	if (configuredMode === "all" || configuredMode === "mcp-only") return configuredMode;
+	if (settings.get("mcp.discoveryMode")) return "mcp-only";
+	if (configuredMode === "auto" && toolCount > TOOL_DISCOVERY_AUTO_THRESHOLD) return "mcp-only";
+	return "off";
+}