@oh-my-pi/pi-coding-agent 17.0.7 → 17.0.9

package/src/session/session-context.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from "bun:test";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import * as snapcompact from "@oh-my-pi/snapcompact";
-import type { CompactionSummaryMessage } from "./messages";
+import { type CompactionSummaryMessage, INTERRUPTED_THINKING_MESSAGE_TYPE } from "./messages";
 import { buildSessionContext, type StrippedToolCallsMarker } from "./session-context";
 import type { SessionEntry } from "./session-entries";
 
@@ -159,3 +160,225 @@ describe("buildSessionContext dangling toolCalls", () => {
 		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
 	});
 });
+
+const assistantUsage: AssistantMessage["usage"] = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function userEntry(id: string, parentId: string | null, content: string, messageTimestamp: number): SessionEntry {
+	return {
+		type: "message",
+		id,
+		parentId,
+		timestamp,
+		message: { role: "user", content, timestamp: messageTimestamp } as AgentMessage,
+	};
+}
+
+function assistantEntry(
+	id: string,
+	parentId: string | null,
+	stopReason: AssistantMessage["stopReason"],
+	text: string,
+	messageTimestamp: number,
+): SessionEntry {
+	return {
+		type: "message",
+		id,
+		parentId,
+		timestamp,
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			usage: assistantUsage,
+			stopReason,
+			timestamp: messageTimestamp,
+		} satisfies AssistantMessage,
+	};
+}
+
+function toolCallAssistantEntry(
+	id: string,
+	parentId: string | null,
+	stopReason: AssistantMessage["stopReason"],
+	toolCallId: string,
+	messageTimestamp: number,
+): SessionEntry {
+	return {
+		type: "message",
+		id,
+		parentId,
+		timestamp,
+		message: {
+			role: "assistant",
+			content: [{ type: "toolCall", id: toolCallId, name: "write", arguments: { path: "plan.md", content: "x" } }],
+			api: "anthropic-messages",
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+			usage: assistantUsage,
+			stopReason,
+			timestamp: messageTimestamp,
+		} satisfies AssistantMessage,
+	};
+}
+
+function syntheticToolResultEntry(
+	id: string,
+	parentId: string | null,
+	toolCallId: string,
+	messageTimestamp: number,
+): SessionEntry {
+	return {
+		type: "message",
+		id,
+		parentId,
+		timestamp,
+		message: {
+			role: "toolResult",
+			toolCallId,
+			toolName: "write",
+			content: [
+				{ type: "text", text: "Tool call was not executed because the provider stream ended with an error." },
+			],
+			details: { __synthetic: true, source: "assistant_stop_error", executed: false },
+			isError: true,
+			timestamp: messageTimestamp,
+		} as AgentMessage,
+	};
+}
+
+function hiddenContinuityEntry(id: string, parentId: string | null): SessionEntry {
+	return {
+		type: "custom_message",
+		id,
+		parentId,
+		timestamp,
+		customType: INTERRUPTED_THINKING_MESSAGE_TYPE,
+		content: "preserved interrupted thinking",
+		display: false,
+		attribution: "agent",
+	};
+}
+
+function expectUserTail(messages: AgentMessage[], content: string): void {
+	const tail = messages.at(-1);
+	expect(tail?.role).toBe("user");
+	if (tail?.role !== "user") {
+		throw new Error(`Expected user tail, received ${tail?.role ?? "none"}`);
+	}
+	expect(tail.content).toBe(content);
+}
+
+describe("buildSessionContext failed replay tails", () => {
+	it("terminates on cyclic parent links and includes each reachable message once", () => {
+		const entries = [userEntry("A", "B", "from A", 1), userEntry("B", "A", "from B", 2)];
+
+		const context = buildSessionContext(entries, "A");
+
+		expect(context.messages.map(message => (message.role === "user" ? message.content : message.role))).toEqual([
+			"from B",
+			"from A",
+		]);
+	});
+
+	it("omits a terminal aborted assistant from normal context", () => {
+		const context = buildSessionContext([
+			userEntry("user", null, "continue", 1),
+			assistantEntry("assistant", "user", "aborted", "partial unsafe replay", 2),
+		]);
+
+		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
+		expectUserTail(context.messages, "continue");
+	});
+
+	it("omits an earlier aborted assistant before a later user from normal context", () => {
+		const context = buildSessionContext([
+			userEntry("user-1", null, "first prompt", 1),
+			assistantEntry("assistant", "user-1", "aborted", "partial unsafe replay", 2),
+			userEntry("user-2", "assistant", "retry", 3),
+		]);
+
+		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
+		expectUserTail(context.messages, "retry");
+	});
+
+	it("preserves a terminal aborted assistant in transcript mode", () => {
+		const context = buildSessionContext(
+			[
+				userEntry("user", null, "continue", 1),
+				assistantEntry("assistant", "user", "aborted", "visible transcript error", 2),
+			],
+			undefined,
+			undefined,
+			{ transcript: true },
+		);
+
+		const assistant = context.messages.find(message => message.role === "assistant");
+		expect(assistant?.role).toBe("assistant");
+		if (assistant?.role !== "assistant") {
+			throw new Error(`Expected transcript assistant, received ${assistant?.role ?? "none"}`);
+		}
+		expect(assistant.stopReason).toBe("aborted");
+		expect(assistant.content).toEqual([{ type: "text", text: "visible transcript error" }]);
+	});
+
+	it("omits a terminal error assistant from normal context", () => {
+		const context = buildSessionContext([
+			userEntry("user", null, "retry with smaller input", 1),
+			assistantEntry("assistant", "user", "error", "provider rejected the request", 2),
+		]);
+
+		expect(context.messages.some(message => message.role === "assistant")).toBe(false);
+		expectUserTail(context.messages, "retry with smaller input");
+	});
+
+	it("keeps an aborted assistant when hidden interrupted-thinking continuity follows it", () => {
+		const context = buildSessionContext([
+			userEntry("user", null, "keep reasoning continuity", 1),
+			assistantEntry("assistant", "user", "aborted", "partial answer before interrupt", 2),
+			hiddenContinuityEntry("continuity", "assistant"),
+		]);
+
+		const assistant = context.messages.find(message => message.role === "assistant");
+		expect(assistant?.role).toBe("assistant");
+		if (assistant?.role !== "assistant") {
+			throw new Error(`Expected assistant before continuity, received ${assistant?.role ?? "none"}`);
+		}
+		expect(assistant.stopReason).toBe("aborted");
+		expect(context.messages.at(-1)?.role).toBe("custom");
+	});
+
+	it("drops synthetic tool results paired with a dropped failed tool-call turn", () => {
+		const context = buildSessionContext([
+			userEntry("user", null, "write the plan", 1),
+			toolCallAssistantEntry("assistant", "user", "error", "call-1", 2),
+			syntheticToolResultEntry("result", "assistant", "call-1", 3),
+		]);
+
+		expect(context.messages.map(message => message.role)).toEqual(["user"]);
+		expectUserTail(context.messages, "write the plan");
+	});
+
+	it("keeps the failed tool-call turn and its result in transcript mode", () => {
+		const context = buildSessionContext(
+			[
+				userEntry("user", null, "write the plan", 1),
+				toolCallAssistantEntry("assistant", "user", "error", "call-1", 2),
+				syntheticToolResultEntry("result", "assistant", "call-1", 3),
+			],
+			undefined,
+			undefined,
+			{ transcript: true, keepDanglingToolCalls: true },
+		);
+
+		expect(context.messages.map(message => message.role)).toEqual(["user", "assistant", "toolResult"]);
+	});
+});

package/src/session/session-context.ts

@@ -5,6 +5,7 @@ import {
 	createBranchSummaryMessage,
 	createCompactionSummaryMessage,
 	createCustomMessage,
+	INTERRUPTED_THINKING_MESSAGE_TYPE,
 	isCustomMessageContent,
 	normalizeCustomMessagePayload,
 } from "./messages";
@@ -197,10 +198,13 @@ export function buildSessionContext(
 		};
 	}
 
-	// Walk from leaf to root, collecting path
+	// Walk from leaf to root, collecting path. Corrupt/pre-fix files can contain
+	// parent cycles; stop at the first repeat so session load is bounded.
 	const path: SessionEntry[] = [];
+	const seenPathIds = new Set<string>();
 	let current: SessionEntry | undefined = leaf;
-	while (current) {
+	while (current && !seenPathIds.has(current.id)) {
+		seenPathIds.add(current.id);
 		path.push(current);
 		current = current.parentId ? byId.get(current.parentId) : undefined;
 	}
@@ -498,6 +502,41 @@ export function buildSessionContext(
 		}
 	}
 
+	// Error/abort assistant turns are transcript events, not safe assistant
+	// turns to replay into the next provider request. Drop them even when a
+	// later user message follows through non-context entries (`session_exit`,
+	// labels, etc.); otherwise a resumed session replays a dead partial turn
+	// and can spend minutes reprocessing old context before the new prompt.
+	// Keep the interrupted-thinking continuity pair: convertToLlm strips the
+	// unsafe trailing thinking from that assistant and sends the hidden
+	// continuity note instead.
+	if (!options?.transcript) {
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const message = messages[i];
+			if (message?.role !== "assistant") continue;
+			if (message.stopReason !== "aborted" && message.stopReason !== "error") continue;
+			const next = messages[i + 1];
+			if (next?.role === "custom" && next.customType === INTERRUPTED_THINKING_MESSAGE_TYPE) continue;
+			// A failed turn that emitted tool calls persists paired synthetic
+			// tool_result placeholders after it. Dropping only the assistant would
+			// strand those results with no preceding tool_use — a shape providers
+			// reject — so remove the paired results alongside the turn.
+			const droppedToolCallIds = new Set<string>();
+			for (const block of message.content) {
+				if (block.type === "toolCall") droppedToolCallIds.add(block.id);
+			}
+			messages.splice(i, 1);
+			if (droppedToolCallIds.size > 0) {
+				for (let j = messages.length - 1; j >= i; j--) {
+					const candidate = messages[j];
+					if (candidate?.role === "toolResult" && droppedToolCallIds.has(candidate.toolCallId)) {
+						messages.splice(j, 1);
+					}
+				}
+			}
+		}
+	}
+
 	return {
 		messages,
 		cacheMissExplainedAt: options?.transcript ? cacheMissExplainedAt : undefined,

package/src/session/session-loader.ts

@@ -306,10 +306,12 @@ export async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore:
 }
 
 /**
- * Read-only message view of a session file: load entries, migrate to the
- * current version, resolve blob refs, and build the context along the
- * persisted leaf path (last entry). Does NOT create a writer or take the
- * session lock — safe to call against a file another session is writing.
+ * Read-only transcript view of a session file: load entries, migrate to the
+ * current version, resolve blob refs, and build the display transcript along
+ * the persisted leaf path (last entry). Uses transcript mode (collapsed to the
+ * latest compaction) so failed/aborted tail turns stay visible, unlike the
+ * provider-context builder which drops them. Does NOT create a writer or take
+ * the session lock — safe to call against a file another session is writing.
  */
 export async function loadSessionMessagesReadOnly(filePath: string): Promise<AgentMessage[]> {
 	const entries = await loadEntriesFromFile(filePath);
@@ -317,5 +319,8 @@ export async function loadSessionMessagesReadOnly(filePath: string): Promise<Age
 	migrateToCurrentVersion(entries);
 	await resolveBlobRefsInEntries(entries, new BlobStore(getBlobsDir()));
 	const sessionEntries = entries.filter((e): e is SessionEntry => e.type !== "session");
-	return buildSessionContext(sessionEntries).messages;
+	return buildSessionContext(sessionEntries, undefined, undefined, {
+		transcript: true,
+		collapseCompactedHistory: true,
+	}).messages;
 }

package/src/slash-commands/helpers/usage-report.ts

@@ -124,7 +124,9 @@ function renderUsageReports(
 				);
 				lines.push(`  ${renderAsciiBar(limit.amount.usedFraction)}`);
 				if (limit.window?.resetsAt && limit.window.resetsAt > nowMs) {
-					lines.push(`  resets in ${formatDuration(limit.window.resetsAt - nowMs)}`);
+					lines.push(
+						`  ${limit.window.resetLabel ?? "resets"} in ${formatDuration(limit.window.resetsAt - nowMs)}`,
+					);
 				}
 				if (limit.notes && limit.notes.length > 0)
 					lines.push(

package/src/system-prompt.ts

@@ -24,7 +24,6 @@ import projectPromptTemplate from "./prompts/system/project-prompt.md" with { ty
 import systemPromptTemplate from "./prompts/system/system-prompt.md" with { type: "text" };
 import { normalizeConcurrencyLimit } from "./task/parallel";
 import { usesCodexTaskPrompt } from "./task/prompt-policy";
-import { shortenPath } from "./tools/render-utils";
 import { type ActiveRepoContext, resolveActiveRepoContext } from "./utils/active-repo-context";
 import { formatLocalCalendarDate } from "./utils/local-date";
 import { normalizePromptPath } from "./utils/prompt-path";
@@ -710,7 +709,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 
 	const date = formatLocalCalendarDate();
 	const dateTime = date;
-	const promptCwd = shortenPath(normalizePromptPath(resolvedCwd));
+	const promptCwd = normalizePromptPath(resolvedCwd);
 	const activeRepoContextPrompt = renderActiveRepoContextPrompt(activeRepoContext);
 
 	// Build tool metadata for system prompt rendering.

package/src/task/executor.ts

@@ -30,7 +30,6 @@ import { getSessionSlashCommands } from "../extensibility/extensions/get-command
 import { buildSkillPromptMessage, type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
-import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
 import type { MnemopiSessionState } from "../mnemopi/state";
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
@@ -55,6 +54,7 @@ import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice } from "../utils/tool-choice";
 import type { WorkspaceTree } from "../workspace-tree";
 import { generateTaskLabel } from "./label";
+import { resolveAgentPrewalkDefault } from "./prewalk";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -729,46 +729,54 @@ function getUsageTokens(usage: unknown): number {
 
 /**
  * Create proxy tools that reuse the parent's MCP connections.
+ *
+ * Each proxy delegates to the current source `MCPTool`/`DeferredMCPTool` rather
+ * than rebuilding a raw `tools/call` request, so the Task/subagent path shares
+ * the source tool's authoritative outbound boundary: harness-intent (`i`)
+ * stripping, optional-placeholder pruning, local-URL resolution, reconnect
+ * retry, abort handling, and result/provider metadata. The source tool is
+ * re-resolved on every call by raw MCP server/tool metadata (not the normalized
+ * display name), so a reconnect that swaps the instance in `getTools()` is
+ * always honored. The proxy adds only the Task-specific 60s call timeout,
+ * combining its abort signal with the caller's around source execution.
  */
 export function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 	return mcpManager.getTools().map(tool => {
-		const mcpTool = tool as { mcpToolName?: string; mcpServerName?: string };
+		const serverName = tool.mcpServerName ?? "";
+		const mcpToolName = tool.mcpToolName ?? "";
 		return {
 			name: tool.name,
 			label: tool.label ?? tool.name,
 			description: tool.description ?? "",
 			parameters: tool.parameters,
-			execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
+			strict: tool.strict,
+			mcpServerName: serverName,
+			mcpToolName,
+			execute: async (toolCallId, params, onUpdate, ctx, signal) => {
 				if (signal?.aborted) {
 					throw new ToolAbortError();
 				}
-				const serverName = mcpTool.mcpServerName ?? "";
-				const mcpToolName = mcpTool.mcpToolName ?? "";
+				// Re-resolve by raw MCP metadata so a reconnect that replaced the
+				// source instance is picked up; the display name alone is not enough.
+				const source = mcpManager
+					.getTools()
+					.find(t => t.mcpServerName === serverName && t.mcpToolName === mcpToolName);
+				if (!source?.execute) {
+					return {
+						content: [{ type: "text" as const, text: `MCP error: tool ${mcpToolName} no longer available` }],
+						details: { serverName, mcpToolName, isError: true },
+					};
+				}
 				try {
 					const timeoutController = new AbortController();
 					const timeoutSignal = timeoutController.signal;
 					const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-					const result = await withAbortTimeout(
-						(async () => {
-							const connection = await untilAborted(combinedSignal, () =>
-								mcpManager.waitForConnection(serverName),
-							);
-							return callTool(connection, mcpToolName, params as Record<string, unknown>, {
-								signal: combinedSignal,
-							});
-						})(),
+					return await withAbortTimeout(
+						Promise.resolve(source.execute(toolCallId, params, onUpdate, ctx, combinedSignal)),
 						MCP_CALL_TIMEOUT_MS,
 						signal,
 						timeoutController,
 					);
-					return {
-						content: (result.content ?? []).map(item =>
-							item.type === "text"
-								? { type: "text" as const, text: item.text ?? "" }
-								: { type: "text" as const, text: JSON.stringify(item) },
-						),
-						details: { serverName, mcpToolName, isError: result.isError },
-					};
 				} catch (error) {
 					if (error instanceof ToolAbortError) {
 						throw error;
@@ -1519,9 +1527,16 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 		scheduleProgress(flushProgress);
 	};
 
-	const attach = (session: AgentSession): (() => void) =>
-		session.subscribe(event => {
+	const attach = (session: AgentSession): (() => void) => {
+		let activeModel = session.model ? formatModelStringWithRouting(session.model) : undefined;
+		return session.subscribe(event => {
 			emitSubagentEvent(event);
+			const nextModel = session.model ? formatModelStringWithRouting(session.model) : undefined;
+			if (nextModel && nextModel !== activeModel) {
+				activeModel = nextModel;
+				progress.resolvedModel = nextModel;
+				scheduleProgress(true);
+			}
 			if (event.type === "auto_retry_start") {
 				progress.retryState = {
 					attempt: event.attempt,
@@ -1563,15 +1578,18 @@ function createSubagentRunMonitor(args: RunMonitorArgs): SubagentRunMonitor {
 			}
 			if (event.type === "retry_fallback_applied") {
 				progress.resolvedModel = event.to;
+				progress.resolvedModelIsFallback = true;
 				scheduleProgress(true);
 				return;
 			}
 			if (event.type === "retry_fallback_succeeded") {
 				progress.resolvedModel = event.model;
+				progress.resolvedModelIsFallback = true;
 				scheduleProgress(true);
 				return;
 			}
 		});
+	};
 
 	const captureSalvage = (session: AgentSession): void => {
 		// Best-effort salvage: capture the last assistant text so
@@ -1973,6 +1991,7 @@ async function finalizeRunResult(args: FinalizeRunArgs): Promise<SingleResult> {
 		contextWindow: progress.contextWindow,
 		modelOverride,
 		resolvedModel: progress.resolvedModel,
+		resolvedModelIsFallback: progress.resolvedModelIsFallback,
 		error: exitCode !== 0 && stderr ? stderr : undefined,
 		aborted: wasAborted,
 		abortReason: finalAbortReason,
@@ -2451,11 +2470,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// frontmatter default; the `task.prewalk` toggle (default off) arms it.
 			// Resolution failures skip prewalk instead of failing the spawn.
 			let prewalk: Prewalk | undefined;
-			const genericTaskPrewalk =
-				agent.source === "bundled" && agent.name === "task" && settings.get("task.prewalk") ? true : undefined;
 			const prewalkPattern = resolveAgentPrewalkPattern({
 				settingsOverride: settings.get("task.agentPrewalk")[agent.name],
-				agentPrewalk: agent.prewalk ?? genericTaskPrewalk,
+				agentPrewalk: resolveAgentPrewalkDefault(agent, settings.get("task.prewalk")),
 			});
 			if (prewalkPattern) {
 				const resolvedPrewalk = resolveModelOverride([prewalkPattern], modelRegistry, settings);