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

package/src/mcp/manager.ts

@@ -38,6 +38,7 @@ import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import type {
+	MCPAuthChallenge,
 	MCPGetPromptResult,
 	MCPPrompt,
 	MCPRequestOptions,
@@ -160,6 +161,9 @@ export interface MCPDiscoverOptions {
 	onStatus?: (event: McpConnectionStatusEvent) => void;
 }
 
+/** Handles an MCP `WWW-Authenticate` challenge and returns refreshed config. */
+export type MCPAuthHandler = (serverName: string, challenge: MCPAuthChallenge) => Promise<MCPServerConfig | undefined>;
+
 /**
  * MCP Server Manager.
  *
@@ -189,6 +193,7 @@ export class MCPManager {
 	#pendingToolLoads = new Map<string, Promise<ToolLoadResult>>();
 	#sources = new Map<string, SourceMeta>();
 	#authStorage: AuthStorage | null = null;
+	#authHandler?: MCPAuthHandler;
 	#onNotification?: (serverName: string, method: string, params: unknown) => void;
 	#onToolsChanged?: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void;
 	#onResourcesChanged?: (serverName: string, uri: string) => void;
@@ -201,7 +206,7 @@ export class MCPManager {
 	/** Preserved configs for reconnection after connection loss. */
 	#serverConfigs = new Map<string, MCPServerConfig>();
 	/**
-	 * Timestamps of recent `reconnectServer` invocations per server, used by the
+	 * Timestamps of recent reconnectServer invocations per server, used by the
 	 * crash-storm circuit breaker (see {@link RECONNECT_BURST_LIMIT}).
 	 */
 	#reconnectHistory = new Map<string, number[]>();
@@ -312,6 +317,11 @@ export class MCPManager {
 		this.#authStorage = authStorage;
 	}
 
+	/** Set the callback used to complete OAuth after a tool-level auth challenge. */
+	setAuthHandler(handler: MCPAuthHandler | undefined): void {
+		this.#authHandler = handler;
+	}
+
 	/**
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
@@ -474,7 +484,8 @@ export class MCPManager {
 				.then(async ({ connection, serverTools }) => {
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
 					this.#pendingToolLoads.delete(name);
-					const reconnect = () => this.reconnectServer(name);
+					const reconnect = (options?: { authChallenge?: MCPAuthChallenge }) =>
+						this.reconnectServer(name, options);
 					const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 					this.#replaceServerTools(name, customTools);
 					this.#onToolsChanged?.(this.#tools);
@@ -810,13 +821,15 @@ export class MCPManager {
 	 * the same server share one reconnection attempt. Returns the new
 	 * connection, or `null` if reconnection failed or the per-server crash
 	 * burst limit (see {@link RECONNECT_BURST_LIMIT}) is exceeded.
-	 *
 	 * @param options.manual - When `true`, resets the crash-burst window so a
 	 *   user-driven retry (e.g. `/mcp reconnect`) is never blocked by an
 	 *   earlier storm. Defaults to `false`; the transport `onClose` callback
 	 *   and the per-tool-call retry path in `tool-bridge` MUST NOT set it.
 	 */
-	async reconnectServer(name: string, options?: { manual?: boolean }): Promise<MCPServerConnection | null> {
+	async reconnectServer(
+		name: string,
+		options?: { manual?: boolean; authChallenge?: MCPAuthChallenge },
+	): Promise<MCPServerConnection | null> {
 		if (options?.manual) {
 			this.#reconnectHistory.delete(name);
 		}
@@ -828,7 +841,7 @@ export class MCPManager {
 			return null;
 		}
 
-		const attempt = this.#doReconnect(name);
+		const attempt = this.#doReconnect(name, options?.authChallenge);
 		this.#pendingReconnections.set(name, attempt);
 		return attempt.finally(() => this.#pendingReconnections.delete(name));
 	}
@@ -873,12 +886,30 @@ export class MCPManager {
 		return false;
 	}
 
-	async #doReconnect(name: string): Promise<MCPServerConnection | null> {
+	async #doReconnect(name: string, authChallenge?: MCPAuthChallenge): Promise<MCPServerConnection | null> {
 		const oldConnection = this.#connections.get(name);
-		const config = oldConnection?.config ?? this.#serverConfigs.get(name);
+		let config = oldConnection?.config ?? this.#serverConfigs.get(name);
 		const source = this.#sources.get(name) ?? oldConnection?._source;
 		if (!config) return null;
 
+		if (authChallenge) {
+			if (!this.#authHandler) {
+				logger.error("MCP auth challenge cannot be handled; no auth handler is configured", {
+					path: `mcp:${name}`,
+				});
+				return null;
+			}
+			try {
+				const refreshedConfig = await this.#authHandler(name, authChallenge);
+				if (!refreshedConfig) return null;
+				config = refreshedConfig;
+				this.#serverConfigs.set(name, config);
+			} catch (error) {
+				logger.error("MCP auth challenge handling failed", { path: `mcp:${name}`, error });
+				return null;
+			}
+		}
+
 		logger.debug("MCP reconnecting", { path: `mcp:${name}` });
 
 		// Close the old transport without removing tools or notifying consumers.
@@ -987,7 +1018,7 @@ export class MCPManager {
 		};
 		try {
 			const serverTools = await listTools(connection);
-			const reconnect = () => this.reconnectServer(name);
+			const reconnect = (options?: { authChallenge?: MCPAuthChallenge }) => this.reconnectServer(name, options);
 			const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 			void this.toolCache?.set(name, config, serverTools);
 			this.#replaceServerTools(name, customTools);

package/src/mcp/render.ts

@@ -4,9 +4,10 @@
  * Provides structured display of MCP tool calls and results,
  * showing args and output in JSON tree format similar to task tool.
  */
-import type { Component } from "@oh-my-pi/pi-tui";
+import { type Component, Markdown } from "@oh-my-pi/pi-tui";
+import { settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
+import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import {
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
@@ -48,6 +49,61 @@ export function renderMCPCall(args: Record<string, unknown>, theme: Theme, label
 	);
 }
 
+/** Render an MCP status/args prefix followed by Markdown-aware text output. */
+function renderMarkdownMCPResult(
+	result: { details?: MCPToolDetails; isError?: boolean },
+	trimmedOutput: string,
+	truncationWarning: string | null,
+	options: RenderResultOptions,
+	theme: Theme,
+	args?: Record<string, unknown>,
+): Component {
+	const markdown = new Markdown(trimmedOutput, 0, 0, getMarkdownTheme(), {
+		color: text => theme.fg("toolOutput", text),
+	});
+	return {
+		render(contentWidth: number): readonly string[] {
+			const lines: string[] = [];
+			const isError = result.isError ?? result.details?.isError ?? false;
+			const title = result.details ? `${result.details.serverName}/${result.details.mcpToolName}` : "MCP";
+			lines.push(
+				renderStatusLine(
+					isError ? { icon: "error", title } : { iconOverride: theme.styledSymbol("tool.mcp", "accent"), title },
+					theme,
+				),
+			);
+
+			if (options.expanded && args && Object.keys(args).length > 0) {
+				lines.push(theme.fg("dim", "Args"));
+				const tree = renderJsonTreeLines(
+					args,
+					theme,
+					JSON_TREE_MAX_DEPTH_EXPANDED,
+					JSON_TREE_MAX_LINES_EXPANDED,
+					JSON_TREE_SCALAR_LEN_EXPANDED,
+				);
+				lines.push(...tree.lines);
+				if (tree.truncated) lines.push(theme.fg("dim", "…"));
+				lines.push("");
+			}
+
+			const rendered = markdown.render(Math.max(1, contentWidth));
+			const maxOutputLines = options.expanded ? 12 : 4;
+			lines.push(...rendered.slice(0, maxOutputLines));
+			if (rendered.length > maxOutputLines) {
+				lines.push(
+					`${theme.fg("dim", `… ${rendered.length - maxOutputLines} more lines`)} ${formatExpandHint(theme, options.expanded, true)}`,
+				);
+			} else if (!options.expanded) {
+				lines.push(formatExpandHint(theme, options.expanded, true));
+			}
+			if (truncationWarning) lines.push(truncationWarning);
+			return lines;
+		},
+		invalidate(): void {},
+	};
+}
+
 /**
  * Render MCP tool result.
  */
@@ -58,6 +114,24 @@ export function renderMCPResult(
 	args?: Record<string, unknown>,
 ): Component {
 	const { expanded } = options;
+	const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+	const trimmedOutput = stripOutputNotice(textContent, result.details?.meta).trimEnd();
+	const truncationWarning = result.details?.meta?.truncation
+		? formatStyledTruncationWarning(result.details.meta, theme)
+		: null;
+	let parsedOutput: unknown;
+	let isJsonOutput = false;
+	if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
+		try {
+			parsedOutput = JSON.parse(trimmedOutput);
+			isJsonOutput = true;
+		} catch {
+			// Non-JSON text beginning with a bracket is still eligible for Markdown.
+		}
+	}
+	if (trimmedOutput && settings.get("mcp.renderMarkdownResults") && !isJsonOutput) {
+		return renderMarkdownMCPResult(result, trimmedOutput, truncationWarning, options, theme, args);
+	}
 	return new WidthAwareText(
 		contentWidth => {
 			const lines: string[] = [];
@@ -86,46 +160,31 @@ export function renderMCPResult(
 				lines.push(""); // Blank line before output
 			}
 
-			// Output section
-			const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-			// Strip the LLM-facing spill notice before parsing/rendering: a spilled
-			// result appends `[Showing… artifact://N]` to the body, which would break
-			// JSON detection and bury the recovery link. Surface it as a styled warning
-			// instead, mirroring the built-in read/bash/ssh/browser renderers.
-			const trimmedOutput = stripOutputNotice(textContent, result.details?.meta).trimEnd();
-			const truncationWarning = result.details?.meta?.truncation
-				? formatStyledTruncationWarning(result.details.meta, theme)
-				: null;
+			// Output section. The body and spill metadata are normalized before
+			// component selection so the opt-in Markdown path can use its own renderer.
 
 			if (!trimmedOutput) {
 				lines.push(theme.fg("dim", "(no output)"));
 				return lines.join("\n");
 			}
 
-			// Try to parse as JSON for structured display
-			if (trimmedOutput.startsWith("{") || trimmedOutput.startsWith("[")) {
-				try {
-					const parsed = JSON.parse(trimmedOutput);
-					const maxDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
-					const maxLines = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
-					const maxScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
-					const tree = renderJsonTreeLines(parsed, theme, maxDepth, maxLines, maxScalarLen);
-
-					if (tree.lines.length > 0) {
-						for (const line of tree.lines) {
-							lines.push(line);
-						}
-						// Always show expand hint when collapsed (expanded view shows longer values and deeper nesting)
-						if (!expanded) {
-							lines.push(formatExpandHint(theme, expanded, true));
-						} else if (tree.truncated) {
-							lines.push(theme.fg("dim", "…"));
-						}
-						if (truncationWarning) lines.push(truncationWarning);
-						return lines.join("\n");
+			// Preserve the existing structured JSON renderer regardless of the
+			// Markdown preference; JSON trees remain more useful than styled source.
+			if (isJsonOutput) {
+				const maxDepth = expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
+				const maxLines = expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
+				const maxScalarLen = expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
+				const tree = renderJsonTreeLines(parsedOutput, theme, maxDepth, maxLines, maxScalarLen);
+
+				if (tree.lines.length > 0) {
+					lines.push(...tree.lines);
+					if (!expanded) {
+						lines.push(formatExpandHint(theme, expanded, true));
+					} else if (tree.truncated) {
+						lines.push(theme.fg("dim", "…"));
 					}
-				} catch {
-					// Fall through to raw output
+					if (truncationWarning) lines.push(truncationWarning);
+					return lines.join("\n");
 				}
 			}
 

package/src/mcp/tool-bridge.ts

@@ -22,10 +22,17 @@ import { normalizeLocalScheme } from "../tools/path-utils";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { callTool } from "./client";
 import { renderMCPCall, renderMCPResult } from "./render";
-import type { MCPContent, MCPServerConnection, MCPToolCallParams, MCPToolCallResult, MCPToolDefinition } from "./types";
+import type {
+	MCPAuthChallenge,
+	MCPContent,
+	MCPServerConnection,
+	MCPToolCallParams,
+	MCPToolCallResult,
+	MCPToolDefinition,
+} from "./types";
 
-/** Reconnect callback: tears down stale connection, returns new one or null. */
-export type MCPReconnect = () => Promise<MCPServerConnection | null>;
+/** Reconnect callback: tears down a stale connection, optionally authorizing first. */
+export type MCPReconnect = (options?: { authChallenge?: MCPAuthChallenge }) => Promise<MCPServerConnection | null>;
 
 /**
  * Network-level and stale-session errors that warrant a reconnect + single retry.
@@ -174,6 +181,8 @@ export interface MCPToolDetails {
 	isError?: boolean;
 	/** Raw content from MCP response */
 	rawContent?: MCPContent[];
+	/** Structured metadata from the MCP response */
+	mcpMeta?: Record<string, unknown>;
 	/** Provider ID (e.g., "claude", "mcp-json") */
 	provider?: string;
 	/** Provider display name (e.g., "Claude Code", "MCP Config") */
@@ -222,6 +231,7 @@ function buildResult(
 		mcpToolName,
 		isError: result.isError,
 		rawContent: result.content,
+		mcpMeta: result._meta,
 		provider,
 		providerName,
 	};
@@ -249,6 +259,51 @@ function buildErrorResult(
 	};
 }
 
+type MCPToolCallAttempt = {
+	connection: MCPServerConnection;
+	result?: MCPToolCallResult;
+	error?: unknown;
+};
+
+function getMcpAuthChallenge(result: MCPToolCallResult): MCPAuthChallenge | undefined {
+	if (!result.isError) return undefined;
+	const values = result._meta?.["mcp/www_authenticate"];
+	if (!Array.isArray(values)) return undefined;
+	const wwwAuthenticate = values.filter((value): value is string => typeof value === "string" && value.trim() !== "");
+	return wwwAuthenticate.length > 0 ? { wwwAuthenticate } : undefined;
+}
+
+async function callToolWithAuthRetry(
+	connection: MCPServerConnection,
+	toolName: string,
+	args: MCPToolArgs,
+	reconnect: MCPReconnect | undefined,
+	signal?: AbortSignal,
+): Promise<MCPToolCallAttempt> {
+	const result = await callTool(connection, toolName, args, { signal });
+	const authChallenge = getMcpAuthChallenge(result);
+	if (!authChallenge || !reconnect) return { connection, result };
+
+	let newConnection: MCPServerConnection | null;
+	try {
+		newConnection = await reconnectWithAbort(reconnect, signal, { authChallenge });
+	} catch (error) {
+		rethrowIfAborted(error, signal);
+		return { connection, error };
+	}
+	if (!newConnection) return { connection, result };
+
+	try {
+		return {
+			connection: newConnection,
+			result: await callTool(newConnection, toolName, args, { signal }),
+		};
+	} catch (error) {
+		rethrowIfAborted(error, signal);
+		return { connection: newConnection, error };
+	}
+}
+
 /** Re-throw abort-related errors so they bypass error-result handling. */
 function rethrowIfAborted(error: unknown, signal?: AbortSignal): void {
 	if (error instanceof ToolAbortError) throw error;
@@ -256,9 +311,13 @@ function rethrowIfAborted(error: unknown, signal?: AbortSignal): void {
 	if (signal?.aborted) throw new ToolAbortError();
 }
 
-async function reconnectWithAbort(reconnect: MCPReconnect, signal?: AbortSignal): Promise<MCPServerConnection | null> {
+async function reconnectWithAbort(
+	reconnect: MCPReconnect,
+	signal?: AbortSignal,
+	options?: { authChallenge?: MCPAuthChallenge },
+): Promise<MCPServerConnection | null> {
 	try {
-		return await untilAborted(signal, reconnect);
+		return await untilAborted(signal, () => reconnect(options));
 	} catch (error) {
 		rethrowIfAborted(error, signal);
 		return null;
@@ -332,6 +391,13 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly approval = "write" as const;
 	/** Render completed MCP calls with the result header replacing the pending call header. */
 	readonly mergeCallAndResult = true;
+	/**
+	 * MCP-backed tools opt out of strict structured-output grammar. The server
+	 * owns validation, and strict mode makes OpenAI-family models over-fill
+	 * mutually exclusive optional fields (#4336/#4340). Serializers preserve an
+	 * explicit `false`; an omitted flag would leave nothing to preserve.
+	 */
+	readonly strict = false as const;
 
 	/** Create MCPTool instances for all tools from an MCP server connection */
 	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[] {
@@ -372,8 +438,27 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		const providerName = this.connection._source?.providerName;
 
 		try {
-			const result = await callTool(this.connection, this.tool.name, args, { signal });
-			return buildResult(result, this.connection.name, this.tool.name, provider, providerName);
+			const attempt = await callToolWithAuthRetry(this.connection, this.tool.name, args, this.reconnect, signal);
+			if (attempt.error !== undefined) {
+				return buildErrorResult(attempt.error, this.connection.name, this.tool.name, provider, providerName);
+			}
+			if (!attempt.result) {
+				return buildErrorResult(
+					new Error("MCP tool call returned no result"),
+					this.connection.name,
+					this.tool.name,
+					provider,
+					providerName,
+				);
+			}
+			this.connection = attempt.connection;
+			return buildResult(
+				attempt.result,
+				attempt.connection.name,
+				this.tool.name,
+				attempt.connection._source?.provider ?? provider,
+				attempt.connection._source?.providerName ?? providerName,
+			);
 		} catch (error) {
 			rethrowIfAborted(error, signal);
 			if (this.reconnect && isRetriableConnectionError(error)) {
@@ -418,6 +503,8 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly approval = "write" as const;
 	/** Render completed MCP calls with the result header replacing the pending call header. */
 	readonly mergeCallAndResult = true;
+	/** See {@link MCPTool.strict}: MCP servers own validation, so stay non-strict. */
+	readonly strict = false as const;
 
 	readonly #fallbackProvider: string | undefined;
 	readonly #fallbackProviderName: string | undefined;
@@ -474,13 +561,31 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 			const connection = await untilAborted(signal, () => this.getConnection());
 			throwIfAborted(signal);
 			try {
-				const result = await callTool(connection, this.tool.name, args, { signal });
+				const attempt = await callToolWithAuthRetry(connection, this.tool.name, args, this.reconnect, signal);
+				if (attempt.error !== undefined) {
+					return buildErrorResult(
+						attempt.error,
+						this.serverName,
+						this.tool.name,
+						attempt.connection._source?.provider ?? provider,
+						attempt.connection._source?.providerName ?? providerName,
+					);
+				}
+				if (!attempt.result) {
+					return buildErrorResult(
+						new Error("MCP tool call returned no result"),
+						this.serverName,
+						this.tool.name,
+						provider,
+						providerName,
+					);
+				}
 				return buildResult(
-					result,
+					attempt.result,
 					this.serverName,
 					this.tool.name,
-					connection._source?.provider ?? provider,
-					connection._source?.providerName ?? providerName,
+					attempt.connection._source?.provider ?? provider,
+					attempt.connection._source?.providerName ?? providerName,
 				);
 			} catch (callError) {
 				rethrowIfAborted(callError, signal);

package/src/mcp/types.ts

@@ -206,10 +206,17 @@ export interface MCPResourceContent {
 
 export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
 
+/** Structured authentication challenge returned in a tool result. */
+export interface MCPAuthChallenge {
+	/** Values from `_meta["mcp/www_authenticate"]`. */
+	readonly wwwAuthenticate: readonly string[];
+}
+
 /** tools/call response */
 export interface MCPToolCallResult {
 	content: MCPContent[];
 	isError?: boolean;
+	_meta?: Record<string, unknown>;
 }
 
 // =============================================================================

package/src/mnemopi/state.ts

@@ -158,6 +158,39 @@ export interface MnemopiScopedMemoryHit {
 
 type MnemopiRetentionMessage = { role: string; content: string };
 
+interface MnemopiRetentionCursorRow {
+	content: string;
+	sourceId: string | null;
+	retainedThroughUserTurn: number | null;
+}
+
+function countRetainedUserTurns(transcript: string): number {
+	let turns = 0;
+	for (const line of transcript.split(/\r?\n/)) {
+		if (line === "[role: user]") turns++;
+	}
+	return turns;
+}
+
+function deriveRetainedTurnCursor(rows: readonly MnemopiRetentionCursorRow[], sessionId: string): number {
+	let cursor = 0;
+	for (const row of rows) {
+		if (Number.isInteger(row.retainedThroughUserTurn) && row.retainedThroughUserTurn !== null) {
+			cursor = Math.max(cursor, row.retainedThroughUserTurn);
+			continue;
+		}
+		if (row.sourceId !== sessionId && !row.sourceId?.startsWith(`${sessionId}-`)) continue;
+		// Legacy rows carry no explicit cursor. Summing incremental rows looks
+		// right, but pre-fix resumed sessions also wrote cumulative rows under the
+		// incremental `${sessionId}-<ts>` id shape, so a sum can overshoot the real
+		// retained prefix and permanently skip unseen turns. Per-row max can only
+		// under-count, which at worst re-stores one suffix before an explicit
+		// cursor row takes over.
+		cursor = Math.max(cursor, countRetainedUserTurns(row.content));
+	}
+	return cursor;
+}
+
 function sliceUnretainedMessages(
 	messages: MnemopiRetentionMessage[],
 	lastRetainedTurn: number,
@@ -208,6 +241,7 @@ export class MnemopiSessionState {
 	hasRecalledForFirstTurn: boolean;
 	lastRecallSnippet?: string;
 	unsubscribe?: () => void;
+	#retentionCursorLoaded = false;
 
 	constructor(options: MnemopiSessionStateOptions) {
 		this.sessionId = options.sessionId;
@@ -222,11 +256,15 @@ export class MnemopiSessionState {
 	}
 
 	setSessionId(sessionId: string): void {
+		if (this.sessionId === sessionId) return;
 		this.sessionId = sessionId;
+		this.lastRetainedTurn = 0;
+		this.#retentionCursorLoaded = false;
 	}
 
 	resetConversationTracking(): void {
 		this.lastRetainedTurn = 0;
+		this.#retentionCursorLoaded = false;
 		this.hasRecalledForFirstTurn = false;
 		this.lastRecallSnippet = undefined;
 	}
@@ -445,11 +483,13 @@ export class MnemopiSessionState {
 	async maybeRetainOnAgentEnd(_messages: AgentMessage[]): Promise<void> {
 		if (!this.config.autoRetain || this.aliasOf) return;
 		const flat = extractMessages(this.session.sessionManager);
+		this.#restoreRetainedTurnCursor();
 		const userTurns = flat.filter(message => message.role === "user").length;
 		if (userTurns - this.lastRetainedTurn < this.config.retainEveryNTurns) return;
 		await this.retainMessages(
 			sliceUnretainedMessages(flat, this.lastRetainedTurn),
 			`${this.sessionId}-${Date.now()}`,
+			{ retainedThroughUserTurn: userTurns },
 		);
 		this.lastRetainedTurn = userTurns;
 	}
@@ -457,14 +497,19 @@ export class MnemopiSessionState {
 	async forceRetainCurrentSession(options: { extract?: boolean } = {}): Promise<void> {
 		if (this.aliasOf) return;
 		const flat = extractMessages(this.session.sessionManager);
-		await this.retainMessages(flat, this.sessionId, options);
-		this.lastRetainedTurn = flat.filter(message => message.role === "user").length;
+		this.#restoreRetainedTurnCursor();
+		const userTurns = flat.filter(message => message.role === "user").length;
+		await this.retainMessages(sliceUnretainedMessages(flat, this.lastRetainedTurn), this.sessionId, {
+			...options,
+			retainedThroughUserTurn: userTurns,
+		});
+		this.lastRetainedTurn = Math.max(this.lastRetainedTurn, userTurns);
 	}
 
 	async retainMessages(
 		messages: Array<{ role: string; content: string }>,
 		sourceId: string,
-		options: { extract?: boolean } = {},
+		options: { extract?: boolean; retainedThroughUserTurn?: number } = {},
 	): Promise<void> {
 		const { transcript, messageCount } = prepareRetentionTranscript(messages, true);
 		if (!transcript) return;
@@ -478,6 +523,9 @@ export class MnemopiSessionState {
 				session_id: this.sessionId,
 				source_id: sourceId,
 				message_count: messageCount,
+				...(options.retainedThroughUserTurn === undefined
+					? {}
+					: { retained_through_user_turn: options.retainedThroughUserTurn }),
 				cwd: this.session.sessionManager.getCwd(),
 			},
 			scope: "bank",
@@ -490,6 +538,25 @@ export class MnemopiSessionState {
 		});
 	}
 
+	#restoreRetainedTurnCursor(): void {
+		if (this.#retentionCursorLoaded) return;
+		this.#retentionCursorLoaded = true;
+		const rows = this.memory.beam.db
+			.prepare<MnemopiRetentionCursorRow, [string]>(`
+				SELECT
+					content,
+					json_extract(metadata_json, '$.source_id') AS sourceId,
+					CAST(json_extract(metadata_json, '$.retained_through_user_turn') AS INTEGER)
+						AS retainedThroughUserTurn
+				FROM working_memory
+				WHERE source = 'coding-agent-transcript'
+				  AND json_extract(metadata_json, '$.session_id') = ?
+				ORDER BY rowid
+			`)
+			.all(this.sessionId);
+		this.lastRetainedTurn = Math.max(this.lastRetainedTurn, deriveRetainedTurnCursor(rows, this.sessionId));
+	}
+
 	attachSessionListeners(): void {
 		this.unsubscribe?.();
 		this.unsubscribe = this.session.subscribe((event: AgentSessionEvent) => {

package/src/modes/components/agent-dashboard.ts

@@ -49,6 +49,7 @@ import agentCreationArchitectPrompt from "../../prompts/system/agent-creation-ar
 import agentCreationUserPrompt from "../../prompts/system/agent-creation-user.md" with { type: "text" };
 import { createAgentSession } from "../../sdk";
 import { discoverAgents } from "../../task/discovery";
+import { resolveAgentPrewalkDefault } from "../../task/prewalk";
 import type { AgentDefinition, AgentSource } from "../../task/types";
 import { shortenPath } from "../../tools/render-utils";
 import { getEditorTheme, theme } from "../theme/theme";
@@ -602,7 +603,7 @@ export class AgentDashboard extends Container {
 		this.#persistPrewalkOverrides();
 		const pattern = resolveAgentPrewalkPattern({
 			settingsOverride: selected.prewalkOverride,
-			agentPrewalk: selected.prewalk,
+			agentPrewalk: resolveAgentPrewalkDefault(selected, this.#settingsManager?.get("task.prewalk") ?? false),
 		});
 		const state = selected.prewalkOverride ?? "agent default";
 		this.#notice = `Prewalk for ${selected.name}: ${state}${pattern ? ` (into ${pattern})` : ""}`;
@@ -1081,7 +1082,10 @@ export class AgentDashboard extends Container {
 			const prewalkPattern = selected
 				? resolveAgentPrewalkPattern({
 						settingsOverride: selected.prewalkOverride,
-						agentPrewalk: selected.prewalk,
+						agentPrewalk: resolveAgentPrewalkDefault(
+							selected,
+							this.#settingsManager?.get("task.prewalk") ?? false,
+						),
 					})
 				: undefined;
 			const prewalkResolution = prewalkPattern ? this.#resolvePatterns([prewalkPattern]) : undefined;