t3code-cli 0.14.0 → 0.14.2

package/dist/client-runtime/state/thread-settled.d.ts

@@ -1,4 +1,4 @@
-import { _v as OrchestrationThreadShell } from "../../shared.js";
+import { Vy as OrchestrationThreadShell } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSettled.d.ts
 type ChangeRequestStateLike = "open" | "closed" | "merged";
 declare function threadLastActivityAt(shell: OrchestrationThreadShell): string | null;
@@ -91,7 +91,8 @@ declare function threadWokeAt(shell: ThreadSnoozeShell, options: {
  * override. Past the blockers, the explicit user override (thread.settle /
  * thread.unsettle commands, projected into settledOverride + settledAt)
  * wins in both directions; without one, a thread auto-settles on a
- * merged/closed PR immediately or on inactivity past the window. The server
+ * merged/closed PR immediately or on inactivity past the window — except
+ * that an open PR blocks the inactivity path entirely. The server
  * un-settles on real activity (user message, session start, approval/
  * user-input request), so an override never goes stale silently.
  */
@@ -100,5 +101,29 @@ declare function effectiveSettled(shell: OrchestrationThreadShell, options: {
   readonly autoSettleAfterDays: number | null;
   readonly changeRequestState?: ChangeRequestStateLike | null;
 }): boolean;
+type SnoozePresetId = "hour" | "evening" | "tomorrow" | "next-week";
+interface SnoozePreset {
+  readonly id: SnoozePresetId;
+  readonly label: string;
+  /** Menu-row time column. Complements the label instead of repeating it:
+        "Tomorrow" pairs with "9:00 AM", not "tomorrow 9:00 AM". */
+  readonly whenLabel: string;
+  /** ISO wake time. */
+  readonly snoozedUntil: string;
+}
+/**
+ * Shared "snooze until" choices for every client. "This evening" only
+ * appears while it is meaningfully before evening; after that the list
+ * starts at "Tomorrow".
+ */
+declare function resolveSnoozePresets(now: Date): ReadonlyArray<SnoozePreset>;
+/**
+ * Compact "wakes in" label for snoozed rows: "2h", "18h", "3d". Minutes
+ * round up so a snooze never reads "0m" while still hidden. Shared by web
+ * and mobile so the same wake time never reads differently per client.
+ */
+declare function snoozeWakeLabel(snoozedUntil: string, options: {
+  readonly now: string;
+}): string;
 //#endregion
-export { ChangeRequestStateLike, QUEUED_TURN_START_GRACE_MS, ThreadSnoozeShell, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };
+export { ChangeRequestStateLike, QUEUED_TURN_START_GRACE_MS, SnoozePreset, SnoozePresetId, ThreadSnoozeShell, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, resolveSnoozePresets, snoozeWakeLabel, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };

package/dist/client-runtime/state/thread-settled.js

@@ -135,7 +135,8 @@ function threadWokeAt(shell, options) {
 * override. Past the blockers, the explicit user override (thread.settle /
 * thread.unsettle commands, projected into settledOverride + settledAt)
 * wins in both directions; without one, a thread auto-settles on a
-* merged/closed PR immediately or on inactivity past the window. The server
+* merged/closed PR immediately or on inactivity past the window — except
+* that an open PR blocks the inactivity path entirely. The server
 * un-settles on real activity (user message, session start, approval/
 * user-input request), so an override never goes stale silently.
 */
@@ -148,10 +149,81 @@ function effectiveSettled(shell, options) {
 	if (shell.settledOverride === "settled") return true;
 	if (shell.settledOverride === "active") return false;
 	if (options.changeRequestState === "merged" || options.changeRequestState === "closed") return true;
+	if (options.changeRequestState === "open") return false;
 	if (options.autoSettleAfterDays === null) return false;
 	const lastActivityAt = threadLastActivityAt(shell);
 	if (lastActivityAt === null) return false;
 	return Date.parse(lastActivityAt) < Date.parse(options.now) - options.autoSettleAfterDays * DAY_MS;
 }
+const HOUR_MS = 3600 * 1e3;
+const EVENING_HOUR = 18;
+const MORNING_HOUR = 9;
+function snoozeTimeOfDayLabel(date) {
+	return date.toLocaleTimeString(void 0, {
+		hour: "numeric",
+		minute: "2-digit"
+	});
+}
+function snoozeAtHour(base, hour) {
+	const next = new Date(base);
+	next.setHours(hour, 0, 0, 0);
+	return next;
+}
+function addSnoozeDays(base, days) {
+	const next = new Date(base);
+	next.setDate(next.getDate() + days);
+	return next;
+}
+/**
+* Shared "snooze until" choices for every client. "This evening" only
+* appears while it is meaningfully before evening; after that the list
+* starts at "Tomorrow".
+*/
+function resolveSnoozePresets(now) {
+	const inAnHour = new Date(now.getTime() + HOUR_MS);
+	const presets = [{
+		id: "hour",
+		label: "In 1 hour",
+		whenLabel: snoozeTimeOfDayLabel(inAnHour),
+		snoozedUntil: inAnHour.toISOString()
+	}];
+	const evening = snoozeAtHour(now, EVENING_HOUR);
+	if (evening.getTime() - now.getTime() > HOUR_MS) presets.push({
+		id: "evening",
+		label: "This evening",
+		whenLabel: snoozeTimeOfDayLabel(evening),
+		snoozedUntil: evening.toISOString()
+	});
+	const tomorrow = snoozeAtHour(addSnoozeDays(now, 1), MORNING_HOUR);
+	presets.push({
+		id: "tomorrow",
+		label: "Tomorrow",
+		whenLabel: snoozeTimeOfDayLabel(tomorrow),
+		snoozedUntil: tomorrow.toISOString()
+	});
+	const nextWeek = snoozeAtHour(addSnoozeDays(now, (1 - now.getDay() + 7) % 7 || 7), MORNING_HOUR);
+	presets.push({
+		id: "next-week",
+		label: "Next week",
+		whenLabel: `${nextWeek.toLocaleDateString(void 0, { weekday: "short" })} ${snoozeTimeOfDayLabel(nextWeek)}`,
+		snoozedUntil: nextWeek.toISOString()
+	});
+	return presets;
+}
+/**
+* Compact "wakes in" label for snoozed rows: "2h", "18h", "3d". Minutes
+* round up so a snooze never reads "0m" while still hidden. Shared by web
+* and mobile so the same wake time never reads differently per client.
+*/
+function snoozeWakeLabel(snoozedUntil, options) {
+	const wakeMs = Date.parse(snoozedUntil);
+	const nowMs = Date.parse(options.now);
+	if (Number.isNaN(wakeMs) || Number.isNaN(nowMs)) return "now";
+	const remainingMs = wakeMs - nowMs;
+	if (remainingMs <= 0) return "now";
+	if (remainingMs < HOUR_MS) return `${Math.max(1, Math.ceil(remainingMs / 6e4))}m`;
+	if (remainingMs < DAY_MS) return `${Math.ceil(remainingMs / HOUR_MS)}h`;
+	return `${Math.ceil(remainingMs / DAY_MS)}d`;
+}
 //#endregion
-export { QUEUED_TURN_START_GRACE_MS, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };
+export { QUEUED_TURN_START_GRACE_MS, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, resolveSnoozePresets, snoozeWakeLabel, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };

package/dist/client-runtime/state/thread-sort.d.ts

@@ -1,4 +1,4 @@
-import { KT as ProjectId, f_ as SidebarThreadSortOrder, u_ as SidebarProjectSortOrder } from "../../shared.js";
+import { Ev as SidebarThreadSortOrder, jD as ProjectId, wv as SidebarProjectSortOrder } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSort.d.ts
 interface ThreadSortInput {
   readonly createdAt: string;
@@ -19,5 +19,62 @@ declare function getLatestThreadForProject<T extends {
   readonly projectId: ProjectId;
   readonly archivedAt: string | null;
 } & ThreadSortInput>(threads: readonly T[], projectId: ProjectId, sortOrder: SidebarThreadSortOrder): T | null;
+/** Key that sorts strictly between two neighbors; null bounds mean "top of
+    the pinned block" / "bottom of the keyed run". Returns null instead of
+    throwing when existing keys are corrupt or out of order — callers fall
+    back to rewriting the section. */
+declare function pinOrderKeyBetween(before: string | null, after: string | null): string | null;
+/** Evenly spaced keys for rewriting a whole pinned section (used when a
+    drop lands next to keyless threads, so single-key insertion has nothing
+    to anchor on). Two base-26 digits give 675 slots — far beyond any real
+    pinned section — with monotonicity enforced as a belt-and-braces. */
+declare function generateSpreadPinOrderKeys(count: number): string[];
+/**
+ * Assignments needed to realize a new pinned order. When the moved thread
+ * sits between two keyed (or absent) neighbors, this is a single write to
+ * the moved thread. When a neighbor is keyless (threads pinned before
+ * reordering shipped), the whole section gets fresh spread keys — a
+ * one-time materialization; every move after that is single-write.
+ */
+declare function planPinnedReorder(input: {
+  /** Thread ids in the desired visual order (after the move). */
+  readonly orderedIds: readonly string[];
+  readonly keysById: ReadonlyMap<string, string | null | undefined>;
+  readonly movedId: string;
+}): ReadonlyArray<{
+  readonly id: string;
+  readonly orderKey: string;
+}>;
+/**
+ * Pinned block order: user-arranged keys first (string comparison, id
+ * tiebreak), then keyless threads newest-created first — so threads on
+ * servers that predate reordering keep the static creation order at the
+ * bottom of the block instead of breaking the section.
+ */
+declare function sortPinnedThreadsByOrderKey<T extends {
+  readonly id: string;
+  readonly createdAt: string;
+  readonly pinOrderKey?: string | null | undefined;
+  /** Thread ids are only unique within an environment, and the pinned
+        block merges environments — the tiebreak needs both parts or two
+        clients could render equal-key threads in stream-arrival order. */
+  readonly environmentId?: string | undefined;
+}>(threads: readonly T[]): T[];
+/**
+ * planPinnedReorder specialized for mobile's Move up / Move down menu
+ * actions: swap the moved thread with its displayed neighbor. Null when the
+ * move falls off either end of the list. Same single-write-per-move
+ * semantics as a web drag.
+ */
+declare function planPinnedMove(input: {
+  /** Reorder-capable pinned thread ids in displayed order. */
+  readonly orderedIds: readonly string[];
+  readonly keysById: ReadonlyMap<string, string | null | undefined>;
+  readonly movedId: string;
+  readonly direction: "up" | "down";
+}): ReadonlyArray<{
+  readonly id: string;
+  readonly orderKey: string;
+}> | null;
 //#endregion
-export { ThreadSortInput, getLatestThreadForProject, getThreadSortTimestamp, sortThreads, toSortableTimestamp };
+export { ThreadSortInput, generateSpreadPinOrderKeys, getLatestThreadForProject, getThreadSortTimestamp, pinOrderKeyBetween, planPinnedMove, planPinnedReorder, sortPinnedThreadsByOrderKey, sortThreads, toSortableTimestamp };

package/dist/client-runtime/state/thread-sort.js

@@ -1,4 +1,4 @@
-import { Jk as Struct, Kk as Number$1, Qk as mapInput, Zk as flip, qk as String, vk as sort } from "../../shared.js";
+import { Fj as Struct, Nj as Number$1, Pj as String, Rj as flip, rj as sort, zj as mapInput } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSort.ts
 function toSortableTimestamp(iso) {
 	if (!iso) return null;
@@ -43,5 +43,131 @@ function sortThreads(threads, sortOrder) {
 function getLatestThreadForProject(threads, projectId, sortOrder) {
 	return sortThreads(threads.filter((thread) => thread.projectId === projectId && thread.archivedAt === null), sortOrder)[0] ?? null;
 }
+const PIN_ORDER_DIGITS = "abcdefghijklmnopqrstuvwxyz";
+function isValidPinOrderKey(key) {
+	if (key.length === 0) return false;
+	for (const char of key) if (!PIN_ORDER_DIGITS.includes(char)) return false;
+	return key.at(-1) !== PIN_ORDER_DIGITS[0];
+}
+/** Midpoint of two digit strings interpreted as fractions in (0, 1).
+"" stands for the open bound on either side. Requires a < b. */
+function pinOrderMidpoint(a, b) {
+	if (b !== "" && a >= b) throw new Error("pinOrderMidpoint: bounds out of order");
+	if (b !== "") {
+		let n = 0;
+		while ((a.charAt(n) || PIN_ORDER_DIGITS[0]) === b.charAt(n)) n += 1;
+		if (n > 0) return b.slice(0, n) + pinOrderMidpoint(a.slice(n), b.slice(n));
+	}
+	const digitA = a === "" ? 0 : PIN_ORDER_DIGITS.indexOf(a.charAt(0));
+	const digitB = b === "" ? 26 : PIN_ORDER_DIGITS.indexOf(b.charAt(0));
+	if (digitB - digitA > 1) return PIN_ORDER_DIGITS.charAt(Math.round((digitA + digitB) / 2));
+	if (b.length > 1) return b.charAt(0);
+	return PIN_ORDER_DIGITS.charAt(digitA) + pinOrderMidpoint(a.slice(1), "");
+}
+/** Key that sorts strictly between two neighbors; null bounds mean "top of
+the pinned block" / "bottom of the keyed run". Returns null instead of
+throwing when existing keys are corrupt or out of order — callers fall
+back to rewriting the section. */
+function pinOrderKeyBetween(before, after) {
+	const a = before ?? "";
+	const b = after ?? "";
+	if (a !== "" && !isValidPinOrderKey(a)) return null;
+	if (b !== "" && !isValidPinOrderKey(b)) return null;
+	if (b !== "" && a >= b) return null;
+	return pinOrderMidpoint(a, b);
+}
+/** Evenly spaced keys for rewriting a whole pinned section (used when a
+drop lands next to keyless threads, so single-key insertion has nothing
+to anchor on). Two base-26 digits give 675 slots — far beyond any real
+pinned section — with monotonicity enforced as a belt-and-braces. */
+function generateSpreadPinOrderKeys(count) {
+	const space = 676;
+	const step = space / (count + 1);
+	const keys = [];
+	let previous = 0;
+	for (let i = 0; i < count; i += 1) {
+		let value = Math.max(Math.round(step * (i + 1)), previous + 1);
+		if (value % 26 === 0) value += 1;
+		value = Math.min(value, space - 1);
+		previous = value;
+		keys.push(PIN_ORDER_DIGITS.charAt(Math.floor(value / 26)) + PIN_ORDER_DIGITS.charAt(value % 26));
+	}
+	return keys;
+}
+/**
+* Assignments needed to realize a new pinned order. When the moved thread
+* sits between two keyed (or absent) neighbors, this is a single write to
+* the moved thread. When a neighbor is keyless (threads pinned before
+* reordering shipped), the whole section gets fresh spread keys — a
+* one-time materialization; every move after that is single-write.
+*/
+function planPinnedReorder(input) {
+	const { orderedIds, keysById, movedId } = input;
+	const movedIndex = orderedIds.indexOf(movedId);
+	if (movedIndex === -1) return [];
+	const beforeId = movedIndex > 0 ? orderedIds[movedIndex - 1] : null;
+	const afterId = movedIndex < orderedIds.length - 1 ? orderedIds[movedIndex + 1] : null;
+	const beforeKey = beforeId != null ? keysById.get(beforeId) ?? null : null;
+	const afterKey = afterId != null ? keysById.get(afterId) ?? null : null;
+	if ((beforeId === null || beforeKey != null) && (afterId === null || afterKey != null)) {
+		const key = pinOrderKeyBetween(beforeKey, afterKey);
+		if (key !== null) return [{
+			id: movedId,
+			orderKey: key
+		}];
+	}
+	const keys = generateSpreadPinOrderKeys(orderedIds.length);
+	return orderedIds.flatMap((id, index) => {
+		const key = keys[index];
+		return keysById.get(id) === key ? [] : [{
+			id,
+			orderKey: key
+		}];
+	});
+}
+/**
+* Pinned block order: user-arranged keys first (string comparison, id
+* tiebreak), then keyless threads newest-created first — so threads on
+* servers that predate reordering keep the static creation order at the
+* bottom of the block instead of breaking the section.
+*/
+function sortPinnedThreadsByOrderKey(threads) {
+	const keyed = [];
+	const keyless = [];
+	for (const thread of threads) (thread.pinOrderKey != null ? keyed : keyless).push(thread);
+	const identityTiebreak = (left, right) => left.id.localeCompare(right.id) || (left.environmentId ?? "").localeCompare(right.environmentId ?? "");
+	keyed.sort((left, right) => {
+		const leftKey = left.pinOrderKey;
+		const rightKey = right.pinOrderKey;
+		return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : identityTiebreak(left, right);
+	});
+	keyless.sort((left, right) => {
+		const leftMs = Date.parse(left.createdAt);
+		const rightMs = Date.parse(right.createdAt);
+		return (Number.isNaN(rightMs) ? 0 : rightMs) - (Number.isNaN(leftMs) ? 0 : leftMs) || identityTiebreak(left, right);
+	});
+	return [...keyed, ...keyless];
+}
+/**
+* planPinnedReorder specialized for mobile's Move up / Move down menu
+* actions: swap the moved thread with its displayed neighbor. Null when the
+* move falls off either end of the list. Same single-write-per-move
+* semantics as a web drag.
+*/
+function planPinnedMove(input) {
+	const { orderedIds, keysById, movedId, direction } = input;
+	const from = orderedIds.indexOf(movedId);
+	if (from === -1) return null;
+	const to = direction === "up" ? from - 1 : from + 1;
+	if (to < 0 || to >= orderedIds.length) return null;
+	const newOrder = [...orderedIds];
+	newOrder.splice(from, 1);
+	newOrder.splice(to, 0, movedId);
+	return planPinnedReorder({
+		orderedIds: newOrder,
+		keysById,
+		movedId
+	});
+}
 //#endregion
-export { getLatestThreadForProject, getThreadSortTimestamp, sortThreads, toSortableTimestamp };
+export { generateSpreadPinOrderKeys, getLatestThreadForProject, getThreadSortTimestamp, pinOrderKeyBetween, planPinnedMove, planPinnedReorder, sortPinnedThreadsByOrderKey, sortThreads, toSortableTimestamp };

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

@@ -1,4 +1,4 @@
-import { $T as ThreadId, B_ as OrchestrationEvent, Ca as EnvironmentCacheStore, Ct as StartThreadTurnInput, Dt as UnsnoozeThreadInput, Et as UnsettleThreadInput, G_ as OrchestrationGetFullThreadDiffResult, Mw as ScopedThreadRef, St as SnoozeThreadInput, Tt as UnarchiveThreadInput, Ua as RemoteEnvironmentRequestError, Y_ as OrchestrationGetTurnDiffResult, _a as EnvironmentSupervisor, _t as RespondToThreadUserInputInput, at as EnvironmentThreadShell, bT as EnvironmentAuthorizationError, bt as SetThreadRuntimeModeInput, cv as OrchestrationShellSnapshot, es as PreparedConnection, f as AtomCommand, ft as CreateThreadInput, gt as RespondToThreadApprovalInput, gv as OrchestrationThreadDetailSnapshot, ha as EnvironmentRegistry, ht as InterruptThreadTurnInput, it as EnvironmentThread, jw as ScopedProjectRef, kt as UpdateThreadMetadataInput, ma as EnvironmentNotRegisteredError, mt as DeleteThreadInput, on as EnvironmentRpcUnavailableError, pv as OrchestrationThread, u as EnvironmentCatalogState, uo as ManagedRelayDpopSigner, ut as ArchiveThreadInput, vt as RevertThreadCheckpointInput, wt as StopThreadSessionInput, xt as SettleThreadInput, yt as SetThreadInteractionModeInput, zT as EnvironmentId, z_ as OrchestrationDispatchCommandError } from "../../shared.js";
+import { $a as RemoteEnvironmentRequestError, $v as OrchestrationDispatchCommandError, At as UnpinThreadInput, CD as EnvironmentId, Ct as SetThreadInteractionModeInput, Da as EnvironmentSupervisor, Dt as StartThreadTurnInput, Et as SnoozeThreadInput, Ly as OrchestrationThreadDetailSnapshot, Mt as UnsnoozeThreadInput, Na as EnvironmentCacheStore, Ny as OrchestrationThread, Ot as StopThreadSessionInput, Oy as OrchestrationShellSnapshot, Pt as UpdateThreadMetadataInput, RD as ThreadId, St as RevertThreadCheckpointInput, Ta as EnvironmentRegistry, Tt as SettleThreadInput, _t as InterruptThreadTurnInput, ay as OrchestrationGetFullThreadDiffResult, bo as ManagedRelayDpopSigner, bt as RespondToThreadApprovalInput, ey as OrchestrationEvent, f as AtomCommand, ft as ArchiveThreadInput, gt as DeleteThreadInput, hE as ScopedThreadRef, iD as EnvironmentAuthorizationError, jt as UnsettleThreadInput, kt as UnarchiveThreadInput, ly as OrchestrationGetTurnDiffResult, mE as ScopedProjectRef, mn as EnvironmentRpcUnavailableError, mt as CreateThreadInput, ot as EnvironmentThread, st as EnvironmentThreadShell, u as EnvironmentCatalogState, us as PreparedConnection, vt as PinThreadInput, wa as EnvironmentNotRegisteredError, wt as SetThreadRuntimeModeInput, xt as RespondToThreadUserInputInput, yt as ReorderPinnedThreadInput } from "../../shared.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -15,11 +15,21 @@ import { AsyncResult, Atom } from "effect/unstable/reactivity";
  * WebSocket subscription's first frame. The response is gzip-compressible by
  * the transport and keeps the (potentially multi-KB) snapshot off the socket.
  */
+/**
+ * Optional turn window for a snapshot fetch. Only send a window to servers
+ * that advertise `threadSnapshotPagination`; older servers reject unknown
+ * query parameters.
+ */
+interface ThreadSnapshotWindow {
+  readonly turnLimit: number;
+  readonly beforeCursor?: string;
+}
 declare const fetchEnvironmentThreadSnapshot: (input: {
   readonly prepared: PreparedConnection;
   readonly threadId: ThreadId;
   readonly signer: Option.Option<ManagedRelayDpopSigner["Service"]>;
   readonly timeoutMs?: number;
+  readonly window?: ThreadSnapshotWindow;
 }) => Effect.Effect<{
   readonly snapshotSequence: number;
   readonly thread: {
@@ -57,6 +67,12 @@ declare const fetchEnvironmentThreadSnapshot: (input: {
     readonly settledAt: string | null;
     readonly snoozedUntil?: string | null | undefined;
     readonly snoozedAt?: string | null | undefined;
+    readonly pinnedAt?: string | null | undefined;
+    readonly pinOrderKey?: string | null | undefined;
+    readonly titleRegeneration?: {
+      readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+      readonly startedAt: string;
+    } | null | undefined;
     readonly deletedAt: string | null;
     readonly messages: readonly {
       readonly id: string & import("effect/Brand").Brand<"MessageId">;
@@ -118,10 +134,16 @@ declare const fetchEnvironmentThreadSnapshot: (input: {
       readonly updatedAt: string;
     } | null;
   };
+  readonly page?: {
+    readonly beforeCursor: string | null;
+    readonly hasMore: boolean;
+    readonly snapshotSequence: number;
+    readonly threadSequence?: number;
+  } | undefined;
 }, RemoteEnvironmentRequestError, HttpClient.HttpClient>;
 type FetchEnvironmentThreadSnapshotError = RemoteEnvironmentRequestError;
 declare const ThreadSnapshotLoader_base: Context.ServiceClass<ThreadSnapshotLoader, "@t3tools/client-runtime/state/threadSnapshotHttp/ThreadSnapshotLoader", {
-  readonly load: (prepared: PreparedConnection, threadId: ThreadId) => Effect.Effect<Option.Option<OrchestrationThreadDetailSnapshot>>;
+  readonly load: (prepared: PreparedConnection, threadId: ThreadId, window?: ThreadSnapshotWindow) => Effect.Effect<Option.Option<OrchestrationThreadDetailSnapshot>>;
 }>;
 /**
  * Loads a thread's detail snapshot over HTTP, returning `Option.none()` when it
@@ -134,12 +156,28 @@ declare const threadSnapshotLoaderLayer: Layer.Layer<ThreadSnapshotLoader, never
 //#endregion
 //#region upstream-t3code/packages/client-runtime/src/state/threadState.d.ts
 type EnvironmentThreadStatus = "empty" | "cached" | "synchronizing" | "live" | "deleted";
+/**
+ * Pagination state for a windowed thread. Present only when the loaded thread
+ * is a window (the server returned `page` metadata); absent means the thread is
+ * fully loaded — either the server predates pagination or the window reached
+ * the top.
+ */
+interface EnvironmentThreadPageState {
+  /** Opaque exclusive cursor for the next older slice; null when fully loaded. */
+  readonly beforeCursor: string | null;
+  readonly hasMore: boolean;
+  /** True while an older page fetch is in flight. */
+  readonly loadingOlder: boolean;
+}
 interface EnvironmentThreadState {
   readonly data: Option.Option<OrchestrationThread>;
   readonly status: EnvironmentThreadStatus;
   readonly error: Option.Option<string>;
+  readonly page: Option.Option<EnvironmentThreadPageState>;
 }
 declare const EMPTY_ENVIRONMENT_THREAD_STATE: EnvironmentThreadState;
+/** Whether the thread has older turns that can be loaded with more pages. */
+declare function threadHasOlderTurns(state: EnvironmentThreadState): boolean;
 //#endregion
 //#region upstream-t3code/packages/client-runtime/src/state/archivedThreads.d.ts
 interface ArchivedSnapshotEntry {
@@ -241,6 +279,24 @@ declare function createThreadEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
   }, {
     readonly sequence: number;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  pin: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: PinThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  unpin: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UnpinThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  reorderPin: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: ReorderPinnedThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   updateMetadata: AtomCommand<{
     readonly environmentId: EnvironmentId;
     readonly input: UpdateThreadMetadataInput;
@@ -446,6 +502,12 @@ declare function createEnvironmentThreadShellAtoms(input: {
     readonly settledAt: string | null;
     readonly snoozedUntil?: string | null | undefined;
     readonly snoozedAt?: string | null | undefined;
+    readonly pinnedAt?: string | null | undefined;
+    readonly pinOrderKey?: string | null | undefined;
+    readonly titleRegeneration?: {
+      readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+      readonly startedAt: string;
+    } | null | undefined;
     readonly session: {
       readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
       readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
@@ -460,6 +522,12 @@ declare function createEnvironmentThreadShellAtoms(input: {
     readonly hasPendingApprovals: boolean;
     readonly hasPendingUserInput: boolean;
     readonly hasActionableProposedPlan: boolean;
+    readonly backgroundLiveness?: "monitoring" | "working" | null | undefined;
+    readonly planProgress?: {
+      readonly step: string;
+      readonly completedSteps: number;
+      readonly totalSteps: number;
+    } | null | undefined;
   }[]>;
   environmentThreadIndexAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"ThreadId">, {
     readonly id: string & import("effect/Brand").Brand<"ThreadId">;
@@ -496,6 +564,12 @@ declare function createEnvironmentThreadShellAtoms(input: {
     readonly settledAt: string | null;
     readonly snoozedUntil?: string | null | undefined;
     readonly snoozedAt?: string | null | undefined;
+    readonly pinnedAt?: string | null | undefined;
+    readonly pinOrderKey?: string | null | undefined;
+    readonly titleRegeneration?: {
+      readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+      readonly startedAt: string;
+    } | null | undefined;
     readonly session: {
       readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
       readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
@@ -510,6 +584,12 @@ declare function createEnvironmentThreadShellAtoms(input: {
     readonly hasPendingApprovals: boolean;
     readonly hasPendingUserInput: boolean;
     readonly hasActionableProposedPlan: boolean;
+    readonly backgroundLiveness?: "monitoring" | "working" | null | undefined;
+    readonly planProgress?: {
+      readonly step: string;
+      readonly completedSteps: number;
+      readonly totalSteps: number;
+    } | null | undefined;
   }>>;
   environmentThreadRefsAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<readonly {
     readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
@@ -529,10 +609,42 @@ declare function createEnvironmentThreadShellAtoms(input: {
 };
 //#endregion
 //#region upstream-t3code/packages/client-runtime/src/state/threads.d.ts
+/**
+ * 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.
+ */
+declare const INITIAL_THREAD_USER_TURN_LIMIT = 10;
+declare const OLDER_THREAD_PAGE_USER_TURN_LIMIT = 20;
+interface ThreadOlderTurnRequestRegistry {
+  /**
+   * Registers the live state machine for a thread. Returns the deregistration
+   * cleanup; registration lives exactly as long as the machine's scope, and a
+   * successor machine for the same thread simply replaces the entry.
+   */
+  readonly register: (key: string, handler: () => void) => () => void;
+  readonly request: (key: string) => boolean;
+}
+declare const ThreadOlderTurnRequests_base: Context.Reference<ThreadOlderTurnRequestRegistry>;
+/**
+ * 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.
+ */
+declare class ThreadOlderTurnRequests extends ThreadOlderTurnRequests_base {}
+/**
+ * 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".
+ */
+declare function requestOlderThreadTurns(environmentId: EnvironmentId, threadId: ThreadId): boolean;
 declare const makeEnvironmentThreadState: (threadId: string & import("effect/Brand").Brand<"ThreadId">) => Effect.Effect<SubscriptionRef.SubscriptionRef<EnvironmentThreadState>, never, EnvironmentCacheStore | EnvironmentSupervisor | import("effect/Scope").Scope | ThreadSnapshotLoader>;
 declare function threadStateChanges(environmentId: EnvironmentId, threadId: ThreadId): Stream.Stream<EnvironmentThreadState, never, EnvironmentCacheStore | EnvironmentRegistry | ThreadSnapshotLoader>;
 declare function createEnvironmentThreadStateAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | ThreadSnapshotLoader | R, E>): {
   stateAtom: (environmentId: EnvironmentId, threadId: ThreadId) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<EnvironmentThreadState, E | Cause.NoSuchElementError>>;
 };
 //#endregion
-export { type ArchiveThreadInput, ArchivedSnapshotEntry, ArchivedThreadSnapshotsState, CheckpointDiffResult, CheckpointDiffState, CheckpointDiffTarget, ComposerPathSearchEntry, ComposerPathSearchState, ComposerPathSearchTarget, type CreateThreadInput, type DeleteThreadInput, EMPTY_ENVIRONMENT_THREAD_STATE, EnvironmentThreadState, EnvironmentThreadStatus, FetchEnvironmentThreadSnapshotError, type InterruptThreadTurnInput, type RespondToThreadApprovalInput, type RespondToThreadUserInputInput, type RevertThreadCheckpointInput, type SetThreadInteractionModeInput, type SetThreadRuntimeModeInput, type SettleThreadInput, type SnoozeThreadInput, type StartThreadTurnInput, type StopThreadSessionInput, ThreadDetailReducerResult, ThreadSnapshotLoader, type UnarchiveThreadInput, type UnsettleThreadInput, type UnsnoozeThreadInput, type UpdateThreadMetadataInput, applyThreadDetailEvent, createArchivedThreadSnapshotsAtomFamily, createEnvironmentThreadDetailAtoms, createEnvironmentThreadShellAtoms, createEnvironmentThreadStateAtoms, createThreadEnvironmentAtoms, fetchEnvironmentThreadSnapshot, makeArchivedThreadsEnvironmentKey, makeEnvironmentThreadState, mergeEnvironmentThread, parseArchivedThreadsEnvironmentKey, threadSnapshotLoaderLayer, threadStateChanges };
+export { type ArchiveThreadInput, ArchivedSnapshotEntry, ArchivedThreadSnapshotsState, CheckpointDiffResult, CheckpointDiffState, CheckpointDiffTarget, ComposerPathSearchEntry, ComposerPathSearchState, ComposerPathSearchTarget, type CreateThreadInput, type DeleteThreadInput, EMPTY_ENVIRONMENT_THREAD_STATE, EnvironmentThreadPageState, EnvironmentThreadState, EnvironmentThreadStatus, FetchEnvironmentThreadSnapshotError, INITIAL_THREAD_USER_TURN_LIMIT, type InterruptThreadTurnInput, OLDER_THREAD_PAGE_USER_TURN_LIMIT, type PinThreadInput, type ReorderPinnedThreadInput, type RespondToThreadApprovalInput, type RespondToThreadUserInputInput, type RevertThreadCheckpointInput, type SetThreadInteractionModeInput, type SetThreadRuntimeModeInput, type SettleThreadInput, type SnoozeThreadInput, type StartThreadTurnInput, type StopThreadSessionInput, ThreadDetailReducerResult, ThreadOlderTurnRequests, ThreadSnapshotLoader, ThreadSnapshotWindow, type UnarchiveThreadInput, type UnpinThreadInput, type UnsettleThreadInput, type UnsnoozeThreadInput, type UpdateThreadMetadataInput, applyThreadDetailEvent, createArchivedThreadSnapshotsAtomFamily, createEnvironmentThreadDetailAtoms, createEnvironmentThreadShellAtoms, createEnvironmentThreadStateAtoms, createThreadEnvironmentAtoms, fetchEnvironmentThreadSnapshot, makeArchivedThreadsEnvironmentKey, makeEnvironmentThreadState, mergeEnvironmentThread, parseArchivedThreadsEnvironmentKey, requestOlderThreadTurns, threadHasOlderTurns, threadSnapshotLoaderLayer, threadStateChanges };