@oh-my-pi/pi-coding-agent 16.2.3 → 16.2.5

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/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);

package/src/prompts/system/autolearn-nudge.md

@@ -1,5 +0,0 @@
-Hidden auto-learn reminder (not a user request). If your previous turn produced anything reusable, capture it now with your learning tools — a repeatable procedure becomes a managed skill (`manage_skill`), and a durable fact, convention, or user preference is worth remembering (`learn`, when memory is enabled).
-
-Only capture what will genuinely help next time. If nothing is worth keeping, do nothing.
-
-This reminder is appended to the user's real message; answer that message normally — the capture is in addition to, not a replacement for, the work the user just asked for.