codeden 0.6.2 → 0.6.3

package/dist/{runner-DYf8dV43.js → runner-CiaiUWOE.js}

@@ -1,5 +1,5 @@
 import { n as __require, r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DegdyBIC.js";
-import { Bn as BROWSER_RELAY_SECRET_HEADER, Er as ReasoningEffort, Hn as RuntimeResponse, Vn as ProviderCapabilities, Wn as ProjectConfigFile, a as childEnv, d as RunnerLock, er as AgentEvent, i as listDescendants, ir as UserInput, m as ServerToRunnerMessage, n as killTree$1, nr as oneLineDescription, o as CODEDEN_VERSION, rr as winningCommands, t as isAlive$1, u as RunnerEventMessage, zn as SETUP_TAIL_LIMIT } from "./tree-CF7Q8tXK.js";
+import { Ar as ReasoningEffort, Bn as BROWSER_RELAY_SECRET_HEADER, Hn as RuntimeResponse, Vn as ProviderCapabilities, Wn as ProjectConfigFile, a as childEnv, ar as winningCommands, d as RunnerLock, er as AgentEvent, i as listDescendants, ir as oneLineDescription, m as ServerToRunnerMessage, n as killTree$1, nr as mergeItemDeltas, o as CODEDEN_VERSION, or as itemDeltaText, sr as UserInput, t as isAlive$1, u as RunnerEventMessage, zn as SETUP_TAIL_LIMIT } from "./tree-31WAOm5k.js";
 import { createRequire } from "node:module";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -3612,6 +3612,8 @@ var import_websocket = /* @__PURE__ */ __toESM(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 // ../../packages/providers/src/adapter.ts
+/** `ProviderSessionError` code: the conversation doesn't hold the fork point it was asked for. */
+const FORK_POINT_MISSING = "fork_point_missing";
 /**
 * Session options ready to open (`SessionOptions.forkFrom`): with `forkFrom` and no
 * `resumeToken`, the conversation is copied first (`forkConversation`) and the session resumes
@@ -4513,6 +4515,33 @@ function parseClaudeAuthStatus(stdout) {
 		return unknown;
 	}
 }
+// ../../packages/providers/src/claude/fork.ts
+const reasonOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Copy a Claude conversation with the SDK's `forkSession()`: the transcript is written to a new
+* session file at once (fresh message ids, the original untouched) and the new session id is
+* returned for resuming. With `upTo` (a turn's fork point: its last transcript message), the
+* transcript is read first (`getSessionMessages`) to confirm it still holds that message, and
+* the copy ends with it. A conversation that no longer holds it (replaced or deleted) throws
+* `FORK_POINT_MISSING` before anything is copied, so it never becomes a whole copy instead.
+*/
+async function forkClaudeConversation(sdk, resumeToken, upTo) {
+	if (upTo) await confirmForkPoint(sdk, resumeToken, upTo);
+	try {
+		return (await sdk.forkSession(resumeToken, upTo ? { upToMessageId: upTo } : void 0)).sessionId;
+	} catch (error) {
+		throw new Error(`Could not fork the Claude conversation ${resumeToken}: ${reasonOf(error)}`);
+	}
+}
+async function confirmForkPoint(sdk, resumeToken, upTo) {
+	let messages;
+	try {
+		messages = await sdk.getSessionMessages(resumeToken, { includeSystemMessages: true });
+	} catch (error) {
+		throw new Error(`Could not read the Claude conversation ${resumeToken}: ${reasonOf(error)}`);
+	}
+	if (!messages.some((m) => m.uuid === upTo)) throw new ProviderSessionError(FORK_POINT_MISSING, "The conversation no longer holds the end of that turn (it was replaced or deleted), so it can't be forked there");
+}
 // ../../packages/providers/src/util/model.ts
 /** The id the model pickers use for "the provider's own default model". */
 const DEFAULT_MODEL_ID = "default";
@@ -8434,6 +8463,12 @@ var ClaudeEventMapper = class {
 	retryNoticeId;
 	/** What the current turn said about a failure, for classifying it (`errors.ts`). */
 	signals = {};
+	/**
+	* The `uuid` of the current root turn's last main-chain transcript message (an `assistant`
+	* or `user` message without `parent_tool_use_id`): the turn's fork point, where
+	* `forkSession({ upToMessageId })` ends a copy that keeps this turn and no later one.
+	*/
+	lastChainUuid;
 	/** The `/` command list last reported, so an unchanged list isn't sent again. */
 	commandsKey;
 	constructor(opts) {
@@ -8491,6 +8526,7 @@ var ClaudeEventMapper = class {
 		this.rootTurnId = turnId;
 		this.turnBaseline = this.queryTotal;
 		this.signals = {};
+		this.lastChainUuid = void 0;
 		this.emit({
 			type: "turn.started",
 			threadId: this.rootThreadId,
@@ -8535,9 +8571,11 @@ var ClaudeEventMapper = class {
 				return;
 			case "assistant":
 				this.onAssistant(msg);
+				this.noteChainMessage(msg);
 				return;
 			case "user":
 				this.onUser(msg);
+				this.noteChainMessage(msg);
 				return;
 			case "system":
 				this.onSystem(msg);
@@ -8560,6 +8598,16 @@ var ClaudeEventMapper = class {
 			default: return;
 		}
 	}
+	/**
+	* Keep a root turn's latest main-chain message as its fork point. Subagents' messages don't
+	* count, nor do meta or synthetic ones, which the transcript read that confirms a fork point
+	* (`getSessionMessages`) may leave out.
+	*/
+	noteChainMessage(msg) {
+		if (msg.parent_tool_use_id || !this.rootTurnId || msg.isMeta || msg.isSynthetic) return;
+		const uuid = str(msg, "uuid");
+		if (uuid) this.lastChainUuid = uuid;
+	}
 	onAssistant(msg) {
 		const message = msg.message ?? {};
 		const ctx = this.ctxFor(msg.parent_tool_use_id);
@@ -8703,19 +8751,24 @@ var ClaudeEventMapper = class {
 		this.tools.finishTurn(ctx, outcome.type === "completed");
 		this.rootTurnId = void 0;
 		this.interruptRequested = false;
+		const end = {
+			...ctx,
+			...this.lastChainUuid ? { forkPoint: this.lastChainUuid } : {}
+		};
+		this.lastChainUuid = void 0;
 		if (outcome.type === "completed") this.emit({
 			type: "turn.completed",
-			...ctx,
+			...end,
 			stopReason: outcome.stopReason
 		});
 		else if (outcome.type === "failed") this.emit({
 			type: "turn.failed",
-			...ctx,
+			...end,
 			error: outcome.error
 		});
 		else this.emit({
 			type: "turn.interrupted",
-			...ctx,
+			...end,
 			reason: outcome.reason
 		});
 	}
@@ -9405,18 +9458,12 @@ var ClaudeAdapter = class {
 		});
 	}
 	/**
-	* Copy a conversation with the SDK's `forkSession()`: the transcript is written to a new
-	* session file at once (fresh message ids, the original untouched) and the new session id is
-	* returned for resuming. The copy is found from any worktree of the project.
+	* Copy a conversation (see `forkClaudeConversation`): at once, with fresh message ids, the
+	* original untouched; with `upTo`, only through the turn that ended with that message. The
+	* copy is found from any worktree of the project.
 	*/
-	async forkConversation(resumeToken) {
-		const { forkSession } = await (this.options.loadSdk ?? loadClaudeSdk)();
-		try {
-			return (await forkSession(resumeToken)).sessionId;
-		} catch (error) {
-			const reason = error instanceof Error ? error.message : String(error);
-			throw new Error(`Could not fork the Claude conversation ${resumeToken}: ${reason}`);
-		}
+	async forkConversation(resumeToken, opts) {
+		return forkClaudeConversation(await (this.options.loadSdk ?? loadClaudeSdk)(), resumeToken, opts?.upTo);
 	}
 	utilityModel() {
 		return new ClaudeUtilityModel(() => this.executable());
@@ -9733,11 +9780,27 @@ async function startAppServer(exe, handlers, opts = {}) {
 	}
 }
 // ../../packages/providers/src/codex/fork.ts
+/** Turns listed per `thread/turns/list` page, and the most pages read to find a turn. */
+const TURNS_PAGE = 100;
+const MAX_PAGES$1 = 50;
+/**
+* How the app-server answers for a thread or turn it doesn't have. Codex 0.160 says
+* `no rollout found for thread id <id>` for a deleted thread and `turn not found: <id>` for a
+* missing `lastTurnId`. Other refusals (a turn still in progress, a malformed id) don't match.
+*/
+const MISSING = /\bno rollout found\b|\b(thread|turn|rollout) not found\b/i;
 /**
 * Copy a Codex thread with `thread/fork` through a short-lived `codex app-server` and return
 * the new thread's id. The original thread is untouched; the session that resumes the copy
 * sets its own cwd, policy and instructions (`thread/resume` overrides). The process is closed
 * before returning, so it no longer holds the new thread when that session resumes it.
+*
+* With `upTo` (a turn id), the copy ends with that turn (`lastTurnId`). A thread that no
+* longer holds the turn, or no longer exists, throws `FORK_POINT_MISSING`: when the turn list
+* (`thread/turns/list`) shows it before anything is copied, or else when `thread/fork` answers
+* so. A short-lived app-server usually can't list a thread it hasn't loaded (Codex 0.160 says
+* `thread not loaded`), so `thread/fork`'s answer is what decides then. Any other failure, and
+* every failure of a whole copy, stays a plain error.
 */
 async function forkCodexThread(exe, threadId, opts) {
 	const { rpc } = await startAppServer(exe, {
@@ -9746,17 +9809,47 @@ async function forkCodexThread(exe, threadId, opts) {
 		onExit: () => {}
 	}, { cwd: opts.cwd });
 	try {
-		return (await rpc.request("thread/fork", {
+		if (opts.upTo && await holdsTurn(rpc, threadId, opts.upTo) === false) throw new ProviderSessionError(FORK_POINT_MISSING, "The thread no longer holds that turn (it was replaced or deleted), so it can't be forked there");
+		const params = {
 			threadId,
 			cwd: opts.cwd,
-			excludeTurns: true
-		})).thread.id;
+			excludeTurns: true,
+			...opts.upTo ? { lastTurnId: opts.upTo } : {}
+		};
+		return (await rpc.request("thread/fork", params)).thread.id;
 	} catch (error) {
-		throw new Error(`Could not fork Codex thread ${threadId}: ${error.message}`);
+		if (error instanceof ProviderSessionError) throw error;
+		const message = error.message;
+		if (opts.upTo && error instanceof CodexRpcError && MISSING.test(message)) throw new ProviderSessionError(FORK_POINT_MISSING, `The thread no longer holds that turn (${message}), so it can't be forked there`);
+		throw new Error(`Could not fork Codex thread ${threadId}: ${message}`);
 	} finally {
 		await rpc.close();
 	}
 }
+/**
+* Whether the thread still holds `turnId`, from its turn list. Undefined when the list can't be
+* read (a thread this app-server hasn't loaded, or an app-server without the method):
+* `thread/fork` then decides.
+*/
+async function holdsTurn(rpc, threadId, turnId) {
+	let cursor = null;
+	try {
+		for (let page = 0; page < MAX_PAGES$1; page++) {
+			const res = await rpc.request("thread/turns/list", {
+				threadId,
+				limit: TURNS_PAGE,
+				itemsView: "notLoaded",
+				...cursor ? { cursor } : {}
+			});
+			if (res.data.some((t) => t.id === turnId)) return true;
+			cursor = res.nextCursor;
+			if (!cursor) return false;
+		}
+		return;
+	} catch {
+		return;
+	}
+}
 /** `model/list` pages are followed up to this many (a guard against a looping cursor). */
 const MAX_PAGES = 20;
 /**
@@ -9946,7 +10039,7 @@ function permissionsRisk(permissions, ctx) {
 		})
 	]);
 }
-// ../../packages/providers/src/codex/approvals.ts
+// ../../packages/providers/src/codex/approval-context.ts
 const decisionOf = (r) => r.kind === "approval" ? r.decision : "cancel";
 /**
 * Approve `item` by policy when the permission level allows `risk`: record it as decided by
@@ -9965,6 +10058,296 @@ function approvedByPolicy(ac, p, item, risk) {
 	});
 	return true;
 }
+// ../../packages/providers/src/codex/elicitation-form.ts
+/** The option that leaves an optional field empty. */
+const LEAVE_EMPTY = "Leave empty";
+/** A form without fields is a confirmation: one question, accept or decline. */
+const CONFIRM_ID = "confirm";
+const ACCEPT = "Accept";
+const DECLINE = "Decline";
+function formFields(schema) {
+	const required = new Set(schema.required ?? []);
+	return Object.entries(schema.properties).flatMap(([name, prop], i) => prop ? [field(name, i, prop, required.has(name))] : []);
+}
+function field(name, index, s, required) {
+	const description = s.description?.trim();
+	const base = {
+		name,
+		id: name.length > 0 && name.length <= 200 ? name : `field-${index}`,
+		label: s.title?.trim() || name,
+		...description ? { description } : {},
+		required,
+		choices: []
+	};
+	if (s.type === "boolean") return {
+		...base,
+		type: "boolean"
+	};
+	if (s.type === "number" || s.type === "integer") return {
+		...base,
+		type: s.type
+	};
+	if (s.type === "array") {
+		const items = s.items;
+		const choices = "anyOf" in items ? items.anyOf.map((o) => ({
+			value: o.const,
+			label: o.title
+		})) : items.enum.map((value) => ({
+			value,
+			label: value
+		}));
+		return {
+			...base,
+			type: "choices",
+			choices: unique(choices)
+		};
+	}
+	if ("oneOf" in s) return {
+		...base,
+		type: "choice",
+		choices: unique(s.oneOf.map((o) => ({
+			value: o.const,
+			label: o.title
+		})))
+	};
+	if ("enum" in s) {
+		const names = "enumNames" in s ? s.enumNames : void 0;
+		const choices = s.enum.map((value, i) => ({
+			value,
+			label: names?.[i] ?? value
+		}));
+		return {
+			...base,
+			type: "choice",
+			choices: unique(choices)
+		};
+	}
+	return {
+		...base,
+		type: "text"
+	};
+}
+/**
+* Labels are how answers come back, so each must name exactly one value: a repeated label (or
+* one that reads as {@link LEAVE_EMPTY}) gets its value added, then a number, until it is free.
+*/
+function unique(choices) {
+	const seen = /* @__PURE__ */ new Set([LEAVE_EMPTY]);
+	return choices.map((c) => {
+		const label = c.label.trim() || c.value;
+		let free = seen.has(label) ? `${label} (${c.value})` : label;
+		for (let n = 2; seen.has(free); n++) free = `${label} (${c.value}) ${n}`;
+		seen.add(free);
+		return {
+			value: c.value,
+			label: free
+		};
+	});
+}
+const HINTS = {
+	integer: " (a whole number)",
+	number: " (a number)"
+};
+/** The form as questions; the first one carries the server's message. */
+function formQuestions(server, message, fields) {
+	const lead = `${server} asks: ${message.trim()}`;
+	if (fields.length === 0) return [{
+		id: CONFIRM_ID,
+		header: server,
+		question: lead,
+		options: [{ label: ACCEPT }, { label: DECLINE }],
+		multiSelect: false,
+		allowFreeText: false
+	}];
+	return fields.map((f, i) => {
+		const ask = `${f.description ?? f.label}${HINTS[f.type] ?? ""}`;
+		const plain = fields.length === 1 && ask === f.label;
+		const question = i > 0 ? ask : plain ? lead : `${lead} — ${ask}`;
+		const options = f.type === "boolean" ? [{ label: "Yes" }, { label: "No" }] : f.choices.map((c) => ({ label: c.label }));
+		return {
+			id: f.id,
+			header: f.label.length > 40 ? `${f.label.slice(0, 39)}…` : f.label,
+			question,
+			options: f.required ? options : [...options, { label: LEAVE_EMPTY }],
+			multiSelect: f.type === "choices",
+			allowFreeText: f.type === "text" || f.type === "number" || f.type === "integer"
+		};
+	});
+}
+/**
+* The form's content from the answers (keyed by question id), or undefined when a required
+* field has no answer or an answer doesn't fit its field.
+*/
+function formContent(fields, answers) {
+	const content = {};
+	for (const f of fields) {
+		const given = (answers[f.id] ?? []).map((a) => a.trim()).filter(Boolean);
+		const values = f.required ? given : given.filter((a) => a !== LEAVE_EMPTY);
+		if (values.length === 0) {
+			if (f.required) return void 0;
+			continue;
+		}
+		const value = parse$1(f, values);
+		if (value === void 0) return void 0;
+		content[f.name] = value;
+	}
+	return content;
+}
+function parse$1(f, values) {
+	const [one] = values;
+	switch (f.type) {
+		case "text": return values.join("\n");
+		case "number":
+		case "integer": {
+			const n = values.length === 1 ? Number(one) : NaN;
+			return Number.isFinite(n) && (f.type === "number" || Number.isInteger(n)) ? n : void 0;
+		}
+		case "boolean": {
+			const v = values.length === 1 ? one?.toLowerCase() : void 0;
+			return v === "yes" || v === "true" ? true : v === "no" || v === "false" ? false : void 0;
+		}
+		case "choice": return values.length === 1 && one !== void 0 ? choice(f, one) : void 0;
+		case "choices": {
+			const picked = values.map((v) => choice(f, v));
+			return picked.every((v) => v !== void 0) ? picked : void 0;
+		}
+	}
+}
+/**
+* The value of the option the user picked. The card sends labels, so labels are matched first,
+* across every option; a raw value (a PM may answer with one) only when no label matches.
+*/
+const choice = (f, answer) => (f.choices.find((c) => c.label === answer) ?? f.choices.find((c) => c.value === answer))?.value;
+// ../../packages/providers/src/codex/elicitation.ts
+const accept = (content, meta = null) => ({
+	action: "accept",
+	content,
+	_meta: meta
+});
+const DECLINED = {
+	action: "decline",
+	content: null,
+	_meta: null
+};
+const CANCELLED = {
+	action: "cancel",
+	content: null,
+	_meta: null
+};
+const READ_ONLY = "This session has read-only permissions: it can't run MCP tools that may change things.";
+async function handleElicitation(p, ac) {
+	if (!p.turnId) return DECLINED;
+	const where = {
+		threadId: p.threadId,
+		turnId: p.turnId
+	};
+	if (p.mode === "url") return openLink(p, where, ac);
+	const meta = asMeta(p._meta);
+	if (meta.codex_approval_kind === "mcp_tool_call") return toolApproval(p, meta, where, ac);
+	if (p.mode === "form") return fillForm(p, where, ac);
+	return DECLINED;
+}
+/**
+* Codex asks before it runs one of the user's MCP tools that isn't marked read-only (its
+* `tool_call_mcp_elicitation` feature, on by default).
+*/
+async function toolApproval(p, meta, where, ac) {
+	const server = p.serverName;
+	const tool = text$1(meta.tool_name) ?? text$1(meta.tool_title) ?? /run tool "([^"]+)"/.exec(p.message)?.[1];
+	const persist = meta.persist;
+	const offersSession = persist === "session" || Array.isArray(persist) && persist.includes("session");
+	const requestId = newRequestId();
+	const item = {
+		id: `approval-${requestId}`,
+		kind: "approval_request",
+		status: "in_progress",
+		requestId,
+		action: "tool",
+		title: tool ? `Use ${server}: ${shorten(tool, 80)}` : `Use a tool of ${server}`,
+		...p.message.trim() ? { reason: p.message.trim() } : {},
+		...tool ? { toolName: `mcp__${server}__${tool}` } : {},
+		...meta.tool_params !== void 0 ? { toolInput: toJson(meta.tool_params) } : {},
+		options: offersSession ? [
+			"allow_once",
+			"allow_session",
+			"deny"
+		] : ["allow_once", "deny"]
+	};
+	const ctx = ac.ctx(where.threadId, where.turnId);
+	if ((ac.autonomy?.() ?? "supervised") === "read_only") {
+		ac.broker.record(ctx, {
+			...item,
+			status: "declined",
+			reason: READ_ONLY,
+			decision: "deny",
+			decidedBy: "policy"
+		});
+		return DECLINED;
+	}
+	if (!(meta.codex_sensitive_action === true || meta.codex_requires_user_input === true) && approvedByPolicy(ac, where, item, { risky: false })) return accept({});
+	const decision = decisionOf(await ac.broker.request(ctx, item));
+	if (decision === "allow_session" && offersSession) return accept({}, { persist: "session" });
+	if (decision === "allow_once" || decision === "allow_session") return accept({});
+	return decision === "deny" ? DECLINED : CANCELLED;
+}
+/** A server's form: a question card built from its schema, the answers sent as its content. */
+async function fillForm(p, where, ac) {
+	const fields = formFields(p.requestedSchema);
+	const requestId = newRequestId();
+	const response = await ac.broker.request(ac.ctx(where.threadId, where.turnId), {
+		id: `question-${requestId}`,
+		kind: "user_question",
+		status: "in_progress",
+		requestId,
+		mcpServer: p.serverName,
+		questions: formQuestions(p.serverName, p.message, fields)
+	});
+	if (response.kind !== "answer") return CANCELLED;
+	if (fields.length === 0) return response.answers["confirm"]?.includes("Accept") ? accept({}) : DECLINED;
+	const content = formContent(fields, response.answers);
+	return content ? accept(content) : DECLINED;
+}
+/**
+* A server asks the user to open a link (to sign in, say). The card shows the link and the user
+* opens it: never decided by policy, and nothing opens it on the user's behalf.
+*/
+async function openLink(p, where, ac) {
+	const url = webUrl(p.url);
+	if (!url) return DECLINED;
+	const requestId = newRequestId();
+	const response = await ac.broker.request(ac.ctx(where.threadId, where.turnId), {
+		id: `approval-${requestId}`,
+		kind: "approval_request",
+		status: "in_progress",
+		requestId,
+		action: "network",
+		title: `${p.serverName} asks you to open ${url.host}`,
+		...p.message.trim() ? { reason: p.message.trim() } : {},
+		url: url.href,
+		options: ["allow_once", "deny"]
+	});
+	const decision = decisionOf(response);
+	if (decision === "allow_once" || decision === "allow_session") return accept(null);
+	return decision === "deny" ? DECLINED : CANCELLED;
+}
+/** Elicitations carry no item id, and app-server request ids restart with each process. */
+const newRequestId = () => `mcp-${randomUUID()}`;
+function asMeta(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text$1(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+/** Web links only: a card never links to a script or a local file. */
+function webUrl(raw) {
+	try {
+		const url = new URL(raw);
+		return url.protocol === "https:" || url.protocol === "http:" ? url : void 0;
+	} catch {
+		return;
+	}
+}
+// ../../packages/providers/src/codex/approvals.ts
 /** The item with the classifier's verdict, for the user to decide. */
 function withRisk(item, risk) {
 	if (!risk.risky) return item;
@@ -10099,11 +10482,7 @@ async function handleServerRequest(req, ac) {
 			if (response.kind === "answer") for (const [id, values] of Object.entries(response.answers)) answers[id] = { answers: values };
 			return { answers };
 		}
-		case "mcpServer/elicitation/request": return {
-			action: "decline",
-			content: null,
-			_meta: null
-		};
+		case "mcpServer/elicitation/request": return handleElicitation(req.params, ac);
 		case "execCommandApproval":
 		case "applyPatchApproval": return { decision: { denied: { rejection: "Unsupported approval request" } } };
 		default: throw new CodexRpcError(-32601, `CodeDen does not handle ${req.method}`);
@@ -11115,10 +11494,16 @@ var CodexThreadMapper = class {
 			});
 		}
 	}
+	/**
+	* Codex ended a turn. On the session's own thread the turn's id is its fork point:
+	* `thread/fork { lastTurnId }` keeps it and drops later turns. Turns CodeDen closes itself
+	* (the process died, the session closed) report none, as Codex may not have finished them.
+	*/
 	completeTurn(turn) {
 		this.beginTurn(turn.id);
-		if (turn.status === "completed") this.endTurn({ type: "completed" }, turn.id);
-		else if (turn.status === "interrupted") this.endTurn({ type: "interrupted" }, turn.id);
+		const forkPoint = this.o.root ? turn.id : void 0;
+		if (turn.status === "completed") this.endTurn({ type: "completed" }, turn.id, forkPoint);
+		else if (turn.status === "interrupted") this.endTurn({ type: "interrupted" }, turn.id, forkPoint);
 		else {
 			const info = turn.error?.codexErrorInfo;
 			const kind = classifyCodexError(info);
@@ -11130,13 +11515,17 @@ var CodexThreadMapper = class {
 				code: codexErrorCode(info),
 				kind,
 				retryAt
-			}, turn.id);
+			}, turn.id, forkPoint);
 		}
 	}
 	/** Close the running turn (also used when the process dies or the session closes). */
-	endTurn(outcome, turnId = this.current) {
+	endTurn(outcome, turnId = this.current, forkPoint) {
 		if (!turnId || turnId !== this.current) return;
 		const ctx = this.ctx(turnId);
+		const end = {
+			...ctx,
+			...forkPoint ? { forkPoint } : {}
+		};
 		const ok = outcome.type === "completed";
 		for (const item of this.open.values()) this.o.emit({
 			type: "item.completed",
@@ -11163,17 +11552,17 @@ var CodexThreadMapper = class {
 		this.current = void 0;
 		if (outcome.type === "completed") this.o.emit({
 			type: "turn.completed",
-			...ctx,
+			...end,
 			stopReason: "end_turn"
 		});
 		else if (outcome.type === "interrupted") this.o.emit({
 			type: "turn.interrupted",
-			...ctx,
+			...end,
 			reason: "user"
 		});
 		else this.o.emit({
 			type: "turn.failed",
-			...ctx,
+			...end,
 			error: {
 				code: outcome.code ?? "turn_failed",
 				message: outcome.message,
@@ -12054,7 +12443,10 @@ var CodexAdapter = class {
 		}
 		return session;
 	}
-	/** Copy a thread with `thread/fork` (see `forkCodexThread`); returns the new thread's id. */
+	/**
+	* Copy a thread with `thread/fork` (see `forkCodexThread`); returns the new thread's id. With
+	* `upTo` (a turn id), the copy ends with that turn.
+	*/
 	async forkConversation(resumeToken, opts) {
 		const executable = this.executable();
 		if (!executable) throw new Error("Codex is not installed (no `codex` on PATH)");
@@ -12316,6 +12708,7 @@ var FakeSession = class {
 	}
 	async runTurn(turn, input) {
 		const { threadId, turnId } = turn;
+		const forkPoint = turnId;
 		const prompt = input.text;
 		try {
 			this.emit({
@@ -12342,6 +12735,7 @@ var FakeSession = class {
 					type: "turn.failed",
 					threadId,
 					turnId,
+					forkPoint,
 					error: {
 						code: "fake_failure",
 						message: "Scripted failure",
@@ -12357,6 +12751,7 @@ var FakeSession = class {
 					type: "turn.failed",
 					threadId,
 					turnId,
+					forkPoint,
 					error: usage ? {
 						code: "usage_limit",
 						message: "Scripted usage limit",
@@ -12378,6 +12773,7 @@ var FakeSession = class {
 						type: "turn.completed",
 						threadId,
 						turnId,
+						forkPoint,
 						stopReason: "end_turn"
 					});
 					return;
@@ -12426,6 +12822,7 @@ var FakeSession = class {
 				type: "turn.completed",
 				threadId,
 				turnId,
+				forkPoint,
 				stopReason: "end_turn"
 			});
 		} catch (error) {
@@ -12434,6 +12831,7 @@ var FakeSession = class {
 					type: "turn.interrupted",
 					threadId,
 					turnId,
+					forkPoint,
 					reason: "user"
 				});
 				return;
@@ -12443,6 +12841,7 @@ var FakeSession = class {
 				type: "turn.failed",
 				threadId,
 				turnId,
+				forkPoint,
 				error: { message }
 			});
 		}
@@ -12843,10 +13242,13 @@ var FakeProvider = class {
 	async openSession(opts) {
 		return new FakeSession(await withFork(this, opts), this.options);
 	}
-	/** A fork gets a conversation of its own, named after the one it copies. */
-	async forkConversation(resumeToken) {
+	/**
+	* A fork gets a conversation of its own, named after the one it copies and, with `upTo`,
+	* the turn it ends with (`<token>:fork-<n>@<turn>`).
+	*/
+	async forkConversation(resumeToken, opts) {
 		this.forks += 1;
-		return `${resumeToken}:fork-${this.forks}`;
+		return `${resumeToken}:fork-${this.forks}${opts?.upTo ? `@${opts.upTo}` : ""}`;
 	}
 	forks = 0;
 };
@@ -21858,9 +22260,12 @@ async function executeCommand(core, command) {
 			const adapter = registry.get(command.providerId);
 			if (!adapter?.capabilities().fork || !adapter.forkConversation) throw new CommandError("unsupported", `Provider ${command.providerId} cannot fork`);
 			try {
-				return { resumeToken: await adapter.forkConversation(command.resumeToken, { cwd: command.cwd }) };
+				return { resumeToken: await adapter.forkConversation(command.resumeToken, {
+					cwd: command.cwd,
+					...command.upTo ? { upTo: command.upTo } : {}
+				}) };
 			} catch (error) {
-				throw new CommandError("fork_failed", error.message);
+				throw new CommandError(error.code === FORK_POINT_MISSING ? FORK_POINT_MISSING : "fork_failed", error.message);
 			}
 		}
 		case "workspace.prepare":
@@ -21943,7 +22348,7 @@ async function executeCommand(core, command) {
 		case "checkpoint.restoreFiles": return restoreFiles(command.cwd, command.sessionId, command.index, command.paths);
 		case "ports.list": return { ports: await listPorts(command.probe) };
 		case "mcp.test": {
-			const { testMcpServer } = await import("./server-test-COAiKxTV.js");
+			const { testMcpServer } = await import("./server-test-b0hHPqXb.js");
 			return testMcpServer({
 				spec: command.spec,
 				cwd: command.cwd,
@@ -22004,21 +22409,44 @@ function removeOwnLock(lockFile) {
 * monotonically increasing seq and kept until the server acks them, so nothing is lost
 * while the server is away. `state.json` holds the stable runner id and seq counters.
 *
-* TODO(M1): batch fsyncs and compact lazily instead of rewriting on every ack.
+* An ack only moves the acked position in memory. While acks flow, the journal persists at
+* most every `persistMs`: it writes `state.json`, then, when enough acked events have piled
+* up and they outweigh what is left, rewrites the file without them (compaction), so each
+* ack costs no more than its append did. State always goes first, so `lastSeq` outlives the
+* events a compaction drops. `close` persists and compacts at once. After a crash the journal
+* may still hold events the server already acked; the server's `resume` acks them again and
+* they are not replayed.
 */
 var Journal = class {
 	file;
 	stateFile;
+	compactEntries;
+	compactBytes;
+	persistMs;
 	state;
+	/** Every event in `journal.jsonl`, oldest first; those before `head` are acked. */
 	entries = [];
-	constructor(dir) {
+	head = 0;
+	fileBytes = 0;
+	ackedBytes = 0;
+	persistTimer;
+	constructor(dir, opts = {}) {
 		mkdirSync(dir, { recursive: true });
 		this.file = join(dir, "journal.jsonl");
 		this.stateFile = join(dir, "state.json");
+		this.compactEntries = opts.compactEntries ?? 1e3;
+		this.compactBytes = opts.compactBytes ?? 1048576;
+		this.persistMs = opts.persistMs ?? 250;
 		this.state = this.loadState();
-		this.entries = this.loadEntries().filter((e) => e.seq > this.state.ackedSeq);
-		const maxSeq = this.entries.at(-1)?.seq ?? 0;
-		this.state.lastSeq = Math.max(this.state.lastSeq, maxSeq);
+		const { entries, torn } = this.loadEntries();
+		this.entries = entries;
+		for (const e of entries) this.fileBytes += e.bytes;
+		this.state.lastSeq = Math.max(this.state.lastSeq, entries.at(-1)?.msg.seq ?? 0);
+		this.advanceHead(this.state.ackedSeq);
+		if (torn) {
+			this.writeState(this.state);
+			this.compact();
+		}
 	}
 	get runnerId() {
 		return this.state.runnerId;
@@ -22027,7 +22455,7 @@ var Journal = class {
 		return this.state.lastSeq;
 	}
 	get unacked() {
-		return this.entries.length;
+		return this.entries.length - this.head;
 	}
 	/** Assign the next seq, persist the event, and return the wire message. */
 	append(event) {
@@ -22038,20 +22466,84 @@ var Journal = class {
 			ts: (/* @__PURE__ */ new Date()).toISOString(),
 			event
 		};
-		appendFileSync(this.file, `${JSON.stringify(msg)}\n`);
-		this.entries.push(msg);
+		const line = `${JSON.stringify(msg)}\n`;
+		appendFileSync(this.file, line);
+		const bytes = Buffer.byteLength(line);
+		this.entries.push({
+			msg,
+			bytes
+		});
+		this.fileBytes += bytes;
 		return msg;
 	}
-	/** Drop everything with `seq <= seq` (cumulative ack). */
+	/** Acknowledge everything with `seq <= seq` (cumulative ack). */
 	ack(seq) {
-		if (seq <= this.state.ackedSeq) return;
-		this.state.ackedSeq = Math.min(seq, this.state.lastSeq);
-		this.entries = this.entries.filter((e) => e.seq > seq);
-		this.rewrite();
+		const upTo = Math.min(seq, this.state.lastSeq);
+		if (upTo <= this.state.ackedSeq) return;
+		this.state.ackedSeq = upTo;
+		this.advanceHead(upTo);
+		this.schedulePersist();
 	}
 	/** Unacked events after `seq`, oldest first (for replay on resume). */
 	after(seq) {
-		return this.entries.filter((e) => e.seq > seq);
+		const out = [];
+		for (let i = this.head; i < this.entries.length; i++) {
+			const msg = this.entries[i]?.msg;
+			if (msg && msg.seq > seq) out.push(msg);
+		}
+		return out;
+	}
+	/** Persist the acked position and drop every acked event from the file (runner shutdown). */
+	close() {
+		this.persist(true);
+	}
+	advanceHead(ackedSeq) {
+		for (;;) {
+			const entry = this.entries[this.head];
+			if (!entry || entry.msg.seq > ackedSeq) return;
+			this.ackedBytes += entry.bytes;
+			this.head += 1;
+		}
+	}
+	/** Enough acked events piled up, and rewriting what is left costs no more than they do. */
+	compactDue() {
+		return (this.head >= this.compactEntries || this.ackedBytes >= this.compactBytes) && this.ackedBytes >= this.fileBytes - this.ackedBytes;
+	}
+	schedulePersist() {
+		if (this.persistTimer) return;
+		this.persistTimer = setTimeout(() => {
+			this.persistTimer = void 0;
+			try {
+				this.persist(false);
+			} catch {}
+		}, this.persistMs);
+		this.persistTimer.unref();
+	}
+	/**
+	* Write the acked position, then compact when it is due (`all`: whenever anything is acked).
+	* State first, so `lastSeq` outlives the events the compaction drops.
+	*/
+	persist(all) {
+		if (this.persistTimer) clearTimeout(this.persistTimer);
+		this.persistTimer = void 0;
+		this.writeState(this.state);
+		if (all ? this.head > 0 : this.compactDue()) this.compact();
+	}
+	/** Rewrite the file without its acked events. Callers write the state first. */
+	compact() {
+		const live = this.entries.slice(this.head);
+		const tmp = `${this.file}.tmp`;
+		writeFileSync(tmp, live.map((e) => `${JSON.stringify(e.msg)}\n`).join(""));
+		renameSync(tmp, this.file);
+		this.entries = live;
+		this.head = 0;
+		this.fileBytes -= this.ackedBytes;
+		this.ackedBytes = 0;
+	}
+	writeState(state) {
+		const tmp = `${this.stateFile}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+		renameSync(tmp, this.stateFile);
 	}
 	loadState() {
 		try {
@@ -22071,25 +22563,26 @@ var Journal = class {
 		return fresh;
 	}
 	loadEntries() {
-		if (!existsSync(this.file)) return [];
-		const out = [];
-		for (const line of readFileSync(this.file, "utf8").split("\n")) {
+		if (!existsSync(this.file)) return {
+			entries: [],
+			torn: false
+		};
+		const raw = readFileSync(this.file, "utf8");
+		const entries = [];
+		let torn = raw.length > 0 && !raw.endsWith("\n");
+		for (const line of raw.split("\n")) {
 			if (!line.trim()) continue;
 			const parsed = RunnerEventMessage.safeParse(safeJson(line));
-			if (parsed.success) out.push(parsed.data);
+			if (parsed.success) entries.push({
+				msg: parsed.data,
+				bytes: Buffer.byteLength(line) + 1
+			});
+			else torn = true;
 		}
-		return out.sort((a, b) => a.seq - b.seq);
-	}
-	rewrite() {
-		const tmp = `${this.file}.tmp`;
-		writeFileSync(tmp, this.entries.map((e) => `${JSON.stringify(e)}\n`).join(""));
-		renameSync(tmp, this.file);
-		this.writeState(this.state);
-	}
-	writeState(state) {
-		const tmp = `${this.stateFile}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
-		renameSync(tmp, this.stateFile);
+		return {
+			entries: entries.sort((a, b) => a.msg.seq - b.msg.seq),
+			torn
+		};
 	}
 };
 function safeJson(line) {
@@ -24047,6 +24540,68 @@ function connectionHandlers(core, register, unregister, onAttach) {
 		}
 	};
 }
+/**
+* Batches streamed `item.delta` events on their way to the journal. Every event the runner
+* journals is also a send, a server transaction and an ack, and providers stream an answer a
+* few characters at a time. Per session, consecutive deltas that extend the same item the
+* same way (`mergeItemDeltas`) are merged and passed on as one: after `windowMs`, once the
+* batch holds `maxChars`, or right before any other event of that session, whoever emits it
+* (the session's provider, a checkpoint command, workspace setup). An event that belongs to
+* no session (a terminal exiting, a drain) passes every batch on first. So no event overtakes
+* a delta that came before it, and only deltas ever wait.
+*/
+var DeltaBatcher = class {
+	out;
+	opts;
+	batches = /* @__PURE__ */ new Map();
+	constructor(out, opts = {}) {
+		this.out = out;
+		this.opts = opts;
+	}
+	push(event) {
+		if (event.kind === "agent" && event.event.type === "item.delta") {
+			this.add(event.sessionId, event.event);
+			return;
+		}
+		this.flush("sessionId" in event ? event.sessionId : void 0);
+		this.out(event);
+	}
+	/** Pass on the pending batch of one session, or of every session. */
+	flush(sessionId) {
+		if (sessionId === void 0) {
+			for (const id of [...this.batches.keys()]) this.flush(id);
+			return;
+		}
+		const batch = this.batches.get(sessionId);
+		if (!batch) return;
+		clearTimeout(batch.timer);
+		this.batches.delete(sessionId);
+		this.out({
+			kind: "agent",
+			sessionId,
+			event: batch.delta
+		});
+	}
+	add(sessionId, delta) {
+		const chars = itemDeltaText(delta.delta).length;
+		let batch = this.batches.get(sessionId);
+		const merged = batch && mergeItemDeltas(batch.delta, delta);
+		if (batch && merged) {
+			batch.delta = merged;
+			batch.chars += chars;
+		} else {
+			this.flush(sessionId);
+			const windowMs = this.opts.windowMs ?? 50;
+			batch = {
+				delta,
+				chars,
+				timer: setTimeout(() => this.flush(sessionId), windowMs)
+			};
+			this.batches.set(sessionId, batch);
+		}
+		if (batch.chars >= (this.opts.maxChars ?? 16384)) this.flush(sessionId);
+	}
+};
 // ../runner/src/session-host.ts
 /**
 * Owns live provider sessions on this runner and pumps their normalized events into the
@@ -24346,11 +24901,15 @@ async function startRunner(opts) {
 	let mcpUpstream = opts.mcpUpstreamUrl ? new HttpMcpUpstream(opts.mcpUpstreamUrl) : void 0;
 	let port = 0;
 	let stopped = false;
-	const emit = (event) => {
+	const journalEvent = (event) => {
 		if (stopped) return;
 		const msg = journal.append(event);
 		attached?.deliver(msg);
 	};
+	const deltas = new DeltaBatcher(journalEvent, opts.deltaBatching);
+	const emit = (event) => {
+		if (!stopped) deltas.push(event);
+	};
 	const stream = (data) => {
 		attached?.deliver({
 			type: "stream",
@@ -24481,7 +25040,13 @@ async function startRunner(opts) {
 				if ("closeAllConnections" in server) server.closeAllConnections();
 			});
 			process.off("exit", removeLock);
+			deltas.flush();
 			stopped = true;
+			try {
+				journal.close();
+			} catch (error) {
+				log(`journal: ${String(error)}`);
+			}
 			log("runner stopped");
 		})();
 		return closing;
@@ -24496,4 +25061,4 @@ async function startRunner(opts) {
 }
 export { isElectronRuntime as A, installClaudeSdk as C, acquireInstallLock as D, resolveNpm as E, import_websocket_server as M, wrapper_default as N, brokenInstallMessage as O, importClaudeSdkFrom as S, runNpm as T, claudeMemoryDir as _, bufferToFormData as a, claudeSdkSource as b, refreshProcessPath as c, ImageEngineRegistry as d, createImageEngineRegistry as f, ImageGenerationError as g, resolveImageOutput as h, tryDecodeURIComponent as i, ownNodeEnv as j, findExecutable as k, defaultShell as l, imageInfo as m, readLock as n, createAdaptorServer as o, IMAGE_ASPECT_RATIOS as p, Hono as r, upgradeWebSocket as s, startRunner as t, shellCommandLine as u, findGitRoot as v, isClaudeSdkInstalled as w, CLAUDE_SDK_VERSION as x, mainRepoRoot as y };
 
-//# sourceMappingURL=runner-DYf8dV43.js.map
+//# sourceMappingURL=runner-CiaiUWOE.js.map