t3code-cli 0.14.0 → 0.14.2

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-import { Fi as CliRuntime, Ii as layer$1, Un as T3CliEnvScope, Wn as T3CliEnvShape, fr as T3ConfigSelection } from "./shared.js";
+import { $n as T3CliEnvShape, Gi as CliRuntime, Ki as layer$1, Qn as T3CliEnvScope, xr as T3ConfigSelection } from "./shared.js";
 import * as Layer from "effect/Layer";
 import { Flag, GlobalFlag } from "effect/unstable/cli";
 //#region src/cli/flags.d.ts

package/dist/cli.js

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "./rolldown-runtime.js";
-import { Ms as selection_layer_exports, SC as layer, Sw as resolveOutputFormat, _C as resolveThreadId, _w as humanJsonFormatChoices, aw as formatFlag, bw as isAgentEnvironment, cw as projectPathFlag, dw as threadFlag, fw as threadFormatFlag, gC as resolveProjectRef, gw as canRenderLiveTerminal, hC as resolveCommandProjectRef, mw as worktreeFlag, ow as modelFlags, pC as cliEnvironmentSetting, pw as waitFormatFlag, sw as projectFlag, vC as resolveWorktreePath, vw as humanJsonNdjsonFormatChoices, xC as CliRuntime, xw as isInteractiveHumanTerminal, yw as humanNdjsonFormatChoices } from "./shared.js";
+import { BT as threadFlag, FT as modelFlags, GT as canRenderLiveTerminal, Gw as resolveProjectRef, HT as waitFormatFlag, Hw as cliEnvironmentSetting, IT as projectFlag, JT as humanNdjsonFormatChoices, KT as humanJsonFormatChoices, Kw as resolveThreadId, LT as projectPathFlag, PT as formatFlag, UT as worktreeFlag, VT as threadFormatFlag, Ww as resolveCommandProjectRef, XT as isInteractiveHumanTerminal, Xw as CliRuntime, YT as isAgentEnvironment, ZT as resolveOutputFormat, Zw as layer, qT as humanJsonNdjsonFormatChoices, qw as resolveWorktreePath, zs as selection_layer_exports } from "./shared.js";
 //#region src/cli/env/index.ts
 var env_exports = /* @__PURE__ */ __exportAll({
 	Selection: () => selection_layer_exports,

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

@@ -1,2 +1,2 @@
-import { Aa as RemoteEnvironmentAuthError, Ba as RemoteEnvironmentAuthInvalidJsonError, Fa as issueRemoteDpopWebSocketTicket, Ha as RemoteEnvironmentAuthUndeclaredStatusError, Ia as issueRemoteWebSocketTicket, La as resolveRemoteDpopWebSocketConnectionUrl, Ma as exchangeRemoteDpopAccessToken, Na as fetchRemoteDpopSessionState, Pa as fetchRemoteSessionState, Ra as resolveRemoteWebSocketConnectionUrl, Va as RemoteEnvironmentAuthTimeoutError, io as RemoteEnvironmentAuthorization, ja as bootstrapRemoteBearerSession, no as AuthorizedRemoteEnvironment, oo as tokenStore_d_exports, ro as RelayEnvironmentAuthorization, za as RemoteEnvironmentAuthFetchError } from "../shared.js";
+import { Ba as RemoteEnvironmentAuthError, Ga as issueRemoteDpopWebSocketTicket, Ha as exchangeRemoteDpopAccessToken, Ja as resolveRemoteWebSocketConnectionUrl, Ka as issueRemoteWebSocketTicket, Qa as RemoteEnvironmentAuthUndeclaredStatusError, Ua as fetchRemoteDpopSessionState, Va as bootstrapRemoteBearerSession, Wa as fetchRemoteSessionState, Xa as RemoteEnvironmentAuthInvalidJsonError, Ya as RemoteEnvironmentAuthFetchError, Za as RemoteEnvironmentAuthTimeoutError, fo as AuthorizedRemoteEnvironment, go as tokenStore_d_exports, mo as RemoteEnvironmentAuthorization, po as RelayEnvironmentAuthorization, qa as resolveRemoteDpopWebSocketConnectionUrl } from "../shared.js";
 export { type AuthorizedRemoteEnvironment, type RelayEnvironmentAuthorization, RemoteEnvironmentAuthError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentAuthorization, tokenStore_d_exports as TokenStore, bootstrapRemoteBearerSession, exchangeRemoteDpopAccessToken, fetchRemoteDpopSessionState, fetchRemoteSessionState, issueRemoteDpopWebSocketTicket, issueRemoteWebSocketTicket, resolveRemoteDpopWebSocketConnectionUrl, resolveRemoteWebSocketConnectionUrl };

package/dist/client-runtime/authorization.js

@@ -1,2 +1,2 @@
-import { Ao as RemoteEnvironmentAuthTimeoutError, Co as fetchRemoteSessionState, Do as resolveRemoteWebSocketConnectionUrl, Eo as resolveRemoteDpopWebSocketConnectionUrl, Ka as tokenStore_exports, Oo as RemoteEnvironmentAuthFetchError, So as fetchRemoteDpopSessionState, To as issueRemoteWebSocketTicket, Wa as RemoteEnvironmentAuthorization, bo as bootstrapRemoteBearerSession, jo as RemoteEnvironmentAuthUndeclaredStatusError, ko as RemoteEnvironmentAuthInvalidJsonError, wo as issueRemoteDpopWebSocketTicket, xo as exchangeRemoteDpopAccessToken } from "../shared.js";
+import { $a as tokenStore_exports, Ao as fetchRemoteSessionState, Do as bootstrapRemoteBearerSession, Fo as RemoteEnvironmentAuthFetchError, Io as RemoteEnvironmentAuthInvalidJsonError, Lo as RemoteEnvironmentAuthTimeoutError, Mo as issueRemoteWebSocketTicket, No as resolveRemoteDpopWebSocketConnectionUrl, Oo as exchangeRemoteDpopAccessToken, Po as resolveRemoteWebSocketConnectionUrl, Ro as RemoteEnvironmentAuthUndeclaredStatusError, Za as RemoteEnvironmentAuthorization, jo as issueRemoteDpopWebSocketTicket, ko as fetchRemoteDpopSessionState } from "../shared.js";
 export { RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentAuthorization, tokenStore_exports as TokenStore, bootstrapRemoteBearerSession, exchangeRemoteDpopAccessToken, fetchRemoteDpopSessionState, fetchRemoteSessionState, issueRemoteDpopWebSocketTicket, issueRemoteWebSocketTicket, resolveRemoteDpopWebSocketConnectionUrl, resolveRemoteWebSocketConnectionUrl };

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

@@ -1,2 +1,2 @@
-import { $i as layer_d_exports, $o as PersistedConnectionTarget, Ao as ConnectionCatalogEntry, Bo as connectionRegistrationTarget, Da as mapManagedRelayError, Do as BearerConnectionCredential, Ea as environmentMismatchError, Eo as connectivity_d_exports, Fo as PrimaryConnectionRegistration, Gi as EnvironmentConnectionPresentation, Go as ConnectionBlockedError, Ho as BearerConnectionTarget, Io as RelayConnectionRegistration, Ja as ConnectionDriverProgress, Ji as connectionPhaseMessage, Jo as ConnectionTarget, Ki as EnvironmentPresentation, Ko as ConnectionBlockedReason, Lo as SshConnectionProfile, Mo as ConnectionProfile, No as ConnectionRegistration, Oa as mapRemoteEnvironmentError, Oo as BearerConnectionProfile, Po as PlatformConnectionRegistration, Qi as presentEnvironmentConnection, Qo as NetworkStatus, Ro as SshConnectionRegistration, Ta as credentialMissingError, To as credentialStore_d_exports, Uo as ConnectionAttemptError, Vo as AVAILABLE_CONNECTION_STATE, Wi as EnvironmentConnectionPhase, Wo as ConnectionAttemptStage, Xi as connectionStatusTitle, Xo as ConnectionTransientError, Ya as EnvironmentConnectionLease, Yi as connectionStatusText, Yo as ConnectionTargetKind, Zi as presentConnectionState, Zo as ConnectionTransientReason, _a as EnvironmentSupervisor, aa as ConnectionOnboarding, as as SupervisorConnectionPhase, ca as prepareBearerConnectionUpdate, da as registerPairingConnection, eo as ConnectionResolver, es as PreparedConnection, fa as registerSshConnection, ga as PlatformEnvironmentRemovalError, ha as EnvironmentRegistry, ia as BearerConnectionUpdateInput, is as SshConnectionTarget, jo as ConnectionCredential, ka as profileMissingError, ko as BearerConnectionRegistration, la as preparePairingRegistration, ma as EnvironmentNotRegisteredError, ns as PrimaryConnectionTarget, oa as PairingConnectionInput, os as SupervisorConnectionState, pa as updateBearerConnection, qa as ConnectionDriver, qi as connectionCatalogDisplayUrl, qo as ConnectionProjectionPhase, rs as RelayConnectionTarget, sa as SshConnectionInput, ss as connectionProjectionPhase, to as profileStore_d_exports, ts as PreparedHttpAuthorization, ua as prepareSshRegistration, va as EnvironmentSupervisorOptions, ya as wakeups_d_exports, zo as connectionRegistrationCatalogEntry } from "../shared.js";
+import { $o as ConnectionAttemptError, Bo as ConnectionCatalogEntry, Ca as updateBearerConnection, Da as EnvironmentSupervisor, Ea as PlatformEnvironmentRemovalError, Fa as credentialMissingError, Fo as credentialStore_d_exports, Go as PrimaryConnectionRegistration, Ho as ConnectionProfile, Ia as environmentMismatchError, Io as connectivity_d_exports, Jo as SshConnectionRegistration, Ko as RelayConnectionRegistration, La as mapManagedRelayError, Lo as BearerConnectionCredential, Oa as EnvironmentSupervisorOptions, Qo as BearerConnectionTarget, Ra as mapRemoteEnvironmentError, Ro as BearerConnectionProfile, Sa as registerSshConnection, Ta as EnvironmentRegistry, Uo as ConnectionRegistration, Vo as ConnectionCredential, Wo as PlatformConnectionRegistration, Xo as connectionRegistrationTarget, Yo as connectionRegistrationCatalogEntry, Zo as AVAILABLE_CONNECTION_STATE, _a as SshConnectionInput, _s as connectionProjectionPhase, aa as connectionStatusText, ao as EnvironmentConnectionLease, as as ConnectionTargetKind, ba as prepareSshRegistration, ca as presentEnvironmentConnection, cs as NetworkStatus, do as profileStore_d_exports, ds as PreparedHttpAuthorization, ea as EnvironmentConnectionPhase, es as ConnectionAttemptStage, fs as PrimaryConnectionTarget, ga as PairingConnectionInput, gs as SupervisorConnectionState, ha as ConnectionOnboarding, hs as SupervisorConnectionPhase, ia as connectionPhaseMessage, io as ConnectionDriverProgress, is as ConnectionTarget, ka as wakeups_d_exports, la as layer_d_exports, ls as PersistedConnectionTarget, ma as BearerConnectionUpdateInput, ms as SshConnectionTarget, na as EnvironmentPresentation, ns as ConnectionBlockedReason, oa as connectionStatusTitle, os as ConnectionTransientError, ps as RelayConnectionTarget, qo as SshConnectionProfile, ra as connectionCatalogDisplayUrl, ro as ConnectionDriver, rs as ConnectionProjectionPhase, sa as presentConnectionState, ss as ConnectionTransientReason, ta as EnvironmentConnectionPresentation, ts as ConnectionBlockedError, uo as ConnectionResolver, us as PreparedConnection, va as prepareBearerConnectionUpdate, wa as EnvironmentNotRegisteredError, xa as registerPairingConnection, ya as preparePairingRegistration, za as profileMissingError, zo as BearerConnectionRegistration } from "../shared.js";
 export { AVAILABLE_CONNECTION_STATE, BearerConnectionCredential, BearerConnectionProfile, BearerConnectionRegistration, BearerConnectionTarget, type BearerConnectionUpdateInput, layer_d_exports as Connection, ConnectionAttemptError, ConnectionAttemptStage, ConnectionBlockedError, ConnectionBlockedReason, ConnectionCatalogEntry, ConnectionCredential, ConnectionDriver, type ConnectionDriverProgress, ConnectionOnboarding, ConnectionProfile, ConnectionProjectionPhase, ConnectionRegistration, ConnectionResolver, ConnectionTarget, ConnectionTargetKind, ConnectionTransientError, ConnectionTransientReason, connectivity_d_exports as Connectivity, credentialStore_d_exports as CredentialStore, type EnvironmentConnectionLease, EnvironmentConnectionPhase, EnvironmentConnectionPresentation, EnvironmentNotRegisteredError, EnvironmentPresentation, EnvironmentRegistry, EnvironmentSupervisor, type EnvironmentSupervisorOptions, NetworkStatus, type PairingConnectionInput, PersistedConnectionTarget, PlatformConnectionRegistration, PlatformEnvironmentRemovalError, PreparedConnection, PreparedHttpAuthorization, PrimaryConnectionRegistration, PrimaryConnectionTarget, profileStore_d_exports as ProfileStore, RelayConnectionRegistration, RelayConnectionTarget, type SshConnectionInput, SshConnectionProfile, SshConnectionRegistration, SshConnectionTarget, SupervisorConnectionPhase, SupervisorConnectionState, wakeups_d_exports as Wakeups, connectionCatalogDisplayUrl, connectionPhaseMessage, connectionProjectionPhase, connectionRegistrationCatalogEntry, connectionRegistrationTarget, connectionStatusText, connectionStatusTitle, credentialMissingError, environmentMismatchError, mapManagedRelayError, mapRemoteEnvironmentError, prepareBearerConnectionUpdate, preparePairingRegistration, prepareSshRegistration, presentConnectionState, presentEnvironmentConnection, profileMissingError, registerPairingConnection, registerSshConnection, updateBearerConnection };

package/dist/client-runtime/connection.js

@@ -1,2 +1,2 @@
-import { $i as connectionStatusText, $o as BearerConnectionRegistration, Aa as EnvironmentSupervisor, Da as EnvironmentNotRegisteredError, Ha as ConnectionResolver, Ma as wakeups_exports, Oa as EnvironmentRegistry, Qi as connectionPhaseMessage, Qo as BearerConnectionProfile, Ua as profileStore_exports, Xo as connectivity_exports, Yo as credentialStore_exports, Zi as connectionCatalogDisplayUrl, Zo as BearerConnectionCredential, _o as mapManagedRelayError, _s as PersistedConnectionTarget, as as RelayConnectionRegistration, bs as SshConnectionTarget, ca as ConnectionOnboarding, cs as connectionRegistrationCatalogEntry, da as prepareSshRegistration, ds as BearerConnectionTarget, ea as connectionStatusTitle, es as ConnectionCredential, fa as registerPairingConnection, fs as ConnectionBlockedError, go as environmentMismatchError, gs as ConnectionTransientReason, ho as credentialMissingError, hs as ConnectionTransientError, is as PrimaryConnectionRegistration, ka as PlatformEnvironmentRemovalError, la as prepareBearerConnectionUpdate, ls as connectionRegistrationTarget, ma as updateBearerConnection, ms as ConnectionTarget, na as presentEnvironmentConnection, ns as ConnectionRegistration, os as SshConnectionProfile, pa as registerSshConnection, ps as ConnectionBlockedReason, ra as layer_exports, rs as PlatformConnectionRegistration, ss as SshConnectionRegistration, ta as presentConnectionState, ts as ConnectionProfile, ua as preparePairingRegistration, us as AVAILABLE_CONNECTION_STATE, vo as mapRemoteEnvironmentError, vs as PrimaryConnectionTarget, xs as connectionProjectionPhase, yo as profileMissingError, ys as RelayConnectionTarget, za as ConnectionDriver } from "../shared.js";
+import { Co as environmentMismatchError, Cs as ConnectionTransientReason, Ds as SshConnectionTarget, Eo as profileMissingError, Es as RelayConnectionTarget, Fa as PlatformEnvironmentRemovalError, Ia as EnvironmentSupervisor, Ka as ConnectionDriver, Na as EnvironmentNotRegisteredError, Os as connectionProjectionPhase, Pa as EnvironmentRegistry, So as credentialMissingError, Ss as ConnectionTransientError, To as mapRemoteEnvironmentError, Ts as PrimaryConnectionTarget, Xa as profileStore_exports, Ya as ConnectionResolver, _a as prepareSshRegistration, _s as AVAILABLE_CONNECTION_STATE, aa as connectionStatusText, as as BearerConnectionProfile, ba as updateBearerConnection, bs as ConnectionBlockedReason, ca as presentEnvironmentConnection, cs as ConnectionProfile, ds as PrimaryConnectionRegistration, fs as RelayConnectionRegistration, ga as preparePairingRegistration, gs as connectionRegistrationTarget, ha as prepareBearerConnectionUpdate, hs as connectionRegistrationCatalogEntry, ia as connectionPhaseMessage, is as BearerConnectionCredential, la as layer_exports, ls as ConnectionRegistration, ma as ConnectionOnboarding, ms as SshConnectionRegistration, ns as credentialStore_exports, oa as connectionStatusTitle, os as BearerConnectionRegistration, ps as SshConnectionProfile, ra as connectionCatalogDisplayUrl, rs as connectivity_exports, sa as presentConnectionState, ss as ConnectionCredential, us as PlatformConnectionRegistration, va as registerPairingConnection, vs as BearerConnectionTarget, wo as mapManagedRelayError, ws as PersistedConnectionTarget, xs as ConnectionTarget, ya as registerSshConnection, ys as ConnectionBlockedError, za as wakeups_exports } from "../shared.js";
 export { AVAILABLE_CONNECTION_STATE, BearerConnectionCredential, BearerConnectionProfile, BearerConnectionRegistration, BearerConnectionTarget, layer_exports as Connection, ConnectionBlockedError, ConnectionBlockedReason, ConnectionCredential, ConnectionDriver, ConnectionOnboarding, ConnectionProfile, ConnectionRegistration, ConnectionResolver, ConnectionTarget, ConnectionTransientError, ConnectionTransientReason, connectivity_exports as Connectivity, credentialStore_exports as CredentialStore, EnvironmentNotRegisteredError, EnvironmentRegistry, EnvironmentSupervisor, PersistedConnectionTarget, PlatformConnectionRegistration, PlatformEnvironmentRemovalError, PrimaryConnectionRegistration, PrimaryConnectionTarget, profileStore_exports as ProfileStore, RelayConnectionRegistration, RelayConnectionTarget, SshConnectionProfile, SshConnectionRegistration, SshConnectionTarget, wakeups_exports as Wakeups, connectionCatalogDisplayUrl, connectionPhaseMessage, connectionProjectionPhase, connectionRegistrationCatalogEntry, connectionRegistrationTarget, connectionStatusText, connectionStatusTitle, credentialMissingError, environmentMismatchError, mapManagedRelayError, mapRemoteEnvironmentError, prepareBearerConnectionUpdate, preparePairingRegistration, prepareSshRegistration, presentConnectionState, presentEnvironmentConnection, profileMissingError, registerPairingConnection, registerSshConnection, updateBearerConnection };

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

@@ -1,4 +1,4 @@
-import { $T as ThreadId, KT as ProjectId, Mw as ScopedThreadRef, Tw as ExecutionEnvironmentDescriptor, Ua as RemoteEnvironmentRequestError, _n as classifyHostedHttpsCompatibility, bn as normalizeHttpBaseUrl, gn as CreateAdvertisedEndpointInput, jw as ScopedProjectRef, vn as createAdvertisedEndpoint, yn as deriveWsBaseUrl, zT as EnvironmentId } from "../shared.js";
+import { $a as RemoteEnvironmentRequestError, CD as EnvironmentId, Dn as createAdvertisedEndpoint, En as classifyHostedHttpsCompatibility, On as deriveWsBaseUrl, RD as ThreadId, Tn as CreateAdvertisedEndpointInput, cE as ExecutionEnvironmentDescriptor, hE as ScopedThreadRef, jD as ProjectId, kn as normalizeHttpBaseUrl, mE as ScopedProjectRef } from "../shared.js";
 import * as Effect from "effect/Effect";
 //#region upstream-t3code/packages/client-runtime/src/environment/descriptor.d.ts
 declare const fetchRemoteEnvironmentDescriptor: (input: {
@@ -17,7 +17,11 @@ declare const fetchRemoteEnvironmentDescriptor: (input: {
     readonly connectionProbe?: boolean;
     readonly threadSettlement?: boolean;
     readonly threadSnooze?: boolean;
+    readonly threadPinning?: boolean;
+    readonly threadPinReorder?: boolean;
+    readonly threadTitleRegeneration?: boolean;
     readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+    readonly serverSelfUpdateProgress?: boolean;
   };
 }, RemoteEnvironmentRequestError, import("effect/unstable/http/HttpClient").HttpClient>;
 //#endregion

package/dist/client-runtime/environment.js

@@ -1,2 +1,2 @@
-import { Bo as normalizeHttpBaseUrl, Io as environmentEndpointUrl, Lo as classifyHostedHttpsCompatibility, Ro as createAdvertisedEndpoint, ai as parseScopedProjectKey, ci as scopeThreadRef, di as scopedThreadKey, fi as attachEnvironmentDescriptor, li as scopedProjectKey, mo as fetchRemoteEnvironmentDescriptor, oi as parseScopedThreadKey, pi as createKnownEnvironment, si as scopeProjectRef, ui as scopedRefKey, zo as deriveWsBaseUrl } from "../shared.js";
+import { Go as createAdvertisedEndpoint, Ko as deriveWsBaseUrl, Uo as environmentEndpointUrl, Wo as classifyHostedHttpsCompatibility, _i as scopedThreadKey, di as parseScopedProjectKey, fi as parseScopedThreadKey, gi as scopedRefKey, hi as scopedProjectKey, mi as scopeThreadRef, pi as scopeProjectRef, qo as normalizeHttpBaseUrl, vi as attachEnvironmentDescriptor, xo as fetchRemoteEnvironmentDescriptor, yi as createKnownEnvironment } from "../shared.js";
 export { attachEnvironmentDescriptor, classifyHostedHttpsCompatibility, createAdvertisedEndpoint, createKnownEnvironment, deriveWsBaseUrl, environmentEndpointUrl, fetchRemoteEnvironmentDescriptor, normalizeHttpBaseUrl, parseScopedProjectKey, parseScopedThreadKey, scopeProjectRef, scopeThreadRef, scopedProjectKey, scopedRefKey, scopedThreadKey };

package/dist/client-runtime/errors.js

@@ -1,4 +1,4 @@
-import { An as findErrorTraceId, Na as safeErrorLogAttributes } from "../shared.js";
+import { Ba as safeErrorLogAttributes, Pn as findErrorTraceId } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/errors/transport.ts
 const TRANSPORT_ERROR_PATTERNS = [
 	/\bSocketCloseError\b/i,

package/dist/client-runtime/operations/projects.d.ts

@@ -1,2 +1,2 @@
-import { $ as getAddProjectInitialQuery, G as AddProjectRemoteSource, J as addProjectRemoteSourcePathHint, K as AddProjectRemoteSourceReadiness, Q as findExistingAddProject, U as AddProjectCloneFlow, W as AddProjectRemoteProviderKind, X as buildAddProjectRemoteSourceReadiness, Y as addProjectRemoteSourceProvider, Z as buildProjectCreateCommand, et as resolveAddProjectPath, q as addProjectRemoteSourceLabel, tt as sortAddProjectProviderSources } from "../../shared.js";
-export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };
+import { $ as canCreateProjectInEnvironment, G as AddProjectRemoteProviderKind, J as addProjectRemoteSourceLabel, K as AddProjectRemoteSource, Q as buildProjectCreateCommand, W as AddProjectCloneFlow, X as addProjectRemoteSourceProvider, Y as addProjectRemoteSourcePathHint, Z as buildAddProjectRemoteSourceReadiness, et as findExistingAddProject, nt as resolveAddProjectPath, q as AddProjectRemoteSourceReadiness, rt as sortAddProjectProviderSources, tt as getAddProjectInitialQuery } from "../../shared.js";
+export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, canCreateProjectInEnvironment, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };

package/dist/client-runtime/operations/projects.js

@@ -1,2 +1,2 @@
-import { At as resolveAddProjectPath, Ct as addProjectRemoteSourceLabel, Dt as buildProjectCreateCommand, Et as buildAddProjectRemoteSourceReadiness, Ot as findExistingAddProject, Tt as addProjectRemoteSourceProvider, jt as sortAddProjectProviderSources, kt as getAddProjectInitialQuery, wt as addProjectRemoteSourcePathHint } from "../../shared.js";
-export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };
+import { At as getAddProjectInitialQuery, Ct as addProjectRemoteSourceLabel, Dt as buildProjectCreateCommand, Et as buildAddProjectRemoteSourceReadiness, Mt as sortAddProjectProviderSources, Ot as canCreateProjectInEnvironment, Tt as addProjectRemoteSourceProvider, jt as resolveAddProjectPath, kt as findExistingAddProject, wt as addProjectRemoteSourcePathHint } from "../../shared.js";
+export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, canCreateProjectInEnvironment, findExistingAddProject, getAddProjectInitialQuery, resolveAddProjectPath, sortAddProjectProviderSources };

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

@@ -1,2 +1,2 @@
-import { $ as getAddProjectInitialQuery, At as archiveThread, Bt as setThreadRuntimeMode, Ct as StartThreadTurnInput, Dt as UnsnoozeThreadInput, Et as UnsettleThreadInput, Ft as interruptThreadTurn, G as AddProjectRemoteSource, Gt as unarchiveThread, Ht as snoozeThread, It as respondToThreadApproval, J as addProjectRemoteSourcePathHint, Jt as updateProject, K as AddProjectRemoteSourceReadiness, Kt as unsettleThread, Lt as respondToThreadUserInput, Mt as createThread, Nt as deleteProject, Ot as UpdateProjectInput, Pt as deleteThread, Q as findExistingAddProject, Rt as revertThreadCheckpoint, St as SnoozeThreadInput, Tt as UnarchiveThreadInput, U as AddProjectCloneFlow, Ut as startThreadTurn, Vt as settleThread, W as AddProjectRemoteProviderKind, Wt as stopThreadSession, X as buildAddProjectRemoteSourceReadiness, Y as addProjectRemoteSourceProvider, Yt as updateThreadMetadata, Z as buildProjectCreateCommand, _t as RespondToThreadUserInputInput, bt as SetThreadRuntimeModeInput, dt as CreateProjectInput, et as resolveAddProjectPath, ft as CreateThreadInput, gt as RespondToThreadApprovalInput, ht as InterruptThreadTurnInput, jt as createProject, kt as UpdateThreadMetadataInput, mt as DeleteThreadInput, pt as DeleteProjectInput, q as addProjectRemoteSourceLabel, qt as unsnoozeThread, tt as sortAddProjectProviderSources, ut as ArchiveThreadInput, vt as RevertThreadCheckpointInput, wt as StopThreadSessionInput, xt as SettleThreadInput, yt as SetThreadInteractionModeInput, zt as setThreadInteractionMode } from "../shared.js";
-export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, ArchiveThreadInput, CreateProjectInput, CreateThreadInput, DeleteProjectInput, DeleteThreadInput, InterruptThreadTurnInput, RespondToThreadApprovalInput, RespondToThreadUserInputInput, RevertThreadCheckpointInput, SetThreadInteractionModeInput, SetThreadRuntimeModeInput, SettleThreadInput, SnoozeThreadInput, StartThreadTurnInput, StopThreadSessionInput, UnarchiveThreadInput, UnsettleThreadInput, UnsnoozeThreadInput, UpdateProjectInput, UpdateThreadMetadataInput, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };
+import { $ as canCreateProjectInEnvironment, $t as unpinThread, At as UnpinThreadInput, Bt as interruptThreadTurn, Ct as SetThreadInteractionModeInput, Dt as StartThreadTurnInput, Et as SnoozeThreadInput, Ft as archiveThread, G as AddProjectRemoteProviderKind, Gt as revertThreadCheckpoint, Ht as reorderPinnedThread, It as createProject, J as addProjectRemoteSourceLabel, Jt as settleThread, K as AddProjectRemoteSource, Kt as setThreadInteractionMode, Lt as createThread, Mt as UnsnoozeThreadInput, Nt as UpdateProjectInput, Ot as StopThreadSessionInput, Pt as UpdateThreadMetadataInput, Q as buildProjectCreateCommand, Qt as unarchiveThread, Rt as deleteProject, St as RevertThreadCheckpointInput, Tt as SettleThreadInput, Ut as respondToThreadApproval, Vt as pinThread, W as AddProjectCloneFlow, Wt as respondToThreadUserInput, X as addProjectRemoteSourceProvider, Xt as startThreadTurn, Y as addProjectRemoteSourcePathHint, Yt as snoozeThread, Z as buildAddProjectRemoteSourceReadiness, Zt as stopThreadSession, _t as InterruptThreadTurnInput, bt as RespondToThreadApprovalInput, en as unsettleThread, et as findExistingAddProject, ft as ArchiveThreadInput, gt as DeleteThreadInput, ht as DeleteProjectInput, jt as UnsettleThreadInput, kt as UnarchiveThreadInput, mt as CreateThreadInput, nn as updateProject, nt as resolveAddProjectPath, pt as CreateProjectInput, q as AddProjectRemoteSourceReadiness, qt as setThreadRuntimeMode, rn as updateThreadMetadata, rt as sortAddProjectProviderSources, tn as unsnoozeThread, tt as getAddProjectInitialQuery, vt as PinThreadInput, wt as SetThreadRuntimeModeInput, xt as RespondToThreadUserInputInput, yt as ReorderPinnedThreadInput, zt as deleteThread } from "../shared.js";
+export { AddProjectCloneFlow, AddProjectRemoteProviderKind, AddProjectRemoteSource, AddProjectRemoteSourceReadiness, ArchiveThreadInput, CreateProjectInput, CreateThreadInput, DeleteProjectInput, DeleteThreadInput, InterruptThreadTurnInput, PinThreadInput, ReorderPinnedThreadInput, RespondToThreadApprovalInput, RespondToThreadUserInputInput, RevertThreadCheckpointInput, SetThreadInteractionModeInput, SetThreadRuntimeModeInput, SettleThreadInput, SnoozeThreadInput, StartThreadTurnInput, StopThreadSessionInput, UnarchiveThreadInput, UnpinThreadInput, UnsettleThreadInput, UnsnoozeThreadInput, UpdateProjectInput, UpdateThreadMetadataInput, addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, canCreateProjectInEnvironment, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, pinThread, reorderPinnedThread, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unpinThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };

package/dist/client-runtime/operations.js

@@ -1,2 +1,2 @@
-import { At as resolveAddProjectPath, Cn as startThreadTurn, Ct as addProjectRemoteSourceLabel, Dn as unsnoozeThread, Dt as buildProjectCreateCommand, En as unsettleThread, Et as buildAddProjectRemoteSourceReadiness, On as updateProject, Ot as findExistingAddProject, Sn as snoozeThread, Tn as unarchiveThread, Tt as addProjectRemoteSourceProvider, _n as respondToThreadUserInput, bn as setThreadRuntimeMode, dn as createProject, fn as createThread, gn as respondToThreadApproval, hn as interruptThreadTurn, jt as sortAddProjectProviderSources, kn as updateThreadMetadata, kt as getAddProjectInitialQuery, mn as deleteThread, pn as deleteProject, un as archiveThread, vn as revertThreadCheckpoint, wn as stopThreadSession, wt as addProjectRemoteSourcePathHint, xn as settleThread, yn as setThreadInteractionMode } from "../shared.js";
-export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };
+import { An as unsettleThread, At as getAddProjectInitialQuery, Cn as setThreadRuntimeMode, Ct as addProjectRemoteSourceLabel, Dn as stopThreadSession, Dt as buildProjectCreateCommand, En as startThreadTurn, Et as buildAddProjectRemoteSourceReadiness, Mn as updateProject, Mt as sortAddProjectProviderSources, Nn as updateThreadMetadata, On as unarchiveThread, Ot as canCreateProjectInEnvironment, Sn as setThreadInteractionMode, Tn as snoozeThread, Tt as addProjectRemoteSourceProvider, _n as pinThread, bn as respondToThreadUserInput, dn as archiveThread, fn as createProject, gn as interruptThreadTurn, hn as deleteThread, jn as unsnoozeThread, jt as resolveAddProjectPath, kn as unpinThread, kt as findExistingAddProject, mn as deleteProject, pn as createThread, vn as reorderPinnedThread, wn as settleThread, wt as addProjectRemoteSourcePathHint, xn as revertThreadCheckpoint, yn as respondToThreadApproval } from "../shared.js";
+export { addProjectRemoteSourceLabel, addProjectRemoteSourcePathHint, addProjectRemoteSourceProvider, archiveThread, buildAddProjectRemoteSourceReadiness, buildProjectCreateCommand, canCreateProjectInEnvironment, createProject, createThread, deleteProject, deleteThread, findExistingAddProject, getAddProjectInitialQuery, interruptThreadTurn, pinThread, reorderPinnedThread, resolveAddProjectPath, respondToThreadApproval, respondToThreadUserInput, revertThreadCheckpoint, setThreadInteractionMode, setThreadRuntimeMode, settleThread, snoozeThread, sortAddProjectProviderSources, startThreadTurn, stopThreadSession, unarchiveThread, unpinThread, unsettleThread, unsnoozeThread, updateProject, updateThreadMetadata };

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

@@ -1,4 +1,4 @@
-import { Ca as EnvironmentCacheStore, Co as SshEnvironmentGateway, Do as BearerConnectionCredential, Ho as BearerConnectionTarget, Jo as ConnectionTarget, Lo as SshConnectionProfile, No as ConnectionRegistration, Oo as BearerConnectionProfile, Sa as ConnectionTargetStore, So as RelayDeviceIdentity, _o as ClientPresentation, ao as RemoteDpopAccessToken, ba as ConnectionPersistenceError, bo as PrimaryEnvironmentAuth, is as SshConnectionTarget, ra as PlatformConnectionSource, rs as RelayConnectionTarget, vo as CloudSession, wa as EnvironmentOwnedDataCleanup, xa as ConnectionRegistrationStore, xo as ProvisionedSshEnvironment, yo as PreparedSshEnvironment } from "../shared.js";
+import { Aa as ConnectionPersistenceError, Ao as PrimaryEnvironmentAuth, Do as ClientPresentation, Lo as BearerConnectionCredential, Ma as ConnectionTargetStore, Mo as RelayDeviceIdentity, Na as EnvironmentCacheStore, No as SshEnvironmentGateway, Oo as CloudSession, Pa as EnvironmentOwnedDataCleanup, Qo as BearerConnectionTarget, Ro as BearerConnectionProfile, Uo as ConnectionRegistration, ho as RemoteDpopAccessToken, is as ConnectionTarget, ja as ConnectionRegistrationStore, jo as ProvisionedSshEnvironment, ko as PreparedSshEnvironment, ms as SshConnectionTarget, pa as PlatformConnectionSource, ps as RelayConnectionTarget, qo as SshConnectionProfile } from "../shared.js";
 import * as Schema from "effect/Schema";
 //#region upstream-t3code/packages/client-runtime/src/platform/storageDocument.d.ts
 declare const StoredConnectionCredential: Schema.Struct<{

package/dist/client-runtime/platform.js

@@ -1,4 +1,4 @@
-import { $T as Struct, Fa as ConnectionRegistrationStore, Ga as RemoteDpopAccessToken, Ia as ConnectionTargetStore, La as EnvironmentCacheStore, Pa as ConnectionPersistenceError, QT as String, Ra as EnvironmentOwnedDataCleanup, WT as ArraySchema, _s as PersistedConnectionTarget, do as PrimaryEnvironmentAuth, es as ConnectionCredential, fo as RelayDeviceIdentity, lo as ClientPresentation, po as SshEnvironmentGateway, qT as Literal, sa as PlatformConnectionSource, ts as ConnectionProfile, uo as CloudSession } from "../shared.js";
+import { CD as Literal, Ga as EnvironmentOwnedDataCleanup, Ha as ConnectionRegistrationStore, OD as String, Qa as RemoteDpopAccessToken, Ua as ConnectionTargetStore, Va as ConnectionPersistenceError, Wa as EnvironmentCacheStore, _o as CloudSession, bD as ArraySchema, bo as SshEnvironmentGateway, cs as ConnectionProfile, go as ClientPresentation, kD as Struct, pa as PlatformConnectionSource, ss as ConnectionCredential, vo as PrimaryEnvironmentAuth, ws as PersistedConnectionTarget, yo as RelayDeviceIdentity } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/platform/storageDocument.ts
 const StoredConnectionCredential = Struct({
 	connectionId: String,

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

@@ -1,4 +1,4 @@
-import { co as ManagedRelayClient, do as ManagedRelayRequestFailedError, fo as ManagedRelayRequestProofCreationError, go as managedRelay_d_exports, ho as ManagedRelayUrlInvalidError, lo as ManagedRelayDpopKeyLoadError, mo as ManagedRelayTokenProofCreationError, na as discovery_d_exports, po as ManagedRelayRequestTimeoutError, so as ManagedRelayAccessTokenScopesUnexpectedError, wo as RelayClientEnvironmentRecord } from "../shared.js";
+import { Co as ManagedRelayRequestTimeoutError, Eo as managedRelay_d_exports, Po as RelayClientEnvironmentRecord, So as ManagedRelayRequestProofCreationError, To as ManagedRelayUrlInvalidError, _o as ManagedRelayAccessTokenScopesUnexpectedError, fa as discovery_d_exports, vo as ManagedRelayClient, wo as ManagedRelayTokenProofCreationError, xo as ManagedRelayRequestFailedError, yo as ManagedRelayDpopKeyLoadError } from "../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Cause from "effect/Cause";
@@ -104,7 +104,11 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
         readonly connectionProbe?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
+        readonly threadPinning?: boolean;
+        readonly threadPinReorder?: boolean;
+        readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        readonly serverSelfUpdateProgress?: boolean;
       };
     } | undefined;
     readonly error?: string | undefined;

package/dist/client-runtime/relay.js

@@ -1,4 +1,4 @@
-import { $D as flatMap, An as findErrorTraceId, EO as succeed, GO as currentTimeMillis, Gr as family, Ik as getOrNull, Jr as setIdleTTL, KE as map, KO as TaggedError, Kr as keepAlive, NO as tryPromise, OO as sync, PE as changes, QD as fail, Qr as toStream, RE as drop, WD as callback, Xr as withLabel, Ya as managedRelay_exports, Yr as swr, ZO as squash, aO as gen, ao as decodeRelayJwt, eO as fn, mO as onExit, oa as discovery_exports, qa as ManagedRelayClient, qr as make, ti as value, vy as RelayEnvironmentConnectScope, yy as RelayEnvironmentStatusScope } from "../shared.js";
+import { $r as make, Ab as RelayEnvironmentConnectScope, Bk as gen, Cj as getOrNull, DA as currentTimeMillis, FA as squash, MO as map, Nk as flatMap, Pk as fn, Pn as findErrorTraceId, Qr as keepAlive, Sk as callback, Xk as onExit, Zr as family, bO as changes, cA as succeed, ei as setIdleTTL, eo as ManagedRelayClient, fa as discovery_exports, fo as decodeRelayJwt, hA as tryPromise, ii as toStream, jb as RelayEnvironmentStatusScope, jk as fail, kA as TaggedError, ni as withLabel, no as managedRelay_exports, si as value, ti as swr, uA as sync, wO as drop } from "../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/relay/managedRelayState.ts
 const DEFAULT_STALE_TIME_MS = 15e3;
 const DEFAULT_IDLE_TTL_MS = 5 * 6e4;

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

@@ -1,2 +1,2 @@
-import { $a as makeWsRpcProtocolClient, $t as EnvironmentRpcRequestObserver, Ba as RemoteEnvironmentAuthInvalidJsonError, Ga as makeEnvironmentHttpApiClient, Ha as RemoteEnvironmentAuthUndeclaredStatusError, Ka as remoteHttpClientLayer, Qa as WsRpcProtocolClient, Qt as EnvironmentRpcRequestObservation, Ua as RemoteEnvironmentRequestError, Va as RemoteEnvironmentAuthTimeoutError, Wa as executeEnvironmentHttpRequest, Xa as RpcSession, Xt as EnvironmentRpcFailure, Za as RpcSessionFactory, Zt as EnvironmentRpcInput, an as EnvironmentRpcTag, cn as EnvironmentStreamRpcTag, dn as config, en as EnvironmentRpcStreamFailure, fn as request, hn as subscribeDynamic, in as EnvironmentRpcSuccess, ln as EnvironmentSubscriptionRpcTag, mn as subscribe, nn as EnvironmentRpcSubscriptionObservation, on as EnvironmentRpcUnavailableError, pn as runStream, rn as EnvironmentRpcSubscriptionObserver, sn as EnvironmentStreamCommandRpcTag, tn as EnvironmentRpcStreamValue, un as EnvironmentUnaryRpcTag, za as RemoteEnvironmentAuthFetchError } from "../shared.js";
-export { EnvironmentRpcFailure, EnvironmentRpcInput, EnvironmentRpcRequestObservation, EnvironmentRpcRequestObserver, EnvironmentRpcStreamFailure, EnvironmentRpcStreamValue, EnvironmentRpcSubscriptionObservation, EnvironmentRpcSubscriptionObserver, EnvironmentRpcSuccess, EnvironmentRpcTag, EnvironmentRpcUnavailableError, EnvironmentStreamCommandRpcTag, EnvironmentStreamRpcTag, EnvironmentSubscriptionRpcTag, EnvironmentUnaryRpcTag, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentRequestError, type RpcSession, RpcSessionFactory, WsRpcProtocolClient, config, executeEnvironmentHttpRequest, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };
+import { $a as RemoteEnvironmentRequestError, Cn as subscribe, Qa as RemoteEnvironmentAuthUndeclaredStatusError, Sn as runStream, Xa as RemoteEnvironmentAuthInvalidJsonError, Ya as RemoteEnvironmentAuthFetchError, Za as RemoteEnvironmentAuthTimeoutError, _n as EnvironmentSubscriptionRpcTag, an as EnvironmentRpcInput, bn as isRpcClientError, cn as EnvironmentRpcStreamFailure, co as WsRpcProtocolClient, dn as EnvironmentRpcSubscriptionObserver, eo as executeEnvironmentHttpRequest, fn as EnvironmentRpcSuccess, gn as EnvironmentStreamRpcTag, hn as EnvironmentStreamCommandRpcTag, in as EnvironmentRpcFailure, ln as EnvironmentRpcStreamValue, lo as makeWsRpcProtocolClient, mn as EnvironmentRpcUnavailableError, no as remoteHttpClientLayer, on as EnvironmentRpcRequestObservation, oo as RpcSession, pn as EnvironmentRpcTag, sn as EnvironmentRpcRequestObserver, so as RpcSessionFactory, to as makeEnvironmentHttpApiClient, un as EnvironmentRpcSubscriptionObservation, vn as EnvironmentUnaryRpcTag, wn as subscribeDynamic, xn as request, yn as config } from "../shared.js";
+export { EnvironmentRpcFailure, EnvironmentRpcInput, EnvironmentRpcRequestObservation, EnvironmentRpcRequestObserver, EnvironmentRpcStreamFailure, EnvironmentRpcStreamValue, EnvironmentRpcSubscriptionObservation, EnvironmentRpcSubscriptionObserver, EnvironmentRpcSuccess, EnvironmentRpcTag, EnvironmentRpcUnavailableError, EnvironmentStreamCommandRpcTag, EnvironmentStreamRpcTag, EnvironmentSubscriptionRpcTag, EnvironmentUnaryRpcTag, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RemoteEnvironmentRequestError, type RpcSession, RpcSessionFactory, WsRpcProtocolClient, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

package/dist/client-runtime/rpc.js

@@ -1,2 +1,2 @@
-import { Ao as RemoteEnvironmentAuthTimeoutError, Ba as RpcSessionFactory, Br as config, Hr as runStream, Lr as EnvironmentRpcRequestObserver, Mo as executeEnvironmentHttpRequest, No as makeEnvironmentHttpApiClient, Oo as RemoteEnvironmentAuthFetchError, Po as remoteHttpClientLayer, Rr as EnvironmentRpcSubscriptionObserver, Ur as subscribe, Va as makeWsRpcProtocolClient, Vr as request, Wr as subscribeDynamic, jo as RemoteEnvironmentAuthUndeclaredStatusError, ko as RemoteEnvironmentAuthInvalidJsonError, zr as EnvironmentRpcUnavailableError } from "../shared.js";
-export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };
+import { Bo as makeEnvironmentHttpApiClient, Fo as RemoteEnvironmentAuthFetchError, Gr as config, Hr as EnvironmentRpcRequestObserver, Io as RemoteEnvironmentAuthInvalidJsonError, Ja as makeWsRpcProtocolClient, Jr as runStream, Kr as isRpcClientError, Lo as RemoteEnvironmentAuthTimeoutError, Ro as RemoteEnvironmentAuthUndeclaredStatusError, Ur as EnvironmentRpcSubscriptionObserver, Vo as remoteHttpClientLayer, Wr as EnvironmentRpcUnavailableError, Xr as subscribeDynamic, Yr as subscribe, qa as RpcSessionFactory, qr as request, zo as executeEnvironmentHttpRequest } from "../shared.js";
+export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeWsRpcProtocolClient, remoteHttpClientLayer, request, runStream, subscribe, subscribeDynamic };

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

@@ -1,4 +1,4 @@
-import { Ax as AssetProjectFaviconNotFoundError, Bx as AssetWorkspaceRootNormalizationError, Fx as AssetWorkspaceAssetNotFoundError, Ix as AssetWorkspaceContextNotFoundError, Lx as AssetWorkspaceContextResolutionError, Mx as AssetResource, Nx as AssetSigningKeyLoadError, Ox as AssetPreviewTypeValidationError, Px as AssetWorkspaceAssetInspectionError, Rx as AssetWorkspacePathValidationError, Tx as AssetAttachmentNotFoundError, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, jx as AssetProjectFaviconResolutionError, kx as AssetProjectFaviconInspectionError, on as EnvironmentRpcUnavailableError, zT as EnvironmentId, zx as AssetWorkspaceResolutionError } from "../../shared.js";
+import { CD as EnvironmentId, Ta as EnvironmentRegistry, _C as AssetWorkspaceContextNotFoundError, bC as AssetWorkspaceResolutionError, dC as AssetProjectFaviconNotFoundError, fC as AssetProjectFaviconResolutionError, gC as AssetWorkspaceAssetNotFoundError, hC as AssetWorkspaceAssetInspectionError, iD as EnvironmentAuthorizationError, lC as AssetPreviewTypeValidationError, mC as AssetSigningKeyLoadError, mn as EnvironmentRpcUnavailableError, oC as AssetAttachmentNotFoundError, pC as AssetResource, uC as AssetProjectFaviconInspectionError, vC as AssetWorkspaceContextResolutionError, xC as AssetWorkspaceRootNormalizationError, yC as AssetWorkspacePathValidationError } from "../../shared.js";
 import * as Schema from "effect/Schema";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/assets.d.ts
@@ -14,19 +14,24 @@ declare function resolveAssetUrl(httpBaseUrl: string, relativeUrl: string): stri
 declare function createAssetEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
   createUrl: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: Schema.Struct.ReadonlyMakeIn<{
-      readonly resource: Schema.Union<readonly [Schema.TaggedStruct<"workspace-file", {
-        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ThreadId">;
-        readonly path: Schema.decodeTo<Schema.String, Schema.String, never, never>;
-      }>, Schema.TaggedStruct<"attachment", {
-        readonly attachmentId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
-      }>, Schema.TaggedStruct<"project-favicon", {
-        readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
-      }>]>;
-    }>;
+    readonly input: {
+      readonly resource: {
+        readonly _tag?: "workspace-file";
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly path: string;
+      } | {
+        readonly _tag?: "attachment";
+        readonly attachmentId: string;
+      } | {
+        readonly _tag?: "project-favicon";
+        readonly cwd: string;
+        readonly path?: string | undefined;
+      };
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly relativeUrl: string;
     readonly expiresAt: number;
+    readonly sourcePath?: string | undefined;
   }, E | AssetAttachmentNotFoundError | AssetPreviewTypeValidationError | AssetProjectFaviconInspectionError | AssetProjectFaviconNotFoundError | AssetProjectFaviconResolutionError | AssetSigningKeyLoadError | AssetWorkspaceAssetInspectionError | AssetWorkspaceAssetNotFoundError | AssetWorkspaceContextNotFoundError | AssetWorkspaceContextResolutionError | AssetWorkspacePathValidationError | AssetWorkspaceResolutionError | AssetWorkspaceRootNormalizationError | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   createUrls: (target: {
     readonly environmentId: EnvironmentId;
@@ -34,6 +39,7 @@ declare function createAssetEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Env
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly relativeUrl: string;
     readonly expiresAt: number;
+    readonly sourcePath?: string | undefined;
   }, E | AssetAttachmentNotFoundError | AssetPreviewTypeValidationError | AssetProjectFaviconInspectionError | AssetProjectFaviconNotFoundError | AssetProjectFaviconResolutionError | AssetSigningKeyLoadError | AssetWorkspaceAssetInspectionError | AssetWorkspaceAssetNotFoundError | AssetWorkspaceContextNotFoundError | AssetWorkspaceContextResolutionError | AssetWorkspacePathValidationError | AssetWorkspaceResolutionError | AssetWorkspaceRootNormalizationError | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>[]>;
 };
 //#endregion

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, GT as Defect, Gr as family, JS as EnvironmentId, Jr as setIdleTTL, QT as String, WT as ArraySchema, Xr as withLabel, eE as TaggedErrorClass, fr as createEnvironmentRpcQueryAtomFamily, oE as decodeUnknownSync, ou as AssetResource, qr as make, tE as Tuple } from "../../shared.js";
+import { $r as make, AD as TaggedErrorClass, Cw as EnvironmentId, Iu as AssetResource, LD as decodeUnknownSync, OD as String, Us as WS_METHODS, Zr as family, bD as ArraySchema, ei as setIdleTTL, gr as createEnvironmentRpcQueryAtomFamily, jD as Tuple, ni as withLabel, xD as Defect } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/assets.ts
 const ASSET_URL_REFRESH_INTERVAL_MS = 30 * 6e4;
 const ASSET_URL_STALE_TIME_MS = 5 * 6e4;

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

@@ -1,4 +1,4 @@
-import { Bw as AuthAccessStreamError, Lw as AuthAccessSnapshot, Vw as AuthAccessStreamEvent, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, zT as EnvironmentId } from "../../shared.js";
+import { CD as EnvironmentId, TE as AuthAccessStreamEvent, Ta as EnvironmentRegistry, iD as EnvironmentAuthorizationError, wE as AuthAccessStreamError, xE as AuthAccessSnapshot } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/auth.d.ts
 declare const EMPTY_AUTH_ACCESS_SNAPSHOT: AuthAccessSnapshot;

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, Ur as subscribe, hr as createEnvironmentSubscriptionAtomFamily, qE as mapAccum } from "../../shared.js";
+import { NO as mapAccum, Us as WS_METHODS, Yr as subscribe, yr as createEnvironmentSubscriptionAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/auth.ts
 const EMPTY_AUTH_ACCESS_SNAPSHOT = {
 	pairingLinks: [],

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

@@ -1,4 +1,4 @@
-import { $D as flatMap, Aa as EnvironmentSupervisor, Fk as getOrElse, Gr as family, KE as map$1, Oa as EnvironmentRegistry, Sv as changes, Xr as withLabel, gr as createRuntimeCommand, lD as unwrap, lr as createAtomCommandScheduler, qr as make, ti as value, uO as map, us as AVAILABLE_CONNECTION_STATE, xr as followStreamInEnvironment } from "../../shared.js";
+import { $r as make, Gk as map, Ia as EnvironmentSupervisor, MO as map$1, Nk as flatMap, Pa as EnvironmentRegistry, Py as changes, Sj as getOrElse, Tr as followStreamInEnvironment, YO as unwrap, Zr as family, _s as AVAILABLE_CONNECTION_STATE, br as createRuntimeCommand, ni as withLabel, pr as createAtomCommandScheduler, si as value } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/connections.ts
 const EMPTY_ENVIRONMENT_CATALOG_STATE = Object.freeze({
 	isReady: false,

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

@@ -1,4 +1,4 @@
-import { Mw as ScopedThreadRef, jw as ScopedProjectRef } from "../../shared.js";
+import { hE as ScopedThreadRef, mE as ScopedProjectRef } from "../../shared.js";
 import * as Schema from "effect/Schema";
 //#region upstream-t3code/packages/client-runtime/src/state/entities.d.ts
 declare const InvalidScopedProjectKeyError_base: Schema.Class<InvalidScopedProjectKeyError, Schema.TaggedStruct<"InvalidScopedProjectKeyError", {

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

@@ -1,2 +1,2 @@
-import { $t as projectRefCollectionKey, Gt as InvalidScopedProjectKeyError, Jt as arrayElementsEqual, Kt as InvalidScopedProjectRefCollectionKeyError, Qt as projectKey, Xt as parseProjectRefCollectionKey, Yt as parseProjectKey, Zt as parseThreadKey, en as projectRefsEqual, nn as threadRefsEqual, qt as InvalidScopedThreadKeyError, tn as threadKey } from "../../shared.js";
+import { $t as projectKey, Jt as InvalidScopedThreadKeyError, Kt as InvalidScopedProjectKeyError, Qt as parseThreadKey, Xt as parseProjectKey, Yt as arrayElementsEqual, Zt as parseProjectRefCollectionKey, en as projectRefCollectionKey, nn as threadKey, qt as InvalidScopedProjectRefCollectionKeyError, rn as threadRefsEqual, tn as projectRefsEqual } from "../../shared.js";
 export { InvalidScopedProjectKeyError, InvalidScopedProjectRefCollectionKeyError, InvalidScopedThreadKeyError, arrayElementsEqual, parseProjectKey, parseProjectRefCollectionKey, parseThreadKey, projectKey, projectRefCollectionKey, projectRefsEqual, threadKey, threadRefsEqual };

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

@@ -1,4 +1,4 @@
-import { Hx as FilesystemBrowseError, Vx as FilesystemBrowseEntry, Wi as EnvironmentConnectionPhase, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, on as EnvironmentRpcUnavailableError, zT as EnvironmentId } from "../../shared.js";
+import { CC as FilesystemBrowseError, CD as EnvironmentId, SC as FilesystemBrowseEntry, Ta as EnvironmentRegistry, ea as EnvironmentConnectionPhase, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/filesystem.d.ts
 declare function getFilesystemBrowsePath(query: string, platform?: string, enabled?: boolean): {

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, It as getBrowseDirectoryPath, Lt as getBrowseLeafPathSegment, Nt as canNavigateUp, Rt as getBrowseParentPath, Vt as isFilesystemBrowseQuery, fr as createEnvironmentRpcQueryAtomFamily, zt as hasTrailingPathSeparator } from "../../shared.js";
+import { Bt as hasTrailingPathSeparator, Ht as isFilesystemBrowseQuery, Lt as getBrowseDirectoryPath, Pt as canNavigateUp, Rt as getBrowseLeafPathSegment, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, zt as getBrowseParentPath } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/filesystem.ts
 function getFilesystemBrowsePath(query, platform = "", enabled = true) {
 	const isBrowsing = enabled && isFilesystemBrowseQuery(query, platform);

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

@@ -1,13 +1,13 @@
-import { AS as GitPullRequestMaterializationError, BS as TextGenerationError, ES as GitManagerError, TS as GitCommandError, bT as EnvironmentAuthorizationError, f as AtomCommand, hC as SourceControlProviderError, ha as EnvironmentRegistry, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, zT as EnvironmentId } from "../../shared.js";
+import { CD as EnvironmentId, Cw as TextGenerationError, Qw as SourceControlProviderError, Ta as EnvironmentRegistry, cw as GitCommandError, f as AtomCommand, iD as EnvironmentAuthorizationError, lw as GitManagerError, mn as EnvironmentRpcUnavailableError, pw as GitPullRequestMaterializationError, wa as EnvironmentNotRegisteredError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/git.d.ts
 declare function createGitEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
   pullRequestResolution: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly reference: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly reference: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly pullRequest: {
       readonly number: number;

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, St as vcsCommandScheduler, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, xt as vcsCommandConcurrency } from "../../shared.js";
+import { St as vcsCommandScheduler, Us as WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, xt as vcsCommandConcurrency } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/git.ts
 function createGitEnvironmentAtoms(runtime) {
 	return {

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

@@ -1,2 +1,2 @@
-import { at as EnvironmentThreadShell, ct as scopeThreadShell, it as EnvironmentThread, lt as selectEnvironmentThreadShell, nt as EnvironmentMessage, ot as scopeProject, rt as EnvironmentProject, st as scopeThread } from "../../shared.js";
+import { at as EnvironmentProject, ct as scopeProject, dt as selectEnvironmentThreadShell, it as EnvironmentMessage, lt as scopeThread, ot as EnvironmentThread, st as EnvironmentThreadShell, ut as scopeThreadShell } from "../../shared.js";
 export { EnvironmentMessage, EnvironmentProject, EnvironmentThread, EnvironmentThreadShell, scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

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

@@ -1,2 +1,2 @@
-import { ar as scopeProject, cr as selectEnvironmentThreadShell, or as scopeThread, sr as scopeThreadShell } from "../../shared.js";
+import { dr as scopeThreadShell, fr as selectEnvironmentThreadShell, lr as scopeProject, ur as scopeThread } from "../../shared.js";
 export { scopeProject, scopeThread, scopeThreadShell, selectEnvironmentThreadShell };

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

@@ -1,4 +1,4 @@
-import { K_ as OrchestrationGetSnapshotError, U_ as OrchestrationGetFullThreadDiffError, bT as EnvironmentAuthorizationError, ha as EnvironmentRegistry, on as EnvironmentRpcUnavailableError, q_ as OrchestrationGetTurnDiffError, zT as EnvironmentId } from "../../shared.js";
+import { CD as EnvironmentId, Cy as OrchestrationSearchThreadsError, Ta as EnvironmentRegistry, iD as EnvironmentAuthorizationError, mn as EnvironmentRpcUnavailableError, oy as OrchestrationGetSnapshotError, ry as OrchestrationGetFullThreadDiffError, sy as OrchestrationGetTurnDiffError, uy as OrchestrationGetWorkflowScriptError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/orchestration.d.ts
 declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
@@ -16,6 +16,17 @@ declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRun
     readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
     readonly diff: string;
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetTurnDiffError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  workflowScript: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly scriptPath: string;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly scriptPath: string;
+    readonly contents: string;
+    readonly truncated: boolean;
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetWorkflowScriptError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   fullThreadDiff: (target: {
     readonly environmentId: EnvironmentId;
     readonly input: {
@@ -29,9 +40,24 @@ declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRun
     readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
     readonly diff: string;
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetFullThreadDiffError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
+  threadSearch: (target: {
+    readonly environmentId: EnvironmentId;
+    readonly input: {
+      readonly query: string;
+      readonly limit?: number;
+    };
+  }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
+    readonly matches: readonly {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+      readonly source: "assistant" | "user";
+      readonly snippet: string;
+      readonly messageCreatedAt: string | null;
+    }[];
+  }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationSearchThreadsError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   archivedShellSnapshot: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly snapshotSequence: number;
     readonly projects: readonly {
@@ -59,6 +85,8 @@ declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRun
           readonly value: string | boolean;
         }[];
       } | null;
+      readonly defaultThreadEnvMode?: "local" | "worktree" | null | undefined;
+      readonly faviconPath?: string | null | undefined;
       readonly scripts: readonly {
         readonly id: string;
         readonly name: string;
@@ -106,6 +134,12 @@ declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRun
       readonly settledAt: string | null;
       readonly snoozedUntil?: string | null | undefined;
       readonly snoozedAt?: string | null | undefined;
+      readonly pinnedAt?: string | null | undefined;
+      readonly pinOrderKey?: string | null | undefined;
+      readonly titleRegeneration?: {
+        readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+        readonly startedAt: string;
+      } | null | undefined;
       readonly session: {
         readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
         readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
@@ -120,6 +154,12 @@ declare function createOrchestrationEnvironmentAtoms<R, E>(runtime: Atom.AtomRun
       readonly hasPendingApprovals: boolean;
       readonly hasPendingUserInput: boolean;
       readonly hasActionableProposedPlan: boolean;
+      readonly backgroundLiveness?: "monitoring" | "working" | null | undefined;
+      readonly planProgress?: {
+        readonly step: string;
+        readonly completedSteps: number;
+        readonly totalSteps: number;
+      } | null | undefined;
     }[];
     readonly updatedAt: string;
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | OrchestrationGetSnapshotError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;

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

@@ -1,4 +1,4 @@
-import { fr as createEnvironmentRpcQueryAtomFamily, ky as ORCHESTRATION_WS_METHODS } from "../../shared.js";
+import { Vb as ORCHESTRATION_WS_METHODS, gr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/orchestration.ts
 function createOrchestrationEnvironmentAtoms(runtime) {
 	return {
@@ -6,10 +6,22 @@ function createOrchestrationEnvironmentAtoms(runtime) {
 			label: "environment-data:orchestration:turn-diff",
 			tag: ORCHESTRATION_WS_METHODS.getTurnDiff
 		}),
+		workflowScript: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:orchestration:workflow-script",
+			tag: ORCHESTRATION_WS_METHODS.getWorkflowScript,
+			staleTimeMs: 3e5,
+			idleTtlMs: 3e5
+		}),
 		fullThreadDiff: createEnvironmentRpcQueryAtomFamily(runtime, {
 			label: "environment-data:orchestration:full-thread-diff",
 			tag: ORCHESTRATION_WS_METHODS.getFullThreadDiff
 		}),
+		threadSearch: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:orchestration:thread-search",
+			tag: ORCHESTRATION_WS_METHODS.searchThreads,
+			staleTimeMs: 3e4,
+			idleTtlMs: 6e4
+		}),
 		archivedShellSnapshot: createEnvironmentRpcQueryAtomFamily(runtime, {
 			label: "environment-data:orchestration:archived-shell-snapshot",
 			tag: ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot

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

@@ -1,4 +1,4 @@
-import { Ao as ConnectionCatalogEntry, Fl as ServerConfig, Gi as EnvironmentConnectionPresentation, Ki as EnvironmentPresentation, Ku as KeybindingWhenNode, os as SupervisorConnectionState, u as EnvironmentCatalogState, zT as EnvironmentId } from "../../shared.js";
+import { Bo as ConnectionCatalogEntry, CD as EnvironmentId, Td as KeybindingWhenNode, du as ServerConfig, gs as SupervisorConnectionState, na as EnvironmentPresentation, ta as EnvironmentConnectionPresentation, u as EnvironmentCatalogState } from "../../shared.js";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/presentation.d.ts
 declare function createEnvironmentPresentationAtoms<E>(input: {
@@ -24,7 +24,11 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
           readonly connectionProbe?: boolean;
           readonly threadSettlement?: boolean;
           readonly threadSnooze?: boolean;
+          readonly threadPinning?: boolean;
+          readonly threadPinReorder?: boolean;
+          readonly threadTitleRegeneration?: boolean;
           readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+          readonly serverSelfUpdateProgress?: boolean;
         };
       };
       readonly auth: {
@@ -36,7 +40,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
       readonly cwd: string;
       readonly keybindingsConfigPath: string;
       readonly keybindings: readonly {
-        readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+        readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
         readonly shortcut: {
           readonly key: string;
           readonly metaKey: boolean;
@@ -101,6 +105,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
           readonly subProvider?: string | undefined;
           readonly isCustom: boolean;
           readonly isDefault?: boolean | undefined;
+          readonly isLegacy?: boolean | undefined;
           readonly capabilities: {
             readonly optionDescriptors?: readonly ({
               readonly id: string;
@@ -167,7 +172,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
         readonly otlpMetricsEnabled: boolean;
       };
       readonly settings: {
-        readonly enableAssistantStreaming: boolean;
+        readonly enableLegacyTokenStreaming: boolean;
         readonly enableProviderUpdateChecks: boolean;
         readonly backgroundActivity: {
           readonly schemaVersion: 1;
@@ -269,6 +274,7 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
       };
       readonly shellResumeCompletionMarker?: boolean;
       readonly threadResumeCompletionMarker?: boolean;
+      readonly threadSnapshotPagination?: boolean;
     } | null;
   } | null>;
   presentationsAtom: Atom.Atom<ReadonlyMap<string & import("effect/Brand").Brand<"EnvironmentId">, EnvironmentPresentation>>;