t3code-cli 0.14.2 → 0.15.0

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, JC as VcsProcessOutputReadError, KC as VcsProcessMissingExitCodeError, QC as VcsProcessTimeoutError, Ta as EnvironmentRegistry, UC as VcsProcessExitError, YC as VcsProcessSpawnError, ZC as VcsProcessStdinWriteError, cw as GitCommandError, f as AtomCommand, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, qC as VcsProcessOutputLimitError, rw as VcsUnsupportedOperationError, tw as VcsRepositoryDetectionError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Cw as VcsProcessExitError, Da as EnvironmentNotRegisteredError, Dw as VcsProcessOutputLimitError, Ew as VcsProcessMissingExitCodeError, Fw as VcsRepositoryDetectionError, Hw as GitCommandError, Lw as VcsUnsupportedOperationError, Mw as VcsProcessTimeoutError, Oa as EnvironmentRegistry, Ow as VcsProcessOutputReadError, f as AtomCommand, hn as EnvironmentRpcUnavailableError, jw as VcsProcessStdinWriteError, kw as VcsProcessSpawnError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/review.d.ts
 declare function createReviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {

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

@@ -1,4 +1,4 @@
-import { Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler } from "../../shared.js";
+import { _r as createEnvironmentRpcCommand, lc as WS_METHODS, mr as createAtomCommandScheduler, vr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/review.ts
 function createReviewEnvironmentAtoms(runtime) {
 	const diffFileScheduler = createAtomCommandScheduler();

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

@@ -1,2 +1,2 @@
-import { A as environmentRpcKey, B as scheduleAtomCommandEffect, C as createEnvironmentRpcCommand, D as createEnvironmentSubscriptionAtomFamily, E as createEnvironmentRpcSubscriptionAtomFamily, F as mapAtomCommandResult, H as settlePromise, I as reportAtomCommandResult, L as runAtomCommand, M as executeAtomQuery, N as followStreamInEnvironment, O as createRuntimeCommand, P as isAtomCommandInterrupted, R as runInEnvironment, S as createEnvironmentCommand, T as createEnvironmentRpcStreamCommand, U as squashAtomCommandFailure, V as settleAsyncResult, _ as AtomCommandResult, b as SettledAsyncResult, f as AtomCommand, g as AtomCommandReporter, h as AtomCommandOptions, j as executeAtomCommand, k as createRuntimeStreamCommand, m as AtomCommandFailure, p as AtomCommandConcurrency, v as AtomCommandScheduler, w as createEnvironmentRpcQueryAtomFamily, x as createAtomCommandScheduler, y as AtomCommandSuccess, z as runStreamInEnvironment } from "../../shared.js";
-export { AtomCommand, AtomCommandConcurrency, AtomCommandFailure, AtomCommandOptions, AtomCommandReporter, AtomCommandResult, AtomCommandScheduler, AtomCommandSuccess, SettledAsyncResult, createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };
+import { A as createRuntimeStreamCommand, B as runStreamInEnvironment, C as createEnvironmentQueryAtomFamily, D as createEnvironmentRpcSubscriptionAtomFamily, E as createEnvironmentRpcStreamCommand, F as isAtomCommandInterrupted, H as settleAsyncResult, I as mapAtomCommandResult, L as reportAtomCommandResult, M as executeAtomCommand, N as executeAtomQuery, O as createEnvironmentSubscriptionAtomFamily, P as followStreamInEnvironment, R as runAtomCommand, S as createEnvironmentCommand, T as createEnvironmentRpcQueryAtomFamily, U as settlePromise, V as scheduleAtomCommandEffect, W as squashAtomCommandFailure, _ as AtomCommandResult, b as SettledAsyncResult, f as AtomCommand, g as AtomCommandReporter, h as AtomCommandOptions, j as environmentRpcKey, k as createRuntimeCommand, m as AtomCommandFailure, p as AtomCommandConcurrency, v as AtomCommandScheduler, w as createEnvironmentRpcCommand, x as createAtomCommandScheduler, y as AtomCommandSuccess, z as runInEnvironment } from "../../shared.js";
+export { AtomCommand, AtomCommandConcurrency, AtomCommandFailure, AtomCommandOptions, AtomCommandReporter, AtomCommandResult, AtomCommandScheduler, AtomCommandSuccess, SettledAsyncResult, createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentQueryAtomFamily, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };

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

@@ -1,2 +1,2 @@
-import { Ar as runInEnvironment, Cr as executeAtomCommand, Dr as mapAtomCommandResult, Er as isAtomCommandInterrupted, Fr as squashAtomCommandFailure, Mr as scheduleAtomCommandEffect, Nr as settleAsyncResult, Or as reportAtomCommandResult, Pr as settlePromise, Sr as environmentRpcKey, Tr as followStreamInEnvironment, _r as createEnvironmentRpcStreamCommand, br as createRuntimeCommand, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, jr as runStreamInEnvironment, kr as runAtomCommand, mr as createEnvironmentCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily, wr as executeAtomQuery, xr as createRuntimeStreamCommand, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
-export { createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };
+import { Ar as reportAtomCommandResult, Cr as createRuntimeStreamCommand, Dr as followStreamInEnvironment, Er as executeAtomQuery, Fr as settleAsyncResult, Ir as settlePromise, Lr as squashAtomCommandFailure, Mr as runInEnvironment, Nr as runStreamInEnvironment, Or as isAtomCommandInterrupted, Pr as scheduleAtomCommandEffect, Sr as createRuntimeCommand, Tr as executeAtomCommand, _r as createEnvironmentRpcCommand, br as createEnvironmentRpcSubscriptionAtomFamily, gr as createEnvironmentQueryAtomFamily, hr as createEnvironmentCommand, jr as runAtomCommand, kr as mapAtomCommandResult, mr as createAtomCommandScheduler, vr as createEnvironmentRpcQueryAtomFamily, wr as environmentRpcKey, xr as createEnvironmentSubscriptionAtomFamily, yr as createEnvironmentRpcStreamCommand } from "../../shared.js";
+export { createAtomCommandScheduler, createEnvironmentCommand, createEnvironmentQueryAtomFamily, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, createEnvironmentRpcStreamCommand, createEnvironmentRpcSubscriptionAtomFamily, createEnvironmentSubscriptionAtomFamily, createRuntimeCommand, createRuntimeStreamCommand, environmentRpcKey, executeAtomCommand, executeAtomQuery, followStreamInEnvironment, isAtomCommandInterrupted, mapAtomCommandResult, reportAtomCommandResult, runAtomCommand, runInEnvironment, runStreamInEnvironment, scheduleAtomCommandEffect, settleAsyncResult, settlePromise, squashAtomCommandFailure };

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Da as EnvironmentSupervisor, Dd as KeybindingsConfigError, Eu as ServerLifecycleWelcomePayload, Ku as ServerProviderUpdateError, Na as EnvironmentCacheStore, Ta as EnvironmentRegistry, Td as KeybindingWhenNode, ad as ServerSelfUpdateProgressEvent, an as EnvironmentRpcInput, du as ServerConfig, f as AtomCommand, gu as ServerConfigStreamEvent, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, sd as ServerSelfUpdateResult, tl as UsageReadError, vs as WS_METHODS, wa as EnvironmentNotRegisteredError, wu as ServerLifecycleStreamReadyEvent, yv as ServerSettingsError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Aa as EnvironmentSupervisor, Cs as WS_METHODS, Da as EnvironmentNotRegisteredError, Du as ServerConfigStreamEvent, Fu as ServerLifecycleStreamReadyEvent, Ia as EnvironmentCacheStore, Id as KeybindingWhenNode, Lu as ServerLifecycleWelcomePayload, Oa as EnvironmentRegistry, Rd as KeybindingsConfigError, Sl as UsageReadError, Su as ServerConfig, Xv as ServerSettingsError, f as AtomCommand, gd as ServerSelfUpdateProgressEvent, hn as EnvironmentRpcUnavailableError, on as EnvironmentRpcInput, rd as ServerProviderUpdateError, vd as ServerSelfUpdateResult, vk as EnvironmentId } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Schema from "effect/Schema";
@@ -112,6 +112,7 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
         readonly threadPinning?: boolean;
@@ -119,6 +120,7 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
         readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
         readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly auth: {
@@ -253,6 +255,10 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
       };
     }[];
     readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+    readonly remoteOpenTargets?: readonly {
+      readonly kind: "mdns" | "tailscale";
+      readonly host: string;
+    }[];
     readonly observability: {
       readonly logsDirectoryPath: string;
       readonly localTracingEnabled: boolean;
@@ -893,6 +899,9 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
       readonly sinceDay: string & import("effect/Brand").Brand<"UsageDay">;
       readonly untilDay: string & import("effect/Brand").Brand<"UsageDay">;
       readonly timeZone: string;
+      readonly resolution?: "day" | "hour" | undefined;
+      readonly sinceTime?: string | undefined;
+      readonly untilTime?: string | undefined;
     };
   }) => Atom.Atom<AsyncResult.AsyncResult<{
     readonly contractVersion: number;
@@ -902,6 +911,7 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
     readonly untilDay: string & import("effect/Brand").Brand<"UsageDay">;
     readonly buckets: readonly {
       readonly day: string & import("effect/Brand").Brand<"UsageDay">;
+      readonly hourStart?: string | undefined;
       readonly provider: "claude" | "codex";
       readonly model: string;
       readonly totals: {
@@ -959,6 +969,7 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
         readonly threadPinning?: boolean;
@@ -966,6 +977,7 @@ declare function createServerEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<En
         readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
         readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly cwd: string;

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

@@ -1,4 +1,4 @@
-import { $r as make, AD as TaggedErrorClass, AO as fromQueue, Aj as none, Ak as exit, Ba as safeErrorLogAttributes, Bk as gen, Cj as getOrNull, DO as filterMap, Dj as isSome, Dk as catch_, EO as filter, Ej as isNone, FA as squash, Fy as get, Gk as map$1, HO as runHead, Ia as EnvironmentSupervisor, Iy as make$1, Jr as runStream, Kr as isRpcClientError, Ly as set$1, MA as hasInterruptsOnly, Mj as toArray, Mk as failCause, Mr as scheduleAtomCommandEffect, NA as isFailReason, NO as mapAccum, Nk as flatMap, OD as String, Oj as map, Pa as EnvironmentRegistry, Pk as fn, Py as changes, Rk as forkChild, SO as debounce, Tr as followStreamInEnvironment, Us as WS_METHODS, VD as optional, VO as runForEach, Vk as ignore, Wa as EnvironmentCacheStore, Wk as logWarning, XA as isSuccess, Xk as onExit, YA as isFailure, YO as unwrap, Yr as subscribe, Zr as family, aj as failVoid, bA as void_, bT as set, bk as as, br as createRuntimeCommand, cA as succeed, ck as sliding, ei as setIdleTTL, fj as minutes, gk as addFinalizer, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, ik as offer, jj as some, jk as fail, kj as match, lj as succeed$1, ni as withLabel, pA as timeoutOption, pj as seconds, pr as createAtomCommandScheduler, qr as request, sA as sleep, si as value, uA as sync, vT as get$1, vk as andThen, vr as createEnvironmentRpcSubscriptionAtomFamily, wD as Literals, xT as update, xk as asVoid, yT as make$2, yj as flatten, yk as annotateLogs, zk as forkScoped } from "../../shared.js";
+import { $A as runHead, $j as ignore, Aj as andThen, By as changes, CM as sync, DD as set, DN as seconds, Dr as followStreamInEnvironment, ED as make$2, EM as timeoutOption, EN as minutes, GM as hasInterruptsOnly, GN as none, Gj as flatMap, HN as isSome, Ha as safeErrorLogAttributes, Hj as exit, Hy as make$1, Ia as EnvironmentRegistry, JM as squash, KM as isFailReason, KN as some, Ka as EnvironmentCacheStore, Kj as fn, Kr as make, LA as filter, Lk as String, Mj as as, NA as debounce, NM as void_, Nj as asVoid, Nk as Literals, OD as update, Oj as addFinalizer, PN as flatten, Pr as scheduleAtomCommandEffect, QA as runForEach, Qj as gen, RA as filterMap, RN as getOrNull, Ra as EnvironmentSupervisor, SN as succeed$1, Sr as createRuntimeCommand, TD as get$1, UN as map, Uj as fail, Uy as set$1, VA as fromQueue, VN as isNone, Vy as get, WA as mapAccum, WN as match, Wj as failCause, Wr as family, Xj as forkChild, Xk as optional, Yr as withLabel, Zj as forkScoped, _r as createEnvironmentRpcCommand, ai as isRpcClientError, bM as sleep, bj as sliding, br as createEnvironmentRpcSubscriptionAtomFamily, cM as onExit, cN as isFailure, ci as subscribe, ei as value, gj as offer, jj as annotateLogs, lN as isSuccess, lc as WS_METHODS, mr as createAtomCommandScheduler, nM as logWarning, oi as request, qN as toArray, qr as setIdleTTL, rM as map$1, si as runStream, sj as unwrap, vN as failVoid, vr as createEnvironmentRpcQueryAtomFamily, xM as succeed, zj as catch_, zk as TaggedErrorClass } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/server.ts
 const IDLE_SERVER_UPDATE_STATE = { status: "idle" };
 const EMPTY_SERVER_UPDATE_STATE_ATOM = make(IDLE_SERVER_UPDATE_STATE).pipe(withLabel("environment-data:server:update-state:empty"));

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

@@ -1,4 +1,4 @@
-import { $a as RemoteEnvironmentRequestError, Ta as EnvironmentRegistry, Td as KeybindingWhenNode, bo as ManagedRelayDpopSigner, du as ServerConfig, us as PreparedConnection } from "../../shared.js";
+import { Id as KeybindingWhenNode, Oa as EnvironmentRegistry, Su as ServerConfig, ms as PreparedConnection, no as RemoteEnvironmentRequestError, wo as ManagedRelayDpopSigner } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { HttpClient } from "effect/unstable/http";
@@ -39,6 +39,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
         readonly threadPinning?: boolean;
@@ -46,6 +47,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
         readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly auth: {
@@ -180,6 +182,10 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       };
     }[];
     readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+    readonly remoteOpenTargets?: readonly {
+      readonly kind: "mdns" | "tailscale";
+      readonly host: string;
+    }[];
     readonly observability: {
       readonly logsDirectoryPath: string;
       readonly localTracingEnabled: boolean;
@@ -305,6 +311,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
         readonly threadPinning?: boolean;
@@ -312,6 +319,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
         readonly serverSelfUpdateProgress?: boolean;
+        readonly agentActivityPublishing?: boolean;
       };
     };
     readonly auth: {
@@ -446,6 +454,10 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       };
     }[];
     readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+    readonly remoteOpenTargets?: readonly {
+      readonly kind: "mdns" | "tailscale";
+      readonly host: string;
+    }[];
     readonly observability: {
       readonly logsDirectoryPath: string;
       readonly localTracingEnabled: boolean;

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

@@ -1,4 +1,4 @@
-import { $r as make, Aj as none, Ba as safeErrorLogAttributes, Bk as gen, Bo as makeEnvironmentHttpApiClient, Br as buildEnvironmentAuthHeaders, Cj as getOrNull, Dk as catch_, Gk as map, Ia as EnvironmentSupervisor, PO as mapEffect, Pk as fn, Py as changes, Sj as getOrElse, Tr as followStreamInEnvironment, Uo as environmentEndpointUrl, Vr as withEnvironmentCredentials, Wk as logWarning, YO as unwrap, Yk as never, Zr as family, bk as as, cA as succeed, ei as setIdleTTL, jj as some, kj as match, ni as withLabel, oA as serviceOption, si as value, ti as swr, to as ManagedRelayDpopSigner, yk as annotateLogs, zo as executeEnvironmentHttpRequest } from "../../shared.js";
+import { By as changes, Dr as followStreamInEnvironment, GA as mapEffect, GN as none, Ha as safeErrorLogAttributes, Ho as makeEnvironmentHttpApiClient, Hr as buildEnvironmentAuthHeaders, Jr as swr, KN as some, Kj as fn, Ko as environmentEndpointUrl, Kr as make, LN as getOrElse, Mj as as, Qj as gen, RN as getOrNull, Ra as EnvironmentSupervisor, Ur as withEnvironmentCredentials, Vo as executeEnvironmentHttpRequest, WN as match, Wr as family, Yr as withLabel, ei as value, jj as annotateLogs, nM as logWarning, qr as setIdleTTL, rM as map, ro as ManagedRelayDpopSigner, sM as never, sj as unwrap, xM as succeed, yM as serviceOption, zj as catch_ } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/session.ts
 function initialConfigOption(initialConfig) {
 	return initialConfig.pipe(map(some), catch_((error) => logWarning("Could not load the initial environment configuration.").pipe(annotateLogs({ ...safeErrorLogAttributes(error) }), as(none()))));

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

@@ -1,4 +1,4 @@
-import { $a as RemoteEnvironmentRequestError, $l as ExternalLauncherBrowserSpawnError, CD as EnvironmentId, Da as EnvironmentSupervisor, Na as EnvironmentCacheStore, Oy as OrchestrationShellSnapshot, Ta as EnvironmentRegistry, Td as KeybindingWhenNode, at as EnvironmentProject, bo as ManagedRelayDpopSigner, ct as scopeProject, dt as selectEnvironmentThreadShell, du as ServerConfig, eu as ExternalLauncherCommandNotFoundError, f as AtomCommand, iD as EnvironmentAuthorizationError, it as EnvironmentMessage, iu as ExternalLauncherUnsupportedEditorError, ky as OrchestrationShellStreamEvent, lt as scopeThread, mn as EnvironmentRpcUnavailableError, ot as EnvironmentThread, ru as ExternalLauncherUnknownEditorError, st as EnvironmentThreadShell, tu as ExternalLauncherEditorSpawnError, u as EnvironmentCatalogState, us as PreparedConnection, ut as scopeThreadShell, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Aa as EnvironmentSupervisor, B_ as ExternalLauncherUnsupportedEditorError, Da as EnvironmentNotRegisteredError, F_ as ExternalLauncherBrowserSpawnError, I_ as ExternalLauncherCommandNotFoundError, Ia as EnvironmentCacheStore, Id as KeybindingWhenNode, L_ as ExternalLauncherEditorSpawnError, Oa as EnvironmentRegistry, Su as ServerConfig, ab as OrchestrationShellSnapshot, at as EnvironmentMessage, ct as EnvironmentThreadShell, dt as scopeThreadShell, f as AtomCommand, ft as selectEnvironmentThreadShell, hn as EnvironmentRpcUnavailableError, lt as scopeProject, ms as PreparedConnection, no as RemoteEnvironmentRequestError, ob as OrchestrationShellStreamEvent, ot as EnvironmentProject, st as EnvironmentThread, u as EnvironmentCatalogState, ut as scopeThread, vk as EnvironmentId, wo as ManagedRelayDpopSigner, z_ as ExternalLauncherUnknownEditorError } from "../../shared.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -301,6 +301,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
     readonly capabilities: {
       readonly repositoryIdentity: boolean;
       readonly connectionProbe?: boolean;
+      readonly pullRequests?: boolean;
       readonly threadSettlement?: boolean;
       readonly threadSnooze?: boolean;
       readonly threadPinning?: boolean;
@@ -308,6 +309,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
       readonly threadTitleRegeneration?: boolean;
       readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
       readonly serverSelfUpdateProgress?: boolean;
+      readonly agentActivityPublishing?: boolean;
     };
   };
   readonly auth: {
@@ -442,6 +444,10 @@ declare function createEnvironmentServerConfigsAtom(input: {
     };
   }[];
   readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+  readonly remoteOpenTargets?: readonly {
+    readonly kind: "mdns" | "tailscale";
+    readonly host: string;
+  }[];
   readonly observability: {
     readonly logsDirectoryPath: string;
     readonly localTracingEnabled: boolean;

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

@@ -1,2 +1,2 @@
-import { Ir as applyShellStreamEvent, Lr as ShellSnapshotLoader, Rr as fetchEnvironmentShellSnapshot, ar as makeEnvironmentShellState, cr as createShellEnvironmentAtoms, dr as scopeThreadShell, fr as selectEnvironmentThreadShell, ir as createEnvironmentShellSummaryAtom, lr as scopeProject, nr as createEnvironmentServerConfigsAtom, or as shellStateChanges, rr as createEnvironmentShellAtoms, sr as createEnvironmentSnapshotAtom, ur as scopeThread, zr as shellSnapshotLoaderLayer } from "../../shared.js";
+import { Br as fetchEnvironmentShellSnapshot, Rr as applyShellStreamEvent, Vr as shellSnapshotLoaderLayer, ar as createEnvironmentShellSummaryAtom, cr as createEnvironmentSnapshotAtom, dr as scopeThread, fr as scopeThreadShell, ir as createEnvironmentShellAtoms, lr as createShellEnvironmentAtoms, or as makeEnvironmentShellState, pr as selectEnvironmentThreadShell, rr as createEnvironmentServerConfigsAtom, sr as shellStateChanges, ur as scopeProject, zr as ShellSnapshotLoader } from "../../shared.js";
 export { ShellSnapshotLoader, applyShellStreamEvent, createEnvironmentServerConfigsAtom, createEnvironmentShellAtoms, createEnvironmentShellSummaryAtom, createEnvironmentSnapshotAtom, createShellEnvironmentAtoms, fetchEnvironmentShellSnapshot, makeEnvironmentShellState, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell, shellSnapshotLoaderLayer, shellStateChanges };

package/dist/client-runtime/state/source-control.d.ts

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Na as EnvironmentCacheStore, Ta as EnvironmentRegistry, aT as SourceControlRepositoryError, f as AtomCommand, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Da as EnvironmentNotRegisteredError, Ia as EnvironmentCacheStore, Oa as EnvironmentRegistry, XD as SourceControlRepositoryError, f as AtomCommand, hn as EnvironmentRpcUnavailableError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/sourceControl.d.ts
 declare function createSourceControlEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>): {

package/dist/client-runtime/state/source-control.js

@@ -1,4 +1,4 @@
-import { St as vcsCommandScheduler, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vt as invalidateCachedVcsRefs, xt as vcsCommandConcurrency } from "../../shared.js";
+import { St as vcsCommandScheduler, _r as createEnvironmentRpcCommand, lc as WS_METHODS, mr as createAtomCommandScheduler, vr as createEnvironmentRpcQueryAtomFamily, vt as invalidateCachedVcsRefs, xt as vcsCommandConcurrency } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/sourceControl.ts
 function createSourceControlEnvironmentAtoms(runtime) {
 	const commandScheduler = createAtomCommandScheduler();

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

@@ -1,4 +1,4 @@
-import { Py as OrchestrationThreadActivity } from "../../shared.js";
+import { db as OrchestrationThreadActivity } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/subagentRuntime.d.ts
 type RuntimeSubagentStatus = "pending" | "running" | "waiting" | "idle" | "completed" | "failed" | "cancelled" | "interrupted";
 interface SubagentUsage {

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

@@ -1,4 +1,4 @@
-import { AS as TerminalSessionLookupError, CD as EnvironmentId, CS as TerminalMetadataStreamEvent, ES as TerminalResizeError, FS as TerminalWriteError, NS as TerminalSummary, RD as ThreadId, SS as TerminalHistoryError, Ta as EnvironmentRegistry, _S as TerminalCwdNotDirectoryError, f as AtomCommand, iD as EnvironmentAuthorizationError, jS as TerminalSessionSnapshot, mn as EnvironmentRpcUnavailableError, pS as TerminalAttachStreamEvent, vS as TerminalCwdNotFoundError, wS as TerminalNotRunningError, wa as EnvironmentNotRegisteredError, yS as TerminalCwdStatError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, $S as TerminalCwdStatError, Da as EnvironmentNotRegisteredError, Nk as ThreadId, Oa as EnvironmentRegistry, QS as TerminalCwdNotFoundError, ZS as TerminalCwdNotDirectoryError, dC as TerminalSessionSnapshot, f as AtomCommand, hC as TerminalWriteError, hn as EnvironmentRpcUnavailableError, iC as TerminalNotRunningError, nC as TerminalHistoryError, oC as TerminalResizeError, pC as TerminalSummary, qS as TerminalAttachStreamEvent, rC as TerminalMetadataStreamEvent, uC as TerminalSessionLookupError, vk as EnvironmentId } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/terminalSession.d.ts
 interface TerminalSessionState {

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

@@ -1,4 +1,4 @@
-import { Us as WS_METHODS, WO as scan, Yr as subscribe, hr as createEnvironmentRpcCommand, pr as createAtomCommandScheduler, vr as createEnvironmentRpcSubscriptionAtomFamily, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
+import { _r as createEnvironmentRpcCommand, br as createEnvironmentRpcSubscriptionAtomFamily, ci as subscribe, lc as WS_METHODS, mr as createAtomCommandScheduler, tj as scan, xr as createEnvironmentSubscriptionAtomFamily } 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);

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

@@ -1,4 +1,4 @@
-import { CD as EnvironmentId, Ty as OrchestrationSearchThreadsResult, zy as OrchestrationThreadSearchMatch } from "../../shared.js";
+import { gb as OrchestrationThreadSearchMatch, nb as OrchestrationSearchThreadsResult, vk as EnvironmentId } from "../../shared.js";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/threadSearch.d.ts
 interface EnvironmentThreadSearchMatch extends OrchestrationThreadSearchMatch {

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

@@ -1,4 +1,4 @@
-import { $r as make, Cj as getOrNull, Cw as EnvironmentId, LD as decodeUnknownSync, Zr as family, bD as ArraySchema, jD as Tuple, ni as withLabel, si as value, yx as OrchestrationSearchThreadsInput } from "../../shared.js";
+import { Bk as Tuple, Dk as ArraySchema, Kk as decodeUnknownSync, Kr as make, ME as EnvironmentId, OC as OrchestrationSearchThreadsInput, RN as getOrNull, Wr as family, Yr as withLabel, ei as value } from "../../shared.js";
 const decodeThreadSearchKey = decodeUnknownSync(Tuple([ArraySchema(EnvironmentId), OrchestrationSearchThreadsInput.fields.query]));
 function makeThreadSearchKey(environmentIds, query) {
 	return JSON.stringify([[...environmentIds].sort((left, right) => left.localeCompare(right)), query]);

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

@@ -1,6 +1,8 @@
-import { Vy 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,18 +92,19 @@ 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 — except
- * that an open PR blocks the inactivity path entirely. 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" | "evening" | "tomorrow" | "next-week";
+type SnoozePresetId = "hour" | "three-hours" | "evening" | "tomorrow" | "next-week";
 interface SnoozePreset {
   readonly id: SnoozePresetId;
   readonly label: string;
@@ -113,8 +116,8 @@ interface SnoozePreset {
 }
 /**
  * Shared "snooze until" choices for every client. "This evening" only
- * appears while it is meaningfully before evening; after that the list
- * starts at "Tomorrow".
+ * appears while it is meaningfully before evening; after that the calendar
+ * choices start at "Tomorrow".
  */
 declare function resolveSnoozePresets(now: Date): ReadonlyArray<SnoozePreset>;
 /**
@@ -126,4 +129,4 @@ declare function snoozeWakeLabel(snoozedUntil: string, options: {
   readonly now: string;
 }): string;
 //#endregion
-export { ChangeRequestStateLike, QUEUED_TURN_START_GRACE_MS, SnoozePreset, SnoozePresetId, ThreadSnoozeShell, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, resolveSnoozePresets, snoozeWakeLabel, 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,229 +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 — except
-* that an open PR blocks the inactivity path entirely. The server
-* un-settles on real activity (user message, session start, approval/
-* user-input request), so an override never goes stale silently.
-*/
-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.changeRequestState === "open") return false;
-	if (options.autoSettleAfterDays === null) return false;
-	const lastActivityAt = threadLastActivityAt(shell);
-	if (lastActivityAt === null) return false;
-	return Date.parse(lastActivityAt) < Date.parse(options.now) - options.autoSettleAfterDays * DAY_MS;
-}
-const HOUR_MS = 3600 * 1e3;
-const EVENING_HOUR = 18;
-const MORNING_HOUR = 9;
-function snoozeTimeOfDayLabel(date) {
-	return date.toLocaleTimeString(void 0, {
-		hour: "numeric",
-		minute: "2-digit"
-	});
-}
-function snoozeAtHour(base, hour) {
-	const next = new Date(base);
-	next.setHours(hour, 0, 0, 0);
-	return next;
-}
-function addSnoozeDays(base, days) {
-	const next = new Date(base);
-	next.setDate(next.getDate() + days);
-	return next;
-}
-/**
-* Shared "snooze until" choices for every client. "This evening" only
-* appears while it is meaningfully before evening; after that the list
-* starts at "Tomorrow".
-*/
-function resolveSnoozePresets(now) {
-	const inAnHour = new Date(now.getTime() + HOUR_MS);
-	const presets = [{
-		id: "hour",
-		label: "In 1 hour",
-		whenLabel: snoozeTimeOfDayLabel(inAnHour),
-		snoozedUntil: inAnHour.toISOString()
-	}];
-	const evening = snoozeAtHour(now, EVENING_HOUR);
-	if (evening.getTime() - now.getTime() > HOUR_MS) presets.push({
-		id: "evening",
-		label: "This evening",
-		whenLabel: snoozeTimeOfDayLabel(evening),
-		snoozedUntil: evening.toISOString()
-	});
-	const tomorrow = snoozeAtHour(addSnoozeDays(now, 1), MORNING_HOUR);
-	presets.push({
-		id: "tomorrow",
-		label: "Tomorrow",
-		whenLabel: snoozeTimeOfDayLabel(tomorrow),
-		snoozedUntil: tomorrow.toISOString()
-	});
-	const nextWeek = snoozeAtHour(addSnoozeDays(now, (1 - now.getDay() + 7) % 7 || 7), MORNING_HOUR);
-	presets.push({
-		id: "next-week",
-		label: "Next week",
-		whenLabel: `${nextWeek.toLocaleDateString(void 0, { weekday: "short" })} ${snoozeTimeOfDayLabel(nextWeek)}`,
-		snoozedUntil: nextWeek.toISOString()
-	});
-	return presets;
-}
-/**
-* Compact "wakes in" label for snoozed rows: "2h", "18h", "3d". Minutes
-* round up so a snooze never reads "0m" while still hidden. Shared by web
-* and mobile so the same wake time never reads differently per client.
-*/
-function snoozeWakeLabel(snoozedUntil, options) {
-	const wakeMs = Date.parse(snoozedUntil);
-	const nowMs = Date.parse(options.now);
-	if (Number.isNaN(wakeMs) || Number.isNaN(nowMs)) return "now";
-	const remainingMs = wakeMs - nowMs;
-	if (remainingMs <= 0) return "now";
-	if (remainingMs < HOUR_MS) return `${Math.max(1, Math.ceil(remainingMs / 6e4))}m`;
-	if (remainingMs < DAY_MS) return `${Math.ceil(remainingMs / HOUR_MS)}h`;
-	return `${Math.ceil(remainingMs / DAY_MS)}d`;
-}
-//#endregion
-export { QUEUED_TURN_START_GRACE_MS, canSettle, canSnooze, effectiveSettled, effectiveSnoozed, hasQueuedTurnStart, resolveSnoozePresets, snoozeWakeLabel, 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 { Ev as SidebarThreadSortOrder, jD as ProjectId, wv 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;

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

@@ -1,4 +1,4 @@
-import { Fj as Struct, Nj as Number$1, Pj as String, Rj as flip, rj as sort, zj as mapInput } 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;

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

@@ -1,4 +1,4 @@
-import { $a as RemoteEnvironmentRequestError, $v as OrchestrationDispatchCommandError, At as UnpinThreadInput, CD as EnvironmentId, Ct as SetThreadInteractionModeInput, Da as EnvironmentSupervisor, Dt as StartThreadTurnInput, Et as SnoozeThreadInput, Ly as OrchestrationThreadDetailSnapshot, Mt as UnsnoozeThreadInput, Na as EnvironmentCacheStore, Ny as OrchestrationThread, Ot as StopThreadSessionInput, Oy as OrchestrationShellSnapshot, Pt as UpdateThreadMetadataInput, RD as ThreadId, St as RevertThreadCheckpointInput, Ta as EnvironmentRegistry, Tt as SettleThreadInput, _t as InterruptThreadTurnInput, ay as OrchestrationGetFullThreadDiffResult, bo as ManagedRelayDpopSigner, bt as RespondToThreadApprovalInput, ey as OrchestrationEvent, f as AtomCommand, ft as ArchiveThreadInput, gt as DeleteThreadInput, hE as ScopedThreadRef, iD as EnvironmentAuthorizationError, jt as UnsettleThreadInput, kt as UnarchiveThreadInput, ly as OrchestrationGetTurnDiffResult, mE as ScopedProjectRef, mn as EnvironmentRpcUnavailableError, mt as CreateThreadInput, ot as EnvironmentThread, st as EnvironmentThreadShell, u as EnvironmentCatalogState, us as PreparedConnection, vt as PinThreadInput, wa as EnvironmentNotRegisteredError, wt as SetThreadRuntimeModeInput, xt as RespondToThreadUserInputInput, yt as ReorderPinnedThreadInput } from "../../shared.js";
+import { $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";