ryco-cli 0.1.21 → 0.1.23

package/dist/{CodexDriver-YG4IwzLm.cjs → CodexDriver-CR0S17Lb.cjs}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
-const require_collectUint8StreamText = require("./collectUint8StreamText-C5fop6Zf.cjs");
-const require_Metrics = require("./Metrics-DIjMQ5pa.cjs");
+const require_collectUint8StreamText = require("./collectUint8StreamText-DStwNTTK.cjs");
+const require_Metrics = require("./Metrics-Bcb9vCAe.cjs");
 const require_bin = require("./bin.cjs");
+const require_makeManagedServerProvider = require("./makeManagedServerProvider-VzxWN-04.cjs");
 const require_sourceControlContextFormatter = require("./sourceControlContextFormatter-BDZqn-4T.cjs");
 const require_ProjectCustomSystemPrompt = require("./ProjectCustomSystemPrompt-B8SUlNGa.cjs");
-const require_makeManagedServerProvider = require("./makeManagedServerProvider-BytnBN6b.cjs");
-const require_CodexTextGeneration = require("./CodexTextGeneration-CBJHkgOz.cjs");
+const require_CodexTextGeneration = require("./CodexTextGeneration-tlfe1S5W.cjs");
 let effect = require("effect");
 let effect_unstable_http = require("effect/unstable/http");
 let effect_unstable_process = require("effect/unstable/process");
@@ -179,13 +179,6 @@ const PROVIDER$1 = require_collectUint8StreamText.ProviderDriverKind.make("codex
 const ANSI_ESCAPE_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 const CODEX_STDERR_LOG_REGEX = /^\d{4}-\d{2}-\d{2}T\S+\s+(TRACE|DEBUG|INFO|WARN|ERROR)\s+\S+:\s+(.*)$/;
 const BENIGN_ERROR_LOG_SNIPPETS = ["state db missing rollout path for thread", "state db record_discrepancy: find_thread_path_by_id_str_in_subdir, falling_back"];
-const RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS = [
-	"not found",
-	"missing thread",
-	"no such thread",
-	"unknown thread",
-	"does not exist"
-];
 const CodexResumeCursorSchema = effect.Schema.Struct({ threadId: effect.Schema.String });
 const CodexUserInputAnswerObject = effect.Schema.Struct({ answers: effect.Schema.Array(effect.Schema.String) });
 const CodexTurnStartParamsWithCollaborationMode = require_bin.V2TurnStartParams.pipe(effect.Schema.fieldsAssign({ collaborationMode: effect.Schema.optionalKey(require_bin.V2TurnStartParams__CollaborationMode) }));
@@ -278,7 +271,10 @@ function buildThreadStartParams(input) {
 		approvalPolicy: config.approvalPolicy,
 		sandbox: config.sandbox,
 		approvalsReviewer: config.approvalsReviewer,
-		...Object.keys(mcpServers).length > 0 ? { config: { mcp_servers: mcpServers } } : {},
+		config: {
+			"features.goals": true,
+			...Object.keys(mcpServers).length > 0 ? { mcp_servers: mcpServers } : {}
+		},
 		...input.model ? { model: input.model } : {},
 		...input.serviceTier ? { serviceTier: input.serviceTier } : {}
 	};
@@ -359,11 +355,6 @@ function classifyCodexStderrLine(rawLine) {
 	}
 	return { message: line };
 }
-function isRecoverableThreadResumeError(error) {
-	const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-	if (!message.includes("thread")) return false;
-	return RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
-}
 const openCodexThread = (input) => {
 	const resumeThreadId = input.resumeThreadId;
 	const startParams = buildThreadStartParams({
@@ -378,13 +369,10 @@ const openCodexThread = (input) => {
 	return input.client.request("thread/resume", {
 		threadId: resumeThreadId,
 		...startParams
-	}).pipe(effect.Effect.catchIf(isRecoverableThreadResumeError, (error) => effect.Effect.logWarning("codex app-server thread resume fell back to fresh start", {
-		threadId: input.threadId,
-		requestedRuntimeMode: input.runtimeMode,
-		resumeThreadId,
-		recoverable: true,
-		cause: error.message
-	}).pipe(effect.Effect.andThen(input.client.request("thread/start", startParams)))));
+	}).pipe(effect.Effect.mapError((error) => error.message.includes("already has an active writer") ? new require_bin.CodexAppServerRequestError({
+		code: -32600,
+		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));
 };
 function readNotificationThreadId(notification) {
 	switch (notification.method) {
@@ -571,10 +559,31 @@ function parseThreadSnapshot(response) {
 		threadId: response.thread.id,
 		turns: response.thread.turns.map((turn) => ({
 			id: require_collectUint8StreamText.TurnId.make(turn.id),
-			items: turn.items
+			items: turn.items,
+			status: turn.status,
+			...turn.startedAt !== void 0 ? { startedAt: turn.startedAt } : {}
 		}))
 	};
 }
+const readStoredCodexThread = (input) => effect.Effect.scoped(effect.Effect.gen(function* () {
+	const context = yield* effect.Layer.build(require_bin.layerCommand({
+		command: input.binaryPath,
+		args: ["app-server"],
+		cwd: input.cwd,
+		env: {
+			...input.environment ?? process.env,
+			...input.homePath ? { CODEX_HOME: require_bin.expandHomePath(input.homePath) } : {}
+		},
+		requestTimeoutMs: 2e4
+	}));
+	const client = yield* effect.Effect.service(require_bin.CodexAppServerClient).pipe(effect.Effect.provide(context));
+	yield* client.request("initialize", require_bin.buildCodexInitializeParams());
+	yield* client.notify("initialized", void 0);
+	return parseThreadSnapshot(yield* client.request("thread/read", {
+		threadId: input.providerThreadId,
+		includeTurns: true
+	}));
+}));
 const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 	const spawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
 	const runtimeScope = yield* effect.Scope.Scope;
@@ -606,7 +615,8 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 		command: `${options.binaryPath} app-server`,
 		cause
 	})));
-	const clientContext = yield* require_bin.layerChildProcess(child).pipe(effect.Layer.build, effect.Effect.provideService(effect.Scope.Scope, runtimeScope));
+	const transportFailure = yield* effect.Deferred.make();
+	const clientContext = yield* require_bin.layerChildProcess(child, { onTermination: (error) => effect.Deferred.succeed(transportFailure, error).pipe(effect.Effect.asVoid) }).pipe(effect.Layer.build, effect.Effect.provideService(effect.Scope.Scope, runtimeScope));
 	const client = yield* effect.Effect.service(require_bin.CodexAppServerClient).pipe(effect.Effect.provide(clientContext));
 	const serverNotifications = yield* effect.Queue.bounded(512);
 	const initialSession = {
@@ -638,6 +648,16 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 		method,
 		message
 	});
+	yield* effect.Deferred.await(transportFailure).pipe(effect.Effect.flatMap((error) => effect.Ref.get(closedRef).pipe(effect.Effect.flatMap((closed) => closed ? effect.Effect.void : effect.Effect.gen(function* () {
+		deviceTurnActive = false;
+		yield* updateSession(sessionRef, {
+			status: "error",
+			activeTurnId: void 0,
+			lastError: "Codex connection was lost. Reopen the chat to recover its history."
+		});
+		yield* emitSessionEvent("session/exited", `Codex connection lost (${error._tag}).`);
+		yield* child.kill().pipe(effect.Effect.ignore);
+	})))), effect.Effect.forkIn(runtimeScope));
 	const settlePendingApprovals = (decision) => effect.Ref.get(pendingApprovalsRef).pipe(effect.Effect.flatMap((pendingApprovals) => effect.Effect.forEach(Array.from(pendingApprovals.values()), (pendingApproval) => effect.Deferred.succeed(pendingApproval.decision, decision).pipe(effect.Effect.ignore), { discard: true })));
 	const settlePendingUserInputs = (answers) => effect.Ref.get(pendingUserInputsRef).pipe(effect.Effect.flatMap((pendingUserInputs) => effect.Effect.forEach(Array.from(pendingUserInputs.values()), (pendingUserInput) => effect.Deferred.succeed(pendingUserInput.answers, answers).pipe(effect.Effect.ignore), { discard: true })));
 	/**
@@ -794,7 +814,8 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 					method: "collabAgent/item",
 					payload: {
 						...childIdentity,
-						item: notification.params.item
+						item: notification.params.item,
+						lifecycle: notification.method
 					}
 				});
 				return true;
@@ -1097,9 +1118,12 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 			...options.agentControl ? { agentControl: options.agentControl } : {}
 		});
 		const providerThreadId = opened.thread.id;
+		const activeTurn = opened.thread.turns.findLast((turn) => turn.status === "inProgress");
+		deviceTurnActive = activeTurn !== void 0;
 		const session = {
 			...yield* effect.Ref.get(sessionRef),
-			status: "ready",
+			status: activeTurn ? "running" : "ready",
+			activeTurnId: activeTurn ? require_collectUint8StreamText.TurnId.make(activeTurn.id) : void 0,
 			cwd: opened.cwd,
 			model: opened.model,
 			resumeCursor: { threadId: providerThreadId },
@@ -1199,10 +1223,19 @@ const makeCodexSessionRuntime = (options) => effect.Effect.gen(function* () {
 		}),
 		readThread: effect.Effect.gen(function* () {
 			const providerThreadId = yield* readProviderThreadId;
-			return parseThreadSnapshot(yield* client.request("thread/read", {
+			const response = yield* client.request("thread/read", {
 				threadId: providerThreadId,
 				includeTurns: true
-			}));
+			});
+			const session = yield* effect.Ref.get(sessionRef);
+			if (session.activeTurnId && response.thread.turns.some((turn) => turn.id === session.activeTurnId && turn.status !== "inProgress")) {
+				deviceTurnActive = false;
+				yield* updateSession(sessionRef, {
+					status: "ready",
+					activeTurnId: void 0
+				});
+			}
+			return parseThreadSnapshot(response);
 		}),
 		rollbackThread: (numTurns) => effect.Effect.gen(function* () {
 			const providerThreadId = yield* readProviderThreadId;
@@ -1364,7 +1397,7 @@ function readTokenReductionInstructions(tokenMode) {
 function normalizeCodexTokenUsage(usage) {
 	const totalProcessedTokens = usage.total.totalTokens;
 	const usedTokens = usage.last.totalTokens;
-	if (usedTokens === void 0 || usedTokens <= 0) return;
+	if (usedTokens === void 0 || usedTokens < 0) return;
 	const maxTokens = usage.modelContextWindow ?? void 0;
 	const inputTokens = usage.last.inputTokens;
 	const cachedInputTokens = usage.last.cachedInputTokens;
@@ -1734,7 +1767,35 @@ function mapCollabAgentEvent(event, canonicalThreadId) {
 			const looseSummary = (typeof item?.command === "string" ? item.command : void 0) ?? (typeof item?.title === "string" ? item.title : void 0) ?? (typeof item?.query === "string" ? item.query : void 0);
 			const canonical = toCanonicalItemType(itemTypeRaw);
 			const summary = looseSummary ?? canonical.replaceAll("_", " ");
-			return [{
+			if (canonical === "assistant_message" && payload.lifecycle === "item/completed" && typeof item?.text === "string" && typeof item.id === "string") return [{
+				...base,
+				type: "subagent.message.delta",
+				payload: {
+					subagentId: require_collectUint8StreamText.RuntimeSubagentId.make(agentThreadId),
+					providerThreadId: agentThreadId,
+					providerMessageId: item.id,
+					delta: item.text,
+					role: "assistant"
+				}
+			}];
+			const toolEvents = [];
+			if (require_collectUint8StreamText.isToolLifecycleItemType(canonical) && typeof item?.id === "string") {
+				const completed = payload.lifecycle === "item/completed" || item.status === "completed" || item.status === "failed";
+				toolEvents.push({
+					...base,
+					eventId: require_collectUint8StreamText.EventId.make(`${base.eventId}:tool`),
+					itemId: require_collectUint8StreamText.RuntimeItemId.make(`${agentThreadId}:${item.id}`),
+					type: completed ? "item.completed" : "item.updated",
+					payload: {
+						itemType: canonical,
+						status: item.status === "failed" ? "failed" : completed ? "completed" : "inProgress",
+						title: summary,
+						agentId: agentThreadId,
+						data: { item }
+					}
+				});
+			}
+			return [...toolEvents, {
 				...base,
 				type: "task.progress",
 				payload: {
@@ -2292,6 +2353,7 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 */
 const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexConfig, options) {
 	const boundInstanceId = options?.instanceId ?? require_collectUint8StreamText.ProviderInstanceId.make("codex");
+	const adapterScope = yield* effect.Scope.Scope;
 	const fileSystem = yield* effect.FileSystem.FileSystem;
 	const childProcessSpawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
 	const serverConfig = yield* effect.Effect.service(require_Metrics.ServerConfig);
@@ -2371,6 +2433,11 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			detail: formatCodexRuntimeErrorDetail(cause),
 			cause
 		})));
+		let runtimeExited = false;
+		const retireRuntime = effect.Effect.gen(function* () {
+			const current = sessions.get(input.threadId);
+			if (current?.runtime === runtime) yield* stopSessionInternal(current);
+		});
 		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_makeManagedServerProvider.stampRuntimeEvent(runtimeEvent, {
@@ -2393,19 +2460,43 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			}
 			yield* effect.Queue.offerAll(runtimeEventQueue, runtimeEvents);
 			yield* runtimeEventQueueMetrics.recordEnqueued(runtimeEvents.length);
-		})).pipe(effect.Effect.forkIn(sessionScope));
+			if (runtimeEvents.some((runtimeEvent) => runtimeEvent.type === "session.exited")) {
+				runtimeExited = true;
+				yield* retireRuntime.pipe(effect.Effect.forkIn(adapterScope));
+			}
+		})).pipe(effect.Effect.catchCause((cause) => effect.Cause.hasInterruptsOnly(cause) ? effect.Effect.interrupt : effect.Effect.gen(function* () {
+			runtimeExited = true;
+			if (agentControl) yield* agentControl.revoke("runtime-teardown");
+			yield* effect.Effect.logWarning("Codex event consumer failed; retiring its runtime", { threadId: input.threadId });
+			yield* effect.Queue.offer(runtimeEventQueue, {
+				eventId: require_collectUint8StreamText.EventId.make(crypto.randomUUID()),
+				provider: PROVIDER,
+				providerInstanceId: boundInstanceId,
+				runtimeSessionId,
+				threadId: input.threadId,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				type: "session.exited",
+				payload: {
+					reason: "Codex event stream failed. Reopen the chat to recover.",
+					recoverable: true,
+					exitKind: "error"
+				}
+			});
+			yield* runtimeEventQueueMetrics.recordEnqueued(1);
+			yield* retireRuntime.pipe(effect.Effect.forkIn(adapterScope));
+		})), effect.Effect.forkIn(sessionScope));
 		const started = yield* runtime.start().pipe(effect.Effect.mapError((cause) => new require_bin.ProviderAdapterProcessError({
 			provider: PROVIDER,
 			threadId: input.threadId,
 			detail: formatCodexRuntimeErrorDetail(cause),
 			cause
 		})), effect.Effect.onError(() => runtime.close.pipe(effect.Effect.andThen(effect.Effect.ignore(effect.Scope.close(sessionScope, effect.Exit.void))), effect.Effect.andThen(effect.Fiber.interrupt(eventFiber)), effect.Effect.ignore)));
-		if (started.runtimeSessionId !== void 0 && started.runtimeSessionId !== runtimeSessionId) {
+		if (runtimeExited || started.runtimeSessionId !== void 0 && started.runtimeSessionId !== runtimeSessionId) {
 			yield* runtime.close.pipe(effect.Effect.andThen(effect.Fiber.interrupt(eventFiber)), effect.Effect.andThen(effect.Scope.close(sessionScope, effect.Exit.void)), effect.Effect.ignore);
 			return yield* new require_bin.ProviderAdapterValidationError({
 				provider: PROVIDER,
 				operation: "startSession",
-				issue: `Codex runtime returned epoch '${started.runtimeSessionId}' for requested epoch '${runtimeSessionId}'.`
+				issue: runtimeExited ? "Codex runtime exited while the session was starting." : `Codex runtime returned epoch '${started.runtimeSessionId}' for requested epoch '${runtimeSessionId}'.`
 			});
 		}
 		sessions.set(input.threadId, {
@@ -2469,13 +2560,21 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			method,
 			detail: `Turn has ${attachments.length} attachments; limit is 8.`
 		});
-		const resolved = yield* effect.Effect.forEach(attachments, (attachment) => resolveAttachmentForPreflight(attachment, method), { concurrency: 1 });
+		const native = attachments.filter((attachment) => attachment.type === "image");
+		const resolved = yield* effect.Effect.forEach(native, (attachment) => resolveAttachmentForPreflight(attachment, method), { concurrency: 1 });
 		const totalBytes = resolved.reduce((total, entry) => total + entry.sizeBytes, 0);
 		if (totalBytes > PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES) return yield* new require_bin.ProviderAdapterRequestError({
 			provider: PROVIDER,
 			method,
 			detail: `Turn attachments total ${totalBytes} bytes; limit is ${PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
 		});
+		const pathLineEntries = attachments.filter((attachment) => attachment.type !== "image").map((attachment) => ({
+			attachment,
+			...attachment.id === void 0 ? {} : { resolvedPath: require_bin.resolveAttachmentPath({
+				attachmentsDir: serverConfig.attachmentsDir,
+				attachment
+			}) ?? void 0 }
+		}));
 		if (resolved.length > 0) {
 			yield* effect.Effect.annotateCurrentSpan({
 				"provider.attachment_count": resolved.length,
@@ -2492,7 +2591,10 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 				}))
 			});
 		}
-		return resolved;
+		return {
+			native: resolved,
+			pathLines: require_makeManagedServerProvider.formatAttachmentPathLines(pathLineEntries)
+		};
 	});
 	const toCodexAttachment = effect.Effect.fn("toCodexAttachment")(function* (resolved, method) {
 		const bytes = yield* fileSystem.readFile(resolved.path).pipe(effect.Effect.mapError((cause) => new require_bin.ProviderAdapterRequestError({
@@ -2507,13 +2609,13 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		};
 	});
 	const sendTurn = effect.Effect.fn("sendTurn")(function* (input) {
-		const resolvedAttachments = yield* preflightAttachments(input, "turn/start");
-		const codexAttachments = yield* effect.Effect.forEach(resolvedAttachments, (attachment) => toCodexAttachment(attachment, "turn/start"), { concurrency: 1 });
+		const { native, pathLines } = yield* preflightAttachments(input, "turn/start");
+		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_bin.getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort") : void 0;
 		const fastMode = input.modelSelection?.instanceId === boundInstanceId ? require_bin.getModelSelectionBooleanOptionValue(input.modelSelection, "fastMode") : void 0;
 		const formatted = require_sourceControlContextFormatter.formatSourceControlContextsForAgent(input.sourceControlContexts ?? []);
-		const codexInput = formatted ? formatted + "\n\n" + (input.input ?? "") : input.input;
+		const codexInput = require_makeManagedServerProvider.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 } : {},
@@ -2531,12 +2633,14 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		return result;
 	});
 	const steerTurn = effect.Effect.fn("steerTurn")(function* (input) {
-		const resolvedAttachments = yield* preflightAttachments(input, "turn/steer");
-		const codexAttachments = yield* effect.Effect.forEach(resolvedAttachments, (attachment) => toCodexAttachment(attachment, "turn/steer"), { concurrency: 1 });
-		return yield* (yield* requireSession(input.threadId)).runtime.steerTurn({
+		const { native, pathLines } = yield* preflightAttachments(input, "turn/steer");
+		const codexAttachments = yield* effect.Effect.forEach(native, (attachment) => toCodexAttachment(attachment, "turn/steer"), { concurrency: 1 });
+		const session = yield* requireSession(input.threadId);
+		const steerInput = require_makeManagedServerProvider.appendAttachmentPathLines(input.input, pathLines);
+		return yield* session.runtime.steerTurn({
 			expectedTurnId: input.expectedTurnId,
 			messageId: input.messageId,
-			...input.input !== void 0 ? { input: input.input } : {},
+			...steerInput !== void 0 ? { input: steerInput } : {},
 			...codexAttachments.length > 0 ? { attachments: codexAttachments } : {}
 		}).pipe(effect.Effect.mapError((cause) => mapCodexRuntimeError(input.threadId, "turn/steer", cause)));
 	});
@@ -2567,6 +2671,64 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		threadId,
 		turns: snapshot.turns
 	})));
+	const readThreadHistory = (input) => effect.Effect.gen(function* () {
+		if (!effect.Schema.is(CodexResumeCursorSchema)(input.resumeCursor)) return yield* new require_bin.ProviderAdapterValidationError({
+			provider: PROVIDER,
+			operation: "readThreadHistory",
+			issue: "Missing Codex thread identity."
+		});
+		const existing = sessions.get(input.threadId);
+		const liveSession = existing && !existing.stopped ? yield* existing.runtime.getSession : void 0;
+		const liveSnapshot = existing && liveSession && (liveSession.status === "ready" || liveSession.status === "running") && effect.Schema.is(CodexResumeCursorSchema)(liveSession.resumeCursor) && liveSession.resumeCursor.threadId === input.resumeCursor.threadId ? yield* existing.runtime.readThread.pipe(effect.Effect.timeoutOption("2 seconds"), effect.Effect.orElseSucceed(() => effect.Option.none())) : effect.Option.none();
+		const snapshot = effect.Option.isSome(liveSnapshot) ? liveSnapshot.value : yield* readStoredCodexThread({
+			binaryPath: codexConfig.binaryPath,
+			cwd: input.cwd ?? process.cwd(),
+			providerThreadId: input.resumeCursor.threadId,
+			...codexConfig.homePath ? { homePath: codexConfig.homePath } : {},
+			...options?.environment ? { environment: options.environment } : {}
+		}).pipe(effect.Effect.provideService(effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner), effect.Effect.mapError((cause) => mapCodexRuntimeError(input.threadId, "thread/read", cause)));
+		const messages = [];
+		const items = [];
+		const completedTurnIds = [];
+		const failedTurnIds = [];
+		for (const turn of snapshot.turns) {
+			if (!turn.status || turn.status === "inProgress") continue;
+			completedTurnIds.push(turn.id);
+			if (turn.status === "failed") failedTurnIds.push(turn.id);
+			const createdAt = (/* @__PURE__ */ new Date((turn.startedAt ?? 0) * 1e3)).toISOString();
+			for (const item of turn.items) if (item.type === "agentMessage" || item.type === "userMessage") messages.push({
+				id: require_collectUint8StreamText.MessageId.make(item.type === "agentMessage" ? `assistant:${item.id}` : item.clientId ?? `user:${item.id}`),
+				turnId: turn.id,
+				role: item.type === "agentMessage" ? "assistant" : "user",
+				text: item.type === "agentMessage" ? item.text : item.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n"),
+				createdAt
+			});
+			else {
+				const event = mapItemLifecycle({
+					id: require_collectUint8StreamText.EventId.make(`history:${input.threadId}:${snapshot.threadId}:${turn.id}:${item.id}`),
+					provider: PROVIDER,
+					threadId: input.threadId,
+					kind: "notification",
+					method: "item/completed",
+					turnId: turn.id,
+					itemId: require_collectUint8StreamText.ProviderItemId.make(item.id),
+					createdAt,
+					payload: {
+						threadId: snapshot.threadId,
+						turnId: turn.id,
+						item
+					}
+				}, input.threadId, "item.completed");
+				if (event) items.push(event);
+			}
+		}
+		return {
+			messages,
+			items,
+			completedTurnIds,
+			failedTurnIds
+		};
+	});
 	const rollbackThread = (threadId, numTurns) => {
 		if (!Number.isInteger(numTurns) || numTurns < 1) return effect.Effect.fail(new require_bin.ProviderAdapterValidationError({
 			provider: PROVIDER,
@@ -2578,11 +2740,34 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 			turns: snapshot.turns
 		})));
 	};
-	const setThreadGoal = (threadId, goal) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.setGoal({
-		objective: goal.objective,
-		status: goal.status,
-		tokenBudget: goal.tokenBudget
-	})), effect.Effect.asVoid, effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/goal/set", cause)));
+	const setThreadGoal = (threadId, goal) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => {
+		const fields = goal.synchronization?.fields ?? [
+			"objective",
+			"status",
+			"tokenBudget"
+		];
+		return session.runtime.setGoal({
+			...fields.includes("objective") ? { objective: goal.objective } : {},
+			...fields.includes("status") ? { status: goal.status } : {},
+			...fields.includes("tokenBudget") ? { tokenBudget: goal.tokenBudget } : {}
+		});
+	}), effect.Effect.flatMap((response) => {
+		const goal = normalizeCodexThreadGoal(response.goal);
+		return goal ? effect.Effect.succeed(goal) : effect.Effect.fail(new require_bin.ProviderAdapterRequestError({
+			provider: "codex",
+			method: "thread/goal/set",
+			detail: "Codex returned an invalid goal."
+		}));
+	}), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" || cause._tag === "ProviderAdapterRequestError" ? cause : mapCodexRuntimeError(threadId, "thread/goal/set", cause)));
+	const getThreadGoal = (threadId) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.getGoal), effect.Effect.flatMap((response) => {
+		if (!response.goal) return effect.Effect.succeed(null);
+		const goal = normalizeCodexThreadGoal(response.goal);
+		return goal ? effect.Effect.succeed(goal) : effect.Effect.fail(new require_bin.ProviderAdapterRequestError({
+			provider: "codex",
+			method: "thread/goal/get",
+			detail: "Codex returned an invalid goal."
+		}));
+	}), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" || cause._tag === "ProviderAdapterRequestError" ? cause : mapCodexRuntimeError(threadId, "thread/goal/get", cause)));
 	const clearThreadGoal = (threadId) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.clearGoal), effect.Effect.asVoid, effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/goal/clear", cause)));
 	const respondToRequest = (threadId, requestId, decision) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.respondToRequest(requestId, decision)), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "item/requestApproval/decision", cause)));
 	const respondToUserInput = (threadId, requestId, answers) => requireSession(threadId).pipe(effect.Effect.flatMap((session) => session.runtime.respondToUserInput(requestId, answers)), effect.Effect.mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "item/tool/requestUserInput", cause)));
@@ -2613,8 +2798,10 @@ const makeCodexAdapter = effect.Effect.fn("makeCodexAdapter")(function* (codexCo
 		steerTurn,
 		interruptTurn,
 		readThread,
+		readThreadHistory,
 		rollbackThread,
 		setThreadGoal,
+		getThreadGoal,
 		clearThreadGoal,
 		respondToRequest,
 		respondToUserInput,