t3code-cli 0.13.0 → 0.14.1

package/dist/client-runtime/state/threads.js

@@ -0,0 +1,934 @@
+import { $D as flatMap, $t as projectRefCollectionKey, Aa as EnvironmentSupervisor, BD as andThen, BE as filter$1, Bk as isSome, Cn as startThreadTurn, Cv as get$1, Dn as unsnoozeThread, EO as succeed, En as unsettleThread, Ev as update, Fk as getOrElse, Fr as buildEnvironmentAuthHeaders, GC as set, GD as catchCause, Gr as family, HD as as, Hk as match, IC as HttpClient, IE as debounce, Ik as getOrNull, Io as environmentEndpointUrl, Ir as withEnvironmentCredentials, JD as catchTags, JS as EnvironmentId, Ja as ManagedRelayDpopSigner, Jr as setIdleTTL, Jt as arrayElementsEqual, KE as map$3, Kk as Number$1, La as EnvironmentCacheStore, Lk as getOrThrow, Mo as executeEnvironmentHttpRequest, No as makeEnvironmentHttpApiClient, QO as effect, Qk as mapInput, RD as addFinalizer, RO as void_, Sn as snoozeThread, Sv as changes, Tn as unarchiveThread, Tv as set$1, UC as get, Uk as none, VD as annotateLogs, Vk as map$2, WC as make$2, WE as fromQueue, Wk as some, Wr as subscribeDynamic, XE as never, XO as pretty, Xk as combineAll, Xr as withLabel, Xt as parseProjectRefCollectionKey, YD as catch_, Yk as combine, ZO as squash, Zt as parseThreadKey, _O as orElseSucceed, _k as map$1, _n as respondToThreadUserInput, aO as gen, bO as provideService, bn as setThreadRuntimeMode, cA as pipe, cO as logDebug, eO as fn, fn as createThread, gk as filter, gn as respondToThreadApproval, hk as append, hn as interruptThreadTurn, iO as forkScoped, ja as ConnectionWakeups, kk as Service, kn as updateThreadMetadata, ky as ORCHESTRATION_WS_METHODS, lD as unwrap, lO as logWarning, lr as createAtomCommandScheduler, mn as deleteThread, nD as runHead, nn as threadRefsEqual, or as scopeThread, qk as String, qr as make, sr as scopeThreadShell, tD as runForEach, ti as value, tn as threadKey, uO as map, un as archiveThread, ur as createEnvironmentCommand, vD as offer, vk as sort, vn as revertThreadCheckpoint, wO as serviceOption, wn as stopThreadSession, wv as make$1, xD as sliding, xn as settleThread, xr as followStreamInEnvironment, xs as connectionProjectionPhase, yn as setThreadInteractionMode, zD as all, zk as isNone } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/threadSnapshotHttp.ts
+const DEFAULT_THREAD_SNAPSHOT_TIMEOUT_MS = 6e3;
+/**
+* Load a thread's detail snapshot over HTTP instead of embedding it in the
+* WebSocket subscription's first frame. The response is gzip-compressible by
+* the transport and keeps the (potentially multi-KB) snapshot off the socket.
+*/
+const fetchEnvironmentThreadSnapshot = fn("clientRuntime.state.fetchEnvironmentThreadSnapshot")(function* (input) {
+	const requestUrl = environmentEndpointUrl(input.prepared.httpBaseUrl, `/api/orchestration/threads/${input.threadId}`);
+	const client = yield* makeEnvironmentHttpApiClient(input.prepared.httpBaseUrl);
+	const headers = yield* buildEnvironmentAuthHeaders(input.prepared.httpAuthorization, "GET", requestUrl, input.signer);
+	return yield* executeEnvironmentHttpRequest(requestUrl, input.timeoutMs ?? DEFAULT_THREAD_SNAPSHOT_TIMEOUT_MS, withEnvironmentCredentials(input.prepared.httpAuthorization, client.orchestration.threadSnapshot({
+		params: { threadId: input.threadId },
+		headers
+	})));
+});
+/**
+* Loads a thread's detail snapshot over HTTP, returning `Option.none()` when it
+* cannot be loaded (so the caller falls back to the socket-embedded snapshot).
+* Decouples the thread state machine from the underlying HTTP + DPoP details and
+* keeps them out of test contexts.
+*/
+var ThreadSnapshotLoader = class extends Service()("@t3tools/client-runtime/state/threadSnapshotHttp/ThreadSnapshotLoader") {};
+const threadSnapshotLoaderLayer = effect(ThreadSnapshotLoader, gen(function* () {
+	const httpClient = yield* HttpClient;
+	const signer = yield* serviceOption(ManagedRelayDpopSigner);
+	return ThreadSnapshotLoader.of({ load: (prepared, threadId) => fetchEnvironmentThreadSnapshot({
+		prepared,
+		threadId,
+		signer
+	}).pipe(map(some), provideService(HttpClient, httpClient), catchTags({ EnvironmentResourceNotFoundError: () => logDebug("Thread snapshot not found over HTTP; deferring to the socket subscription.").pipe(annotateLogs({ threadId }), as(none())) }), catchCause((cause) => logWarning("Could not load the thread snapshot over HTTP; using the socket snapshot instead.").pipe(annotateLogs({
+		threadId,
+		cause: pretty(cause)
+	}), as(none())))) });
+}));
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadReducer.ts
+const proposedPlanOrder = combine(mapInput(String, (p) => p.createdAt), mapInput(String, (p) => p.id));
+const checkpointOrder = mapInput(Number$1, (cp) => cp.checkpointTurnCount ?? Number.MAX_SAFE_INTEGER);
+const activityOrder = combineAll([
+	mapInput(Number$1, (a) => a.sequence ?? Number.MAX_SAFE_INTEGER),
+	mapInput(String, (a) => a.createdAt),
+	mapInput(String, (a) => a.id)
+]);
+/**
+* Apply a single orchestration event to an `OrchestrationThread`, returning
+* the updated thread, a deletion signal, or an "unchanged" marker when the
+* event doesn't affect this thread.
+*
+* This is a pure reducer operating on contract types. UI-specific mapping
+* (e.g. resolving attachment preview URLs, normalising model slugs, adding
+* scoped fields like `environmentId`) is the caller's responsibility.
+*/
+function applyThreadDetailEvent(thread, event) {
+	switch (event.type) {
+		case "project.created":
+		case "project.meta-updated":
+		case "project.deleted": return { kind: "unchanged" };
+		case "thread.created": return {
+			kind: "updated",
+			thread: {
+				id: event.payload.threadId,
+				projectId: event.payload.projectId,
+				title: event.payload.title,
+				modelSelection: event.payload.modelSelection,
+				runtimeMode: event.payload.runtimeMode,
+				interactionMode: event.payload.interactionMode,
+				branch: event.payload.branch,
+				worktreePath: event.payload.worktreePath,
+				latestTurn: null,
+				createdAt: event.payload.createdAt,
+				updatedAt: event.payload.updatedAt,
+				archivedAt: null,
+				settledOverride: null,
+				settledAt: null,
+				snoozedUntil: null,
+				snoozedAt: null,
+				deletedAt: null,
+				messages: [],
+				proposedPlans: [],
+				activities: [],
+				checkpoints: [],
+				session: null
+			}
+		};
+		case "thread.deleted": return { kind: "deleted" };
+		case "thread.archived": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				archivedAt: event.payload.archivedAt,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.unarchived": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				archivedAt: null,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.settled": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				settledOverride: "settled",
+				settledAt: event.payload.settledAt,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.unsettled": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				settledOverride: event.payload.reason === "user" ? "active" : null,
+				settledAt: null,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.snoozed": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				snoozedUntil: event.payload.snoozedUntil,
+				snoozedAt: event.payload.snoozedAt,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.unsnoozed": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				snoozedUntil: null,
+				snoozedAt: null,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.meta-updated": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				...event.payload.title !== void 0 ? { title: event.payload.title } : {},
+				...event.payload.modelSelection !== void 0 ? { modelSelection: event.payload.modelSelection } : {},
+				...event.payload.branch !== void 0 ? { branch: event.payload.branch } : {},
+				...event.payload.worktreePath !== void 0 ? { worktreePath: event.payload.worktreePath } : {},
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.runtime-mode-set": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				runtimeMode: event.payload.runtimeMode,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.interaction-mode-set": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				interactionMode: event.payload.interactionMode,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.turn-start-requested": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				...event.payload.modelSelection !== void 0 ? { modelSelection: event.payload.modelSelection } : {},
+				runtimeMode: event.payload.runtimeMode,
+				interactionMode: event.payload.interactionMode,
+				updatedAt: event.occurredAt
+			}
+		};
+		case "thread.turn-interrupt-requested": {
+			if (event.payload.turnId === void 0) return { kind: "unchanged" };
+			const latestTurn = thread.latestTurn;
+			if (latestTurn === null || latestTurn.turnId !== event.payload.turnId) return { kind: "unchanged" };
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					latestTurn: {
+						...latestTurn,
+						state: "interrupted",
+						startedAt: latestTurn.startedAt ?? event.payload.createdAt,
+						completedAt: latestTurn.completedAt ?? event.payload.createdAt
+					},
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.message-sent": {
+			const message = {
+				id: event.payload.messageId,
+				role: event.payload.role,
+				text: event.payload.text,
+				...event.payload.attachments !== void 0 ? { attachments: event.payload.attachments } : {},
+				turnId: event.payload.turnId,
+				streaming: event.payload.streaming,
+				createdAt: event.payload.createdAt,
+				updatedAt: event.payload.updatedAt
+			};
+			const messages = thread.messages.find((entry) => entry.id === message.id) ? map$1(thread.messages, (entry) => entry.id !== message.id ? entry : {
+				...entry,
+				text: message.streaming ? `${entry.text}${message.text}` : message.text.length > 0 ? message.text : entry.text,
+				streaming: message.streaming,
+				...message.turnId !== void 0 ? { turnId: message.turnId } : {},
+				...message.streaming ? {} : { updatedAt: message.updatedAt },
+				...message.attachments !== void 0 ? { attachments: message.attachments } : {}
+			}) : append(thread.messages, message);
+			const turnStillRunning = event.payload.turnId !== null && thread.session?.status === "running" && thread.session.activeTurnId === event.payload.turnId;
+			const settlesTurn = !event.payload.streaming && !turnStillRunning;
+			const latestTurn = event.payload.role === "assistant" && event.payload.turnId !== null && (thread.latestTurn === null || thread.latestTurn.turnId === event.payload.turnId) ? {
+				turnId: event.payload.turnId,
+				state: settlesTurn ? thread.latestTurn?.state === "interrupted" ? "interrupted" : thread.latestTurn?.state === "error" ? "error" : "completed" : "running",
+				requestedAt: thread.latestTurn?.turnId === event.payload.turnId ? thread.latestTurn.requestedAt : event.payload.createdAt,
+				startedAt: thread.latestTurn?.turnId === event.payload.turnId ? thread.latestTurn.startedAt ?? event.payload.createdAt : event.payload.createdAt,
+				completedAt: settlesTurn ? event.payload.updatedAt : thread.latestTurn?.turnId === event.payload.turnId ? thread.latestTurn.completedAt ?? null : null,
+				assistantMessageId: event.payload.messageId
+			} : thread.latestTurn;
+			const checkpoints = event.payload.role === "assistant" && event.payload.turnId !== null ? rebindCheckpointAssistantMessage(thread.checkpoints, event.payload.turnId, event.payload.messageId) : thread.checkpoints;
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					messages,
+					checkpoints,
+					latestTurn,
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.session-set": {
+			const settledTurnState = settledTurnStateForSessionStatus(event.payload.session.status);
+			const latestTurn = event.payload.session.status === "running" && event.payload.session.activeTurnId !== null ? {
+				turnId: event.payload.session.activeTurnId,
+				state: "running",
+				requestedAt: thread.latestTurn?.turnId === event.payload.session.activeTurnId ? thread.latestTurn.requestedAt : event.payload.session.updatedAt,
+				startedAt: thread.latestTurn?.turnId === event.payload.session.activeTurnId ? thread.latestTurn.startedAt ?? event.payload.session.updatedAt : event.payload.session.updatedAt,
+				completedAt: null,
+				assistantMessageId: thread.latestTurn?.turnId === event.payload.session.activeTurnId ? thread.latestTurn.assistantMessageId : null
+			} : thread.latestTurn !== null && thread.latestTurn.state === "running" && settledTurnState !== null ? {
+				...thread.latestTurn,
+				state: settledTurnState,
+				completedAt: event.payload.session.updatedAt
+			} : thread.latestTurn;
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					session: event.payload.session,
+					latestTurn,
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.session-stop-requested": return thread.session === null ? { kind: "unchanged" } : {
+			kind: "updated",
+			thread: {
+				...thread,
+				session: {
+					...thread.session,
+					status: "stopped",
+					activeTurnId: null,
+					updatedAt: event.payload.createdAt
+				},
+				updatedAt: event.occurredAt
+			}
+		};
+		case "thread.proposed-plan-upserted": {
+			const proposedPlan = event.payload.proposedPlan;
+			const proposedPlans = pipe(thread.proposedPlans, filter((entry) => entry.id !== proposedPlan.id), append(proposedPlan), sort(proposedPlanOrder));
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					proposedPlans,
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.turn-diff-completed": {
+			const checkpoint = {
+				turnId: event.payload.turnId,
+				checkpointTurnCount: event.payload.checkpointTurnCount,
+				checkpointRef: event.payload.checkpointRef,
+				status: event.payload.status,
+				files: event.payload.files,
+				assistantMessageId: event.payload.assistantMessageId,
+				completedAt: event.payload.completedAt
+			};
+			const existing = thread.checkpoints.find((entry) => entry.turnId === checkpoint.turnId);
+			if (existing && existing.status !== "missing" && checkpoint.status === "missing") return { kind: "unchanged" };
+			const checkpoints = pipe(thread.checkpoints, filter((entry) => entry.turnId !== checkpoint.turnId), append(checkpoint), sort(checkpointOrder));
+			const latestTurn = !(thread.session?.status === "running" && thread.session.activeTurnId === event.payload.turnId) && (thread.latestTurn === null || thread.latestTurn.turnId === event.payload.turnId) ? {
+				turnId: event.payload.turnId,
+				state: checkpointStatusToTurnState(event.payload.status),
+				requestedAt: thread.latestTurn?.requestedAt ?? event.payload.completedAt,
+				startedAt: thread.latestTurn?.startedAt ?? event.payload.completedAt,
+				completedAt: event.payload.completedAt,
+				assistantMessageId: event.payload.assistantMessageId
+			} : thread.latestTurn;
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					checkpoints,
+					latestTurn,
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.reverted": {
+			const checkpoints = pipe(thread.checkpoints, filter((entry) => entry.checkpointTurnCount !== void 0 && entry.checkpointTurnCount <= event.payload.turnCount), sort(checkpointOrder));
+			const retainedTurnIds = new Set(map$1(checkpoints, (entry) => entry.turnId));
+			const messages = retainMessagesAfterRevert(thread.messages, retainedTurnIds);
+			const proposedPlans = pipe(thread.proposedPlans, filter((plan) => plan.turnId === null || retainedTurnIds.has(plan.turnId)));
+			const activities = pipe(thread.activities, filter((activity) => activity.turnId === null || retainedTurnIds.has(activity.turnId)));
+			const latestCheckpoint = checkpoints.at(-1) ?? null;
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					checkpoints,
+					messages,
+					proposedPlans,
+					activities,
+					latestTurn: latestCheckpoint === null ? null : {
+						turnId: latestCheckpoint.turnId,
+						state: checkpointStatusToTurnState(latestCheckpoint.status),
+						requestedAt: latestCheckpoint.completedAt,
+						startedAt: latestCheckpoint.completedAt,
+						completedAt: latestCheckpoint.completedAt,
+						assistantMessageId: latestCheckpoint.assistantMessageId ?? null
+					},
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.activity-appended": {
+			const activities = pipe(thread.activities, filter((activity) => activity.id !== event.payload.activity.id), append(event.payload.activity), sort(activityOrder));
+			return {
+				kind: "updated",
+				thread: {
+					...thread,
+					activities,
+					updatedAt: event.occurredAt
+				}
+			};
+		}
+		case "thread.approval-response-requested":
+		case "thread.user-input-response-requested":
+		case "thread.checkpoint-revert-requested": return { kind: "unchanged" };
+	}
+	return { kind: "unchanged" };
+}
+/**
+* Turn state to settle a still-running latest turn with when its session
+* leaves the "running" status, or null while the session is (re)starting or
+* running and the turn must stay unsettled.
+*/
+function settledTurnStateForSessionStatus(status) {
+	switch (status) {
+		case "idle":
+		case "ready": return "completed";
+		case "error": return "error";
+		case "interrupted":
+		case "stopped": return "interrupted";
+		case "starting":
+		case "running": return null;
+	}
+}
+function checkpointStatusToTurnState(status) {
+	switch (status) {
+		case "ready": return "completed";
+		case "error": return "error";
+		case "missing": return "completed";
+	}
+}
+function rebindCheckpointAssistantMessage(checkpoints, turnId, messageId) {
+	return map$1(checkpoints, (entry) => entry.turnId === turnId ? {
+		...entry,
+		assistantMessageId: messageId
+	} : entry);
+}
+function retainMessagesAfterRevert(messages, retainedTurnIds) {
+	return filter(messages, (message) => {
+		if (message.role === "system") return true;
+		if (message.turnId === null) return true;
+		return retainedTurnIds.has(message.turnId);
+	});
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadRetention.ts
+const THREAD_STATE_IDLE_TTL_MS = 5 * 6e4;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadState.ts
+const EMPTY_ENVIRONMENT_THREAD_STATE = {
+	data: none(),
+	status: "empty",
+	error: none()
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/archivedThreads.ts
+const ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR = "";
+const environmentIdOrder = String;
+function makeArchivedThreadsEnvironmentKey(environmentIds) {
+	return pipe(environmentIds, sort(environmentIdOrder), (sortedEnvironmentIds) => sortedEnvironmentIds.join(ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR));
+}
+function parseArchivedThreadsEnvironmentKey(key) {
+	if (key.length === 0) return [];
+	return pipe(key.split(ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR), map$1((environmentId) => EnvironmentId.make(environmentId)));
+}
+function createArchivedThreadSnapshotsAtomFamily(options) {
+	return family((environmentKey) => make((get) => {
+		const snapshots = [];
+		let error = null;
+		let isLoading = false;
+		for (const environmentId of parseArchivedThreadsEnvironmentKey(environmentKey)) {
+			const result = get(options.getSnapshotAtom(environmentId));
+			isLoading ||= result.waiting;
+			const snapshot = getOrNull(value(result));
+			if (snapshot !== null) snapshots.push({
+				environmentId,
+				snapshot
+			});
+			if (error === null && result._tag === "Failure") error = "Failed to load archived threads.";
+		}
+		return {
+			snapshots,
+			error,
+			isLoading
+		};
+	}).pipe(withLabel(`${options.labelPrefix}:${environmentKey}`)));
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadCommands.ts
+function createThreadEnvironmentAtoms(runtime) {
+	const scheduler = createAtomCommandScheduler();
+	const concurrency = {
+		mode: "serial",
+		key: ({ environmentId, input }) => JSON.stringify([environmentId, input.threadId])
+	};
+	return {
+		create: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:create",
+			execute: (input) => createThread(input),
+			scheduler,
+			concurrency
+		}),
+		delete: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:delete",
+			execute: (input) => deleteThread(input),
+			scheduler,
+			concurrency
+		}),
+		archive: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:archive",
+			execute: (input) => archiveThread(input),
+			scheduler,
+			concurrency
+		}),
+		unarchive: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:unarchive",
+			execute: (input) => unarchiveThread(input),
+			scheduler,
+			concurrency
+		}),
+		settle: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:settle",
+			execute: (input) => settleThread(input),
+			scheduler,
+			concurrency
+		}),
+		unsettle: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:unsettle",
+			execute: (input) => unsettleThread(input),
+			scheduler,
+			concurrency
+		}),
+		snooze: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:snooze",
+			execute: (input) => snoozeThread(input),
+			scheduler,
+			concurrency
+		}),
+		unsnooze: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:unsnooze",
+			execute: (input) => unsnoozeThread(input),
+			scheduler,
+			concurrency
+		}),
+		updateMetadata: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:update-metadata",
+			execute: (input) => updateThreadMetadata(input),
+			scheduler,
+			concurrency
+		}),
+		setRuntimeMode: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:set-runtime-mode",
+			execute: (input) => setThreadRuntimeMode(input),
+			scheduler,
+			concurrency
+		}),
+		setInteractionMode: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:set-interaction-mode",
+			execute: (input) => setThreadInteractionMode(input),
+			scheduler,
+			concurrency
+		}),
+		startTurn: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:start-turn",
+			execute: (input) => startThreadTurn(input),
+			scheduler,
+			concurrency
+		}),
+		interruptTurn: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:interrupt-turn",
+			execute: (input) => interruptThreadTurn(input),
+			scheduler,
+			concurrency
+		}),
+		respondToApproval: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:respond-to-approval",
+			execute: (input) => respondToThreadApproval(input),
+			scheduler,
+			concurrency
+		}),
+		respondToUserInput: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:respond-to-user-input",
+			execute: (input) => respondToThreadUserInput(input),
+			scheduler,
+			concurrency
+		}),
+		revertCheckpoint: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:revert-checkpoint",
+			execute: (input) => revertThreadCheckpoint(input),
+			scheduler,
+			concurrency
+		}),
+		stopSession: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:stop-session",
+			execute: (input) => stopThreadSession(input),
+			scheduler,
+			concurrency
+		})
+	};
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadDetail.ts
+const EMPTY_MESSAGES = Object.freeze([]);
+const EMPTY_ACTIVITIES = Object.freeze([]);
+const EMPTY_PROPOSED_PLANS = Object.freeze([]);
+const EMPTY_CHECKPOINTS = Object.freeze([]);
+/**
+* Combine detail-only collections with the shell's authoritative thread metadata.
+*
+* Shell and detail subscriptions are intentionally independent. A cached detail can
+* therefore briefly outlive a newer shell snapshot after reconnecting. Workspace
+* consumers must use the shell branch/worktree/project fields so they do not target
+* a stale checkout while retaining messages, activities, plans, and checkpoints
+* from the detail subscription.
+*/
+function mergeEnvironmentThread(detail, shell) {
+	if (detail === null || shell === null) return detail;
+	if (detail.environmentId !== shell.environmentId || detail.id !== shell.id) return detail;
+	return {
+		...detail,
+		environmentId: shell.environmentId,
+		id: shell.id,
+		projectId: shell.projectId,
+		title: shell.title,
+		modelSelection: shell.modelSelection,
+		runtimeMode: shell.runtimeMode,
+		interactionMode: shell.interactionMode,
+		branch: shell.branch,
+		worktreePath: shell.worktreePath,
+		latestTurn: shell.latestTurn,
+		createdAt: shell.createdAt,
+		updatedAt: shell.updatedAt,
+		archivedAt: shell.archivedAt,
+		settledOverride: shell.settledOverride,
+		settledAt: shell.settledAt,
+		snoozedUntil: shell.snoozedUntil,
+		snoozedAt: shell.snoozedAt,
+		session: shell.session
+	};
+}
+function createEnvironmentThreadDetailAtoms(threadStateAtom) {
+	const threadStateValueAtomFamily = family((key) => {
+		const ref = parseThreadKey(key);
+		return make((get) => getOrElse(value(get(threadStateAtom(ref.environmentId, ref.threadId))), () => EMPTY_ENVIRONMENT_THREAD_STATE)).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-state-value:${key}`));
+	});
+	const threadDetailAtomFamily = family((key) => {
+		const ref = parseThreadKey(key);
+		let previousSource = null;
+		let previousValue = null;
+		return make((get) => {
+			const source = getOrNull(get(threadStateValueAtomFamily(key)).data);
+			if (source === previousSource) return previousValue;
+			previousSource = source;
+			previousValue = source === null ? null : scopeThread(ref.environmentId, source);
+			return previousValue;
+		}).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-detail:${key}`));
+	});
+	const threadStatusAtomFamily = family((key) => make((get) => get(threadStateValueAtomFamily(key)).status).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-status:${key}`)));
+	const threadErrorAtomFamily = family((key) => make((get) => getOrNull(get(threadStateValueAtomFamily(key)).error)).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-error:${key}`)));
+	const threadMessagesAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.messages ?? EMPTY_MESSAGES).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-messages:${key}`)));
+	const threadActivitiesAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.activities ?? EMPTY_ACTIVITIES).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-activities:${key}`)));
+	const threadProposedPlansAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.proposedPlans ?? EMPTY_PROPOSED_PLANS).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-proposed-plans:${key}`)));
+	const threadCheckpointsAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.checkpoints ?? EMPTY_CHECKPOINTS).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-checkpoints:${key}`)));
+	const threadSessionAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.session ?? null).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-session:${key}`)));
+	const threadLatestTurnAtomFamily = family((key) => make((get) => get(threadDetailAtomFamily(key))?.latestTurn ?? null).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-latest-turn:${key}`)));
+	return {
+		stateAtom: (ref) => threadStateValueAtomFamily(threadKey(ref)),
+		detailAtom: (ref) => threadDetailAtomFamily(threadKey(ref)),
+		statusAtom: (ref) => threadStatusAtomFamily(threadKey(ref)),
+		errorAtom: (ref) => threadErrorAtomFamily(threadKey(ref)),
+		messagesAtom: (ref) => threadMessagesAtomFamily(threadKey(ref)),
+		activitiesAtom: (ref) => threadActivitiesAtomFamily(threadKey(ref)),
+		proposedPlansAtom: (ref) => threadProposedPlansAtomFamily(threadKey(ref)),
+		checkpointsAtom: (ref) => threadCheckpointsAtomFamily(threadKey(ref)),
+		sessionAtom: (ref) => threadSessionAtomFamily(threadKey(ref)),
+		latestTurnAtom: (ref) => threadLatestTurnAtomFamily(threadKey(ref))
+	};
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadShell.ts
+const EMPTY_THREADS = Object.freeze([]);
+const EMPTY_SCOPED_THREAD_REFS = Object.freeze([]);
+const EMPTY_THREAD_INDEX = /* @__PURE__ */ new Map();
+const EMPTY_THREAD_REFS_BY_PROJECT = /* @__PURE__ */ new Map();
+function createEnvironmentThreadShellAtoms(input) {
+	const environmentThreadsAtom = family((environmentId) => make((get) => get(input.snapshotAtom(environmentId))?.threads ?? EMPTY_THREADS).pipe(withLabel(`environment-threads:${environmentId}`)));
+	const environmentThreadIndexAtom = family((environmentId) => make((get) => {
+		const threads = get(environmentThreadsAtom(environmentId));
+		if (threads.length === 0) return EMPTY_THREAD_INDEX;
+		return new Map(threads.map((thread) => [thread.id, thread]));
+	}).pipe(withLabel(`environment-thread-index:${environmentId}`)));
+	const environmentThreadRefsAtom = family((environmentId) => {
+		let previous = [];
+		return make((get) => {
+			const next = get(environmentThreadsAtom(environmentId)).map((thread) => ({
+				environmentId,
+				threadId: thread.id
+			}));
+			if (threadRefsEqual(previous, next)) return previous;
+			previous = next;
+			return next;
+		}).pipe(withLabel(`environment-thread-refs:${environmentId}`));
+	});
+	const environmentThreadRefsByProjectAtom = family((environmentId) => {
+		let previous = EMPTY_THREAD_REFS_BY_PROJECT;
+		return make((get) => {
+			const grouped = /* @__PURE__ */ new Map();
+			for (const thread of get(environmentThreadsAtom(environmentId))) {
+				const refs = grouped.get(thread.projectId);
+				const ref = {
+					environmentId,
+					threadId: thread.id
+				};
+				if (refs === void 0) grouped.set(thread.projectId, [ref]);
+				else refs.push(ref);
+			}
+			if (grouped.size === 0) {
+				previous = EMPTY_THREAD_REFS_BY_PROJECT;
+				return previous;
+			}
+			const next = /* @__PURE__ */ new Map();
+			for (const [projectId, refs] of grouped) {
+				const previousRefs = previous.get(projectId);
+				next.set(projectId, previousRefs !== void 0 && threadRefsEqual(previousRefs, refs) ? previousRefs : refs);
+			}
+			previous = next;
+			return previous;
+		}).pipe(withLabel(`environment-thread-refs-by-project:${environmentId}`));
+	});
+	const threadShellAtomFamily = family((key) => {
+		const ref = parseThreadKey(key);
+		let previousSource = null;
+		let previousValue = null;
+		return make((get) => {
+			const source = get(environmentThreadIndexAtom(ref.environmentId)).get(ref.threadId) ?? null;
+			if (source === previousSource) return previousValue;
+			previousSource = source;
+			previousValue = source === null ? null : scopeThreadShell(ref.environmentId, source);
+			return previousValue;
+		}).pipe(withLabel(`environment-thread-shell:${key}`));
+	});
+	const threadShellsForProjectRefsAtomFamily = family((key) => {
+		const projectRefs = parseProjectRefCollectionKey(key);
+		let previous = [];
+		return make((get) => {
+			const next = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const projectRef of projectRefs) {
+				const refs = get(environmentThreadRefsByProjectAtom(projectRef.environmentId)).get(projectRef.projectId) ?? EMPTY_SCOPED_THREAD_REFS;
+				for (const ref of refs) {
+					const key = threadKey(ref);
+					if (seen.has(key)) continue;
+					seen.add(key);
+					const thread = get(threadShellAtomFamily(key));
+					if (thread !== null) next.push(thread);
+				}
+			}
+			if (arrayElementsEqual(previous, next)) return previous;
+			previous = next;
+			return previous;
+		}).pipe(withLabel(`environment-thread-shells-for-projects:${key}`));
+	});
+	let previousThreadRefs = [];
+	const threadRefsAtom = make((get) => {
+		const refs = [];
+		for (const environmentId of get(input.catalogValueAtom).entries.keys()) refs.push(...get(environmentThreadRefsAtom(environmentId)));
+		if (threadRefsEqual(previousThreadRefs, refs)) return previousThreadRefs;
+		previousThreadRefs = refs;
+		return refs;
+	}).pipe(withLabel("environment-thread-refs"));
+	let previousThreadShells = [];
+	return {
+		environmentThreadsAtom,
+		environmentThreadIndexAtom,
+		environmentThreadRefsAtom,
+		environmentThreadRefsByProjectAtom,
+		threadRefsAtom,
+		threadShellsAtom: make((get) => {
+			const next = get(threadRefsAtom).flatMap((ref) => {
+				const thread = get(threadShellAtomFamily(threadKey(ref)));
+				return thread === null ? [] : [thread];
+			});
+			if (arrayElementsEqual(previousThreadShells, next)) return previousThreadShells;
+			previousThreadShells = next;
+			return previousThreadShells;
+		}).pipe(withLabel("environment-thread-shell-list")),
+		threadShellsForProjectRefsAtom: (refs) => threadShellsForProjectRefsAtomFamily(projectRefCollectionKey(refs)),
+		threadShellAtom: (ref) => threadShellAtomFamily(threadKey(ref))
+	};
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threads.ts
+function statusWithoutLiveData(data) {
+	return isSome(data) ? "cached" : "empty";
+}
+function formatThreadError(cause) {
+	const error = squash(cause);
+	return error instanceof Error && error.message.trim().length > 0 ? error.message : "Could not synchronize the thread.";
+}
+function shouldPersistThread(thread) {
+	const status = thread.session?.status;
+	return status !== "starting" && status !== "running";
+}
+const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (threadId) {
+	const supervisor = yield* EnvironmentSupervisor;
+	const cache = yield* EnvironmentCacheStore;
+	const snapshotLoader = yield* ThreadSnapshotLoader;
+	const wakeups = yield* serviceOption(ConnectionWakeups);
+	const environmentId = supervisor.target.environmentId;
+	const cached = yield* cache.loadThread(environmentId, threadId).pipe(catch_((error) => logWarning("Could not load cached thread.").pipe(annotateLogs({
+		environmentId,
+		threadId,
+		error: error.message
+	}), as(none()))));
+	const cachedThread = map$2(cached, (snapshot) => snapshot.thread);
+	const state = yield* make$1({
+		data: cachedThread,
+		status: statusWithoutLiveData(cachedThread),
+		error: none()
+	});
+	const lastSequence = yield* make$1(match(cached, {
+		onNone: () => 0,
+		onSome: (snapshot) => snapshot.snapshotSequence
+	}));
+	const awaitingCompletion = yield* make$2(false);
+	const persistence = yield* sliding(1);
+	const persist = fn("EnvironmentThreadState.persist")(function* (snapshot) {
+		yield* cache.saveThread(environmentId, snapshot).pipe(catch_((error) => logWarning("Could not persist the thread cache.").pipe(annotateLogs({
+			environmentId,
+			threadId,
+			error: error.message
+		}))));
+	});
+	yield* fromQueue(persistence).pipe(debounce("500 millis"), runForEach(persist), forkScoped);
+	const setSynchronizing = update(state, (current) => current.status === "deleted" ? current : {
+		...current,
+		status: "synchronizing",
+		error: none()
+	});
+	const setReady = update(state, (current) => current.status === "live" || current.status === "deleted" ? current : {
+		...current,
+		status: "synchronizing",
+		error: none()
+	});
+	const setDisconnected = gen(function* () {
+		yield* set(awaitingCompletion, false);
+		yield* update(state, (current) => ({
+			...current,
+			status: current.status === "deleted" ? current.status : statusWithoutLiveData(current.data)
+		}));
+	});
+	const setStreamError = (cause) => set(awaitingCompletion, false).pipe(andThen(update(state, (current) => ({
+		...current,
+		status: current.status === "deleted" ? current.status : statusWithoutLiveData(current.data),
+		error: some(formatThreadError(cause))
+	}))));
+	const setThread = fn("EnvironmentThreadState.setThread")(function* (thread) {
+		const waiting = yield* get(awaitingCompletion);
+		yield* set$1(state, {
+			data: some(thread),
+			status: waiting ? "synchronizing" : "live",
+			error: none()
+		});
+		if (shouldPersistThread(thread)) {
+			const snapshotSequence = yield* get$1(lastSequence);
+			yield* offer(persistence, {
+				snapshotSequence,
+				thread
+			});
+		}
+	});
+	const setDeleted = fn("EnvironmentThreadState.setDeleted")(function* () {
+		yield* set(awaitingCompletion, false);
+		yield* set$1(state, {
+			data: none(),
+			status: "deleted",
+			error: none()
+		});
+		yield* cache.removeThread(environmentId, threadId).pipe(catch_((error) => logWarning("Could not remove the cached thread.").pipe(annotateLogs({
+			environmentId,
+			threadId,
+			error: error.message
+		}))));
+	});
+	const applyItem = fn("EnvironmentThreadState.applyItem")(function* (item) {
+		if (item.kind === "synchronized") {
+			yield* set(awaitingCompletion, false);
+			yield* update(state, (current) => isSome(current.data) && current.status !== "deleted" ? {
+				...current,
+				status: "live",
+				error: none()
+			} : current);
+			return;
+		}
+		if (item.kind === "snapshot") {
+			yield* set$1(lastSequence, item.snapshot.snapshotSequence);
+			yield* setThread(item.snapshot.thread);
+			return;
+		}
+		const sequence = yield* get$1(lastSequence);
+		if (item.event.sequence <= sequence) return;
+		yield* set$1(lastSequence, item.event.sequence);
+		const current = yield* get$1(state);
+		if (isNone(current.data)) {
+			if (item.event.type === "thread.deleted") yield* setDeleted();
+			return;
+		}
+		const result = applyThreadDetailEvent(current.data.value, item.event);
+		if (result.kind === "updated") yield* setThread(result.thread);
+		else if (result.kind === "deleted") yield* setDeleted();
+	});
+	yield* changes(supervisor.state).pipe(runForEach((connectionState) => {
+		switch (connectionProjectionPhase(connectionState)) {
+			case "synchronizing": return setSynchronizing;
+			case "disconnected": return setDisconnected;
+			case "ready": return setReady;
+		}
+	}), forkScoped);
+	const foregroundResubscriptions = match(wakeups, {
+		onNone: () => never,
+		onSome: (service) => service.changes.pipe(filter$1((reason) => reason === "application-active"))
+	});
+	yield* setSynchronizing;
+	yield* forkScoped(subscribeDynamic(ORCHESTRATION_WS_METHODS.subscribeThread, fn("EnvironmentThreadState.makeSubscribeInput")(function* (session) {
+		const supportsCompletionMarker = yield* session.initialConfig.pipe(map((config) => config.threadResumeCompletionMarker === true), orElseSucceed(() => false));
+		yield* set(awaitingCompletion, supportsCompletionMarker);
+		yield* setSynchronizing;
+		let current = yield* get$1(state);
+		if (isNone(current.data) && current.status !== "deleted") {
+			const prepared = yield* get$1(supervisor.prepared).pipe(flatMap(match({
+				onSome: succeed,
+				onNone: () => changes(supervisor.prepared).pipe(filter$1(isSome), map$3((value) => value.value), runHead, map(getOrThrow))
+			})));
+			const httpSnapshot = yield* snapshotLoader.load(prepared, threadId);
+			if (isSome(httpSnapshot)) {
+				yield* applyItem({
+					kind: "snapshot",
+					snapshot: httpSnapshot.value
+				});
+				current = yield* get$1(state);
+			}
+		}
+		const sequence = yield* get$1(lastSequence);
+		const canResume = isSome(current.data);
+		if (!supportsCompletionMarker && canResume) yield* update(state, (value) => ({
+			...value,
+			status: value.status === "deleted" ? value.status : "live",
+			error: none()
+		}));
+		return {
+			threadId,
+			...canResume ? { afterSequence: sequence } : {},
+			...supportsCompletionMarker ? { requestCompletionMarker: true } : {}
+		};
+	}), {
+		onExpectedFailure: setStreamError,
+		retryExpectedFailureAfter: "250 millis",
+		resubscribe: foregroundResubscriptions
+	}).pipe(runForEach(applyItem)));
+	yield* addFinalizer(() => all([get$1(state), get$1(lastSequence)]).pipe(flatMap(([current, snapshotSequence]) => match(current.data, {
+		onNone: () => void_,
+		onSome: (thread) => shouldPersistThread(thread) ? persist({
+			snapshotSequence,
+			thread
+		}) : void_
+	}))));
+	return state;
+});
+function threadStateChanges(environmentId, threadId) {
+	return followStreamInEnvironment(environmentId, unwrap(makeEnvironmentThreadState(threadId).pipe(map(changes))));
+}
+function createEnvironmentThreadStateAtoms(runtime) {
+	const family$1 = family((key) => {
+		const { environmentId, threadId } = parseThreadKey(key);
+		return runtime.atom(threadStateChanges(environmentId, threadId), { initialValue: EMPTY_ENVIRONMENT_THREAD_STATE }).pipe(setIdleTTL(THREAD_STATE_IDLE_TTL_MS), withLabel(`environment-thread-state:${key}`));
+	});
+	return { stateAtom: (environmentId, threadId) => family$1(threadKey({
+		environmentId,
+		threadId
+	})) };
+}
+//#endregion
+export { EMPTY_ENVIRONMENT_THREAD_STATE, ThreadSnapshotLoader, applyThreadDetailEvent, createArchivedThreadSnapshotsAtomFamily, createEnvironmentThreadDetailAtoms, createEnvironmentThreadShellAtoms, createEnvironmentThreadStateAtoms, createThreadEnvironmentAtoms, fetchEnvironmentThreadSnapshot, makeArchivedThreadsEnvironmentKey, makeEnvironmentThreadState, mergeEnvironmentThread, parseArchivedThreadsEnvironmentKey, threadSnapshotLoaderLayer, threadStateChanges };