t3code-cli 0.13.0 → 0.14.0

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

@@ -0,0 +1,23 @@
+import { KT as ProjectId, f_ as SidebarThreadSortOrder, u_ as SidebarProjectSortOrder } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/threadSort.d.ts
+interface ThreadSortInput {
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly latestUserMessageAt?: string | null;
+  readonly messages?: ReadonlyArray<{
+    readonly createdAt: string;
+    readonly role: string;
+  }>;
+}
+declare function toSortableTimestamp(iso: string | undefined): number | null;
+declare function getThreadSortTimestamp(thread: ThreadSortInput, sortOrder: SidebarThreadSortOrder | Exclude<SidebarProjectSortOrder, "manual">): number;
+declare function sortThreads<T extends {
+  readonly id: string;
+} & ThreadSortInput>(threads: readonly T[], sortOrder: SidebarThreadSortOrder): T[];
+declare function getLatestThreadForProject<T extends {
+  readonly id: string;
+  readonly projectId: ProjectId;
+  readonly archivedAt: string | null;
+} & ThreadSortInput>(threads: readonly T[], projectId: ProjectId, sortOrder: SidebarThreadSortOrder): T | null;
+//#endregion
+export { ThreadSortInput, getLatestThreadForProject, getThreadSortTimestamp, sortThreads, toSortableTimestamp };

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

@@ -0,0 +1,47 @@
+import { Jk as Struct, Kk as Number$1, Qk as mapInput, Zk as flip, qk as String, vk as sort } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/threadSort.ts
+function toSortableTimestamp(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+function getFirstSortableTimestamp(...values) {
+	for (const value of values) {
+		const timestamp = toSortableTimestamp(value ?? void 0);
+		if (timestamp !== null) return timestamp;
+	}
+	return null;
+}
+function getLatestUserMessageTimestamp(thread) {
+	if (thread.latestUserMessageAt) {
+		const latestUserMessageTimestamp = toSortableTimestamp(thread.latestUserMessageAt);
+		if (latestUserMessageTimestamp !== null) return latestUserMessageTimestamp;
+	}
+	let latestUserMessageTimestamp = null;
+	for (const message of thread.messages ?? []) {
+		if (message.role !== "user") continue;
+		const messageTimestamp = toSortableTimestamp(message.createdAt);
+		if (messageTimestamp === null) continue;
+		latestUserMessageTimestamp = latestUserMessageTimestamp === null ? messageTimestamp : Math.max(latestUserMessageTimestamp, messageTimestamp);
+	}
+	if (latestUserMessageTimestamp !== null) return latestUserMessageTimestamp;
+	return getFirstSortableTimestamp(thread.updatedAt, thread.createdAt) ?? Number.NEGATIVE_INFINITY;
+}
+function getThreadSortTimestamp(thread, sortOrder) {
+	if (sortOrder === "created_at") return getFirstSortableTimestamp(thread.createdAt, thread.updatedAt) ?? Number.NEGATIVE_INFINITY;
+	return getLatestUserMessageTimestamp(thread);
+}
+function sortThreads(threads, sortOrder) {
+	return sort(threads, mapInput(Struct({
+		timestamp: flip(Number$1),
+		id: flip(String)
+	}), (thread) => ({
+		timestamp: getThreadSortTimestamp(thread, sortOrder),
+		id: thread.id
+	})));
+}
+function getLatestThreadForProject(threads, projectId, sortOrder) {
+	return sortThreads(threads.filter((thread) => thread.projectId === projectId && thread.archivedAt === null), sortOrder)[0] ?? null;
+}
+//#endregion
+export { getLatestThreadForProject, getThreadSortTimestamp, sortThreads, toSortableTimestamp };

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

@@ -0,0 +1,538 @@
+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 * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Option from "effect/Option";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import * as Cause from "effect/Cause";
+import * as Crypto from "effect/Crypto";
+import { AsyncResult, Atom } from "effect/unstable/reactivity";
+//#region upstream-t3code/packages/client-runtime/src/state/threadSnapshotHttp.d.ts
+/**
+ * Load a thread's detail snapshot over HTTP instead of embedding it in the
+ * WebSocket subscription's first frame. The response is gzip-compressible by
+ * the transport and keeps the (potentially multi-KB) snapshot off the socket.
+ */
+declare const fetchEnvironmentThreadSnapshot: (input: {
+  readonly prepared: PreparedConnection;
+  readonly threadId: ThreadId;
+  readonly signer: Option.Option<ManagedRelayDpopSigner["Service"]>;
+  readonly timeoutMs?: number;
+}) => Effect.Effect<{
+  readonly snapshotSequence: number;
+  readonly thread: {
+    readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly modelSelection: {
+      readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+      readonly model: string;
+      readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+      }[];
+    };
+    readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+    readonly interactionMode: "default" | "plan";
+    readonly branch: string | null;
+    readonly worktreePath: string | null;
+    readonly latestTurn: {
+      readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+      readonly state: "completed" | "error" | "interrupted" | "running";
+      readonly requestedAt: string;
+      readonly startedAt: string | null;
+      readonly completedAt: string | null;
+      readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+      readonly sourceProposedPlan?: {
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly planId: string;
+      } | undefined;
+    } | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly archivedAt: string | null;
+    readonly settledOverride: "active" | "settled" | null;
+    readonly settledAt: string | null;
+    readonly snoozedUntil?: string | null | undefined;
+    readonly snoozedAt?: string | null | undefined;
+    readonly deletedAt: string | null;
+    readonly messages: readonly {
+      readonly id: string & import("effect/Brand").Brand<"MessageId">;
+      readonly role: "assistant" | "system" | "user";
+      readonly text: string;
+      readonly attachments?: readonly {
+        readonly type: "image";
+        readonly id: string;
+        readonly name: string;
+        readonly mimeType: string;
+        readonly sizeBytes: number;
+      }[] | undefined;
+      readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly streaming: boolean;
+      readonly createdAt: string;
+      readonly updatedAt: string;
+    }[];
+    readonly proposedPlans: readonly {
+      readonly id: string;
+      readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly planMarkdown: string;
+      readonly implementedAt: string | null;
+      readonly implementationThreadId: (string & import("effect/Brand").Brand<"ThreadId">) | null;
+      readonly createdAt: string;
+      readonly updatedAt: string;
+    }[];
+    readonly activities: readonly {
+      readonly id: string & import("effect/Brand").Brand<"EventId">;
+      readonly tone: "approval" | "error" | "info" | "tool";
+      readonly kind: string;
+      readonly summary: string;
+      readonly payload: unknown;
+      readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly sequence?: number | undefined;
+      readonly createdAt: string;
+    }[];
+    readonly checkpoints: readonly {
+      readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+      readonly checkpointTurnCount: number;
+      readonly checkpointRef: string & import("effect/Brand").Brand<"CheckpointRef">;
+      readonly status: "error" | "missing" | "ready";
+      readonly files: readonly {
+        readonly path: string;
+        readonly kind: string;
+        readonly additions: number;
+        readonly deletions: number;
+      }[];
+      readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+      readonly completedAt: string;
+    }[];
+    readonly session: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
+      readonly providerName: string | null;
+      readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+      readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+      readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly lastError: string | null;
+      readonly updatedAt: string;
+    } | null;
+  };
+}, 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>>;
+}>;
+/**
+ * Loads a thread's detail snapshot over HTTP, returning `Option.none()` when it
+ * cannot be loaded (so the caller falls back to the socket-embedded snapshot).
+ * Decouples the thread state machine from the underlying HTTP + DPoP details and
+ * keeps them out of test contexts.
+ */
+declare class ThreadSnapshotLoader extends ThreadSnapshotLoader_base {}
+declare const threadSnapshotLoaderLayer: Layer.Layer<ThreadSnapshotLoader, never, HttpClient.HttpClient>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadState.d.ts
+type EnvironmentThreadStatus = "empty" | "cached" | "synchronizing" | "live" | "deleted";
+interface EnvironmentThreadState {
+  readonly data: Option.Option<OrchestrationThread>;
+  readonly status: EnvironmentThreadStatus;
+  readonly error: Option.Option<string>;
+}
+declare const EMPTY_ENVIRONMENT_THREAD_STATE: EnvironmentThreadState;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/archivedThreads.d.ts
+interface ArchivedSnapshotEntry {
+  readonly environmentId: EnvironmentId;
+  readonly snapshot: OrchestrationShellSnapshot;
+}
+interface ArchivedThreadSnapshotsState {
+  readonly snapshots: ReadonlyArray<ArchivedSnapshotEntry>;
+  readonly error: string | null;
+  readonly isLoading: boolean;
+}
+declare function makeArchivedThreadsEnvironmentKey(environmentIds: ReadonlyArray<EnvironmentId>): string;
+declare function parseArchivedThreadsEnvironmentKey(key: string): ReadonlyArray<EnvironmentId>;
+declare function createArchivedThreadSnapshotsAtomFamily<E>(options: {
+  readonly getSnapshotAtom: (environmentId: EnvironmentId) => Atom.Atom<AsyncResult.AsyncResult<OrchestrationShellSnapshot, E>>;
+  readonly labelPrefix: string;
+}): (arg: string) => Atom.Atom<ArchivedThreadSnapshotsState>;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/checkpointDiff.d.ts
+type CheckpointDiffResult = OrchestrationGetTurnDiffResult | OrchestrationGetFullThreadDiffResult;
+interface CheckpointDiffState {
+  readonly data: CheckpointDiffResult | null;
+  readonly error: string | null;
+  readonly isPending: boolean;
+}
+interface CheckpointDiffTarget {
+  readonly environmentId: EnvironmentId | null;
+  readonly threadId: ThreadId | null;
+  readonly fromTurnCount: number | null;
+  readonly toTurnCount: number | null;
+  readonly ignoreWhitespace: boolean;
+  readonly cacheScope?: string | null;
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/composerPathSearch.d.ts
+interface ComposerPathSearchEntry {
+  readonly path: string;
+  readonly kind: "file" | "directory";
+  readonly parentPath?: string;
+}
+interface ComposerPathSearchState {
+  readonly entries: ReadonlyArray<ComposerPathSearchEntry>;
+  readonly isPending: boolean;
+  readonly error: string | null;
+}
+interface ComposerPathSearchTarget {
+  readonly environmentId: EnvironmentId | null;
+  readonly cwd: string | null;
+  readonly query: string | null;
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadCommands.d.ts
+declare function createThreadEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | Crypto.Crypto | R, E>): {
+  create: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: CreateThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  delete: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: DeleteThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  archive: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: ArchiveThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  unarchive: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UnarchiveThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  settle: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: SettleThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  unsettle: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UnsettleThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  snooze: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: SnoozeThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  unsnooze: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UnsnoozeThreadInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  updateMetadata: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: UpdateThreadMetadataInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  setRuntimeMode: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: SetThreadRuntimeModeInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  setInteractionMode: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: SetThreadInteractionModeInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  startTurn: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: StartThreadTurnInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  interruptTurn: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: InterruptThreadTurnInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  respondToApproval: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: RespondToThreadApprovalInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  respondToUserInput: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: RespondToThreadUserInputInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  revertCheckpoint: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: RevertThreadCheckpointInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+  stopSession: AtomCommand<{
+    readonly environmentId: EnvironmentId;
+    readonly input: StopThreadSessionInput;
+  }, {
+    readonly sequence: number;
+  }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadDetail.d.ts
+/**
+ * Combine detail-only collections with the shell's authoritative thread metadata.
+ *
+ * Shell and detail subscriptions are intentionally independent. A cached detail can
+ * therefore briefly outlive a newer shell snapshot after reconnecting. Workspace
+ * consumers must use the shell branch/worktree/project fields so they do not target
+ * a stale checkout while retaining messages, activities, plans, and checkpoints
+ * from the detail subscription.
+ */
+declare function mergeEnvironmentThread(detail: EnvironmentThread | null, shell: EnvironmentThreadShell | null): EnvironmentThread | null;
+declare function createEnvironmentThreadDetailAtoms<E>(threadStateAtom: (environmentId: ScopedThreadRef["environmentId"], threadId: ScopedThreadRef["threadId"]) => Atom.Atom<AsyncResult.AsyncResult<EnvironmentThreadState, E>>): {
+  stateAtom: (ref: ScopedThreadRef) => Atom.Atom<EnvironmentThreadState>;
+  detailAtom: (ref: ScopedThreadRef) => Atom.Atom<EnvironmentThread | null>;
+  statusAtom: (ref: ScopedThreadRef) => Atom.Atom<EnvironmentThreadStatus>;
+  errorAtom: (ref: ScopedThreadRef) => Atom.Atom<string | null>;
+  messagesAtom: (ref: ScopedThreadRef) => Atom.Atom<readonly {
+    readonly id: string & import("effect/Brand").Brand<"MessageId">;
+    readonly role: "assistant" | "system" | "user";
+    readonly text: string;
+    readonly attachments?: readonly {
+      readonly type: "image";
+      readonly id: string;
+      readonly name: string;
+      readonly mimeType: string;
+      readonly sizeBytes: number;
+    }[] | undefined;
+    readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+    readonly streaming: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  }[]>;
+  activitiesAtom: (ref: ScopedThreadRef) => Atom.Atom<readonly {
+    readonly id: string & import("effect/Brand").Brand<"EventId">;
+    readonly tone: "approval" | "error" | "info" | "tool";
+    readonly kind: string;
+    readonly summary: string;
+    readonly payload: unknown;
+    readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+    readonly sequence?: number | undefined;
+    readonly createdAt: string;
+  }[]>;
+  proposedPlansAtom: (ref: ScopedThreadRef) => Atom.Atom<readonly {
+    readonly id: string;
+    readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+    readonly planMarkdown: string;
+    readonly implementedAt: string | null;
+    readonly implementationThreadId: (string & import("effect/Brand").Brand<"ThreadId">) | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+  }[]>;
+  checkpointsAtom: (ref: ScopedThreadRef) => Atom.Atom<readonly {
+    readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+    readonly checkpointTurnCount: number;
+    readonly checkpointRef: string & import("effect/Brand").Brand<"CheckpointRef">;
+    readonly status: "error" | "missing" | "ready";
+    readonly files: readonly {
+      readonly path: string;
+      readonly kind: string;
+      readonly additions: number;
+      readonly deletions: number;
+    }[];
+    readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+    readonly completedAt: string;
+  }[]>;
+  sessionAtom: (ref: ScopedThreadRef) => Atom.Atom<{
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
+    readonly providerName: string | null;
+    readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+    readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+    readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+    readonly lastError: string | null;
+    readonly updatedAt: string;
+  } | null>;
+  latestTurnAtom: (ref: ScopedThreadRef) => Atom.Atom<{
+    readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+    readonly state: "completed" | "error" | "interrupted" | "running";
+    readonly requestedAt: string;
+    readonly startedAt: string | null;
+    readonly completedAt: string | null;
+    readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+    readonly sourceProposedPlan?: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly planId: string;
+    } | undefined;
+  } | null>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadReducer.d.ts
+type ThreadDetailReducerResult = {
+  readonly kind: "updated";
+  readonly thread: OrchestrationThread;
+} | {
+  readonly kind: "deleted";
+} | {
+  readonly kind: "unchanged";
+};
+/**
+ * Apply a single orchestration event to an `OrchestrationThread`, returning
+ * the updated thread, a deletion signal, or an "unchanged" marker when the
+ * event doesn't affect this thread.
+ *
+ * This is a pure reducer operating on contract types. UI-specific mapping
+ * (e.g. resolving attachment preview URLs, normalising model slugs, adding
+ * scoped fields like `environmentId`) is the caller's responsibility.
+ */
+declare function applyThreadDetailEvent(thread: OrchestrationThread, event: OrchestrationEvent): ThreadDetailReducerResult;
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threadShell.d.ts
+declare function createEnvironmentThreadShellAtoms(input: {
+  readonly catalogValueAtom: Atom.Atom<EnvironmentCatalogState>;
+  readonly snapshotAtom: (environmentId: EnvironmentId) => Atom.Atom<OrchestrationShellSnapshot | null>;
+}): {
+  environmentThreadsAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<readonly {
+    readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly modelSelection: {
+      readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+      readonly model: string;
+      readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+      }[];
+    };
+    readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+    readonly interactionMode: "default" | "plan";
+    readonly branch: string | null;
+    readonly worktreePath: string | null;
+    readonly latestTurn: {
+      readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+      readonly state: "completed" | "error" | "interrupted" | "running";
+      readonly requestedAt: string;
+      readonly startedAt: string | null;
+      readonly completedAt: string | null;
+      readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+      readonly sourceProposedPlan?: {
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly planId: string;
+      } | undefined;
+    } | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly archivedAt: string | null;
+    readonly settledOverride: "active" | "settled" | null;
+    readonly settledAt: string | null;
+    readonly snoozedUntil?: string | null | undefined;
+    readonly snoozedAt?: string | null | undefined;
+    readonly session: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
+      readonly providerName: string | null;
+      readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+      readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+      readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly lastError: string | null;
+      readonly updatedAt: string;
+    } | null;
+    readonly latestUserMessageAt: string | null;
+    readonly hasPendingApprovals: boolean;
+    readonly hasPendingUserInput: boolean;
+    readonly hasActionableProposedPlan: boolean;
+  }[]>;
+  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">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly modelSelection: {
+      readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+      readonly model: string;
+      readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+      }[];
+    };
+    readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+    readonly interactionMode: "default" | "plan";
+    readonly branch: string | null;
+    readonly worktreePath: string | null;
+    readonly latestTurn: {
+      readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+      readonly state: "completed" | "error" | "interrupted" | "running";
+      readonly requestedAt: string;
+      readonly startedAt: string | null;
+      readonly completedAt: string | null;
+      readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+      readonly sourceProposedPlan?: {
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly planId: string;
+      } | undefined;
+    } | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly archivedAt: string | null;
+    readonly settledOverride: "active" | "settled" | null;
+    readonly settledAt: string | null;
+    readonly snoozedUntil?: string | null | undefined;
+    readonly snoozedAt?: string | null | undefined;
+    readonly session: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
+      readonly providerName: string | null;
+      readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+      readonly runtimeMode: "approval-required" | "auto" | "auto-accept-edits" | "full-access";
+      readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+      readonly lastError: string | null;
+      readonly updatedAt: string;
+    } | null;
+    readonly latestUserMessageAt: string | null;
+    readonly hasPendingApprovals: boolean;
+    readonly hasPendingUserInput: boolean;
+    readonly hasActionableProposedPlan: boolean;
+  }>>;
+  environmentThreadRefsAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+  }[]>;
+  environmentThreadRefsByProjectAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"ProjectId">, readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+  }[]>>;
+  threadRefsAtom: Atom.Atom<readonly {
+    readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+  }[]>;
+  threadShellsAtom: Atom.Atom<readonly EnvironmentThreadShell[]>;
+  threadShellsForProjectRefsAtom: (refs: ReadonlyArray<ScopedProjectRef>) => Atom.Atom<readonly EnvironmentThreadShell[]>;
+  threadShellAtom: (ref: ScopedThreadRef) => Atom.Atom<EnvironmentThreadShell | null>;
+};
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/threads.d.ts
+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 };