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

package/src/mcp/client.ts

@@ -8,6 +8,7 @@ import * as url from "node:url";
 import { getProjectDir, logger, withTimeout } from "@oh-my-pi/pi-utils";
 import { describeMCPTimeout, isMCPTimeoutEnabled, resolveMCPTimeoutMs } from "./timeout";
 import { createHttpTransport } from "./transports/http";
+import { createSseTransport } from "./transports/sse";
 import { createStdioTransport } from "./transports/stdio";
 import type {
 	MCPGetPromptParams,
@@ -77,8 +78,9 @@ async function createTransport(config: MCPServerConfig): Promise<MCPTransport> {
 		case "stdio":
 			return createStdioTransport(config as MCPStdioServerConfig);
 		case "http":
+			return createHttpTransport(config as MCPHttpServerConfig);
 		case "sse":
-			return createHttpTransport(config as MCPHttpServerConfig | MCPSseServerConfig);
+			return createSseTransport(config as MCPSseServerConfig);
 		default:
 			throw new Error(`Unknown server type: ${serverType}`);
 	}

package/src/mcp/manager.ts

@@ -37,7 +37,6 @@ import type { McpConnectionStatusEvent } from "./startup-events";
 import type { MCPToolDetails } from "./tool-bridge";
 import { DeferredMCPTool, MCPTool } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
-import { HttpTransport } from "./transports/http";
 import type {
 	MCPGetPromptResult,
 	MCPPrompt,
@@ -48,6 +47,7 @@ import type {
 	MCPServerConfig,
 	MCPServerConnection,
 	MCPToolDefinition,
+	MCPTransport,
 } from "./types";
 import { MCPNotificationMethods } from "./types";
 
@@ -56,6 +56,13 @@ type ToolLoadResult = {
 	serverTools: MCPToolDefinition[];
 };
 
+interface AuthRefreshableMCPTransport extends MCPTransport {
+	onAuthError?: () => Promise<Record<string, string> | null>;
+}
+
+function isAuthRefreshableMCPTransport(transport: MCPTransport): transport is AuthRefreshableMCPTransport {
+	return "onAuthError" in transport;
+}
 type TrackedPromise<T> = {
 	promise: Promise<T>;
 	status: "pending" | "fulfilled" | "rejected";
@@ -419,12 +426,12 @@ export class MCPManager {
 						this.#connections.set(name, connection);
 					}
 
-					// Wire auth refresh for HTTP transports so 401s trigger token refresh.
+					// Wire auth refresh for HTTP-like transports so 401s trigger token refresh.
 					// Gate on a resolvable managed credential, not on the auth block:
 					// definition-only configs (url-keyed fallback) get Bearer injection
 					// too and need the same mid-session refresh hook.
 					if (
-						connection.transport instanceof HttpTransport &&
+						isAuthRefreshableMCPTransport(connection.transport) &&
 						lookupMcpOAuthCredential(this.#authStorage, config)
 					) {
 						connection.transport.onAuthError = async () => {
@@ -957,9 +964,9 @@ export class MCPManager {
 
 		this.#connections.set(name, connection);
 
-		// Wire auth refresh for HTTP transports, and reconnect for any transport.
+		// Wire auth refresh for HTTP-like transports, and reconnect for any transport.
 		// Same gate as connectServers: any resolvable managed credential.
-		if (connection.transport instanceof HttpTransport && lookupMcpOAuthCredential(this.#authStorage, config)) {
+		if (isAuthRefreshableMCPTransport(connection.transport) && lookupMcpOAuthCredential(this.#authStorage, config)) {
 			connection.transport.onAuthError = async () => {
 				const refreshed = await this.#resolveAuthConfig(config, { forceRefresh: true });
 				if (refreshed.type === "http" || refreshed.type === "sse") {

package/src/mcp/transports/index.ts

@@ -3,4 +3,5 @@
  */
 
 export * from "./http";
+export * from "./sse";
 export * from "./stdio";

package/src/mcp/transports/sse.ts

@@ -0,0 +1,377 @@
+import * as AIError from "@oh-my-pi/pi-ai/error";
+import { logger, readSseEvents, Snowflake } from "@oh-my-pi/pi-utils";
+import type {
+	JsonRpcError,
+	JsonRpcMessage,
+	JsonRpcRequest,
+	JsonRpcResponse,
+	MCPRequestOptions,
+	MCPSseServerConfig,
+	MCPTransport,
+} from "../../mcp/types";
+import { toJsonRpcError } from "../../mcp/types";
+import { createMCPTimeout, getNeverAbortSignal, resolveMCPTimeoutMs } from "../timeout";
+
+interface MCPTimeoutOperation {
+	signal?: AbortSignal;
+	clear: () => void;
+	isTimeoutAbort: (error: unknown) => boolean;
+}
+
+interface PendingLegacySseRequest {
+	resolve: (value: unknown) => void;
+	reject: (reason?: unknown) => void;
+	operation: MCPTimeoutOperation;
+	abortHandler?: () => void;
+}
+
+/** Legacy MCP HTTP+SSE transport from protocol revision 2024-11-05. */
+export class LegacySseTransport implements MCPTransport {
+	#connected = false;
+	#endpointUrl: string | null = null;
+	#sseConnection: AbortController | null = null;
+	#pending = new Map<string | number, PendingLegacySseRequest>();
+	#config: MCPSseServerConfig;
+
+	onClose?: () => void;
+	onError?: (error: Error) => void;
+	onNotification?: (method: string, params: unknown) => void;
+	onRequest?: (method: string, params: unknown) => Promise<unknown>;
+	/** Called on 401/403 to attempt token refresh. Returns updated headers or null. */
+	onAuthError?: () => Promise<Record<string, string> | null>;
+
+	constructor(config: MCPSseServerConfig) {
+		this.#config = config;
+	}
+
+	get connected(): boolean {
+		return this.#connected;
+	}
+
+	get url(): string {
+		return this.#config.url;
+	}
+
+	async connect(): Promise<void> {
+		if (this.#connected) return;
+		if (this.#sseConnection) return;
+
+		const connection = new AbortController();
+		const timeout = resolveMCPTimeoutMs(this.#config.timeout);
+		const operation = createMCPTimeout(timeout, connection.signal);
+		const endpointReady = Promise.withResolvers<void>();
+		this.#sseConnection = connection;
+
+		try {
+			const response = await fetch(this.#config.url, {
+				method: "GET",
+				headers: {
+					Accept: "text/event-stream",
+					...this.#config.headers,
+				},
+				signal: operation.signal,
+			});
+
+			if (!response.ok) {
+				const text = await response.text();
+				throw new Error(`HTTP ${response.status}: ${text}`);
+			}
+			if (!response.body) {
+				throw new Error("Legacy SSE response did not include a body");
+			}
+
+			void this.#readSSEStream(response.body, operation, endpointReady).finally(() => {
+				const wasConnected = this.#connected;
+				if (this.#sseConnection === connection) this.#sseConnection = null;
+				if (wasConnected) this.onClose?.();
+			});
+			await endpointReady.promise;
+		} catch (error) {
+			operation.clear();
+			if (this.#sseConnection === connection) this.#sseConnection = null;
+			connection.abort();
+			if (operation.isTimeoutAbort(error)) {
+				throw new Error(`Legacy SSE endpoint timeout after ${timeout}ms`);
+			}
+			throw error;
+		}
+	}
+
+	async #readSSEStream(
+		body: ReadableStream<Uint8Array>,
+		operation: MCPTimeoutOperation,
+		endpointReady: PromiseWithResolvers<void>,
+	): Promise<void> {
+		const signal = operation.signal ?? getNeverAbortSignal();
+		let endpointReceived = false;
+		try {
+			for await (const event of readSseEvents(body, signal)) {
+				if (event.event === "endpoint") {
+					if (!this.#endpointUrl) {
+						const endpointUrl = new URL(event.data, this.#config.url);
+						const configuredUrl = new URL(this.#config.url);
+						if (endpointUrl.origin !== configuredUrl.origin) {
+							throw new Error(
+								`Legacy SSE endpoint origin mismatch: expected ${configuredUrl.origin}, received ${endpointUrl.origin}`,
+							);
+						}
+						this.#endpointUrl = endpointUrl.href;
+						this.#connected = true;
+						endpointReceived = true;
+						operation.clear();
+						endpointReady.resolve();
+					}
+					continue;
+				}
+				if (event.data === "" || event.data === "[DONE]") continue;
+
+				let payload: unknown;
+				try {
+					payload = JSON.parse(event.data) as unknown;
+				} catch (error) {
+					if (error instanceof SyntaxError) {
+						throw new Error(`Legacy SSE message event contained non-JSON data: ${event.data}`);
+					}
+					throw error;
+				}
+
+				const messages = Array.isArray(payload) ? payload : [payload];
+				for (const message of messages) {
+					if (typeof message !== "object" || message === null) continue;
+					this.#dispatchMessage(message as JsonRpcMessage);
+				}
+			}
+			if (!endpointReceived) {
+				endpointReady.reject(new Error("Legacy SSE endpoint event not received"));
+			}
+		} catch (error) {
+			if (!endpointReceived) {
+				endpointReady.reject(error);
+			} else if (error instanceof Error && error.name !== "AbortError") {
+				logger.debug("Legacy SSE stream error", { url: this.#config.url, error: error.message });
+				this.onError?.(error);
+				this.#rejectPending(error);
+			}
+		} finally {
+			operation.clear();
+			if (endpointReceived) {
+				this.#rejectPending(new Error("Transport closed: legacy SSE stream closed"));
+			}
+		}
+	}
+
+	#dispatchMessage(message: JsonRpcMessage): void {
+		if ("id" in message && ("result" in message || "error" in message)) {
+			const pending = this.#pending.get(message.id);
+			if (pending) {
+				this.#pending.delete(message.id);
+				pending.operation.clear();
+				if (pending.abortHandler) pending.operation.signal?.removeEventListener("abort", pending.abortHandler);
+				const response = message as JsonRpcResponse;
+				if (response.error) {
+					pending.reject(new Error(`MCP error ${response.error.code}: ${response.error.message}`));
+				} else {
+					pending.resolve(response.result);
+				}
+				return;
+			}
+		}
+		if ("method" in message && "id" in message && message.id != null) {
+			void this.#handleServerRequest(message as JsonRpcRequest);
+			return;
+		}
+		if ("method" in message && !("id" in message)) {
+			this.onNotification?.(message.method, message.params);
+		}
+	}
+
+	async request<T = unknown>(
+		method: string,
+		params?: Record<string, unknown>,
+		options?: MCPRequestOptions,
+	): Promise<T> {
+		if (!this.#connected || !this.#endpointUrl) {
+			throw new Error("Transport not connected");
+		}
+
+		const id = Snowflake.next();
+		const body = {
+			jsonrpc: "2.0" as const,
+			id,
+			method,
+			params: params ?? {},
+		};
+		const timeout = resolveMCPTimeoutMs(this.#config.timeout);
+		const operation = createMCPTimeout(timeout, options?.signal);
+		const deferred = Promise.withResolvers<unknown>();
+		// Observe the response promise synchronously so a stream-close rejection
+		// from `#rejectPending` that lands while `request()` is still awaiting the
+		// POST round-trip is never flagged as an unhandled rejection. The real
+		// `await deferred.promise` below still receives and propagates the error.
+		void deferred.promise.catch(() => undefined);
+		const pending: PendingLegacySseRequest = {
+			resolve: deferred.resolve,
+			reject: deferred.reject,
+			operation,
+		};
+		if (operation.signal) {
+			pending.abortHandler = () => {
+				this.#pending.delete(id);
+				operation.clear();
+				deferred.reject(
+					options?.signal?.aborted && options.signal.reason instanceof Error
+						? options.signal.reason
+						: new Error(`Legacy SSE response timeout after ${timeout}ms`),
+				);
+			};
+			operation.signal.addEventListener("abort", pending.abortHandler, { once: true });
+		}
+		this.#pending.set(id, pending);
+
+		try {
+			const response = await this.#postJson(body, operation.signal);
+			if (!response.ok) {
+				const text = await response.text();
+				throw new Error(`HTTP ${response.status}: ${text}`);
+			}
+			await response.body?.cancel();
+			return (await deferred.promise) as T;
+		} catch (error) {
+			this.#pending.delete(id);
+			operation.clear();
+			if (pending.abortHandler) operation.signal?.removeEventListener("abort", pending.abortHandler);
+			if (operation.isTimeoutAbort(error)) {
+				throw new Error(`Request timeout after ${timeout}ms`);
+			}
+			throw error;
+		}
+	}
+
+	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
+		if (!this.#connected || !this.#endpointUrl) {
+			throw new Error("Transport not connected");
+		}
+
+		const timeout = resolveMCPTimeoutMs(this.#config.timeout);
+		const operation = createMCPTimeout(timeout);
+		try {
+			const response = await this.#postJson(
+				{
+					jsonrpc: "2.0" as const,
+					method,
+					params: params ?? {},
+				},
+				operation.signal,
+			);
+			operation.clear();
+			if (!response.ok) {
+				const text = await response.text();
+				throw new Error(`HTTP ${response.status}: ${text}`);
+			}
+			await response.body?.cancel();
+		} catch (error) {
+			operation.clear();
+			if (operation.isTimeoutAbort(error)) {
+				throw new Error(`Notify timeout after ${timeout}ms`);
+			}
+			throw error;
+		}
+	}
+
+	async #postJson(
+		body: JsonRpcRequest | JsonRpcResponse | { jsonrpc: "2.0"; method: string; params: Record<string, unknown> },
+		signal?: AbortSignal,
+	): Promise<Response> {
+		const endpointUrl = this.#endpointUrl;
+		if (!endpointUrl) throw new Error("Transport not connected");
+		let headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.#config.headers,
+		};
+		let response = await fetch(endpointUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal,
+		});
+		const status = AIError.status(response);
+		if (!this.onAuthError || (status !== 401 && status !== 403)) return response;
+
+		const refreshedHeaders = await this.onAuthError();
+		if (!refreshedHeaders) return response;
+		await response.body?.cancel();
+		this.#config.headers = refreshedHeaders;
+		headers = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.#config.headers,
+		};
+		response = await fetch(endpointUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal,
+		});
+		return response;
+	}
+
+	async #handleServerRequest(request: JsonRpcRequest): Promise<void> {
+		if (!this.onRequest) {
+			await this.#sendServerResponse(request.id, undefined, { code: -32601, message: "Method not found" });
+			return;
+		}
+		try {
+			const result = await this.onRequest(request.method, request.params);
+			await this.#sendServerResponse(request.id, result);
+		} catch (error) {
+			await this.#sendServerResponse(request.id, undefined, toJsonRpcError(error));
+		}
+	}
+
+	async #sendServerResponse(id: string | number, result?: unknown, error?: JsonRpcError): Promise<void> {
+		if (!this.#connected) return;
+		const timeout = resolveMCPTimeoutMs(this.#config.timeout);
+		const operation = createMCPTimeout(timeout);
+		try {
+			const response = await this.#postJson(
+				error ? { jsonrpc: "2.0" as const, id, error } : { jsonrpc: "2.0" as const, id, result: result ?? {} },
+				operation.signal,
+			);
+			operation.clear();
+			await response.body?.cancel();
+		} catch {
+			operation.clear();
+		}
+	}
+
+	#rejectPending(error: Error): void {
+		for (const [id, pending] of this.#pending) {
+			this.#pending.delete(id);
+			pending.operation.clear();
+			if (pending.abortHandler) pending.operation.signal?.removeEventListener("abort", pending.abortHandler);
+			pending.reject(error);
+		}
+	}
+
+	async close(): Promise<void> {
+		if (!this.#connected && !this.#sseConnection) return;
+		const wasConnected = this.#connected;
+		this.#connected = false;
+		this.#endpointUrl = null;
+		if (this.#sseConnection) {
+			this.#sseConnection.abort();
+			this.#sseConnection = null;
+		}
+		this.#rejectPending(new Error("Transport closed"));
+		if (wasConnected) this.onClose?.();
+		this.onClose = undefined;
+	}
+}
+
+/** Create and connect a legacy HTTP+SSE transport. */
+export async function createSseTransport(config: MCPSseServerConfig): Promise<LegacySseTransport> {
+	const transport = new LegacySseTransport(config);
+	await transport.connect();
+	return transport;
+}

package/src/memories/index.ts

@@ -147,16 +147,42 @@ export function startMemoryStartupTask(options: {
 	});
 }
 
-/**
- * Build memory usage instructions for prompt injection.
- */
-export async function buildMemoryToolDeveloperInstructions(
+interface MemoryInstructionSession {
+	sessionManager: Pick<AgentSession["sessionManager"], "getSessionFile">;
+}
+
+interface MemoryToolDeveloperInstructionsSnapshot {
+	summary: string;
+	learned: string;
+}
+
+interface CachedMemoryToolDeveloperInstructions {
+	sessionFile: string | undefined;
+	snapshot: MemoryToolDeveloperInstructionsSnapshot | undefined;
+	value: string | undefined;
+}
+
+const memoryToolDeveloperInstructionsBySession = new WeakMap<
+	MemoryInstructionSession,
+	CachedMemoryToolDeveloperInstructions
+>();
+const memoryToolDeveloperInstructionsByRoot = new Map<string, MemoryToolDeveloperInstructionsSnapshot | undefined>();
+
+function getMemoryInstructionRoot(agentDir: string, settings: Settings): string {
+	return getMemoryRoot(agentDir, settings.getCwd());
+}
+
+function getMemoryInstructionSessionFile(session: MemoryInstructionSession): string | undefined {
+	return session.sessionManager.getSessionFile() ?? undefined;
+}
+
+async function readMemoryToolDeveloperInstructionsSnapshot(
 	agentDir: string,
 	settings: Settings,
-): Promise<string | undefined> {
+): Promise<MemoryToolDeveloperInstructionsSnapshot | undefined> {
 	const cfg = loadMemoryConfig(settings);
 	if (!cfg.enabled) return undefined;
-	const memoryRoot = getMemoryRoot(agentDir, settings.getCwd());
+	const memoryRoot = getMemoryInstructionRoot(agentDir, settings);
 
 	let summary = "";
 	try {
@@ -166,9 +192,21 @@ export async function buildMemoryToolDeveloperInstructions(
 		// so any captured lessons still surface on their own.
 	}
 	const learned = await readLearnedLessons(memoryRoot);
-	if (!summary && !learned) return undefined;
+	return { summary, learned };
+}
+
+function renderMemoryToolDeveloperInstructionsSnapshot(
+	snapshot: MemoryToolDeveloperInstructionsSnapshot | undefined,
+	settings: Settings,
+): string | undefined {
+	if (!snapshot) return undefined;
+	const cfg = loadMemoryConfig(settings);
+	if (!cfg.enabled) return undefined;
+	if (!snapshot.summary && !snapshot.learned) return undefined;
 
-	const summaryOut = summary ? truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit).trim() : "";
+	const summaryOut = snapshot.summary
+		? truncateByApproxTokens(snapshot.summary, cfg.summaryInjectionTokenLimit).trim()
+		: "";
 	// Lessons share ONE injection budget with the summary so the combined block
 	// stays within `summaryInjectionTokenLimit` (~4 chars/token, matching
 	// truncateByApproxTokens). With no summary, lessons get the whole budget.
@@ -176,7 +214,8 @@ export async function buildMemoryToolDeveloperInstructions(
 	// can exceed `limit * 4` chars and drive the remainder negative — when the
 	// summary already fills the budget, lessons are simply dropped.
 	const learnedBudget = Math.max(0, cfg.summaryInjectionTokenLimit - Math.ceil(summaryOut.length / 4));
-	const learnedOut = learned && learnedBudget > 0 ? truncateByApproxTokens(learned, learnedBudget).trim() : "";
+	const learnedOut =
+		snapshot.learned && learnedBudget > 0 ? truncateByApproxTokens(snapshot.learned, learnedBudget).trim() : "";
 	if (!summaryOut && !learnedOut) return undefined;
 
 	return prompt.render(readPathTemplate, {
@@ -185,6 +224,72 @@ export async function buildMemoryToolDeveloperInstructions(
 	});
 }
 
+function cacheMemoryToolDeveloperInstructions(
+	session: MemoryInstructionSession,
+	sessionFile: string | undefined,
+	snapshot: MemoryToolDeveloperInstructionsSnapshot | undefined,
+	settings: Settings,
+): string | undefined {
+	const value = renderMemoryToolDeveloperInstructionsSnapshot(snapshot, settings);
+	memoryToolDeveloperInstructionsBySession.set(session, { sessionFile, snapshot, value });
+	return value;
+}
+
+/**
+ * Drop the per-session memory instruction snapshot after explicit memory state
+ * changes that must affect the active conversation immediately, such as
+ * `/memory clear`.
+ */
+export function clearMemoryToolDeveloperInstructionsCache(session: MemoryInstructionSession | undefined): void {
+	if (session) memoryToolDeveloperInstructionsBySession.delete(session);
+}
+
+/**
+ * Refresh the active session's consolidated-memory snapshot after startup maintenance.
+ *
+ * Startup may finish after the first prompt build and write `memory_summary.md`;
+ * the active session should see that summary. It must not reread `learned.md`,
+ * because a `learn` call racing with startup belongs to the next session's
+ * memory prompt, not the active prompt-cache prefix.
+ */
+export async function refreshMemoryToolDeveloperInstructionsCacheAfterStartup(
+	session: MemoryInstructionSession,
+	agentDir: string,
+	settings: Settings,
+): Promise<void> {
+	const sessionFile = getMemoryInstructionSessionFile(session);
+	const cached = memoryToolDeveloperInstructionsBySession.get(session);
+	const current = await readMemoryToolDeveloperInstructionsSnapshot(agentDir, settings);
+	const root = getMemoryInstructionRoot(agentDir, settings);
+	const baseline = memoryToolDeveloperInstructionsByRoot.get(root);
+	const cachedLearned = cached && cached.sessionFile === sessionFile ? cached.snapshot?.learned : undefined;
+	const learned = cachedLearned ?? baseline?.learned ?? "";
+	const snapshot = current ? { summary: current.summary, learned } : undefined;
+	cacheMemoryToolDeveloperInstructions(session, sessionFile, snapshot, settings);
+}
+
+/**
+ * Build memory usage instructions for prompt injection.
+ */
+export async function buildMemoryToolDeveloperInstructions(
+	agentDir: string,
+	settings: Settings,
+	session?: MemoryInstructionSession,
+): Promise<string | undefined> {
+	if (!session) {
+		const snapshot = await readMemoryToolDeveloperInstructionsSnapshot(agentDir, settings);
+		memoryToolDeveloperInstructionsByRoot.set(getMemoryInstructionRoot(agentDir, settings), snapshot);
+		return renderMemoryToolDeveloperInstructionsSnapshot(snapshot, settings);
+	}
+
+	const sessionFile = getMemoryInstructionSessionFile(session);
+	const cached = memoryToolDeveloperInstructionsBySession.get(session);
+	if (cached && cached.sessionFile === sessionFile) return cached.value;
+
+	const snapshot = await readMemoryToolDeveloperInstructionsSnapshot(agentDir, settings);
+	return cacheMemoryToolDeveloperInstructions(session, sessionFile, snapshot, settings);
+}
+
 /**
  * Clear all persisted memory state and generated artifacts.
  */
@@ -219,6 +324,7 @@ async function runMemoryStartup(options: {
 }): Promise<void> {
 	await runPhase1(options);
 	await runPhase2(options);
+	await refreshMemoryToolDeveloperInstructionsCacheAfterStartup(options.session, options.agentDir, options.settings);
 	await options.session.refreshBaseSystemPrompt?.();
 }
 
@@ -529,12 +635,21 @@ async function collectThreads(session: AgentSession, currentThreadId?: string):
 		let id = name.slice(0, -6);
 		try {
 			const fileText = await Bun.file(fullPath).text();
-			const firstLine = fileText.split("\n", 1)[0] ?? "";
-			const parsed = parseJsonlLenient(firstLine);
-			const header = Array.isArray(parsed) && parsed.length > 0 ? (parsed[0] as Record<string, unknown>) : undefined;
-			if (header && header.type === "session") {
-				if (typeof header.cwd === "string") cwd = header.cwd;
-				if (typeof header.id === "string") id = header.id;
+			let sawTitleSlot = false;
+			for (const rawLine of fileText.split(/\r?\n/)) {
+				const line = rawLine.trim();
+				if (!line) continue;
+				const parsed = parseJsonlLenient<Record<string, unknown>>(line);
+				const header = Array.isArray(parsed) && parsed.length > 0 ? parsed[0] : undefined;
+				if (!sawTitleSlot && header?.type === "title") {
+					sawTitleSlot = true;
+					continue;
+				}
+				if (header?.type === "session") {
+					if (typeof header.cwd === "string") cwd = header.cwd;
+					if (typeof header.id === "string") id = header.id;
+				}
+				break;
 			}
 		} catch {
 			// ignore malformed session files

package/src/memory-backend/local-backend.ts

@@ -1,6 +1,7 @@
 import {
 	buildMemoryToolDeveloperInstructions,
 	clearMemoryData,
+	clearMemoryToolDeveloperInstructionsCache,
 	enqueueMemoryConsolidation,
 	saveLearnedLesson,
 	startMemoryStartupTask,
@@ -20,10 +21,11 @@ export const localBackend: MemoryBackend = {
 	start(options) {
 		startMemoryStartupTask(options);
 	},
-	async buildDeveloperInstructions(agentDir, settings) {
-		return buildMemoryToolDeveloperInstructions(agentDir, settings);
+	async buildDeveloperInstructions(agentDir, settings, session) {
+		return buildMemoryToolDeveloperInstructions(agentDir, settings, session);
 	},
-	async clear(agentDir, cwd) {
+	async clear(agentDir, cwd, session) {
+		clearMemoryToolDeveloperInstructionsCache(session);
 		await clearMemoryData(agentDir, cwd);
 	},
 	async enqueue(agentDir, cwd) {