t3code-cli 0.14.1 → 0.15.0

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

@@ -1,6 +1,8 @@
-import { _v as OrchestrationThreadShell } from "../../shared.js";
+import { vb as OrchestrationThreadShell } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSettled.d.ts
 type ChangeRequestStateLike = "open" | "closed" | "merged";
+/** Returns whether the change request state settles the thread immediately. */
+declare function changeRequestAutoSettles(state: ChangeRequestStateLike | null | undefined, autoSettleOnMerge?: boolean): boolean;
 declare function threadLastActivityAt(shell: OrchestrationThreadShell): string | null;
 /**
  * A queued turn start lives for at most this long: session adoption takes
@@ -90,15 +92,41 @@ declare function threadWokeAt(shell: ThreadSnoozeShell, options: {
  * queued turn) are checked first and hold a thread active regardless of any
  * 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
+ * wins in both directions; without one, a thread can auto-settle on a
+ * merged PR, always settles on a closed PR, or settles on inactivity past
+ * the window. 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.
  */
 declare function effectiveSettled(shell: OrchestrationThreadShell, options: {
   readonly now: string;
   readonly autoSettleAfterDays: number | null;
+  readonly autoSettleOnMerge?: boolean;
   readonly changeRequestState?: ChangeRequestStateLike | null;
 }): boolean;
+type SnoozePresetId = "hour" | "three-hours" | "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 calendar
+ * choices start 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, changeRequestAutoSettles, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, resolveSnoozePresets, snoozeWakeLabel, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };

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

@@ -1,157 +1,2 @@
-//#region upstream-t3code/packages/client-runtime/src/state/threadSettled.ts
-const DAY_MS = 1440 * 60 * 1e3;
-function threadLastActivityAt(shell) {
-	const candidates = [
-		shell.latestUserMessageAt,
-		shell.latestTurn?.requestedAt,
-		shell.latestTurn?.startedAt,
-		shell.latestTurn?.completedAt
-	];
-	let latest = null;
-	let latestTimestamp = Number.NEGATIVE_INFINITY;
-	for (const candidate of candidates) {
-		if (candidate === null || candidate === void 0) continue;
-		const timestamp = Date.parse(candidate);
-		if (timestamp > latestTimestamp) {
-			latest = candidate;
-			latestTimestamp = timestamp;
-		}
-	}
-	return latest;
-}
-/**
-* A queued turn start lives for at most this long: session adoption takes
-* seconds, so a user message still unadopted after the grace window is a
-* failed start (or stale data — shells from older servers can carry user
-* messages with no latestTurn at all), not pending work. Without this bound
-* such threads would be permanently unsettleable.
-*/
-const QUEUED_TURN_START_GRACE_MS = 120 * 1e3;
-/**
-* A user message no turn has picked up yet: the turn.start command was
-* dispatched (message-sent + turn-start-requested) but no session has
-* adopted it, so `session` is still null and the pending work is invisible
-* to the session-status checks. Detectable as a user message strictly newer
-* than every timestamp on the latest turn — on adoption the new turn's
-* requestedAt equals the message time, clearing the condition — and only
-* within the adoption grace window.
-*/
-function hasQueuedTurnStart(shell, options) {
-	if (shell.latestUserMessageAt == null) return false;
-	if (shell.session?.status === "error") return false;
-	const messageAt = Date.parse(shell.latestUserMessageAt);
-	if (Number.isNaN(messageAt)) return false;
-	const nowMs = Date.parse(options.now);
-	if (Number.isNaN(nowMs)) return false;
-	if (Math.abs(nowMs - messageAt) > 12e4) return false;
-	const turn = shell.latestTurn;
-	if (turn === null) return true;
-	return [
-		turn.requestedAt,
-		turn.startedAt,
-		turn.completedAt
-	].every((candidate) => candidate == null || Date.parse(candidate) < messageAt);
-}
-/**
-* A thread may be settled only when none of effectiveSettled's activity
-* blockers hold. This is deliberately the same list: anything the partition
-* refuses to CLASSIFY as settled must also be refused as a settle TARGET.
-* The server enforces its own invariants; this client-side twin exists so
-* the UI can disable/reject before a round trip.
-*/
-function canSettle(shell, options) {
-	if (shell.hasPendingApprovals || shell.hasPendingUserInput) return false;
-	if (shell.session?.status === "starting" || shell.session?.status === "running") return false;
-	if (hasQueuedTurnStart(shell, options)) return false;
-	return true;
-}
-/**
-* A snoozed thread "raises its hand" when something happens that outranks
-* the user's snooze: the agent is blocked on them (approval / user input),
-* the session failed, or a run completed after the snooze was set — the
-* v1 taste of event-based snooze ("something happened" wakes early).
-* Raising a hand never clears the server-side snooze fields; it only stops
-* the thread from CLASSIFYING as snoozed, exactly like blocked work and
-* effectiveSettled.
-*/
-function threadRaisedHandWhileSnoozed(shell) {
-	if (shell.hasPendingApprovals || shell.hasPendingUserInput) return true;
-	if (shell.session?.status === "error" && (shell.snoozedAt == null || Date.parse(shell.session.updatedAt) > Date.parse(shell.snoozedAt))) return true;
-	if (shell.snoozedAt != null && shell.latestTurn?.state === "completed" && shell.latestTurn.completedAt != null && Date.parse(shell.latestTurn.completedAt) > Date.parse(shell.snoozedAt)) return true;
-	return false;
-}
-/**
-* A thread may be snoozed unless the agent is blocked on the user: hiding a
-* pending approval or user-input request defeats the request, and a queued
-* turn start (a message no turn has adopted yet) is invisible pending work
-* the same way it is for settle. A running session IS snoozable — snooze
-* only affects visibility, never the agent. Client-side twin of the server
-* invariants so the UI can reject before a round trip.
-*/
-function canSnooze(shell, options) {
-	if (shell.hasPendingApprovals || shell.hasPendingUserInput) return false;
-	if (hasQueuedTurnStart(shell, options)) return false;
-	return true;
-}
-/**
-* Snoozed resolution: hidden from the inbox while the wake time is in the
-* future and the thread has not raised its hand. Timer wakes are derived —
-* no server event fires when snoozedUntil passes; the stale fields simply
-* stop classifying as snoozed (and feed the woke indicator until the user
-* visits or re-engages).
-*/
-function effectiveSnoozed(shell, options) {
-	if (shell.snoozedUntil == null) return false;
-	const wakeAtMs = Date.parse(shell.snoozedUntil);
-	if (Number.isNaN(wakeAtMs)) return false;
-	if (wakeAtMs <= Date.parse(options.now)) return false;
-	return !threadRaisedHandWhileSnoozed(shell);
-}
-/**
-* When a previously-snoozed thread woke, or null if it never snoozed / is
-* still snoozed. Used for the "Woke" indicator: the thread reappears in its
-* original sort position (the inbox sort is deliberately static), so the
-* wake signal has to carry the weight. Compare against the client's
-* lastVisitedAt — visiting clears the indicator like it clears unread.
-*
-* Timer wakes report the wake time itself; raised-hand wakes report the
-* triggering timestamp so a visit BEFORE the early wake doesn't suppress
-* the indicator.
-*/
-function threadWokeAt(shell, options) {
-	if (shell.snoozedUntil == null) return null;
-	const wakeAtMs = Date.parse(shell.snoozedUntil);
-	if (Number.isNaN(wakeAtMs)) return null;
-	if (threadRaisedHandWhileSnoozed(shell)) {
-		if (shell.snoozedAt != null && shell.latestTurn?.state === "completed" && shell.latestTurn.completedAt != null && Date.parse(shell.latestTurn.completedAt) > Date.parse(shell.snoozedAt)) return shell.latestTurn.completedAt;
-		return shell.session?.updatedAt ?? shell.snoozedAt ?? null;
-	}
-	return wakeAtMs <= Date.parse(options.now) ? shell.snoozedUntil : null;
-}
-/**
-* Settled resolution over the server-backed settled lifecycle. Activity
-* blockers (pending approval/user-input, a live session, an unadjudicated
-* queued turn) are checked first and hold a thread active regardless of any
-* 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
-* un-settles on real activity (user message, session start, approval/
-* user-input request), so an override never goes stale silently.
-*/
-function effectiveSettled(shell, options) {
-	if (shell.hasPendingApprovals || shell.hasPendingUserInput) return false;
-	if (shell.session?.status === "starting" || shell.session?.status === "running") return false;
-	if (hasQueuedTurnStart(shell, { now: options.now })) {
-		if (!(shell.settledOverride === "settled" && shell.settledAt !== null && shell.latestUserMessageAt !== null && Date.parse(shell.settledAt) >= Date.parse(shell.latestUserMessageAt))) return false;
-	}
-	if (shell.settledOverride === "settled") return true;
-	if (shell.settledOverride === "active") return false;
-	if (options.changeRequestState === "merged" || options.changeRequestState === "closed") return true;
-	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;
-}
-//#endregion
-export { QUEUED_TURN_START_GRACE_MS, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };
+import { $s as threadRaisedHandWhileSnoozed, Gs as canSnooze, Js as effectiveSnoozed, Ks as changeRequestAutoSettles, Qs as threadLastActivityAt, Us as QUEUED_TURN_START_GRACE_MS, Ws as canSettle, Xs as resolveSnoozePresets, Ys as hasQueuedTurnStart, Zs as snoozeWakeLabel, ec as threadWokeAt, qs as effectiveSettled } from "../../shared.js";
+export { QUEUED_TURN_START_GRACE_MS, canSettle, canSnooze, changeRequestAutoSettles, 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 { Ek as ProjectId, ry as SidebarThreadSortOrder, ty 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 { $N as flip, JN as Number$1, XN as Struct, YN as String, eP as mapInput, gN as sort } 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 { $O as EnvironmentAuthorizationError, Aa as EnvironmentSupervisor, At as UnarchiveThreadInput, Ay as OrchestrationDispatchCommandError, By as OrchestrationGetTurnDiffResult, Ct as RevertThreadCheckpointInput, Da as EnvironmentNotRegisteredError, Dt as SnoozeThreadInput, Et as SettleThreadInput, Ft as UpdateThreadMetadataInput, Ia as EnvironmentCacheStore, Iy as OrchestrationGetFullThreadDiffResult, Mt as UnsettleThreadInput, Nk as ThreadId, Nt as UnsnoozeThreadInput, Oa as EnvironmentRegistry, Ot as StartThreadTurnInput, St as RespondToThreadUserInputInput, Tt as SetThreadRuntimeModeInput, _t as DeleteThreadInput, ab as OrchestrationShellSnapshot, bt as ReorderPinnedThreadInput, ct as EnvironmentThreadShell, f as AtomCommand, hn as EnvironmentRpcUnavailableError, ht as CreateThreadInput, jt as UnpinThreadInput, jy as OrchestrationEvent, kt as StopThreadSessionInput, lO as ScopedProjectRef, mb as OrchestrationThreadDetailSnapshot, ms as PreparedConnection, no as RemoteEnvironmentRequestError, pt as ArchiveThreadInput, st as EnvironmentThread, u as EnvironmentCatalogState, uO as ScopedThreadRef, ub as OrchestrationThread, vk as EnvironmentId, vt as InterruptThreadTurnInput, wo as ManagedRelayDpopSigner, wt as SetThreadInteractionModeInput, xt as RespondToThreadApprovalInput, yt as PinThreadInput } 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 };