t3code-cli 0.12.0 → 0.14.0

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

@@ -0,0 +1,237 @@
+import { $T as ThreadId, Hb as TerminalCwdNotDirectoryError, Jb as TerminalMetadataStreamEvent, Rb as TerminalAttachStreamEvent, Ub as TerminalCwdNotFoundError, Wb as TerminalCwdStatError, Yb as TerminalNotRunningError, Zb as TerminalResizeError, bT as EnvironmentAuthorizationError, f as AtomCommand, ha as EnvironmentRegistry, ix as TerminalSummary, ma as EnvironmentNotRegisteredError, nx as TerminalSessionSnapshot, on as EnvironmentRpcUnavailableError, ox as TerminalWriteError, qb as TerminalHistoryError, tx as TerminalSessionLookupError, zT as EnvironmentId } from "../../shared.js";
+import { Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/terminalSession.d.ts
+interface TerminalSessionState {
+  readonly summary: TerminalSummary | null;
+  readonly buffer: string;
+  readonly status: TerminalSessionSnapshot["status"] | "closed";
+  readonly error: string | null;
+  readonly hasRunningSubprocess: boolean;
+  readonly updatedAt: string | null;
+  readonly version: number;
+}
+interface TerminalBufferState {
+  readonly buffer: string;
+  readonly status: TerminalSessionSnapshot["status"] | "closed";
+  readonly error: string | null;
+  readonly updatedAt: string | null;
+  readonly version: number;
+}
+interface KnownTerminalSessionTarget {
+  readonly environmentId: EnvironmentId;
+  readonly threadId: ThreadId;
+  readonly terminalId: string;
+}
+interface KnownTerminalSession {
+  readonly target: KnownTerminalSessionTarget;
+  readonly state: TerminalSessionState;
+}
+declare function selectRunningSubprocessTerminalIds(sessions: ReadonlyArray<KnownTerminalSession>): ReadonlyArray<string>;
+declare const EMPTY_TERMINAL_BUFFER_STATE: Readonly<TerminalBufferState>;
+declare const EMPTY_TERMINAL_SESSION_STATE: Readonly<TerminalSessionState>;
+declare const DEFAULT_MAX_TERMINAL_BUFFER_BYTES: number;
+declare function terminalBufferStateFromSnapshot(snapshot: TerminalSessionSnapshot, maxBufferBytes: number): TerminalBufferState;
+declare function combineTerminalSessionState(summary: TerminalSummary | null, buffer: TerminalBufferState): TerminalSessionState;
+declare function applyTerminalAttachStreamEvent(current: TerminalBufferState, event: TerminalAttachStreamEvent, maxBufferBytes?: number): TerminalBufferState;
+declare function applyTerminalMetadataStreamEvent(current: ReadonlyArray<TerminalSummary>, event: TerminalMetadataStreamEvent): ReadonlyArray<TerminalSummary>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/terminal.d.ts
+declare function createTerminalEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+  attach: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cwd?: string | undefined;
+      readonly worktreePath?: string | null | undefined;
+      readonly cols?: number | undefined;
+      readonly rows?: number | undefined;
+      readonly env?: {
+        readonly [x: string]: string;
+      } | undefined;
+      readonly restartIfNotRunning?: boolean | undefined;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<TerminalBufferState, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>>;
+  events: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "output";
+    readonly data: string;
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "exited";
+    readonly exitCode: number | null;
+    readonly exitSignal: number | null;
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "closed";
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "error";
+    readonly message: string;
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "cleared";
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "restarted";
+    readonly snapshot: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cwd: string;
+      readonly worktreePath: string | null;
+      readonly status: "error" | "exited" | "running" | "starting";
+      readonly pid: number | null;
+      readonly history: string;
+      readonly exitCode: number | null;
+      readonly exitSignal: number | null;
+      readonly label: string;
+      readonly updatedAt: string;
+      readonly sequence?: number | undefined;
+    };
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "activity";
+    readonly hasRunningSubprocess: boolean;
+    readonly label: string;
+  } | {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly sequence?: number | undefined;
+    readonly type: "started";
+    readonly snapshot: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cwd: string;
+      readonly worktreePath: string | null;
+      readonly status: "error" | "exited" | "running" | "starting";
+      readonly pid: number | null;
+      readonly history: string;
+      readonly exitCode: number | null;
+      readonly exitSignal: number | null;
+      readonly label: string;
+      readonly updatedAt: string;
+      readonly sequence?: number | undefined;
+    };
+  }, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  metadata: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: null;
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<readonly {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly cwd: string;
+    readonly worktreePath: string | null;
+    readonly status: "error" | "exited" | "running" | "starting";
+    readonly pid: number | null;
+    readonly exitCode: number | null;
+    readonly exitSignal: number | null;
+    readonly hasRunningSubprocess: boolean;
+    readonly label: string;
+    readonly updatedAt: string;
+  }[], E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  open: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cwd: string;
+      readonly worktreePath?: string | null | undefined;
+      readonly cols?: number | undefined;
+      readonly rows?: number | undefined;
+      readonly env?: {
+        readonly [x: string]: string;
+      } | undefined;
+    };
+  }, {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly cwd: string;
+    readonly worktreePath: string | null;
+    readonly status: "error" | "exited" | "running" | "starting";
+    readonly pid: number | null;
+    readonly history: string;
+    readonly exitCode: number | null;
+    readonly exitSignal: number | null;
+    readonly label: string;
+    readonly updatedAt: string;
+    readonly sequence?: number | undefined;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+  write: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly data: import("effect/Schema").String;
+    }>;
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+  resize: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly cols: import("effect/Schema").Int;
+      readonly rows: import("effect/Schema").Int;
+    }>;
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+  clear: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
+      readonly threadId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+      readonly terminalId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
+    }>;
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+  restart: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId: string;
+      readonly cwd: string;
+      readonly worktreePath?: string | null | undefined;
+      readonly cols: number;
+      readonly rows: number;
+      readonly env?: {
+        readonly [x: string]: string;
+      } | undefined;
+    };
+  }, {
+    readonly threadId: string;
+    readonly terminalId: string;
+    readonly cwd: string;
+    readonly worktreePath: string | null;
+    readonly status: "error" | "exited" | "running" | "starting";
+    readonly pid: number | null;
+    readonly history: string;
+    readonly exitCode: number | null;
+    readonly exitSignal: number | null;
+    readonly label: string;
+    readonly updatedAt: string;
+    readonly sequence?: number | undefined;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+  close: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string;
+      readonly terminalId?: string | undefined;
+      readonly deleteHistory?: boolean | undefined;
+    };
+  }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError | TerminalCwdNotDirectoryError | TerminalCwdNotFoundError | TerminalCwdStatError | TerminalHistoryError | TerminalNotRunningError | TerminalResizeError | TerminalSessionLookupError | TerminalWriteError>;
+};
+//#endregion
+export { DEFAULT_MAX_TERMINAL_BUFFER_BYTES, EMPTY_TERMINAL_BUFFER_STATE, EMPTY_TERMINAL_SESSION_STATE, KnownTerminalSession, KnownTerminalSessionTarget, TerminalBufferState, TerminalSessionState, applyTerminalAttachStreamEvent, applyTerminalMetadataStreamEvent, combineTerminalSessionState, createTerminalEnvironmentAtoms, selectRunningSubprocessTerminalIds, terminalBufferStateFromSnapshot };

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

@@ -0,0 +1,173 @@
+import { Fs as WS_METHODS, Ur as subscribe, dr as createEnvironmentRpcCommand, hr as createEnvironmentSubscriptionAtomFamily, iD as scan, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/terminalSession.ts
+function selectRunningSubprocessTerminalIds(sessions) {
+	return sessions.filter((session) => session.state.hasRunningSubprocess).map((session) => session.target.terminalId);
+}
+const EMPTY_TERMINAL_BUFFER_STATE = Object.freeze({
+	buffer: "",
+	status: "closed",
+	error: null,
+	updatedAt: null,
+	version: 0
+});
+const EMPTY_TERMINAL_SESSION_STATE = Object.freeze({
+	summary: null,
+	buffer: "",
+	status: "closed",
+	error: null,
+	hasRunningSubprocess: false,
+	updatedAt: null,
+	version: 0
+});
+const DEFAULT_MAX_TERMINAL_BUFFER_BYTES = 512 * 1024;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function trimBufferToBytes(buffer, maxBufferBytes) {
+	if (maxBufferBytes <= 0) return "";
+	const encoded = textEncoder.encode(buffer);
+	if (encoded.byteLength <= maxBufferBytes) return buffer;
+	let start = encoded.byteLength - maxBufferBytes;
+	while (start < encoded.length) {
+		const byte = encoded[start];
+		if (byte === void 0 || (byte & 192) !== 128) break;
+		start += 1;
+	}
+	return textDecoder.decode(encoded.subarray(start));
+}
+function terminalBufferStateFromSnapshot(snapshot, maxBufferBytes) {
+	return {
+		buffer: trimBufferToBytes(snapshot.history, maxBufferBytes),
+		status: snapshot.status,
+		error: null,
+		updatedAt: snapshot.updatedAt,
+		version: 1
+	};
+}
+function latestTimestamp(left, right) {
+	if (left === null) return right;
+	if (right === null) return left;
+	return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function combineTerminalSessionState(summary, buffer) {
+	return {
+		summary,
+		buffer: buffer.buffer,
+		status: buffer.version > 0 ? buffer.status : summary?.status ?? buffer.status,
+		error: buffer.error,
+		hasRunningSubprocess: summary?.hasRunningSubprocess ?? false,
+		updatedAt: latestTimestamp(summary?.updatedAt ?? null, buffer.updatedAt),
+		version: buffer.version
+	};
+}
+function applyTerminalAttachStreamEvent(current, event, maxBufferBytes = DEFAULT_MAX_TERMINAL_BUFFER_BYTES) {
+	switch (event.type) {
+		case "snapshot":
+		case "restarted": return terminalBufferStateFromSnapshot(event.snapshot, maxBufferBytes);
+		case "output": return {
+			...current,
+			buffer: trimBufferToBytes(`${current.buffer}${event.data}`, maxBufferBytes),
+			status: current.status === "closed" ? "running" : current.status,
+			error: null,
+			version: current.version + 1
+		};
+		case "cleared": return {
+			...current,
+			buffer: "",
+			error: null,
+			version: current.version + 1
+		};
+		case "exited": return {
+			...current,
+			status: "exited",
+			error: null,
+			version: current.version + 1
+		};
+		case "closed": return {
+			...current,
+			status: "closed",
+			error: null,
+			version: current.version + 1
+		};
+		case "error": return {
+			...current,
+			status: "error",
+			error: event.message,
+			version: current.version + 1
+		};
+		case "activity": return current;
+	}
+}
+function applyTerminalMetadataStreamEvent(current, event) {
+	if (event.type === "snapshot") return event.terminals;
+	if (event.type === "remove") return current.filter((terminal) => terminal.threadId !== event.threadId || terminal.terminalId !== event.terminalId);
+	return [...current.filter((terminal) => terminal.threadId !== event.terminal.threadId || terminal.terminalId !== event.terminal.terminalId), event.terminal];
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/terminal.ts
+function createTerminalEnvironmentAtoms(runtime) {
+	const lifecycleScheduler = createAtomCommandScheduler();
+	const resizeScheduler = createAtomCommandScheduler();
+	const terminalThreadKey = ({ environmentId, input }) => JSON.stringify([environmentId, input.threadId]);
+	const terminalSessionKey = ({ environmentId, input }) => JSON.stringify([
+		environmentId,
+		input.threadId,
+		input.terminalId ?? null
+	]);
+	const lifecycleConcurrency = {
+		mode: "serial",
+		key: terminalThreadKey
+	};
+	return {
+		attach: createEnvironmentSubscriptionAtomFamily(runtime, {
+			label: "environment-data:terminal:attach",
+			subscribe: (input) => subscribe(WS_METHODS.terminalAttach, input).pipe(scan(EMPTY_TERMINAL_BUFFER_STATE, applyTerminalAttachStreamEvent))
+		}),
+		events: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
+			label: "environment-data:terminal:events",
+			tag: WS_METHODS.subscribeTerminalEvents
+		}),
+		metadata: createEnvironmentSubscriptionAtomFamily(runtime, {
+			label: "environment-data:terminal:metadata",
+			subscribe: (_input) => subscribe(WS_METHODS.subscribeTerminalMetadata, {}).pipe(scan([], applyTerminalMetadataStreamEvent))
+		}),
+		open: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:open",
+			tag: WS_METHODS.terminalOpen,
+			scheduler: lifecycleScheduler,
+			concurrency: lifecycleConcurrency
+		}),
+		write: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:write",
+			tag: WS_METHODS.terminalWrite
+		}),
+		resize: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:resize",
+			tag: WS_METHODS.terminalResize,
+			scheduler: resizeScheduler,
+			concurrency: {
+				mode: "latest",
+				key: terminalSessionKey
+			}
+		}),
+		clear: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:clear",
+			tag: WS_METHODS.terminalClear,
+			scheduler: lifecycleScheduler,
+			concurrency: lifecycleConcurrency
+		}),
+		restart: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:restart",
+			tag: WS_METHODS.terminalRestart,
+			scheduler: lifecycleScheduler,
+			concurrency: lifecycleConcurrency
+		}),
+		close: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:terminal:close",
+			tag: WS_METHODS.terminalClose,
+			scheduler: lifecycleScheduler,
+			concurrency: lifecycleConcurrency
+		})
+	};
+}
+//#endregion
+export { DEFAULT_MAX_TERMINAL_BUFFER_BYTES, EMPTY_TERMINAL_BUFFER_STATE, EMPTY_TERMINAL_SESSION_STATE, applyTerminalAttachStreamEvent, applyTerminalMetadataStreamEvent, combineTerminalSessionState, createTerminalEnvironmentAtoms, selectRunningSubprocessTerminalIds, terminalBufferStateFromSnapshot };

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

@@ -0,0 +1,104 @@
+import { _v 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;
+/**
+ * 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.
+ */
+declare const QUEUED_TURN_START_GRACE_MS: number;
+/**
+ * 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.
+ */
+declare function hasQueuedTurnStart(shell: Pick<OrchestrationThreadShell, "latestUserMessageAt" | "latestTurn" | "session">, options: {
+  readonly now: string;
+}): boolean;
+/**
+ * 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.
+ */
+declare function canSettle(shell: Pick<OrchestrationThreadShell, "hasPendingApprovals" | "hasPendingUserInput" | "session" | "latestUserMessageAt" | "latestTurn">, options: {
+  readonly now: string;
+}): boolean;
+/**
+ * The snooze lifecycle fields plus everything needed to detect a raised
+ * hand. Snooze is an overlay on the active state: a snoozed thread stays
+ * "active" in the data model and is only suppressed from the inbox until
+ * its wake time passes or the thread demands attention.
+ */
+type ThreadSnoozeShell = Pick<OrchestrationThreadShell, "snoozedUntil" | "snoozedAt" | "hasPendingApprovals" | "hasPendingUserInput" | "session" | "latestTurn">;
+/**
+ * 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.
+ */
+declare function threadRaisedHandWhileSnoozed(shell: ThreadSnoozeShell): boolean;
+/**
+ * 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.
+ */
+declare function canSnooze(shell: Pick<OrchestrationThreadShell, "hasPendingApprovals" | "hasPendingUserInput" | "latestUserMessageAt" | "latestTurn" | "session">, options: {
+  readonly now: string;
+}): boolean;
+/**
+ * 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).
+ */
+declare function effectiveSnoozed(shell: ThreadSnoozeShell, options: {
+  readonly now: string;
+}): boolean;
+/**
+ * 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.
+ */
+declare function threadWokeAt(shell: ThreadSnoozeShell, options: {
+  readonly now: string;
+}): string | 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.
+ */
+declare function effectiveSettled(shell: OrchestrationThreadShell, options: {
+  readonly now: string;
+  readonly autoSettleAfterDays: number | null;
+  readonly changeRequestState?: ChangeRequestStateLike | null;
+}): boolean;
+//#endregion
+export { ChangeRequestStateLike, QUEUED_TURN_START_GRACE_MS, ThreadSnoozeShell, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, threadLastActivityAt, threadRaisedHandWhileSnoozed, threadWokeAt };

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

@@ -0,0 +1,157 @@
+//#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 };