@oh-my-pi/pi-coding-agent 16.2.4 → 16.2.6

package/src/session/session-loader.ts

@@ -1,8 +1,11 @@
+import * as fs from "node:fs";
+import * as readline from "node:readline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { getBlobsDir, isEnoent, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import { BlobStore, isBlobRef, resolveImageData, resolveImageDataUrl } from "./blob-store";
 import { buildSessionContext } from "./session-context";
 import {
+	type CompactionEntry,
 	type FileEntry,
 	type RawFileEntry,
 	SESSION_TITLE_SLOT_BYTES,
@@ -20,6 +23,10 @@ import {
 	titleUpdateFromSlot,
 } from "./session-title-slot";
 
+const STREAM_LOAD_THRESHOLD_BYTES = 8 * 1024 * 1024;
+const ELIDED_COMPACTION_SUMMARY = "[Superseded compaction summary elided during session load]";
+const ELIDED_COMPACTION_SHORT_SUMMARY = "Superseded compaction elided";
+
 function splitTitleSlot(content: string): { body: string; slot: SessionTitleUpdate | undefined } {
 	const slot = titleUpdateFromSlot(parseTitleSlotFromContent(content));
 	if (!slot) return { body: content, slot: undefined };
@@ -54,6 +61,89 @@ export function parseSessionContent(content: string): {
 	return { entries: foldTitleSlot(entries, slot), titleSlot: slot };
 }
 
+function elideCompactionSummary(entry: CompactionEntry | undefined): boolean {
+	if (!entry) return false;
+	if (
+		entry.summary === ELIDED_COMPACTION_SUMMARY &&
+		entry.shortSummary === ELIDED_COMPACTION_SHORT_SUMMARY &&
+		entry.preserveData === undefined
+	) {
+		return false;
+	}
+	entry.summary = ELIDED_COMPACTION_SUMMARY;
+	entry.shortSummary = ELIDED_COMPACTION_SHORT_SUMMARY;
+	entry.preserveData = undefined;
+	return true;
+}
+
+function collectActiveBranchIds(entries: FileEntry[]): Set<string> {
+	const byId = new Map<string, SessionEntry>();
+	for (const entry of entries) {
+		const id = (entry as SessionEntry).id;
+		if (typeof id === "string") byId.set(id, entry as SessionEntry);
+	}
+	const branchIds = new Set<string>();
+	let cursor = entries[entries.length - 1] as SessionEntry | undefined;
+	while (cursor && typeof cursor.id === "string" && !branchIds.has(cursor.id)) {
+		branchIds.add(cursor.id);
+		const parentId = cursor.parentId;
+		cursor = parentId ? byId.get(parentId) : undefined;
+	}
+	return branchIds;
+}
+
+function elideSupersededCompactionEntries(entries: FileEntry[]): void {
+	const branchIds = collectActiveBranchIds(entries);
+	let previousCompaction: CompactionEntry | undefined;
+	for (const entry of entries) {
+		if (entry.type !== "compaction") continue;
+		if (!branchIds.has(entry.id)) continue;
+		elideCompactionSummary(previousCompaction);
+		previousCompaction = entry;
+	}
+}
+
+async function loadEntriesFromFileStream(filePath: string): Promise<{
+	entries: FileEntry[];
+	titleSlot: SessionTitleUpdate | undefined;
+}> {
+	const entries: FileEntry[] = [];
+	let titleSlot: SessionTitleUpdate | undefined;
+	let sawBodyLine = false;
+	const input = fs.createReadStream(filePath, { encoding: "utf8" });
+	const lines = readline.createInterface({ input, crlfDelay: Infinity });
+
+	try {
+		for await (const rawLine of lines) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			if (!sawBodyLine) {
+				const slot = parseTitleSlotLine(line);
+				if (slot) {
+					titleSlot = titleUpdateFromSlot(slot);
+					sawBodyLine = true;
+					continue;
+				}
+				sawBodyLine = true;
+			}
+
+			let entry: FileEntry;
+			try {
+				entry = JSON.parse(line) as FileEntry;
+			} catch {
+				continue;
+			}
+			entries.push(entry);
+		}
+	} catch (err) {
+		input.destroy();
+		if (isEnoent(err)) return { entries: [], titleSlot: undefined };
+		throw err;
+	}
+
+	return { entries: foldTitleSlot(entries, titleSlot), titleSlot };
+}
+
 /** Read only the fixed-size head window to detect a physical title slot. */
 export async function readTitleSlotFromFile(
 	filePath: string,
@@ -80,14 +170,19 @@ export async function loadEntriesFromFile(
 	filePath: string,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<FileEntry[]> {
-	let content: string;
+	let loaded: { entries: FileEntry[]; titleSlot: SessionTitleUpdate | undefined };
 	try {
-		content = await storage.readText(filePath);
+		const stat = storage.statSync(filePath);
+		loaded =
+			storage instanceof FileSessionStorage && stat.size >= STREAM_LOAD_THRESHOLD_BYTES
+				? await loadEntriesFromFileStream(filePath)
+				: parseSessionContent(await storage.readText(filePath));
 	} catch (err) {
 		if (isEnoent(err)) return [];
 		throw err;
 	}
-	const { entries } = parseSessionContent(content);
+	const { entries } = loaded;
+	elideSupersededCompactionEntries(entries);
 
 	// Validate session header
 	if (entries.length === 0) return entries;

package/src/session/session-manager.ts

@@ -66,6 +66,8 @@ import {
 import { type SessionTitleUpdate, serializeTitleSlot } from "./session-title-slot";
 
 const JSONL_SUFFIX_LENGTH = ".jsonl".length;
+const SUPERSEDED_COMPACTION_SUMMARY = "[Superseded compaction summary elided after a newer compaction]";
+const SUPERSEDED_COMPACTION_SHORT_SUMMARY = "Superseded compaction elided";
 
 function mintSessionId(): string {
 	return Bun.randomUUIDv7();
@@ -502,6 +504,26 @@ export class SessionManager {
 		return this.#forceFileCreation || this.#fileIsCurrent || this.#historyContainsAssistantMessage();
 	}
 
+	#elideSupersededCompactionsOnBranch(leafId: string | null): boolean {
+		if (!leafId) return false;
+		let changed = false;
+		for (const entry of this.#index.pathTo(leafId)) {
+			if (entry.type !== "compaction") continue;
+			if (
+				entry.summary === SUPERSEDED_COMPACTION_SUMMARY &&
+				entry.shortSummary === SUPERSEDED_COMPACTION_SHORT_SUMMARY &&
+				entry.preserveData === undefined
+			) {
+				continue;
+			}
+			entry.summary = SUPERSEDED_COMPACTION_SUMMARY;
+			entry.shortSummary = SUPERSEDED_COMPACTION_SHORT_SUMMARY;
+			entry.preserveData = undefined;
+			changed = true;
+		}
+		return changed;
+	}
+
 	/**
 	 * Synchronously rewrite the whole file (header + entries) and keep no open
 	 * writer; the next append re-opens one. `writeTextSync` returns with the
@@ -1024,14 +1046,18 @@ export class SessionManager {
 	}
 
 	/**
-	 * Synchronously flush all in-memory entries to disk. Use when the process may
-	 * exit before an async flush settles (Ctrl+C in the TUI). Software-crash
-	 * durable; not atomic and not power-loss safe — a same-process crash never
-	 * lands mid-`writeFileSync`.
+	 * Synchronously makes the current append-only session durable. Avoid rewriting
+	 * an already-current file: large restored sessions can contain GiB of compacted
+	 * history, and Ctrl+C must not rebuild the whole JSONL string just to flush.
 	 */
 	flushSync(): void {
 		if (!this.#persist || !this.#sessionFile) return;
 		if (this.#diskFailure) throw this.#diskFailure;
+		if (this.#fileIsCurrent && !this.#rewriteRequired) {
+			const writerError = this.#writer?.getError();
+			if (writerError) throw writerError;
+			return;
+		}
 		this.#rewriteSynchronously();
 		if (this.#diskFailure) throw this.#diskFailure;
 	}
@@ -1305,6 +1331,7 @@ export class SessionManager {
 		fromExtension?: boolean,
 		preserveData?: Record<string, unknown>,
 	): string {
+		const elidedSupersededCompactions = this.#elideSupersededCompactionsOnBranch(this.#index.leafId());
 		const entry: CompactionEntry<T> = {
 			type: "compaction",
 			...this.#freshEntryFields(),
@@ -1317,6 +1344,9 @@ export class SessionManager {
 			preserveData,
 		};
 		this.#recordEntry(entry);
+		if (elidedSupersededCompactions) {
+			void this.#rewriteAtomically().catch(err => this.#noteDiskFailure(err));
+		}
 		return entry.id;
 	}
 

package/src/subprocess/worker-client.ts

@@ -1,5 +1,12 @@
 import * as path from "node:path";
-import { $env, isBunTestRuntime, isCompiledBinary, logger, workerHostEntry } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	isBunTestRuntime,
+	isCompiledBinary,
+	logger,
+	stripWindowsExtendedLengthPathPrefix,
+	workerHostEntry,
+} from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
 
 /**
@@ -90,13 +97,14 @@ export const SMOKE_TEST_TIMEOUT_MS = 30_000;
  * embedding).
  */
 export function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand {
-	if (isCompiledBinary()) return { cmd: [process.execPath, workerArg] };
+	const executable = stripWindowsExtendedLengthPathPrefix(process.execPath);
+	if (isCompiledBinary()) return { cmd: [executable, workerArg] };
 	const hostEntry = workerHostEntry();
 	if (hostEntry) {
-		return { cmd: [process.execPath, path.basename(hostEntry), workerArg], cwd: path.dirname(hostEntry) };
+		return { cmd: [executable, path.basename(hostEntry), workerArg], cwd: path.dirname(hostEntry) };
 	}
 	const packageRoot = path.resolve(import.meta.dir, "..", "..");
-	return { cmd: [process.execPath, "src/cli.ts", workerArg], cwd: packageRoot };
+	return { cmd: [executable, "src/cli.ts", workerArg], cwd: packageRoot };
 }
 
 /**

package/src/task/executor.ts

@@ -56,7 +56,6 @@ import { ToolAbortError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice } from "../utils/tool-choice";
 import type { WorkspaceTree } from "../workspace-tree";
-import { Semaphore } from "./parallel";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -199,51 +198,6 @@ function installSubagentRetryFallbackChain(args: {
 	return role;
 }
 
-const PROVIDER_MAX_CONCURRENCY_SETTINGS: Record<string, SettingPath> = {
-	"ollama-cloud": "providers.ollama-cloud.maxConcurrency",
-};
-
-interface ProviderSemaphoreEntry {
-	limit: number;
-	semaphore: Semaphore;
-}
-
-const providerSemaphores = new Map<string, ProviderSemaphoreEntry>();
-
-/**
- * Resolve the configured concurrency ceiling for a provider, or `undefined`
- * when the provider has no cap concept at all. A configured value `<= 0` means
- * "unlimited" and maps to `Infinity` — still a tracked ceiling, so every run
- * holds a slot and a later finite resize counts work started while unlimited.
- */
-function getProviderConcurrencyLimit(settings: Settings, provider: string): number | undefined {
-	const settingPath = PROVIDER_MAX_CONCURRENCY_SETTINGS[provider];
-	if (!settingPath) return undefined;
-	const raw = settings.get(settingPath);
-	const limit = Number.isFinite(raw) ? Math.trunc(raw) : 0;
-	return limit > 0 ? limit : Number.POSITIVE_INFINITY;
-}
-
-function getProviderSemaphore(settings: Settings, provider: string): Semaphore | undefined {
-	const limit = getProviderConcurrencyLimit(settings, provider);
-	if (limit === undefined) return undefined;
-	// Always hand out (and acquire on) the single shared limiter, even when
-	// unlimited (Infinity). Resizing it in place — rather than replacing it —
-	// keeps every in-flight slot counted, so a runtime or mixed limit change can
-	// never push concurrency past the cap (issue #3464 review feedback).
-	const existing = providerSemaphores.get(provider);
-	if (existing) {
-		if (existing.limit !== limit) {
-			existing.limit = limit;
-			existing.semaphore.resize(limit);
-		}
-		return existing.semaphore;
-	}
-	const semaphore = new Semaphore(limit);
-	providerSemaphores.set(provider, { limit, semaphore });
-	return semaphore;
-}
-
 function renderIrcPeerRoster(selfId: string): string {
 	const peers = AgentRegistry.global()
 		.list()
@@ -2028,8 +1982,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		let sessionOpenedAt: number | undefined;
 		let sessionCreatedAt: number | undefined;
 		let readyAt: number | undefined;
-		let providerSemaphore: Semaphore | undefined;
-		let providerSemaphoreAcquired = false;
 
 		try {
 			checkAbort();
@@ -2098,13 +2050,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				? resolvedThinkingLevel
 				: (thinkingLevel ?? resolvedThinkingLevel);
 			resolvedAt = performance.now();
-			if (model) {
-				providerSemaphore = getProviderSemaphore(settings, model.provider);
-				if (providerSemaphore) {
-					await providerSemaphore.acquire(abortSignal);
-					providerSemaphoreAcquired = true;
-				}
-			}
 
 			const effectiveCwd = worktree ?? cwd;
 			const sessionManager = sessionFile
@@ -2395,10 +2340,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 				if (exitCode === 0) exitCode = 1;
 			}
-			if (providerSemaphoreAcquired) {
-				providerSemaphore?.release();
-				providerSemaphoreAcquired = false;
-			}
 			sessionAbortController.abort();
 			try {
 				await untilAborted(AbortSignal.timeout(5000), () => monitor.waitForActiveSessionAbort());
@@ -2429,9 +2370,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		}
 
 		// Launch-latency breakdown (subagent invocation → first chat dispatch).
-		// Phase deltas are performance.now() spans; the semaphore brackets use the
-		// Date.now epochs captured by the spawn site (invokedAt before acquire,
-		// acquiredAt after) so queue wait and pre-run setup are reported apart.
+		// Phase deltas are performance.now() spans; the task-tool concurrency
+		// brackets use the Date.now epochs captured by the spawn site
+		// (invokedAt before acquire, acquiredAt after) so queue wait and
+		// pre-run setup are reported apart.
 		const span = (from: number | undefined, to: number | undefined): number | undefined =>
 			from !== undefined && to !== undefined ? Math.round(to - from) : undefined;
 		const queueMs =

package/src/task/provider-concurrency.ts

@@ -0,0 +1,100 @@
+/**
+ * Per-provider LLM concurrency cap, applied around each provider HTTP request.
+ *
+ * The semaphore brackets only the streaming request itself, not the whole
+ * agent lifetime: a parent subagent releases its slot the moment its LLM
+ * stream finishes producing, so children spawned during tool execution can
+ * acquire slots for their own turns. Holding the slot across the parent's
+ * full conversation deadlocks any spawn tree whose width exceeds
+ * `maxConcurrency` because the parents wait for children that wait for
+ * slots the parents are holding (issue
+ * [#3749](https://github.com/can1357/oh-my-pi/issues/3749)).
+ */
+
+import type { StreamFn } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "../config/settings";
+import type { SettingPath } from "../config/settings-schema";
+import { Semaphore } from "./parallel";
+
+const PROVIDER_MAX_CONCURRENCY_SETTINGS: Record<string, SettingPath> = {
+	"ollama-cloud": "providers.ollama-cloud.maxConcurrency",
+};
+
+interface ProviderSemaphoreEntry {
+	limit: number;
+	semaphore: Semaphore;
+}
+
+const providerSemaphores = new Map<string, ProviderSemaphoreEntry>();
+
+/**
+ * Resolve the configured concurrency ceiling for a provider, or `undefined`
+ * when the provider has no cap concept at all. A configured value `<= 0` means
+ * "unlimited" and maps to `Infinity` — still a tracked ceiling, so every run
+ * holds a slot and a later finite resize counts work started while unlimited.
+ */
+export function getProviderConcurrencyLimit(settings: Settings, provider: string): number | undefined {
+	const settingPath = PROVIDER_MAX_CONCURRENCY_SETTINGS[provider];
+	if (!settingPath) return undefined;
+	const raw = settings.get(settingPath);
+	const limit = Number.isFinite(raw) ? Math.trunc(raw) : 0;
+	return limit > 0 ? limit : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * Hand out the single shared limiter for `provider` (creating one lazily) and
+ * resize it in place when the configured limit changes. Replacing the
+ * semaphore would orphan in-flight slots on the old instance and let a
+ * runtime or mixed limit value exceed the cap (issue #3464 review feedback).
+ */
+export function getProviderSemaphore(settings: Settings, provider: string): Semaphore | undefined {
+	const limit = getProviderConcurrencyLimit(settings, provider);
+	if (limit === undefined) return undefined;
+	const existing = providerSemaphores.get(provider);
+	if (existing) {
+		if (existing.limit !== limit) {
+			existing.limit = limit;
+			existing.semaphore.resize(limit);
+		}
+		return existing.semaphore;
+	}
+	const semaphore = new Semaphore(limit);
+	providerSemaphores.set(provider, { limit, semaphore });
+	return semaphore;
+}
+
+/**
+ * Wrap a {@link StreamFn} so every LLM HTTP request acquires the provider's
+ * concurrency slot before the request goes out and releases it when the
+ * stream finishes producing (success, error, or abort). Providers without a
+ * configured cap pass straight through.
+ *
+ * The acquire bracket is intentionally narrow (one slot per LLM call), so
+ * spawn trees deeper than `maxConcurrency` no longer deadlock on themselves —
+ * see the module-level comment for the failure mode this fixes.
+ */
+export function wrapStreamFnWithProviderConcurrency(settings: Settings, base: StreamFn): StreamFn {
+	return async (model, context, options) => {
+		const semaphore = getProviderSemaphore(settings, model.provider);
+		if (!semaphore) return base(model, context, options);
+		await semaphore.acquire(options?.signal);
+		let released = false;
+		const release = () => {
+			if (released) return;
+			released = true;
+			semaphore.release();
+		};
+		try {
+			const stream = await base(model, context, options);
+			// EventStream.result() settles when the producer pushes 'done'/'error'
+			// or calls fail() — i.e. once the provider has finished producing.
+			// Releasing here keeps the slot held for the network request and
+			// nothing else.
+			stream.result().then(release, release);
+			return stream;
+		} catch (err) {
+			release();
+			throw err;
+		}
+	};
+}

package/src/task/worktree.ts

@@ -3,12 +3,16 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as natives from "@oh-my-pi/pi-natives";
-import { getWorktreeDir, hashPath, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { getWorktreeDir, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import * as git from "../utils/git";
 import * as jj from "../utils/jj";
 import { mapWithConcurrencyLimit } from "./parallel";
 
 const { IsoBackendKind } = natives;
+
+const TASK_ISOLATION_DIR_PREFIX = "t";
+const TASK_ISOLATION_DIR_DIGEST_CHARS = 9;
+const TASK_ISOLATION_MOUNT_DIR = "m";
 type IsoBackendKind = natives.IsoBackendKind;
 
 /** Baseline state for a single git repository. */
@@ -389,15 +393,20 @@ function errorMessage(err: unknown): string {
 	return err instanceof Error ? err.message : String(err);
 }
 
+function getTaskIsolationSegment(repoRoot: string, id: string): string {
+	const key = `${path.resolve(repoRoot)}\0${id}`;
+	const digest = Bun.hash(key).toString(16).padStart(16, "0").slice(-TASK_ISOLATION_DIR_DIGEST_CHARS);
+	return `${TASK_ISOLATION_DIR_PREFIX}${digest}`;
+}
+
 export async function ensureIsolation(
 	baseCwd: string,
 	id: string,
 	preferred?: IsoBackendKind,
 ): Promise<IsolationHandle> {
 	const repoRoot = await getRepoRoot(baseCwd);
-	const baseDir = getWorktreeDir(`${id}-${hashPath(repoRoot)}`);
-	const mergedDir = path.join(baseDir, "merged");
-
+	const baseDir = getWorktreeDir(getTaskIsolationSegment(repoRoot, id));
+	const mergedDir = path.join(baseDir, TASK_ISOLATION_MOUNT_DIR);
 	const resolution = natives.isoResolve(preferred ?? null);
 	const candidates = resolution.candidates.length > 0 ? resolution.candidates : [resolution.kind];
 	let fallbackReason = resolution.reason ?? null;

package/src/task/yield-assembly.ts

@@ -130,74 +130,62 @@ export function assembleYieldResult(
 	arrayLabels?: ReadonlySet<string>,
 ): AssembledYieldResult | undefined {
 	if (yieldItems.length === 0) return undefined;
+
+	// Terminal = the last non-incremental yield (untyped, or string-typed like
+	// `type: "result"`). Array-typed yields are incremental sections and never
+	// terminate on their own.
 	let terminalItem: YieldItem | undefined;
 	for (let index = yieldItems.length - 1; index >= 0; index--) {
 		const item = yieldItems[index];
-		if (!item) continue;
-		if (!isIncrementalYieldType(item.type)) {
+		if (item && !isIncrementalYieldType(item.type)) {
 			terminalItem = item;
 			break;
 		}
 	}
-	let hasTypedSections = false;
-	for (const item of yieldItems) {
-		if (getYieldLabels(item.type).length > 0) {
-			hasTypedSections = true;
-			break;
-		}
-	}
-	if (terminalItem && typeof terminalItem.type === "string" && terminalItem.data === undefined) {
-		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, getYieldLabels(terminalItem.type));
-		return {
-			data: resolved.value,
-			schemaOverridden: terminalItem.schemaOverridden === true,
-			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
-			missingData: resolved.missingData,
-		};
-	}
-	if (!hasTypedSections && terminalItem) {
-		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
-		return {
-			data: resolved.value,
-			schemaOverridden: terminalItem.schemaOverridden === true,
-			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
-			missingData: resolved.missingData,
-		};
-	}
 
+	// Sections come ONLY from incremental (array-typed) yields. A string `type`
+	// is a terminal marker, never a section label: folding its data under the
+	// label is what nested a finalize payload (`type: "result"`, `data: {…}`) one
+	// level deep and made output-schema validation report every field missing.
 	const sections: Record<string, unknown> = {};
 	const sectionCounts = new Map<string, number>();
 	let schemaOverridden = false;
 	let missingData = false;
 	let hasSections = false;
-
 	for (const item of yieldItems) {
 		if (item.status === "aborted") continue;
+		if (!isIncrementalYieldType(item.type)) continue;
 		schemaOverridden ||= item.schemaOverridden === true;
 		const labels = getYieldLabels(item.type);
-		if (labels.length === 0) continue;
 		const resolved = resolveYieldPayload(item, lastAssistantText, labels);
 		missingData ||= resolved.missingData;
-		const incremental = isIncrementalYieldType(item.type);
 		for (const label of labels) {
-			appendYieldSection(
-				sections,
-				sectionCounts,
-				label,
-				resolved.value,
-				incremental && (arrayLabels?.has(label) ?? false),
-			);
+			appendYieldSection(sections, sectionCounts, label, resolved.value, arrayLabels?.has(label) ?? false);
 			hasSections = true;
 		}
-		if (!isIncrementalYieldType(item.type)) break;
 	}
 
+	// An explicit terminal payload wins: an untyped final result or a
+	// `type: "result"` finalize that carries `data` is the complete result, used
+	// verbatim — never wrapped in a section.
+	if (terminalItem && terminalItem.data !== undefined) {
+		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
+		return {
+			data: resolved.value,
+			schemaOverridden: terminalItem.schemaOverridden === true,
+			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+			missingData: resolved.missingData,
+		};
+	}
+
+	// A data-less terminal finalize keeps accumulated sections; only when none
+	// exist does the last assistant turn become the raw result.
 	if (hasSections) {
 		return { data: sections, schemaOverridden, rawText: false, missingData };
 	}
 
 	if (!terminalItem) return undefined;
-	const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
+	const resolved = resolveYieldPayload(terminalItem, lastAssistantText, getYieldLabels(terminalItem.type));
 	return {
 		data: resolved.value,
 		schemaOverridden: terminalItem.schemaOverridden === true,

package/src/tools/path-utils.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
-import { isEnoent } from "@oh-my-pi/pi-utils";
+import { isEnoent, stripWindowsExtendedLengthPathPrefix } from "@oh-my-pi/pi-utils";
 import type { Skill } from "../extensibility/skills";
 import { InternalUrlRouter, type LocalProtocolOptions } from "../internal-urls";
 import { ToolError } from "./tool-errors";
@@ -147,7 +147,9 @@ export function expandTilde(filePath: string, home?: string): string {
 }
 
 export function expandPath(filePath: string): string {
-	const normalized = stripFileUrl(normalizeUnicodeSpaces(normalizeAtPrefix(filePath)));
+	const normalized = stripWindowsExtendedLengthPathPrefix(
+		stripFileUrl(normalizeUnicodeSpaces(normalizeAtPrefix(filePath))),
+	);
 	return expandTilde(normalized);
 }
 

package/src/tools/read.ts

@@ -178,7 +178,17 @@ interface HashlineHeaderContext {
 }
 
 function formatReadHashlineHeader(displayPath: string, tag: string): string {
-	return formatHashlineHeader(path.basename(displayPath), tag);
+	// In-workspace reads collapse to the bare filename for brevity: the edit
+	// tool's snapshot-tag recovery rebinds a bare `[name#tag]` onto the in-tree
+	// file it uniquely names. Out-of-workspace reads can't lean on that —
+	// recovery refuses to redirect a write outside the cwd/sandbox
+	// (HashlineFilesystem.allowTagPathRecovery) — so an absolute displayPath
+	// must stay directly resolvable, otherwise the basename resolves against
+	// cwd, misses, and the edit fails with "File not found" (e.g. ~/.claude/*).
+	// `shortenPath` keeps `~/.claude/...` (round-trips through resolveToCwd's ~
+	// expansion) instead of leaking the full home path into the read output.
+	const anchor = path.isAbsolute(displayPath) ? shortenPath(displayPath) : path.basename(displayPath);
+	return formatHashlineHeader(anchor, tag);
 }
 
 function recordFullHashlineContext(

package/src/utils/git.ts

@@ -1712,6 +1712,19 @@ export const repo = {
 		return primaryRootFromRepositorySync(repository);
 	},
 
+	/**
+	 * Linked-worktree metadata for `cwd`, or `null` when `cwd` is the primary
+	 * checkout (or outside a repository). `root` is the worktree's own checkout
+	 * root; `primaryRoot` is the shared main checkout that names the project.
+	 * Resolves purely via on-disk `.git`/`commondir` walking — no subprocess —
+	 * so the status line may call it on every render.
+	 */
+	linkedWorktreeSync(cwd: string): { root: string; primaryRoot: string } | null {
+		const repository = resolveRepositorySync(cwd);
+		if (!repository || !isLinkedWorktree(repository)) return null;
+		return { root: repository.repoRoot, primaryRoot: primaryRootFromRepositorySync(repository) };
+	},
+
 	/** Full GitRepository metadata (sync). */
 	resolveSync(cwd: string): GitRepository | null {
 		return resolveRepositorySync(cwd);