alink-cli 0.9.1 → 0.10.0

package/README.md

@@ -1,50 +1,49 @@
 # alink-cli
 
-在手机上或浏览器里远程控制你电脑上的 Claude Code、Codex、Gemini、Qwen、Kimi 等编码 agent。
+在手机或浏览器上，继续使用运行在你自己电脑上的 Claude Code、Codex、Gemini、Qwen、Kimi 等编码 agent。
 
-## 快速开始
+> **Local-first：** agent 在你的电脑上运行，项目文件和任务记录保存在本机。AgentLink 只负责加密连接设备，Hub 不保存你的对话。
 
-1. **全局安装**
+## 三步开始
+
+需要 Node.js 22.16 或更高版本。
+
+1. 安装 CLI
 
    ```bash
    npm install -g alink-cli
    ```
 
-2. **运行 CLI**
+2. 启动 AgentLink，并按提示登录
 
    ```bash
    alink-cli
    ```
 
-3. **按提示登录 AgentLink 账号**
+3. 在手机或浏览器打开 [AgentLink 控制台](https://link.harmopath.com/login)
 
-   首次登录后，这台电脑会自动加入你的账号。之后直接运行 `alink-cli` 就能重新上线。
+   登录同一个账号，你的电脑会自动出现。选择 agent 和工作目录，就可以开始任务或继续已有工作。
 
-4. **打开手机或浏览器访问控制台**
+关闭浏览器或锁屏后，任务仍会在你的电脑上继续运行。
 
-   选择你的电脑、选择 agent、选择工作目录，然后发任务。输出会实时流回；锁屏或关掉浏览器后，任务仍会继续在电脑上运行。
+## 为什么是 local-first
 
-同一台电脑只允许一个 AgentLink daemon 使用本机凭证运行；重复启动会被 CLI 拒绝，不会互相顶掉连接。
+- **本地运行：** agent 和命令都在你的电脑上执行。
+- **本地保存：** AgentLink 不会把你的项目复制到云端，任务记录保存在本机。
+- **安全连接：** 设备之间端到端加密；Hub 只转发连接，不保存对话内容。
+- **账号隔离：** 只有登录你账号的设备才能看到你的电脑。
 
 ## 常用命令
 
 ```bash
 alink-cli           # 启动或管理连接
-alink-cli login     # 登录并注册这台电脑
+alink-cli login     # 登录并添加这台电脑
 alink-cli status    # 查看连接状态
 alink-cli machines  # 查看账号下的电脑
 alink-cli logout    # 退出登录
 ```
 
-## 常用选项
-
-- `--dir <path>`：设置默认工作目录。
-- `--hub <url>`：连接到自己的 hub（自托管时使用）。
-- `--no-tui`：跳过交互界面，直接前台运行（适合脚本或非交互环境）。
-
-需要 Node.js 22.16 或更高版本。
-
 ## 了解更多
 
-- 完整文档：[github.com/baichen99/agentlink](https://github.com/baichen99/agentlink)
-- 提交问题：[github.com/baichen99/agentlink/issues](https://github.com/baichen99/agentlink/issues)
+- [完整文档](https://github.com/baichen99/agentlink)
+- [提交问题](https://github.com/baichen99/agentlink/issues)

package/dist/bin.mjs

@@ -14414,6 +14414,15 @@ Union([DispatchableClientOrchestrationCommand, Union([
 		session: OrchestrationSession,
 		createdAt: IsoDateTime
 	}),
+	Struct({
+		type: Literal("thread.message.user.import"),
+		commandId: CommandId,
+		threadId: ThreadId,
+		messageId: MessageId,
+		turnId: TurnId,
+		text: String$1,
+		createdAt: IsoDateTime
+	}),
 	Struct({
 		type: Literal("thread.message.assistant.delta"),
 		commandId: CommandId,
@@ -35789,6 +35798,32 @@ const decideOrchestrationCommand = fn("decideOrchestrationCommand")(function* ({
 					updatedAt: command.createdAt
 				}
 			};
+		case "thread.message.user.import":
+			yield* requireThread({
+				readModel,
+				command,
+				threadId: command.threadId
+			});
+			return {
+				...yield* withEventBase({
+					aggregateKind: "thread",
+					aggregateId: command.threadId,
+					occurredAt: command.createdAt,
+					commandId: command.commandId
+				}),
+				type: "thread.message-sent",
+				payload: {
+					threadId: command.threadId,
+					messageId: command.messageId,
+					role: "user",
+					text: command.text,
+					attachments: [],
+					turnId: command.turnId,
+					streaming: false,
+					createdAt: command.createdAt,
+					updatedAt: command.createdAt
+				}
+			};
 		case "thread.message.assistant.complete":
 			yield* requireThread({
 				readModel,
@@ -50911,6 +50946,29 @@ const normalizeDispatchCommand = (command) => gen(function* () {
 	};
 });
 //#endregion
+//#region src/orchestration/Services/ProviderRuntimeIngestion.ts
+/**
+* ProviderRuntimeIngestionService - Provider runtime ingestion service interface.
+*
+* Owns background workers that consume provider runtime streams and emit
+* orchestration commands/events.
+*
+* @module ProviderRuntimeIngestionService
+*/
+var ProviderRuntimeReconciliationError = class extends TaggedErrorClass()("ProviderRuntimeReconciliationError", {
+	threadId: ThreadId,
+	detail: String$1,
+	cause: optional$3(Defect())
+}) {
+	get message() {
+		return `Failed to reconcile provider thread '${this.threadId}': ${this.detail}`;
+	}
+};
+/**
+* ProviderRuntimeIngestionService - Service tag for runtime ingestion workers.
+*/
+var ProviderRuntimeIngestionService = class extends Service$2()("t3/orchestration/Services/ProviderRuntimeIngestion/ProviderRuntimeIngestionService") {};
+//#endregion
 //#region src/observability/RpcInstrumentation.ts
 const RPC_SPAN_PREFIX = "ws.rpc";
 const DEFAULT_RPC_SPAN_ATTRIBUTES = {
@@ -52518,6 +52576,7 @@ const wsRpcServices = gen(function* () {
 		crypto: yield* Crypto,
 		projectionSnapshotQuery: yield* ProjectionSnapshotQuery,
 		orchestrationEngine: yield* OrchestrationEngineService,
+		providerRuntimeIngestion: yield* ProviderRuntimeIngestionService,
 		keybindings: yield* Keybindings,
 		externalLauncher: yield* ExternalLauncher,
 		providerRegistry: yield* ProviderRegistry,
@@ -52538,7 +52597,7 @@ const wsRpcServices = gen(function* () {
 });
 const makeWsRpcLayer = (currentSession) => WsRpcGroup.toLayer(gen(function* () {
 	const currentSessionId = currentSession.sessionId;
-	const { crypto, projectionSnapshotQuery, orchestrationEngine, keybindings, externalLauncher, providerRegistry, config, lifecycleEvents, serverSettings, startup, workspaceEntries, workspaceFileSystem, gitWorkspace, terminalManager, serverEnvironment, backgroundPolicy, serverAuth, bootstrapCredentials, sessions } = yield* wsRpcServices;
+	const { crypto, projectionSnapshotQuery, orchestrationEngine, providerRuntimeIngestion, keybindings, externalLauncher, providerRegistry, config, lifecycleEvents, serverSettings, startup, workspaceEntries, workspaceFileSystem, gitWorkspace, terminalManager, serverEnvironment, backgroundPolicy, serverAuth, bootstrapCredentials, sessions } = yield* wsRpcServices;
 	const providerMaintenanceRunner = yield* ProviderMaintenanceRunner;
 	const rpcClientIds = yield* make$63(/* @__PURE__ */ new Set());
 	yield* addFinalizer(() => get$3(rpcClientIds).pipe(flatMap$1((clientIds) => forEach(clientIds, (clientId) => backgroundPolicy.removeRpcClient(currentSessionId, clientId), { discard: true })), ignore$1));
@@ -52681,7 +52740,8 @@ const makeWsRpcLayer = (currentSession) => WsRpcGroup.toLayer(gen(function* () {
 	});
 	const dispatchNormalizedCommand = (normalizedCommand) => {
 		const dispatchEffect = normalizedCommand.type === "thread.turn.start" && normalizedCommand.bootstrap ? dispatchBootstrapTurnStart(normalizedCommand) : orchestrationEngine.dispatch(normalizedCommand).pipe(mapError((cause) => toDispatchCommandError(cause, "Failed to dispatch orchestration command")));
-		return startup.enqueueCommand(dispatchEffect).pipe(mapError((cause) => toDispatchCommandError(cause, "Failed to dispatch orchestration command")));
+		const guardedDispatchEffect = normalizedCommand.type === "thread.turn.start" && normalizedCommand.bootstrap === void 0 ? providerRuntimeIngestion.reconcileThread(normalizedCommand.threadId, { requireWritable: true }).pipe(mapError((cause) => toDispatchCommandError(cause, "Failed to reconcile provider thread")), andThen(dispatchEffect)) : dispatchEffect;
+		return startup.enqueueCommand(guardedDispatchEffect).pipe(mapError((cause) => toDispatchCommandError(cause, "Failed to dispatch orchestration command")));
 	};
 	const loadServerConfig = gen(function* () {
 		const keybindingsConfig = yield* keybindings.loadConfigState;
@@ -52782,6 +52842,10 @@ const makeWsRpcLayer = (currentSession) => WsRpcGroup.toLayer(gen(function* () {
 			const liveBuffer = yield* unbounded$2();
 			yield* forkScoped(liveStream.pipe(runForEach((item) => offer$1(liveBuffer, item))));
 			const bufferedLiveStream = fromQueue(liveBuffer);
+			yield* providerRuntimeIngestion.reconcileThread(input.threadId).pipe(mapError((cause) => new OrchestrationGetSnapshotError({
+				message: cause.message,
+				cause
+			})));
 			if (input.afterSequence !== void 0) {
 				const afterSequence = input.afterSequence;
 				const replayGap = (yield* orchestrationEngine.latestSequence) - afterSequence;
@@ -54914,6 +54978,29 @@ const ProviderServiceLive = effect(ProviderService, fn("makeProviderService")(fu
 	});
 	const getCapabilities = (instanceId) => registry.getByInstance(instanceId).pipe(map$4((adapter) => adapter.capabilities));
 	const getInstanceInfo = (instanceId) => registry.getInstanceInfo(instanceId);
+	const readThread = fn("readThread")(function* (threadId) {
+		const binding = getOrUndefined(yield* directory.getBinding(threadId));
+		if (!binding) return yield* toValidationError("ProviderService.readThread", `Cannot read thread '${threadId}' because no persisted provider binding exists.`);
+		const instanceId = yield* requireBindingInstanceId("ProviderService.readThread", binding);
+		const adapter = yield* registry.getByInstance(instanceId);
+		const cwd = readPersistedCwd(binding.runtimePayload);
+		const modelSelection = readPersistedModelSelection(binding.runtimePayload);
+		const hasResumeCursor = binding.resumeCursor !== null && binding.resumeCursor !== void 0;
+		return yield* adapter.readThread({
+			threadId,
+			provider: binding.provider,
+			providerInstanceId: instanceId,
+			...cwd ? { cwd } : {},
+			...modelSelection ? { modelSelection } : {},
+			...hasResumeCursor ? { resumeCursor: binding.resumeCursor } : {},
+			runtimeMode: binding.runtimeMode ?? "full-access"
+		});
+	});
+	const ensureSession = (threadId) => resolveRoutableSession({
+		threadId,
+		operation: "ProviderService.ensureSession",
+		allowRecovery: true
+	}).pipe(asVoid);
 	const rollbackConversation = fn("rollbackConversation")(function* (rawInput) {
 		const input = yield* decodeInputOrValidationError({
 			operation: "ProviderService.rollbackConversation",
@@ -54984,6 +55071,8 @@ const ProviderServiceLive = effect(ProviderService, fn("makeProviderService")(fu
 		listSessions,
 		getCapabilities,
 		getInstanceInfo,
+		readThread,
+		ensureSession,
 		rollbackConversation,
 		get streamEvents() {
 			return fromPubSub(runtimeEventPubSub);
@@ -59352,8 +59441,8 @@ const makeClaudeAdapter = fn("makeClaudeAdapter")(function* (claudeSettings, opt
 			catch: (cause) => toRequestError(threadId, "turn/interrupt", cause)
 		});
 	});
-	const readThread = fn("readThread")(function* (threadId) {
-		const context = yield* requireSession(threadId);
+	const readThread = fn("readThread")(function* (input) {
+		const context = yield* requireSession(input.threadId);
 		return yield* snapshotThread(context);
 	});
 	const rollbackThread = fn("rollbackThread")(function* (threadId, numTurns) {
@@ -78832,8 +78921,14 @@ function updateSession(sessionRef, updates) {
 function parseThreadSnapshot(response) {
 	return {
 		threadId: response.thread.id,
+		createdAt: response.thread.createdAt,
+		updatedAt: response.thread.updatedAt,
+		status: response.thread.status,
 		turns: response.thread.turns.map((turn) => ({
 			id: TurnId.make(turn.id),
+			status: turn.status,
+			...turn.startedAt !== void 0 && turn.startedAt !== null ? { startedAt: turn.startedAt } : {},
+			...turn.completedAt !== void 0 && turn.completedAt !== null ? { completedAt: turn.completedAt } : {},
 			items: turn.items
 		}))
 	};
@@ -78874,6 +78969,10 @@ const makeCodexSessionRuntime = (options) => gen(function* () {
 	})));
 	const clientContext = yield* layerChildProcess$1(child).pipe(build, provideService(Scope, runtimeScope));
 	const client = yield* service(CodexAppServerClient).pipe(provide$1(clientContext));
+	const initializeClient = yield* cached(gen(function* () {
+		yield* client.request("initialize", buildCodexInitializeParams());
+		yield* client.notify("initialized", void 0);
+	}));
 	const serverNotifications = yield* unbounded$2();
 	const nowIso = map$4(now$1, formatIso);
 	const randomUUIDv4 = (purpose) => crypto.randomUUIDv4.pipe(mapError((cause) => new CodexAppServerIdentifierGenerationError({
@@ -79352,8 +79451,7 @@ const makeCodexSessionRuntime = (options) => gen(function* () {
 	}))), forkIn(runtimeScope));
 	const start = fn("CodexSessionRuntime.start")(function* () {
 		yield* emitSessionEvent("session/connecting", "Starting Codex App Server session.");
-		yield* client.request("initialize", buildCodexInitializeParams());
-		yield* client.notify("initialized", void 0);
+		yield* initializeClient;
 		const requestedModel = normalizeCodexModelSlug(options.model);
 		const opened = yield* openCodexThread({
 			client,
@@ -79447,6 +79545,7 @@ const makeCodexSessionRuntime = (options) => gen(function* () {
 		}),
 		readThread: gen(function* () {
 			const providerThreadId = yield* readProviderThreadId;
+			yield* initializeClient;
 			return parseThreadSnapshot(yield* client.request("thread/read", {
 				threadId: providerThreadId,
 				includeTurns: true
@@ -79748,6 +79847,7 @@ function runtimeEventBase(event, canonicalThreadId) {
 	return {
 		eventId: event.id,
 		provider: event.provider,
+		...event.providerInstanceId !== void 0 ? { providerInstanceId: event.providerInstanceId } : {},
 		threadId: canonicalThreadId,
 		createdAt: event.createdAt,
 		...event.turnId ? { turnId: event.turnId } : {},
@@ -80473,6 +80573,90 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 	}
 	return [];
 }
+function unixSecondsToIso(value, fallback) {
+	return (/* @__PURE__ */ new Date((value ?? fallback) * 1e3)).toISOString();
+}
+function summarizeCodexUserInput(input) {
+	switch (input.type) {
+		case "text": return input.text;
+		case "image":
+		case "localImage": return "[Image input omitted]";
+		case "audio":
+		case "localAudio": return "[Audio input omitted]";
+		case "skill": return `[Skill: ${input.name}]`;
+		case "mention": return `[Mention: ${input.name}]`;
+	}
+}
+/** Converts a native `thread/read` snapshot through the same item mapper as live events. */
+function mapCodexThreadSnapshot(canonicalThreadId, providerInstanceId, snapshot) {
+	const makeEvent = (input) => {
+		const itemId = input.item ? ProviderItemId.make(input.item.id) : void 0;
+		const suffix = itemId ? `item:${itemId}:completed` : input.method.replace("/", ":");
+		const createdAt = unixSecondsToIso(input.method === "turn/started" ? input.turn.startedAt : input.turn.completedAt, input.method === "turn/started" ? snapshot.createdAt : snapshot.updatedAt);
+		const payload = input.method === "item/completed" && input.item ? {
+			completedAtMs: Date.parse(createdAt),
+			threadId: snapshot.threadId,
+			turnId: input.turn.id,
+			item: input.item
+		} : {
+			threadId: snapshot.threadId,
+			turn: input.turn
+		};
+		return {
+			id: EventId.make(`codex-snapshot:${snapshot.threadId}:turn:${input.turn.id}:${suffix}`),
+			kind: "notification",
+			provider: PROVIDER,
+			providerInstanceId,
+			threadId: canonicalThreadId,
+			createdAt,
+			method: input.method,
+			turnId: input.turn.id,
+			...itemId ? { itemId } : {},
+			payload
+		};
+	};
+	return {
+		threadId: canonicalThreadId,
+		providerThreadId: snapshot.threadId,
+		status: snapshot.status.type,
+		activeFlags: snapshot.status.type === "active" ? snapshot.status.activeFlags : [],
+		turns: snapshot.turns.map((turn) => {
+			const terminal = turn.status !== "inProgress";
+			const nativeEvents = [
+				makeEvent({
+					method: "turn/started",
+					turn
+				}),
+				...terminal ? turn.items.map((item) => makeEvent({
+					method: "item/completed",
+					turn,
+					item
+				})) : [],
+				...terminal ? [makeEvent({
+					method: "turn/completed",
+					turn
+				})] : []
+			];
+			const userMessages = turn.items.flatMap((item) => {
+				if (item.type !== "userMessage") return [];
+				const text = item.content.map(summarizeCodexUserInput).filter((part) => part.trim().length > 0).join("\n");
+				return [{
+					id: ProviderItemId.make(item.id),
+					text: text.length > 0 ? text : "[Empty user message]"
+				}];
+			});
+			return {
+				id: turn.id,
+				status: turn.status,
+				...turn.startedAt !== void 0 ? { startedAt: unixSecondsToIso(turn.startedAt, snapshot.createdAt) } : {},
+				...turn.completedAt !== void 0 ? { completedAt: unixSecondsToIso(turn.completedAt, snapshot.updatedAt) } : {},
+				items: turn.items,
+				userMessages,
+				runtimeEvents: nativeEvents.flatMap((event) => mapToRuntimeEvents(event, canonicalThreadId))
+			};
+		})
+	};
+}
 /**
 * Build a Codex provider adapter bound to a specific `CodexSettings` payload.
 *
@@ -80492,16 +80676,10 @@ const makeCodexAdapter = fn("makeCodexAdapter")(function* (codexConfig, options)
 	const managedNativeEventLogger = options?.nativeEventLogger === void 0 ? nativeEventLogger : void 0;
 	const runtimeEventQueue = yield* unbounded$2();
 	const sessions = /* @__PURE__ */ new Map();
-	const startSession = (input) => scoped(gen(function* () {
-		if (input.provider !== void 0 && input.provider !== PROVIDER) return yield* new ProviderAdapterValidationError({
-			provider: PROVIDER,
-			operation: "startSession",
-			issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`
-		});
-		const existing = sessions.get(input.threadId);
-		if (existing && !existing.stopped) yield* suspend(() => stopSessionInternal(existing));
+	const createRuntime = options?.makeRuntime ?? makeCodexSessionRuntime;
+	const toRuntimeInput = (input) => {
 		const serviceTier = input.modelSelection?.instanceId === boundInstanceId ? getCodexServiceTierOptionValue(input.modelSelection) : void 0;
-		const runtimeInput = {
+		return {
 			threadId: input.threadId,
 			providerInstanceId: boundInstanceId,
 			cwd: input.cwd ?? process.cwd(),
@@ -80514,10 +80692,20 @@ const makeCodexAdapter = fn("makeCodexAdapter")(function* (codexConfig, options)
 			...input.modelSelection?.instanceId === boundInstanceId ? { model: input.modelSelection.model } : {},
 			...serviceTier ? { serviceTier } : {}
 		};
+	};
+	const startSession = (input) => scoped(gen(function* () {
+		if (input.provider !== void 0 && input.provider !== PROVIDER) return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER,
+			operation: "startSession",
+			issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`
+		});
+		const existing = sessions.get(input.threadId);
+		if (existing && !existing.stopped) yield* suspend(() => stopSessionInternal(existing));
+		const runtimeInput = toRuntimeInput(input);
 		const sessionScope = yield* make$76("sequential");
 		let sessionScopeTransferred = false;
 		yield* addFinalizer(() => sessionScopeTransferred ? void_$1 : close(sessionScope, void_$2));
-		const runtime = yield* (options?.makeRuntime ?? makeCodexSessionRuntime)(runtimeInput).pipe(provideService(Scope, sessionScope), provideService(ChildProcessSpawner, childProcessSpawner), provideService(Crypto, crypto), mapError((cause) => new ProviderAdapterProcessError({
+		const runtime = yield* createRuntime(runtimeInput).pipe(provideService(Scope, sessionScope), provideService(ChildProcessSpawner, childProcessSpawner), provideService(Crypto, crypto), mapError((cause) => new ProviderAdapterProcessError({
 			provider: PROVIDER,
 			threadId: input.threadId,
 			detail: cause.message,
@@ -80536,7 +80724,7 @@ const makeCodexAdapter = fn("makeCodexAdapter")(function* (codexConfig, options)
 				return;
 			}
 			yield* offerAll(runtimeEventQueue, runtimeEvents);
-		})).pipe(forkChild);
+		})).pipe(forkIn(sessionScope));
 		const started = yield* runtime.start().pipe(mapError((cause) => new ProviderAdapterProcessError({
 			provider: PROVIDER,
 			threadId: input.threadId,
@@ -80597,20 +80785,24 @@ const makeCodexAdapter = fn("makeCodexAdapter")(function* (codexConfig, options)
 		return session;
 	});
 	const interruptTurn = (threadId, turnId) => requireSession(threadId).pipe(flatMap$1((session) => session.runtime.interruptTurn(turnId)), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "turn/interrupt", cause)));
-	const readThread = (threadId) => requireSession(threadId).pipe(flatMap$1((session) => session.runtime.readThread), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/read", cause)), map$4((snapshot) => ({
-		threadId,
-		turns: snapshot.turns
-	})));
+	const readThread = (input) => {
+		const active = sessions.get(input.threadId);
+		return (active && !active.stopped ? active.runtime.readThread.pipe(mapError((cause) => mapCodexRuntimeError(input.threadId, "thread/read", cause))) : scoped(gen(function* () {
+			return yield* (yield* createRuntime(toRuntimeInput(input)).pipe(provideService(ChildProcessSpawner, childProcessSpawner), provideService(Crypto, crypto), mapError((cause) => new ProviderAdapterProcessError({
+				provider: PROVIDER,
+				threadId: input.threadId,
+				detail: cause.message,
+				cause
+			})))).readThread.pipe(mapError((cause) => mapCodexRuntimeError(input.threadId, "thread/read", cause)));
+		}))).pipe(map$4((snapshot) => mapCodexThreadSnapshot(input.threadId, boundInstanceId, snapshot)));
+	};
 	const rollbackThread = (threadId, numTurns) => {
 		if (!Number.isInteger(numTurns) || numTurns < 1) return fail(new ProviderAdapterValidationError({
 			provider: PROVIDER,
 			operation: "rollbackThread",
 			issue: "numTurns must be an integer >= 1."
 		}));
-		return requireSession(threadId).pipe(flatMap$1((session) => session.runtime.rollbackThread(numTurns)), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/rollback", cause)), map$4((snapshot) => ({
-			threadId,
-			turns: snapshot.turns
-		})));
+		return requireSession(threadId).pipe(flatMap$1((session) => session.runtime.rollbackThread(numTurns)), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "thread/rollback", cause)), map$4((snapshot) => mapCodexThreadSnapshot(threadId, boundInstanceId, snapshot)));
 	};
 	const respondToRequest = (threadId, requestId, decision) => requireSession(threadId).pipe(flatMap$1((session) => session.runtime.respondToRequest(requestId, decision)), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "item/requestApproval/decision", cause)));
 	const respondToUserInput = (threadId, requestId, answers) => requireSession(threadId).pipe(flatMap$1((session) => session.runtime.respondToUserInput(requestId, answers)), mapError((cause) => cause._tag === "ProviderAdapterSessionNotFoundError" ? cause : mapCodexRuntimeError(threadId, "item/tool/requestUserInput", cause)));
@@ -87085,10 +87277,11 @@ function makeAcpAgentAdapter(descriptor, settings, options) {
 				detail: `${descriptor.displayName} ACP sessions do not emit structured user-input requests (request ${requestId}).`
 			});
 		});
-		const readThread = (threadId) => gen(function* () {
+		const readThread = (input) => gen(function* () {
+			const ctx = yield* requireSession(input.threadId);
 			return {
-				threadId,
-				turns: (yield* requireSession(threadId)).turns
+				threadId: input.threadId,
+				turns: ctx.turns
 			};
 		});
 		const rollbackThread = (threadId, numTurns) => gen(function* () {
@@ -87986,20 +88179,6 @@ const ProviderInstanceRegistryHydrationLive = unwrap(gen(function* () {
 */
 var ProviderCommandReactor = class extends Service$2()("t3/orchestration/Services/ProviderCommandReactor") {};
 //#endregion
-//#region src/orchestration/Services/ProviderRuntimeIngestion.ts
-/**
-* ProviderRuntimeIngestionService - Provider runtime ingestion service interface.
-*
-* Owns background workers that consume provider runtime streams and emit
-* orchestration commands/events.
-*
-* @module ProviderRuntimeIngestionService
-*/
-/**
-* ProviderRuntimeIngestionService - Service tag for runtime ingestion workers.
-*/
-var ProviderRuntimeIngestionService = class extends Service$2()("t3/orchestration/Services/ProviderRuntimeIngestion/ProviderRuntimeIngestionService") {};
-//#endregion
 //#region src/orchestration/Services/ThreadDeletionReactor.ts
 /**
 * ThreadDeletionReactor - Thread deletion cleanup reactor service interface.
@@ -88560,7 +88739,18 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 	const providerService = yield* ProviderService;
 	const projectionTurnRepository = yield* ProjectionTurnRepository;
 	const serverSettingsService = yield* ServerSettingsService;
-	const providerCommandId = (event, tag) => crypto.randomUUIDv4.pipe(map$4((uuid) => CommandId.make(`provider:${event.eventId}:${tag}:${uuid}`)));
+	const providerCommandId = (event, tag) => String(event.eventId).startsWith("codex-snapshot:") ? succeed$1(CommandId.make(`provider:${event.eventId}:${tag}`)) : crypto.randomUUIDv4.pipe(map$4((uuid) => CommandId.make(`provider:${event.eventId}:${tag}:${uuid}`)));
+	const threadLocksRef = yield* make$53(/* @__PURE__ */ new Map());
+	const getThreadSemaphore = (threadId) => modifyEffect(threadLocksRef, (current) => {
+		const existing = current.get(threadId);
+		if (existing) return succeed$1([existing, current]);
+		return make$75(1).pipe(map$4((semaphore) => {
+			const next = new Map(current);
+			next.set(threadId, semaphore);
+			return [semaphore, next];
+		}));
+	});
+	const withThreadLock = (threadId, effect) => flatMap$1(getThreadSemaphore(threadId), (semaphore) => semaphore.withPermit(effect));
 	const turnMessageIdsByTurnKey = yield* make$81({
 		capacity: TURN_MESSAGE_IDS_BY_TURN_CACHE_CAPACITY,
 		timeToLive: TURN_MESSAGE_IDS_BY_TURN_TTL,
@@ -88679,7 +88869,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 		if (!hasRenderableAssistantText(bufferedText)) return false;
 		yield* orchestrationEngine.dispatch({
 			type: "thread.message.assistant.delta",
-			commandId: yield* providerCommandId(input.event, input.commandTag),
+			commandId: yield* providerCommandId(input.event, `${input.commandTag}:${input.messageId}`),
 			threadId: input.threadId,
 			messageId: input.messageId,
 			delta: bufferedText,
@@ -88707,7 +88897,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 		const hasRenderableText = hasRenderableAssistantText(text);
 		if (hasRenderableText) yield* orchestrationEngine.dispatch({
 			type: "thread.message.assistant.delta",
-			commandId: yield* providerCommandId(input.event, input.finalDeltaCommandTag),
+			commandId: yield* providerCommandId(input.event, `${input.finalDeltaCommandTag}:${input.messageId}`),
 			threadId: input.threadId,
 			messageId: input.messageId,
 			delta: text,
@@ -88716,7 +88906,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 		});
 		if (input.hasProjectedMessage || hasRenderableText) yield* orchestrationEngine.dispatch({
 			type: "thread.message.assistant.complete",
-			commandId: yield* providerCommandId(input.event, input.commandTag),
+			commandId: yield* providerCommandId(input.event, `${input.commandTag}:${input.messageId}`),
 			threadId: input.threadId,
 			messageId: input.messageId,
 			...input.turnId ? { turnId: input.turnId } : {},
@@ -88750,7 +88940,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 		const existingPlan = findProposedPlanById(input.threadProposedPlans, input.planId);
 		yield* orchestrationEngine.dispatch({
 			type: "thread.proposed-plan.upsert",
-			commandId: yield* providerCommandId(input.event, "proposed-plan-upsert"),
+			commandId: yield* providerCommandId(input.event, `proposed-plan-upsert:${input.planId}`),
 			threadId: input.threadId,
 			proposedPlan: {
 				id: input.planId,
@@ -89094,7 +89284,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 			taskTitle = yield* lookupTaskDescription(thread.id, event.payload.taskId);
 			if (!taskTitle) taskTitle = findTaskTitleInActivities((yield* getLoadedThreadDetail())?.activities, event.payload.taskId);
 		}
-		yield* forEach(runtimeEventToActivities(event, taskTitle), (activity) => providerCommandId(event, "thread-activity-append").pipe(flatMap$1((commandId) => orchestrationEngine.dispatch({
+		yield* forEach(runtimeEventToActivities(event, taskTitle), (activity) => providerCommandId(event, `thread-activity-append:${activity.id}`).pipe(flatMap$1((commandId) => orchestrationEngine.dispatch({
 			type: "thread.activity.append",
 			commandId,
 			threadId: thread.id,
@@ -89102,6 +89292,51 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 			createdAt: activity.createdAt
 		})))).pipe(asVoid);
 	});
+	const reconcileThreadUnlocked = fn("reconcileThreadUnlocked")(function* (threadId, options) {
+		const thread = yield* resolveThreadShell(threadId);
+		if (!thread || thread.session?.providerName !== ProviderDriverKind.make("codex")) return;
+		const snapshot = yield* providerService.readThread(threadId);
+		for (const turn of snapshot.turns) {
+			const existing = getOrUndefined(yield* projectionTurnRepository.getByTurnId({
+				threadId,
+				turnId: turn.id
+			}));
+			const isTerminal = turn.status === "completed" || turn.status === "failed" || turn.status === "interrupted";
+			if (isTerminal && existing && (existing.state === "completed" || existing.state === "error" || existing.state === "interrupted")) continue;
+			if (isTerminal) {
+				const pendingTurnStart = yield* projectionTurnRepository.getPendingTurnStartByThreadId({ threadId });
+				if (!(existing?.pendingMessageId !== null && existing?.pendingMessageId !== void 0 ? true : isSome(pendingTurnStart))) {
+					const createdAt = turn.startedAt ?? turn.runtimeEvents?.[0]?.createdAt ?? thread.session.updatedAt;
+					const providerThreadId = snapshot.providerThreadId ?? String(threadId);
+					for (const userMessage of turn.userMessages ?? []) yield* orchestrationEngine.dispatch({
+						type: "thread.message.user.import",
+						commandId: CommandId.make(`provider-user:${providerThreadId}:${turn.id}:${userMessage.id}:import`),
+						threadId,
+						messageId: MessageId.make(`provider-user:${providerThreadId}:${turn.id}:${userMessage.id}`),
+						turnId: turn.id,
+						text: userMessage.text,
+						createdAt
+					});
+				}
+			}
+			const runtimeEvents = turn.runtimeEvents ?? [];
+			yield* forEach(isTerminal ? runtimeEvents : runtimeEvents.filter((event) => event.type === "turn.started"), processRuntimeEvent, {
+				concurrency: 1,
+				discard: true
+			});
+		}
+		if (options?.requireWritable !== true) return;
+		if (snapshot.status !== "idle" && snapshot.status !== "notLoaded" || snapshot.turns.some((turn) => turn.status === "inProgress")) return yield* new ProviderRuntimeReconciliationError({
+			threadId,
+			detail: snapshot.status === "active" ? "Codex is still processing this thread; wait for it to finish before sending." : `Codex thread is not writable while its native status is '${snapshot.status ?? "unknown"}'.`
+		});
+		yield* providerService.ensureSession(threadId);
+	});
+	const reconcileThread = (threadId, options) => withThreadLock(threadId, reconcileThreadUnlocked(threadId, options)).pipe(mapError((cause) => cause instanceof ProviderRuntimeReconciliationError ? cause : new ProviderRuntimeReconciliationError({
+		threadId,
+		detail: cause instanceof Error ? cause.message : "Provider snapshot sync failed.",
+		cause
+	})));
 	const processDomainEvent = (_event) => void_$1;
 	const processInput = (input) => input.source === "runtime" ? processRuntimeEvent(input.event) : processDomainEvent(input.event);
 	const processInputSafely = (input) => processInput(input).pipe(catchCause((cause) => {
@@ -89129,6 +89364,7 @@ const ProviderRuntimeIngestionLive = effect(ProviderRuntimeIngestionService, gen
 	});
 	return {
 		start,
+		reconcileThread,
 		drain: worker.drain
 	};
 })).pipe(provide(ProjectionTurnRepositoryLive));