ryco-cli 0.1.30 → 0.1.31

package/dist/{CodexDriver-6Ph2cjAW.cjs → CodexDriver-CBQPHJqU.cjs}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-HbSU0i7K.cjs");
-const require_Metrics = require("./Metrics-C0LSU8s7.cjs");
-const require_src = require("./src-CARHuYkT.cjs");
+const require_Metrics = require("./Metrics-DjRPLE98.cjs");
+const require_src = require("./src-FmeCeBJ9.cjs");
 const require_bin = require("./bin.cjs");
 const require_runtimeSession = require("./runtimeSession-Bj0OUcNJ.cjs");
 const require_sourceControlContextFormatter = require("./sourceControlContextFormatter-BDZqn-4T.cjs");
 const require_ProjectCustomSystemPrompt = require("./ProjectCustomSystemPrompt-B8SUlNGa.cjs");
-const require_makeManagedServerProvider = require("./makeManagedServerProvider-CF776SAO.cjs");
-const require_CodexTextGeneration = require("./CodexTextGeneration-sXPR9eld.cjs");
+const require_makeManagedServerProvider = require("./makeManagedServerProvider-B5tP7tvg.cjs");
+const require_CodexTextGeneration = require("./CodexTextGeneration-C9MDQmZm.cjs");
 let effect = require("effect");
 let effect_unstable_http = require("effect/unstable/http");
 let effect_unstable_process = require("effect/unstable/process");
@@ -419,6 +419,7 @@ function buildTurnStartParams(input) {
 		...input.model ? { model: input.model } : {},
 		...input.serviceTier ? { serviceTier: input.serviceTier } : {},
 		...input.effort ? { effort: input.effort } : {},
+		summary: "auto",
 		...collaborationMode ? { collaborationMode } : {}
 	}).pipe(effect.Effect.mapError((error) => toProtocolParseError("Invalid turn/start request payload", error)));
 }
@@ -478,6 +479,35 @@ const openCodexThread = (input) => {
 		errorMessage: "This Codex thread already has an active writer in another process. Its history can still be recovered. Release the thread in that process before continuing it here."
 	}) : error));
 };
+const CodexThreadRevertResponse = effect.Schema.Struct({ thread: effect.Schema.Struct({ id: effect.Schema.String }) });
+function isUnknownCodexMethod(error) {
+	return effect.Schema.is(require_bin.CodexAppServerRequestError)(error) && (error.code === -32601 || error.code === -32600 && /unknown variant/i.test(error.errorMessage));
+}
+/**
+* Makes a Codex thread forget its newest turns. Current binaries replace the
+* durable history with the prefix before `beforeTurnId` (`thread/revert`); old
+* binaries only know the deprecated `thread/rollback`. Neither touches files.
+*/
+const revertCodexThread = (client, input) => {
+	const legacyRollback = (revertError) => client.request("thread/rollback", {
+		threadId: input.threadId,
+		numTurns: input.numTurns
+	}).pipe(effect.Effect.as({
+		threadId: input.threadId,
+		turns: []
+	}), effect.Effect.catch((rollbackError) => !isUnknownCodexMethod(rollbackError) ? effect.Effect.fail(rollbackError) : effect.Effect.fail(revertError ?? new require_bin.CodexAppServerRequestError({
+		code: -32601,
+		errorMessage: "This Codex version can't rewind threads."
+	}))));
+	if (input.beforeTurnId === void 0) return legacyRollback(void 0);
+	return client.raw.request("thread/revert", {
+		threadId: input.threadId,
+		beforeTurnId: input.beforeTurnId
+	}).pipe(effect.Effect.flatMap((raw) => effect.Schema.decodeUnknownEffect(CodexThreadRevertResponse)(raw).pipe(effect.Effect.mapError((error) => toProtocolParseError("Invalid thread/revert response payload", error)))), effect.Effect.as({
+		threadId: input.threadId,
+		turns: []
+	}), effect.Effect.catch((error) => effect.Schema.is(require_bin.CodexAppServerRequestError)(error) ? legacyRollback(error) : effect.Effect.fail(error)));
+};
 function readNotificationThreadId(notification) {
 	switch (notification.method) {
 		case "thread/started": return notification.params.thread.id;
@@ -1442,17 +1472,18 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 			}
 			return parseThreadSnapshot(response);
 		}),
-		rollbackThread: (numTurns) => effect.Effect.gen(function* () {
+		rollbackThread: (input) => effect.Effect.gen(function* () {
 			const providerThreadId = yield* readProviderThreadId;
-			const response = yield* client.request("thread/rollback", {
+			const snapshot = yield* revertCodexThread(client, {
 				threadId: providerThreadId,
-				numTurns
+				numTurns: input.numTurns,
+				beforeTurnId: input.beforeTurnId
 			});
 			yield* updateSession(sessionRef, {
 				status: "ready",
 				activeTurnId: void 0
 			});
-			return parseThreadSnapshot(response);
+			return snapshot;
 		}),
 		setGoal: (input) => effect.Effect.gen(function* () {
 			const providerThreadId = yield* readProviderThreadId;
@@ -1538,6 +1569,131 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 		close
 	};
 });
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+/**
+* Codex's rolling update is sparse: a present value overrides the previous one, while
+* null or absent never clears it. Window objects merge the same way one level down.
+*/
+function mergeCodexRateLimitSnapshot(previous, update) {
+	const next = asRecord(update);
+	if (!next) return previous;
+	const merged = { ...previous };
+	for (const [key, value] of Object.entries(next)) {
+		if (value === null || value === void 0) continue;
+		const before = asRecord(merged[key]);
+		const after = asRecord(value);
+		if (before && after) {
+			const window = { ...before };
+			for (const [field, fieldValue] of Object.entries(after)) if (fieldValue !== null && fieldValue !== void 0) window[field] = fieldValue;
+			merged[key] = window;
+		} else merged[key] = value;
+	}
+	return merged;
+}
+function readWindow(value) {
+	const window = asRecord(value);
+	const usedPercent = window?.usedPercent;
+	if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent)) return void 0;
+	const resetsAt = window?.resetsAt;
+	return {
+		exhausted: usedPercent >= 100,
+		resetAtMs: typeof resetsAt === "number" && Number.isFinite(resetsAt) ? resetsAt * 1e3 : null
+	};
+}
+function codexUsageLimitState(snapshot, nowMs) {
+	const windows = [readWindow(snapshot?.primary), readWindow(snapshot?.secondary)].filter((window) => window !== void 0);
+	return require_bin.usageLimitStateFromWindows(windows, nowMs);
+}
+/** `"usageLimitExceeded"` → itself; `{ httpConnectionFailed: {...} }` → its single key. */
+function codexErrorInfoCode(info) {
+	if (typeof info === "string") return info.length > 0 ? info : void 0;
+	const record = asRecord(info);
+	if (!record) return void 0;
+	const keys = Object.keys(record);
+	return keys.length === 1 ? keys[0] : void 0;
+}
+/**
+* `usageLimitExceeded` is a limit. `rateLimitExceeded` is not in the pinned schema; it
+* counts only while the account snapshot is exhausted, so a transient 429 stays an error.
+*/
+function isCodexUsageLimitError(code, state) {
+	if (code === "usageLimitExceeded") return true;
+	if (code === "rateLimitExceeded") return state.exhausted;
+	return false;
+}
+function readTurnError(payload) {
+	const error = asRecord(asRecord(asRecord(payload)?.turn)?.error);
+	if (!error) return {};
+	const message = typeof error.message === "string" ? error.message.trim() : "";
+	const code = codexErrorInfoCode(error.codexErrorInfo);
+	return {
+		...code !== void 0 ? { code } : {},
+		...message.length > 0 ? { message } : {}
+	};
+}
+/** Per-session state: the merged rate-limit snapshot and turns already reported as limited. */
+function makeCodexUsageLimitTracker() {
+	let snapshot;
+	const announcedTurnIds = /* @__PURE__ */ new Set();
+	const annotate = (event, mapped, nowMs = Date.now()) => {
+		if (event.method === "account/rateLimits/updated") {
+			snapshot = mergeCodexRateLimitSnapshot(snapshot, asRecord(event.payload)?.rateLimits);
+			const usageLimitState = codexUsageLimitState(snapshot, nowMs);
+			return mapped.map((runtimeEvent) => runtimeEvent.type === "account.rate-limits.updated" ? {
+				...runtimeEvent,
+				payload: {
+					...runtimeEvent.payload,
+					usageLimitState
+				}
+			} : runtimeEvent);
+		}
+		if (event.method === "error") {
+			const payload = asRecord(event.payload);
+			if (payload?.willRetry === true) return mapped;
+			const code = codexErrorInfoCode(asRecord(payload?.error)?.codexErrorInfo);
+			const state = codexUsageLimitState(snapshot, nowMs);
+			if (!isCodexUsageLimitError(code, state)) return mapped;
+			return mapped.map((runtimeEvent) => {
+				if (runtimeEvent.type !== "runtime.error") return runtimeEvent;
+				if (runtimeEvent.turnId !== void 0) announcedTurnIds.add(runtimeEvent.turnId);
+				return {
+					...runtimeEvent,
+					payload: {
+						...runtimeEvent.payload,
+						class: "usage_limit",
+						resetAt: state.exhausted ? state.resetAt : null
+					}
+				};
+			});
+		}
+		if (event.method === "turn/completed") {
+			const completed = mapped.find((runtimeEvent) => runtimeEvent.type === "turn.completed");
+			if (!completed) return mapped;
+			const turnId = completed.turnId;
+			const alreadyAnnounced = turnId !== void 0 && announcedTurnIds.has(turnId);
+			if (turnId !== void 0) announcedTurnIds.delete(turnId);
+			if (completed.payload.state !== "failed" || alreadyAnnounced) return mapped;
+			const turnError = readTurnError(event.payload);
+			const state = codexUsageLimitState(snapshot, nowMs);
+			if (!isCodexUsageLimitError(turnError.code, state)) return mapped;
+			const { type: _type, payload: _payload, ...base } = completed;
+			return [{
+				...base,
+				eventId: require_src.EventId.make(`${completed.eventId}:usage-limit`),
+				type: "runtime.error",
+				payload: {
+					message: turnError.message ?? "Codex usage limit reached.",
+					class: "usage_limit",
+					resetAt: state.exhausted ? state.resetAt : null
+				}
+			}, ...mapped];
+		}
+		return mapped;
+	};
+	return { annotate };
+}
 //#endregion
 //#region src/provider/Layers/CodexAdapter.ts
 /**
@@ -1557,9 +1713,10 @@ const PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES = 8 * require_src.PROVIDER_S
 * The revocation sentence keeps the note truthful for the runtime's whole
 * lifetime: instructions are fixed at session start, but the lease can be
 * revoked mid-session (feature disabled, listener stopped), after which
-* every request is rejected as unauthorized.
+* every request is rejected as unauthorized. Built on the shared host
+* context so Codex hears the same guidance as every other provider.
 */
-const CODEX_AGENT_CONTROL_INSTRUCTIONS = `Ryco Agent Control tools (ryco_*) are available through the '${CODEX_AGENT_CONTROL_SERVER_NAME}' MCP server on a private local connection. They can inspect Ryco projects, threads, transcripts, and request status. During an active turn, the four thread-action tools create immutable requests that require user approval in Ryco; they never mutate immediately. If the server is unreachable or rejects requests as unauthorized, Ryco has revoked this session's access — treat the tools as unavailable instead of retrying.`;
+const CODEX_AGENT_CONTROL_INSTRUCTIONS = `${require_bin.agentControlHostContext(true)} The server is '${CODEX_AGENT_CONTROL_SERVER_NAME}' on a private local connection; if it becomes unreachable, Ryco has revoked this session's access.`;
 function formatCodexRuntimeErrorDetail(error) {
 	if (!(error.message.includes("Expected \"fast\" | \"flex\"") && error.message.includes("[\"serviceTier\"]"))) return error.message;
 	return `${error.message}. This usually means the installed Codex CLI returned a newer service tier name than Ryco's generated app-server schema knows about. Rebuild effect-codex-app-server before rebuilding the server bundle.`;
@@ -1621,7 +1778,7 @@ function readTokenReductionInstructions(tokenMode) {
 		rtkInstalled: availability.installed
 	})));
 }
-function normalizeCodexTokenUsage(usage) {
+function normalizeCodexTokenUsage(usage, sessionId) {
 	const totalProcessedTokens = usage.total.totalTokens;
 	const usedTokens = usage.last.totalTokens;
 	if (usedTokens === void 0 || usedTokens < 0) return;
@@ -1631,6 +1788,15 @@ function normalizeCodexTokenUsage(usage) {
 	const outputTokens = usage.last.outputTokens;
 	const reasoningOutputTokens = usage.last.reasoningOutputTokens;
 	return {
+		processedUsage: {
+			scope: "session",
+			sessionId,
+			inputTokens: usage.total.inputTokens,
+			cachedInputTokens: usage.total.cachedInputTokens,
+			outputTokens: usage.total.outputTokens,
+			reasoningOutputTokens: usage.total.reasoningOutputTokens,
+			totalTokens: usage.total.totalTokens
+		},
 		usedTokens,
 		...totalProcessedTokens !== void 0 && totalProcessedTokens > usedTokens ? { totalProcessedTokens } : {},
 		...maxTokens !== void 0 ? { maxTokens } : {},
@@ -1655,6 +1821,22 @@ function toTurnStatus(value) {
 		default: return "completed";
 	}
 }
+/**
+* Fallback for a `turn/completed` that strict decoding rejects (for example a
+* `codexErrorInfo` literal newer than the pinned schema). Dropping it would leave the
+* turn running and its Agent Control authority bound.
+*/
+function readTurnCompletedStructurally(payload) {
+	const turn = payload !== null && typeof payload === "object" ? payload.turn : void 0;
+	if (turn === null || typeof turn !== "object") return void 0;
+	const { status, error } = turn;
+	const errorRecord = error !== null && typeof error === "object" ? error : null;
+	const errorMessage = trimText(typeof errorRecord?.message === "string" ? errorRecord.message : void 0);
+	return {
+		status: status === "completed" || status === "failed" || status === "cancelled" || status === "interrupted" ? status : errorRecord !== null ? "failed" : "completed",
+		...errorMessage ? { errorMessage } : {}
+	};
+}
 function normalizeItemType(raw) {
 	const type = trimText(raw);
 	if (!type) return "item";
@@ -1812,12 +1994,39 @@ function runtimeEventBase(event, canonicalThreadId) {
 		}
 	};
 }
+/**
+* A call to one of Ryco's HTML tools: shown by page title or viewport, and
+* carried without the page markup its arguments hold.
+*/
+function htmlRenderToolItem(payload) {
+	const { item } = payload;
+	if (item.type !== "mcpToolCall") return void 0;
+	const presentation = require_bin.resolveHtmlRenderToolPresentation({
+		toolName: item.tool,
+		serverName: item.server,
+		input: item.arguments
+	});
+	if (!presentation) return void 0;
+	return {
+		...presentation,
+		payload: {
+			...payload,
+			item: {
+				...item,
+				arguments: require_bin.withoutHtmlRenderMarkup(item.arguments)
+			}
+		}
+	};
+}
 function mapItemLifecycle(event, canonicalThreadId, lifecycle) {
-	const item = (readPayload(require_bin.V2ItemStartedNotification, event.payload) ?? readPayload(require_bin.V2ItemCompletedNotification, event.payload))?.item;
+	const payload = readPayload(require_bin.V2ItemStartedNotification, event.payload) ?? readPayload(require_bin.V2ItemCompletedNotification, event.payload);
+	const item = payload?.item;
 	if (!item) return;
 	const itemType = toCanonicalItemType(item.type);
 	if (itemType === "unknown" && lifecycle !== "item.updated") return;
-	const detail = itemDetail(item);
+	const htmlRender = htmlRenderToolItem(payload);
+	const title = htmlRender?.title ?? itemTitle(itemType);
+	const detail = htmlRender ? htmlRender.detail : itemDetail(item);
 	const status = lifecycle === "item.started" ? "inProgress" : lifecycle === "item.completed" ? "completed" : void 0;
 	return {
 		...runtimeEventBase(event, canonicalThreadId),
@@ -1825,9 +2034,9 @@ function mapItemLifecycle(event, canonicalThreadId, lifecycle) {
 		payload: {
 			itemType,
 			...status ? { status } : {},
-			...itemTitle(itemType) ? { title: itemTitle(itemType) } : {},
+			...title ? { title } : {},
 			...detail ? { detail } : {},
-			...event.payload !== void 0 ? { data: event.payload } : {}
+			...htmlRender ? { data: htmlRender.payload } : event.payload !== void 0 ? { data: event.payload } : {}
 		}
 	};
 }
@@ -2189,7 +2398,7 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 	}
 	if (event.method === "thread/tokenUsage/updated") {
 		const payload = readPayload(require_bin.V2ThreadTokenUsageUpdatedNotification, event.payload);
-		const normalizedUsage = payload ? normalizeCodexTokenUsage(payload.tokenUsage) : void 0;
+		const normalizedUsage = payload ? normalizeCodexTokenUsage(payload.tokenUsage, payload.threadId) : void 0;
 		if (!normalizedUsage) return [];
 		return [{
 			type: "thread.token-usage.updated",
@@ -2227,14 +2436,17 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 	}
 	if (event.method === "turn/completed") {
 		const payload = readPayload(require_bin.V2TurnCompletedNotification, event.payload);
-		if (!payload) return [];
-		const errorMessage = trimText(payload.turn.error?.message);
+		const completed = payload ? {
+			status: toTurnStatus(payload.turn.status),
+			errorMessage: trimText(payload.turn.error?.message)
+		} : readTurnCompletedStructurally(event.payload);
+		if (!completed) return [];
 		return [{
 			...runtimeEventBase(event, canonicalThreadId),
 			type: "turn.completed",
 			payload: {
-				state: toTurnStatus(payload.turn.status),
-				...errorMessage ? { errorMessage } : {}
+				state: completed.status,
+				...completed.errorMessage ? { errorMessage: completed.errorMessage } : {}
 			}
 		}];
 	}
@@ -2644,6 +2856,7 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			authorization: agentControlLease.value.credential,
 			instructions: CODEX_AGENT_CONTROL_INSTRUCTIONS
 		} : void 0;
+		const startServiceTier = input.modelSelection?.instanceId === boundInstanceId ? require_bin.codexServiceTierForSelection(input.modelSelection) : void 0;
 		const runtimeInput = {
 			threadId: input.threadId,
 			providerInstanceId: boundInstanceId,
@@ -2658,7 +2871,7 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			runtimeMode: input.runtimeMode,
 			tokenMode,
 			...input.modelSelection?.instanceId === boundInstanceId ? { model: input.modelSelection.model } : {},
-			...input.modelSelection?.instanceId === boundInstanceId && require_Metrics.getModelSelectionBooleanOptionValue(input.modelSelection, "fastMode") === true ? { serviceTier: "fast" } : {}
+			...startServiceTier ? { serviceTier: startServiceTier } : {}
 		};
 		const agentControl = effect.Option.getOrUndefined(agentControlLease);
 		const sessionScope = yield* effect.Scope.make("sequential");
@@ -2676,9 +2889,10 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			const current = sessions.get(input.threadId);
 			if (current?.runtime === runtime) yield* stopSessionInternal(current);
 		});
+		const usageLimits = makeCodexUsageLimitTracker();
 		const eventFiber = yield* effect.Stream.runForEach(runtime.events, (event) => effect.Effect.gen(function* () {
 			yield* writeNativeEvent(event);
-			const runtimeEvents = mapToRuntimeEvents(event, event.threadId).map((runtimeEvent) => require_runtimeSession.stampRuntimeEvent(runtimeEvent, {
+			const runtimeEvents = usageLimits.annotate(event, mapToRuntimeEvents(event, event.threadId), yield* effect.Clock.currentTimeMillis).map((runtimeEvent) => require_runtimeSession.stampRuntimeEvent(runtimeEvent, {
 				providerInstanceId: boundInstanceId,
 				runtimeSessionId
 			}));
@@ -2851,14 +3065,14 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		const codexAttachments = yield* effect.Effect.forEach(native, (attachment) => toCodexAttachment(attachment, "turn/start"), { concurrency: 1 });
 		const session = yield* requireSession(input.threadId);
 		const reasoningEffort = input.modelSelection?.instanceId === boundInstanceId ? require_Metrics.getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort") : void 0;
-		const fastMode = input.modelSelection?.instanceId === boundInstanceId ? require_Metrics.getModelSelectionBooleanOptionValue(input.modelSelection, "fastMode") : void 0;
+		const serviceTier = input.modelSelection?.instanceId === boundInstanceId ? require_bin.codexServiceTierForSelection(input.modelSelection) : void 0;
 		const formatted = require_sourceControlContextFormatter.formatSourceControlContextsForAgent(input.sourceControlContexts ?? []);
 		const codexInput = require_runtimeSession.appendAttachmentPathLines(formatted ? formatted + "\n\n" + (input.input ?? "") : input.input, pathLines);
 		const result = yield* session.runtime.sendTurn({
 			...codexInput !== void 0 ? { input: codexInput } : {},
 			...input.modelSelection?.instanceId === boundInstanceId ? { model: input.modelSelection.model } : {},
 			...reasoningEffort ? { effort: reasoningEffort } : {},
-			...fastMode === true ? { serviceTier: "fast" } : {},
+			...serviceTier ? { serviceTier } : {},
 			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {},
 			...input.customSystemPrompt !== void 0 ? { customSystemPrompt: input.customSystemPrompt } : {},
 			...codexAttachments.length > 0 ? { attachments: codexAttachments } : {}
@@ -2880,7 +3094,17 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			messageId: input.messageId,
 			...steerInput !== void 0 ? { input: steerInput } : {},
 			...codexAttachments.length > 0 ? { attachments: codexAttachments } : {}
-		}).pipe(effect.Effect.mapError((cause) => mapCodexRuntimeError(input.threadId, "turn/steer", cause)));
+		}).pipe(effect.Effect.mapError((cause) => mapCodexRuntimeError(input.threadId, "turn/steer", cause)), effect.Effect.catchTag("ProviderAdapterRequestError", (error) => effect.Effect.gen(function* () {
+			if ((yield* session.runtime.getSession).activeTurnId === input.expectedTurnId) return yield* error;
+			return yield* new require_bin.ProviderTurnNotSteerableError({
+				provider: PROVIDER,
+				threadId: input.threadId,
+				turnId: input.expectedTurnId,
+				reason: "turn-ended",
+				detail: "The turn finished before this message could be steered. It stays queued and is sent next.",
+				cause: error
+			});
+		})));
 	});
 	const requireSession = effect.Effect.fn("requireSession")(function* (threadId) {
 		const session = sessions.get(threadId);
@@ -2983,13 +3207,17 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			failedTurnIds
 		};
 	});
-	const rollbackThread = (threadId, numTurns) => {
+	const rollbackThread = (threadId, input) => {
+		const numTurns = input.numTurns;
 		if (!Number.isInteger(numTurns) || numTurns < 1) return effect.Effect.fail(new require_bin.ProviderAdapterValidationError({
 			provider: PROVIDER,
 			operation: "rollbackThread",
 			issue: "numTurns must be an integer >= 1."
 		}));
-		return requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.rollbackThread(numTurns)), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/rollback", cause)), effect.Effect.map((snapshot) => ({
+		return requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.rollbackThread({
+			numTurns,
+			beforeTurnId: input.droppedTurnIds[0]
+		})), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/rollback", cause)), effect.Effect.map((snapshot) => ({
 			threadId,
 			turns: snapshot.turns
 		})));
@@ -3045,7 +3273,9 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		provider: PROVIDER,
 		capabilities: {
 			sessionModelSwitch: "in-session",
-			turnSteering: "native"
+			turnSteering: "native",
+			conversationRollback: "native",
+			resumeSurvivesCwdChange: true
 		},
 		startSession,
 		sendTurn,