t3code-cli 0.14.1 → 0.15.0

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

@@ -1,17 +1,16 @@
-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";
+import { $A as runHead, AN as Service, Aj as andThen, An as unsettleThread, Ba as shouldResubscribeAfterWakeup, By as changes, CM as sync, Cn as setThreadRuntimeMode, DD as set, Dn as stopThreadSession, Dr as followStreamInEnvironment, ED as make$2, En as startThreadTurn, Fj as catchCause, GN as none, Gj as flatMap$1, HN as isSome, Ho as makeEnvironmentHttpApiClient, Hr as buildEnvironmentAuthHeaders, Hy as make$1, JM as squash, JN as Number$1, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Ko as environmentEndpointUrl, Kr as make, LA as filter$1, LN as getOrElse, ME as EnvironmentId, Mj as as, NA as debounce, NM as void_, NN as flatMap, Nn as updateThreadMetadata, OD as update$1, Oj as addFinalizer, On as unarchiveThread, QA as runForEach, QN as combineAll, Qj as gen, Qt as parseThreadKey, RN as getOrNull, Ra as EnvironmentSupervisor, Rj as catchTags, Sn as setThreadInteractionMode, TD as get, Tn as snoozeThread, UA as map$3, UN as map$2, Ur as withEnvironmentCredentials, Uy as set$1, VA as fromQueue, VN as isNone, Vo as executeEnvironmentHttpRequest, Vy as get$1, WN as match, Wr as family, Wy as update, XS as ORCHESTRATION_WS_METHODS, YM as effect, YN as String, Yr as withLabel, Yt as arrayElementsEqual, ZN as combine, Zj as forkScoped, Zt as parseProjectRefCollectionKey, _j as offerUnsafe, _n as pinThread, bj as sliding, bn as respondToThreadUserInput, dn as archiveThread, dr as scopeThread, eP as mapInput, ei as value, en as projectRefCollectionKey, fM as orElseSucceed, fj as make$3, fr as scopeThreadShell, gN as sort, gj as offer, gn as interruptThreadTurn, hM as provideService, hN as map$1, hn as deleteThread, hr as createEnvironmentCommand, jj as annotateLogs, jn as unsnoozeThread, js as connectionProjectionPhase, kN as Reference, kj as all, kn as unpinThread, li as subscribeDynamic, mN as filter, mr as createAtomCommandScheduler, nM as logWarning, nn as threadKey, pN as append, pn as createThread, qA as never, qM as pretty, qr as setIdleTTL, rM as map, rn as threadRefsEqual, ro as ManagedRelayDpopSigner, sj as unwrap, tM as logDebug, uP as pipe, vD as HttpClient, vn as reorderPinnedThread, wn as settleThread, xM as succeed, xn as revertThreadCheckpoint, yM as serviceOption, yn as respondToThreadApproval, zN as getOrThrow, za as ConnectionWakeups, zj as catch_ } 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 },
+		payload: {
+			...input.window !== void 0 ? { turnLimit: input.window.turnLimit } : {},
+			...input.window?.beforeCursor !== void 0 ? { beforeCursor: input.window.beforeCursor } : {}
+		},
 		headers
 	})));
 });
@@ -25,10 +24,11 @@ var ThreadSnapshotLoader = class extends Service()("@t3tools/client-runtime/stat
 const threadSnapshotLoaderLayer = effect(ThreadSnapshotLoader, gen(function* () {
 	const httpClient = yield* HttpClient;
 	const signer = yield* serviceOption(ManagedRelayDpopSigner);
-	return ThreadSnapshotLoader.of({ load: (prepared, threadId) => fetchEnvironmentThreadSnapshot({
+	return ThreadSnapshotLoader.of({ load: (prepared, threadId, window) => fetchEnvironmentThreadSnapshot({
 		prepared,
 		threadId,
-		signer
+		signer,
+		...window !== void 0 ? { window } : {}
 	}).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)
@@ -44,6 +44,17 @@ const activityOrder = combineAll([
 	mapInput(String, (a) => a.id)
 ]);
 /**
+* Matches the validity rule in `deriveLatestContextWindowSnapshot` (and the
+* server's snapshot-side `dropStaleContextWindowActivities`): rows without a
+* finite, non-negative `usedTokens` are skipped during the consumer's backward
+* walk, so they must not replace an earlier resolvable row here.
+*/
+function isResolvableContextWindowActivity(activity) {
+	if (activity.kind !== "context-window.updated") return false;
+	const usedTokens = (activity.payload && typeof activity.payload === "object" ? activity.payload : null)?.usedTokens;
+	return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0;
+}
+/**
 * 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.
@@ -90,6 +101,7 @@ function applyThreadDetailEvent(thread, event) {
 			thread: {
 				...thread,
 				archivedAt: event.payload.archivedAt,
+				titleRegeneration: null,
 				updatedAt: event.payload.updatedAt
 			}
 		};
@@ -137,11 +149,38 @@ function applyThreadDetailEvent(thread, event) {
 				updatedAt: event.payload.updatedAt
 			}
 		};
+		case "thread.pinned": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				pinnedAt: event.payload.pinnedAt,
+				...event.payload.pinOrderKey !== void 0 ? { pinOrderKey: event.payload.pinOrderKey } : {},
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.unpinned": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				pinnedAt: null,
+				pinOrderKey: null,
+				updatedAt: event.payload.updatedAt
+			}
+		};
+		case "thread.pin-reordered": return {
+			kind: "updated",
+			thread: {
+				...thread,
+				pinOrderKey: event.payload.orderKey,
+				updatedAt: event.payload.updatedAt
+			}
+		};
 		case "thread.meta-updated": return {
 			kind: "updated",
 			thread: {
 				...thread,
 				...event.payload.title !== void 0 ? { title: event.payload.title } : {},
+				...event.payload.titleRegeneration !== void 0 ? { titleRegeneration: event.payload.titleRegeneration } : {},
 				...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 } : {},
@@ -341,7 +380,9 @@ function applyThreadDetailEvent(thread, event) {
 			};
 		}
 		case "thread.activity-appended": {
-			const activities = pipe(thread.activities, filter((activity) => activity.id !== event.payload.activity.id), append(event.payload.activity), sort(activityOrder));
+			const activity = event.payload.activity;
+			const supersedesContextWindow = isResolvableContextWindowActivity(activity);
+			const activities = pipe(thread.activities, filter((entry) => entry.id !== activity.id && !(supersedesContextWindow && entry.turnId === activity.turnId && isResolvableContextWindowActivity(entry))), append(activity), sort(activityOrder));
 			return {
 				kind: "updated",
 				thread: {
@@ -401,8 +442,16 @@ const THREAD_STATE_IDLE_TTL_MS = 5 * 6e4;
 const EMPTY_ENVIRONMENT_THREAD_STATE = {
 	data: none(),
 	status: "empty",
-	error: none()
+	error: none(),
+	page: none()
 };
+/** Whether the thread has older turns that can be loaded with more pages. */
+function threadHasOlderTurns(state) {
+	return match(state.page, {
+		onNone: () => false,
+		onSome: (page) => page.hasMore
+	});
+}
 //#endregion
 //#region upstream-t3code/packages/client-runtime/src/state/archivedThreads.ts
 const ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR = "";
@@ -493,6 +542,24 @@ function createThreadEnvironmentAtoms(runtime) {
 			scheduler,
 			concurrency
 		}),
+		pin: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:pin",
+			execute: (input) => pinThread(input),
+			scheduler,
+			concurrency
+		}),
+		unpin: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:unpin",
+			execute: (input) => unpinThread(input),
+			scheduler,
+			concurrency
+		}),
+		reorderPin: createEnvironmentCommand(runtime, {
+			label: "environment-data:commands:thread:reorder-pin",
+			execute: (input) => reorderPinnedThread(input),
+			scheduler,
+			concurrency
+		}),
 		updateMetadata: createEnvironmentCommand(runtime, {
 			label: "environment-data:commands:thread:update-metadata",
 			execute: (input) => updateThreadMetadata(input),
@@ -586,6 +653,8 @@ function mergeEnvironmentThread(detail, shell) {
 		settledAt: shell.settledAt,
 		snoozedUntil: shell.snoozedUntil,
 		snoozedAt: shell.snoozedAt,
+		pinnedAt: shell.pinnedAt,
+		pinOrderKey: shell.pinOrderKey,
 		session: shell.session
 	};
 }
@@ -744,6 +813,58 @@ function createEnvironmentThreadShellAtoms(input) {
 function statusWithoutLiveData(data) {
 	return isSome(data) ? "cached" : "empty";
 }
+/**
+* Turn window sizes for paginated thread loads: the initial page covers the
+* last 10 user-anchored turns (subagent/fan-out turns ride along), each
+* "load earlier" tap fetches 20 more. Sized so first paint on the heaviest
+* observed threads stays around 100K gzipped while median threads load fully.
+*/
+const INITIAL_THREAD_USER_TURN_LIMIT = 10;
+const OLDER_THREAD_PAGE_USER_TURN_LIMIT = 20;
+function pageStateFromSnapshot(page) {
+	return page === void 0 ? none() : some({
+		beforeCursor: page.beforeCursor,
+		hasMore: page.hasMore,
+		loadingOlder: false
+	});
+}
+function makeThreadOlderTurnRequestRegistry() {
+	const handlers = /* @__PURE__ */ new Map();
+	return {
+		register: (key, handler) => {
+			handlers.set(key, handler);
+			return () => {
+				if (handlers.get(key) === handler) handlers.delete(key);
+			};
+		},
+		request: (key) => {
+			const handler = handlers.get(key);
+			if (handler === void 0) return false;
+			handler();
+			return true;
+		}
+	};
+}
+const defaultOlderTurnRequestRegistry = makeThreadOlderTurnRequestRegistry();
+/**
+* Channel from UI actions to the live per-thread state machines. The machines
+* resolve it from the Effect environment (overridable in tests); the default
+* instance is shared with the sync `requestOlderThreadTurns` entry point so
+* the apps get working wiring without providing anything.
+*/
+var ThreadOlderTurnRequests = class extends Reference("@t3tools/client-runtime/state/threads/ThreadOlderTurnRequests", { defaultValue: () => defaultOlderTurnRequestRegistry }) {};
+/**
+* Asks the live state machine for `threadId` to fetch the next older page.
+* Returns false when no machine is live or no fetch was started (no cursor,
+* already loading); callers render from `EnvironmentThreadState.page` and can
+* treat false as "nothing to do".
+*/
+function requestOlderThreadTurns(environmentId, threadId) {
+	return defaultOlderTurnRequestRegistry.request(threadKey({
+		environmentId,
+		threadId
+	}));
+}
 function formatThreadError(cause) {
 	const error = squash(cause);
 	return error instanceof Error && error.message.trim().length > 0 ? error.message : "Could not synchronize the thread.";
@@ -767,13 +888,18 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 	const state = yield* make$1({
 		data: cachedThread,
 		status: statusWithoutLiveData(cachedThread),
-		error: none()
+		error: none(),
+		page: flatMap(cached, (snapshot) => pageStateFromSnapshot(snapshot.page))
 	});
 	const lastSequence = yield* make$1(match(cached, {
 		onNone: () => 0,
 		onSome: (snapshot) => snapshot.snapshotSequence
 	}));
 	const awaitingCompletion = yield* make$2(false);
+	const historyEpoch = yield* make$2(0);
+	const applyLock = yield* make$3(1);
+	const paginationSupported = yield* make$2(false);
+	const pendingOlderPage = yield* make$2(null);
 	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({
@@ -795,6 +921,7 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 	});
 	const setDisconnected = gen(function* () {
 		yield* set(awaitingCompletion, false);
+		yield* set(paginationSupported, false);
 		yield* update(state, (current) => ({
 			...current,
 			status: current.status === "deleted" ? current.status : statusWithoutLiveData(current.data)
@@ -805,27 +932,39 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 		status: current.status === "deleted" ? current.status : statusWithoutLiveData(current.data),
 		error: some(formatThreadError(cause))
 	}))));
-	const setThread = fn("EnvironmentThreadState.setThread")(function* (thread) {
+	const setThread = fn("EnvironmentThreadState.setThread")(function* (thread, page) {
 		const waiting = yield* get(awaitingCompletion);
-		yield* set$1(state, {
+		yield* update(state, (current) => ({
 			data: some(thread),
 			status: waiting ? "synchronizing" : "live",
-			error: none()
-		});
+			error: none(),
+			page: page === "keep" ? current.page : page
+		}));
 		if (shouldPersistThread(thread)) {
 			const snapshotSequence = yield* get$1(lastSequence);
+			const currentPage = yield* get$1(state).pipe(map((value) => value.page));
 			yield* offer(persistence, {
 				snapshotSequence,
-				thread
+				thread,
+				...match(currentPage, {
+					onNone: () => ({}),
+					onSome: (value) => ({ page: {
+						beforeCursor: value.beforeCursor,
+						hasMore: value.hasMore,
+						snapshotSequence
+					} })
+				})
 			});
 		}
 	});
 	const setDeleted = fn("EnvironmentThreadState.setDeleted")(function* () {
 		yield* set(awaitingCompletion, false);
+		yield* update$1(historyEpoch, (epoch) => epoch + 1);
 		yield* set$1(state, {
 			data: none(),
 			status: "deleted",
-			error: none()
+			error: none(),
+			page: none()
 		});
 		yield* cache.removeThread(environmentId, threadId).pipe(catch_((error) => logWarning("Could not remove the cached thread.").pipe(annotateLogs({
 			environmentId,
@@ -833,7 +972,7 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 			error: error.message
 		}))));
 	});
-	const applyItem = fn("EnvironmentThreadState.applyItem")(function* (item) {
+	const applyItemLocked = fn("EnvironmentThreadState.applyItemLocked")(function* (item) {
 		if (item.kind === "synchronized") {
 			yield* set(awaitingCompletion, false);
 			yield* update(state, (current) => isSome(current.data) && current.status !== "deleted" ? {
@@ -844,8 +983,9 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 			return;
 		}
 		if (item.kind === "snapshot") {
+			yield* update$1(historyEpoch, (epoch) => epoch + 1);
 			yield* set$1(lastSequence, item.snapshot.snapshotSequence);
-			yield* setThread(item.snapshot.thread);
+			yield* setThread(item.snapshot.thread, pageStateFromSnapshot(item.snapshot.page));
 			return;
 		}
 		const sequence = yield* get$1(lastSequence);
@@ -856,9 +996,117 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 			if (item.event.type === "thread.deleted") yield* setDeleted();
 			return;
 		}
+		if (item.event.type === "thread.reverted") yield* update$1(historyEpoch, (epoch) => epoch + 1);
 		const result = applyThreadDetailEvent(current.data.value, item.event);
-		if (result.kind === "updated") yield* setThread(result.thread);
+		if (result.kind === "updated") yield* setThread(result.thread, "keep");
 		else if (result.kind === "deleted") yield* setDeleted();
+		yield* tryMergePendingOlderPage();
+	});
+	const tryMergePendingOlderPage = fn("EnvironmentThreadState.tryMergePendingOlderPage")(function* () {
+		const pending = yield* get(pendingOlderPage);
+		if (pending === null) return;
+		if ((yield* get(historyEpoch)) !== pending.epoch) {
+			yield* set(pendingOlderPage, null);
+			yield* update(state, (value) => ({
+				...value,
+				page: map$2(value.page, (existing) => ({
+					...existing,
+					loadingOlder: false
+				}))
+			}));
+			return;
+		}
+		const watermark = pending.snapshot.page?.threadSequence;
+		const loadedSequence = yield* get$1(lastSequence);
+		if (watermark !== void 0 && watermark > loadedSequence) return;
+		yield* set(pendingOlderPage, null);
+		yield* mergeOlderPage(pending.snapshot);
+	});
+	const applyItem = fn("EnvironmentThreadState.applyItem")(function* (item) {
+		yield* applyLock.withPermits(1)(applyItemLocked(item));
+	});
+	const mergeOlderPage = fn("EnvironmentThreadState.mergeOlderPage")(function* (snapshot) {
+		let merged = null;
+		yield* update(state, (value) => {
+			if (isNone(value.data)) return value;
+			const loaded = value.data.value;
+			const older = snapshot.thread;
+			const mergeById = (olderRows, loadedRows) => {
+				const seen = new Set(loadedRows.map((row) => row.id));
+				return [...olderRows.filter((row) => !seen.has(row.id)), ...loadedRows];
+			};
+			const seenCheckpoints = new Set(loaded.checkpoints.map((row) => row.turnId));
+			merged = {
+				...loaded,
+				messages: mergeById(older.messages, loaded.messages),
+				activities: mergeById(older.activities, loaded.activities),
+				proposedPlans: mergeById(older.proposedPlans, loaded.proposedPlans),
+				checkpoints: [...older.checkpoints.filter((row) => !seenCheckpoints.has(row.turnId)), ...loaded.checkpoints]
+			};
+			return {
+				...value,
+				data: some(merged),
+				page: pageStateFromSnapshot(snapshot.page)
+			};
+		});
+		if (merged !== null && shouldPersistThread(merged)) {
+			const snapshotSequence = yield* get$1(lastSequence);
+			yield* offer(persistence, {
+				snapshotSequence,
+				thread: merged,
+				...snapshot.page === void 0 ? {} : { page: {
+					...snapshot.page,
+					snapshotSequence
+				} }
+			});
+		}
+	});
+	const loadOlderTurns = fn("EnvironmentThreadState.loadOlderTurns")(function* () {
+		if (!(yield* get(paginationSupported))) return;
+		const page = getOrNull((yield* get$1(state)).page);
+		if (page === null || page.loadingOlder || !page.hasMore || page.beforeCursor === null) return;
+		const prepared = getOrNull(yield* get$1(supervisor.prepared));
+		if (prepared === null) return;
+		const epochAtStart = yield* get(historyEpoch);
+		yield* update(state, (value) => ({
+			...value,
+			page: map$2(value.page, (existing) => ({
+				...existing,
+				loadingOlder: true
+			}))
+		}));
+		const window = {
+			turnLimit: 20,
+			beforeCursor: page.beforeCursor
+		};
+		const response = yield* snapshotLoader.load(prepared, threadId, window);
+		yield* applyLock.withPermits(1)(gen(function* () {
+			const epochNow = yield* get(historyEpoch);
+			const loadedSequence = yield* get$1(lastSequence);
+			const stale = epochNow !== epochAtStart || match(response, {
+				onNone: () => false,
+				onSome: (snapshot) => snapshot.snapshotSequence < loadedSequence
+			});
+			if (isNone(response) || stale) {
+				yield* update(state, (value) => ({
+					...value,
+					page: map$2(value.page, (existing) => ({
+						...existing,
+						loadingOlder: false
+					}))
+				}));
+				return;
+			}
+			const watermark = response.value.page?.threadSequence;
+			if (watermark !== void 0 && watermark > loadedSequence) {
+				yield* set(pendingOlderPage, {
+					snapshot: response.value,
+					epoch: epochNow
+				});
+				return;
+			}
+			yield* mergeOlderPage(response.value);
+		}));
 	});
 	yield* changes(supervisor.state).pipe(runForEach((connectionState) => {
 		switch (connectionProjectionPhase(connectionState)) {
@@ -869,20 +1117,34 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 	}), forkScoped);
 	const foregroundResubscriptions = match(wakeups, {
 		onNone: () => never,
-		onSome: (service) => service.changes.pipe(filter$1((reason) => reason === "application-active"))
+		onSome: (service) => service.changes.pipe(filter$1(shouldResubscribeAfterWakeup))
 	});
 	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));
+		const config = yield* session.initialConfig.pipe(orElseSucceed(() => ({})));
+		const supportsCompletionMarker = config.threadResumeCompletionMarker === true;
+		const supportsPagination = config.threadSnapshotPagination === true;
+		yield* set(paginationSupported, supportsPagination);
 		yield* set(awaitingCompletion, supportsCompletionMarker);
 		yield* setSynchronizing;
 		let current = yield* get$1(state);
+		if (!supportsPagination && isSome(current.page)) {
+			yield* update$1(historyEpoch, (epoch) => epoch + 1);
+			yield* update(state, (value) => ({
+				...value,
+				data: none(),
+				status: value.status === "deleted" ? value.status : "empty",
+				page: none()
+			}));
+			yield* set$1(lastSequence, 0);
+			current = yield* get$1(state);
+		}
 		if (isNone(current.data) && current.status !== "deleted") {
-			const prepared = yield* get$1(supervisor.prepared).pipe(flatMap(match({
+			const prepared = yield* get$1(supervisor.prepared).pipe(flatMap$1(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);
+			const httpSnapshot = yield* snapshotLoader.load(prepared, threadId, supportsPagination ? { turnLimit: 10 } : void 0);
 			if (isSome(httpSnapshot)) {
 				yield* applyItem({
 					kind: "snapshot",
@@ -901,18 +1163,37 @@ const makeEnvironmentThreadState = fn("EnvironmentThreadState.make")(function* (
 		return {
 			threadId,
 			...canResume ? { afterSequence: sequence } : {},
-			...supportsCompletionMarker ? { requestCompletionMarker: true } : {}
+			...supportsCompletionMarker ? { requestCompletionMarker: true } : {},
+			...supportsPagination ? { turnLimit: 10 } : {}
 		};
 	}), {
 		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, {
+	const olderTurnRequestRegistry = yield* ThreadOlderTurnRequests;
+	const olderTurnRequests = yield* sliding(1);
+	yield* fromQueue(olderTurnRequests).pipe(runForEach(() => loadOlderTurns()), forkScoped);
+	const deregister = olderTurnRequestRegistry.register(threadKey({
+		environmentId,
+		threadId
+	}), () => {
+		offerUnsafe(olderTurnRequests, void 0);
+	});
+	yield* addFinalizer(() => sync(deregister));
+	yield* addFinalizer(() => all([get$1(state), get$1(lastSequence)]).pipe(flatMap$1(([current, snapshotSequence]) => match(current.data, {
 		onNone: () => void_,
 		onSome: (thread) => shouldPersistThread(thread) ? persist({
 			snapshotSequence,
-			thread
+			thread,
+			...match(current.page, {
+				onNone: () => ({}),
+				onSome: (page) => ({ page: {
+					beforeCursor: page.beforeCursor,
+					hasMore: page.hasMore,
+					snapshotSequence
+				} })
+			})
 		}) : void_
 	}))));
 	return state;
@@ -931,4 +1212,4 @@ function createEnvironmentThreadStateAtoms(runtime) {
 	})) };
 }
 //#endregion
-export { EMPTY_ENVIRONMENT_THREAD_STATE, ThreadSnapshotLoader, applyThreadDetailEvent, createArchivedThreadSnapshotsAtomFamily, createEnvironmentThreadDetailAtoms, createEnvironmentThreadShellAtoms, createEnvironmentThreadStateAtoms, createThreadEnvironmentAtoms, fetchEnvironmentThreadSnapshot, makeArchivedThreadsEnvironmentKey, makeEnvironmentThreadState, mergeEnvironmentThread, parseArchivedThreadsEnvironmentKey, threadSnapshotLoaderLayer, threadStateChanges };
+export { EMPTY_ENVIRONMENT_THREAD_STATE, INITIAL_THREAD_USER_TURN_LIMIT, OLDER_THREAD_PAGE_USER_TURN_LIMIT, ThreadOlderTurnRequests, ThreadSnapshotLoader, applyThreadDetailEvent, createArchivedThreadSnapshotsAtomFamily, createEnvironmentThreadDetailAtoms, createEnvironmentThreadShellAtoms, createEnvironmentThreadStateAtoms, createThreadEnvironmentAtoms, fetchEnvironmentThreadSnapshot, makeArchivedThreadsEnvironmentKey, makeEnvironmentThreadState, mergeEnvironmentThread, parseArchivedThreadsEnvironmentKey, requestOlderThreadTurns, threadHasOlderTurns, threadSnapshotLoaderLayer, threadStateChanges };

package/dist/client-runtime/state/vcs.d.ts

@@ -1,4 +1,4 @@
-import { $T as ThreadId, AS as GitPullRequestMaterializationError, BS as TextGenerationError, Ca as EnvironmentCacheStore, ES as GitManagerError, FS as GitRunStackedActionResult, Fl as ServerConfig, KS as VcsListRefsInput, PS as GitRunStackedActionInput, TS as GitCommandError, XS as VcsRef$1, _ as AtomCommandResult, _a as EnvironmentSupervisor, bS as VcsUnsupportedOperationError, bT as EnvironmentAuthorizationError, ba as ConnectionPersistenceError, cv as OrchestrationShellSnapshot, dS as VcsProcessOutputReadError, f as AtomCommand, fS as VcsProcessSpawnError, gv as OrchestrationThreadDetailSnapshot, hC as SourceControlProviderError, hS as VcsProcessTimeoutError, ha as EnvironmentRegistry, lS as VcsProcessMissingExitCodeError, mS as VcsProcessStdinWriteError, ma as EnvironmentNotRegisteredError, oS as VcsProcessExitError, on as EnvironmentRpcUnavailableError, qS as VcsListRefsResult, tC as VcsStatusResult, uS as VcsProcessOutputLimitError, vS as VcsRepositoryDetectionError, xS as GitActionProgressEvent, zS as GitStackedAction, zT as EnvironmentId } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Aa as EnvironmentSupervisor, Cw as VcsProcessExitError, Da as EnvironmentNotRegisteredError, Dw as VcsProcessOutputLimitError, Ew as VcsProcessMissingExitCodeError, Fw as VcsRepositoryDetectionError, Hw as GitCommandError, Ia as EnvironmentCacheStore, Lw as VcsUnsupportedOperationError, Mw as VcsProcessTimeoutError, Na as ConnectionPersistenceError, Nk as ThreadId, Oa as EnvironmentRegistry, Ow as VcsProcessOutputReadError, Qw as GitRunStackedActionResult, Rw as GitActionProgressEvent, Su as ServerConfig, UD as SourceControlProviderError, Uw as GitManagerError, Zw as GitRunStackedActionInput, _ as AtomCommandResult, ab as OrchestrationShellSnapshot, f as AtomCommand, hn as EnvironmentRpcUnavailableError, jw as VcsProcessStdinWriteError, kw as VcsProcessSpawnError, lT as VcsListRefsInput, mb as OrchestrationThreadDetailSnapshot, nT as GitStackedAction, pT as VcsRef$1, qw as GitPullRequestMaterializationError, rT as TextGenerationError, uT as VcsListRefsResult, vT as VcsStatusResult, vk as EnvironmentId } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Schema from "effect/Schema";
@@ -304,9 +304,9 @@ declare function createVcsEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   status: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly isRepo: boolean;
     readonly sourceControlProvider?: {
@@ -342,9 +342,9 @@ declare function createVcsEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
   }, E | EnvironmentAuthorizationError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>>;
   pull: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+    };
   }, {
     readonly status: "pulled" | "skipped_up_to_date";
     readonly refName: string;
@@ -352,9 +352,9 @@ declare function createVcsEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   refreshStatus: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+    };
   }, {
     readonly isRepo: boolean;
     readonly sourceControlProvider?: {
@@ -423,10 +423,10 @@ declare function createVcsEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   switchRef: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly refName: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly refName: string;
+    };
   }, {
     readonly refName: string | null;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;

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

@@ -1,4 +1,4 @@
-import { $D as flatMap, $r as failure, AO as tapError, Aa as EnvironmentSupervisor, Cv as get, DO as suspend, Dk as seconds, Dr as runStreamInEnvironment, EO as succeed, Ek as min, FE as concat, Fs as WS_METHODS, GT as Defect, Gr as family, HD as as, HE as fromEffect, HO as modifyDelay, Hk as match, Hr as runStream, Hu as GitActionProgressPhase, JS as EnvironmentId, JT as Literals, Jr as setIdleTTL, KE as map, Kr as keepAlive, La as EnvironmentCacheStore, MD as nowUnsafe, ND as toEpochMillis, Na as safeErrorLogAttributes, OO as sync, PE as changes$1, Q as applyGitStatusStreamEvent, QD as fail, QT as String, RO as void_, St as vcsCommandScheduler, Sv as changes, Uk as none, Ur as subscribe, VD as annotateLogs, VE as filterMap, VO as exponential, Vr as request, Wk as some, XT as NullOr, Xr as withLabel, YD as catch_, YO as hasInterruptsOnly, ZD as ensuring, ZE as retry, ZO as squash, ZT as Number, Zr as AtomRegistry, aO as gen, bO as provideService, bk as failVoid, bt as withVcsRefsPersistenceLock, dr as createEnvironmentRpcCommand, eE as TaggedErrorClass, eO as fn, ei as isSuccess, gr as createRuntimeCommand, hr as createEnvironmentSubscriptionAtomFamily, lD as unwrap, lO as logWarning, nE as Union, oD as switchMap, oE as decodeUnknownSync, qE as mapAccum, qO as fail$1, qr as make, rt as isTemporaryWorktreeBranch, tD as runForEach, tE as Tuple, td as GitStackedAction, vt as invalidateCachedVcsRefs, wk as succeed$1, xr as followStreamInEnvironment, xt as vcsCommandConcurrency, yt as vcsRefsCacheStateAtom, zE as empty } from "../../shared.js";
+import { $r as isSuccess, Bk as Tuple, By as changes, CM as sync, DN as seconds, Dr as followStreamInEnvironment, Fk as NullOr, GM as hasInterruptsOnly, GN as none, Gj as flatMap, Gr as keepAlive, Ha as safeErrorLogAttributes, IA as empty, IM as exponential, Ik as Number, JA as retry, JM as squash, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Kk as decodeUnknownSync, Kr as make, LM as modifyDelay, Lk as String, MA as concat, ME as EnvironmentId, Mj as as, NM as void_, Nk as Literals, Nr as runStreamInEnvironment, Q as applyGitStatusStreamEvent, QA as runForEach, Qj as gen, Qr as failure, RA as filterMap, Ra as EnvironmentSupervisor, SM as suspend, SN as succeed$1, Sr as createRuntimeCommand, St as vcsCommandScheduler, TM as tapError, TN as min, UA as map, UM as fail$1, Uj as fail, Vj as ensuring, Vk as Union, Vy as get, WA as mapAccum, WN as match, Wr as family, Xr as AtomRegistry, Yr as withLabel, _r as createEnvironmentRpcCommand, bA as nowUnsafe, bf as GitStackedAction, bt as withVcsRefsPersistenceLock, ci as subscribe, hM as provideService, jA as changes$1, jj as annotateLogs, kk as Defect, lc as WS_METHODS, nM as logWarning, oi as request, qr as setIdleTTL, rj as switchMap, rt as isTemporaryWorktreeBranch, sf as GitActionProgressPhase, si as runStream, sj as unwrap, vN as failVoid, vt as invalidateCachedVcsRefs, xA as toEpochMillis, xM as succeed, xr as createEnvironmentSubscriptionAtomFamily, xt as vcsCommandConcurrency, yt as vcsRefsCacheStateAtom, zA as fromEffect, zj as catch_, zk as TaggedErrorClass } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/gitActions.ts
 function buildGitActionProgressStages(input) {
 	const branchStages = input.featureBranch ? ["Preparing feature branch..."] : [];

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { Gn as loadT3CliEnv, Hi as ConfigError, Hn as T3CliEnvConfig, Sr as CredentialCipherError, Ui as ConfigServiceError, Un as T3CliEnvScope, Vi as UrlError, Wn as T3CliEnvShape, _r as service_d_exports$1, br as T3CredentialCipher, cr as EncryptedConfig, dr as UpsertEnvironmentInput, gr as T3MasterKeyKeystoreFactory, hr as MasterKeyReadResult, lr as EnvironmentSummary, mr as service_d_exports, pr as service_d_exports$2, sr as config_d_exports, ur as ResolvedConfig, vr as KeystoreUnavailableError, xr as cipher_d_exports, yr as EncryptedToken } from "./shared.js";
+import { $n as T3CliEnvConfig, Ar as EncryptedToken, Dr as T3MasterKeyKeystoreFactory, Er as MasterKeyReadResult, Mr as cipher_d_exports, Nr as CredentialCipherError, Or as service_d_exports$1, Sr as UpsertEnvironmentInput, Tr as service_d_exports, br as EnvironmentSummary, ea as UrlError, er as T3CliEnvScope, jr as T3CredentialCipher, kr as KeystoreUnavailableError, na as ConfigServiceError, nr as loadT3CliEnv, ta as ConfigError, tr as T3CliEnvShape, vr as config_d_exports, wr as service_d_exports$2, xr as ResolvedConfig, yr as EncryptedConfig } from "./shared.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Layer from "effect/Layer";

package/dist/config.js

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime.js";
-import { $C as ConfigError, AC as validateEnvironmentName, As as CredentialCipherError, Cw as T3CliEnvConfig, DC as defaultEnvironmentNameFromUrl, Ds as KeystoreUnavailableError, EC as defaultEnvironmentNameForLocal, FC as UrlError, JC as file_exports, MC as toHttpEndpointUrl, NC as toWebSocketBaseUrl, NO as tryPromise, OC as migrateV1EnvironmentName, Os as cipher_node_exports, PC as toWebSocketEndpointUrl, QC as service_exports$1, QD as fail, TC as service_exports$2, Ts as keyring_node_exports, XC as resolveKeyFilePath, YC as resolveConfigFilePath, ZC as resolveT3cliConfigDir, aO as gen, ew as T3CredentialCipher, jC as normalizeHttpBaseUrl, kC as slugifyEnvironmentName, ki as resolveT3BaseDir, nk as succeed, nw as credentialTokenFromEnv, qC as service_exports, tw as cipher_exports, wC as config_exports, ww as loadT3CliEnv } from "./shared.js";
+import { $M as succeed, AD as file_exports, Bs as CredentialCipherError, FD as ConfigError, Fs as keyring_node_exports, ID as T3CredentialCipher, LD as cipher_exports, Li as resolveT3BaseDir, Ls as KeystoreUnavailableError, MD as resolveKeyFilePath, ND as resolveT3cliConfigDir, OM as tryPromise, PD as service_exports$1, Qj as gen, RD as credentialTokenFromEnv, Rs as cipher_node_exports, Uj as fail, _D as UrlError, aO as T3CliEnvConfig, cD as defaultEnvironmentNameForLocal, dD as slugifyEnvironmentName, fD as validateEnvironmentName, gD as toWebSocketEndpointUrl, hD as toWebSocketBaseUrl, jD as resolveConfigFilePath, kD as service_exports, lD as defaultEnvironmentNameFromUrl, mD as toHttpEndpointUrl, oD as config_exports, oO as loadT3CliEnv, pD as normalizeHttpBaseUrl, sD as service_exports$2, uD as migrateV1EnvironmentName } from "./shared.js";
 //#region src/config/credential/cipher-web.ts
 var cipher_web_exports = /* @__PURE__ */ __exportAll({ layerWeb: () => layerWeb });
 const aesGcmAlgorithm = "AES-GCM";

package/dist/connection.d.ts

@@ -1,4 +1,4 @@
-import { Bi as T3CodeConnectionError, Bn as T3CodeConnection, In as T3CodeConnectionProvider, Ln as T3CodeConnectionProviderLive, Rn as makeT3CodeConnectionProvider, Vn as T3CodeOrigin, li as T3Rpc, zn as T3CodeAuth } from "./shared.js";
+import { $i as T3CodeConnectionError, Jn as T3CodeConnectionProviderLive, Qn as T3CodeOrigin, Xn as T3CodeAuth, Yn as makeT3CodeConnectionProvider, Zn as T3CodeConnection, bi as T3Rpc, qn as T3CodeConnectionProvider } from "./shared.js";
 import * as Layer from "effect/Layer";
 //#region src/connection/layer.d.ts
 declare function makeT3CodeRpcLayer(): Layer.Layer<T3Rpc, never, import("effect/unstable/http/HttpClient").HttpClient | T3CodeConnectionProvider | import("effect/unstable/socket/Socket").WebSocketConstructor>;

package/dist/connection.js

@@ -1,2 +1,2 @@
-import { Mn as makeT3CodeRpcLayer, Xi as T3CodeConnectionError, ii as makeT3CodeConnectionProvider, jn as T3CodeRpcLayer, ni as T3CodeConnectionProvider, ri as T3CodeConnectionProviderLive } from "./shared.js";
+import { Fn as T3CodeRpcLayer, In as makeT3CodeRpcLayer, di as T3CodeConnectionProviderLive, fi as makeT3CodeConnectionProvider, ia as T3CodeConnectionError, ui as T3CodeConnectionProvider } from "./shared.js";
 export { T3CodeConnectionError, T3CodeConnectionProvider, T3CodeConnectionProviderLive, T3CodeRpcLayer, makeT3CodeConnectionProvider, makeT3CodeRpcLayer };