t3code-cli 0.14.1 → 0.15.0

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 { Cr as T3ConfigSelection, Gi as layer$1, Wi as CliRuntime, er as T3CliEnvScope, tr as T3CliEnvShape } 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 { $D as humanJsonFormatChoices, $E as resolveThreadId, HD as modelFlags, Hs as selection_layer_exports, JD as threadFormatFlag, QD as canRenderLiveTerminal, QE as resolveProjectRef, UD as projectFlag, VD as formatFlag, WD as projectPathFlag, XD as worktreeFlag, YD as waitFormatFlag, ZE as resolveCommandProjectRef, eD as resolveWorktreePath, eO as humanJsonNdjsonFormatChoices, iD as layer, iO as resolveOutputFormat, nO as isAgentEnvironment, nc as cliEnvironmentSetting, qD as threadFlag, rD as CliRuntime, rO as isInteractiveHumanTerminal, tO as humanNdjsonFormatChoices } 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 { $a as RemoteEnvironmentAuthInvalidJsonError, Ga as exchangeRemoteDpopAccessToken, Ja as issueRemoteDpopWebSocketTicket, Ka as fetchRemoteDpopSessionState, Qa as RemoteEnvironmentAuthFetchError, Ua as RemoteEnvironmentAuthError, Wa as bootstrapRemoteBearerSession, Xa as resolveRemoteDpopWebSocketConnectionUrl, Ya as issueRemoteWebSocketTicket, Za as resolveRemoteWebSocketConnectionUrl, _o as RelayEnvironmentAuthorization, bo as tokenStore_d_exports, eo as RemoteEnvironmentAuthTimeoutError, go as AuthorizedRemoteEnvironment, qa as fetchRemoteSessionState, to as RemoteEnvironmentAuthUndeclaredStatusError, vo as RemoteEnvironmentAuthorization } 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 RemoteEnvironmentAuthorization, Ao as exchangeRemoteDpopAccessToken, Bo as RemoteEnvironmentAuthUndeclaredStatusError, Fo as resolveRemoteDpopWebSocketConnectionUrl, Io as resolveRemoteWebSocketConnectionUrl, Lo as RemoteEnvironmentAuthFetchError, Mo as fetchRemoteSessionState, No as issueRemoteDpopWebSocketTicket, Po as issueRemoteWebSocketTicket, Ro as RemoteEnvironmentAuthInvalidJsonError, jo as fetchRemoteDpopSessionState, ko as bootstrapRemoteBearerSession, to as tokenStore_exports, zo as RemoteEnvironmentAuthTimeoutError } 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 connectionRegistrationCatalogEntry, Aa as EnvironmentSupervisor, Ba as mapManagedRelayError, Bo as connectivity_d_exports, Ca as prepareSshRegistration, Da as EnvironmentNotRegisteredError, Ea as updateBearerConnection, Go as ConnectionCredential, Ha as profileMissingError, Ho as BearerConnectionProfile, Jo as PlatformConnectionRegistration, Ko as ConnectionProfile, Ma as wakeups_d_exports, Oa as EnvironmentRegistry, Qo as SshConnectionRegistration, Ra as credentialMissingError, Sa as preparePairingRegistration, Ta as registerSshConnection, Uo as BearerConnectionRegistration, Va as mapRemoteEnvironmentError, Vo as BearerConnectionCredential, Wo as ConnectionCatalogEntry, Xo as RelayConnectionRegistration, Yo as PrimaryConnectionRegistration, Zo as SshConnectionProfile, _a as BearerConnectionUpdateInput, _s as RelayConnectionTarget, aa as EnvironmentPresentation, as as ConnectionBlockedError, ba as SshConnectionInput, bs as SupervisorConnectionState, ca as connectionStatusText, co as ConnectionDriverProgress, cs as ConnectionTarget, da as presentEnvironmentConnection, ds as ConnectionTransientReason, es as connectionRegistrationTarget, fa as layer_d_exports, fs as NetworkStatus, gs as PrimaryConnectionTarget, ho as profileStore_d_exports, hs as PreparedHttpAuthorization, ia as EnvironmentConnectionPresentation, is as ConnectionAttemptStage, ja as EnvironmentSupervisorOptions, ka as PlatformEnvironmentRemovalError, la as connectionStatusTitle, lo as EnvironmentConnectionLease, ls as ConnectionTargetKind, mo as ConnectionResolver, ms as PreparedConnection, ns as BearerConnectionTarget, oa as connectionCatalogDisplayUrl, os as ConnectionBlockedReason, ps as PersistedConnectionTarget, qo as ConnectionRegistration, ra as EnvironmentConnectionPhase, rs as ConnectionAttemptError, sa as connectionPhaseMessage, so as ConnectionDriver, ss as ConnectionProjectionPhase, ts as AVAILABLE_CONNECTION_STATE, ua as presentConnectionState, us as ConnectionTransientError, va as ConnectionOnboarding, vs as SshConnectionTarget, wa as registerPairingConnection, xa as prepareBearerConnectionUpdate, xs as connectionProjectionPhase, ya as PairingConnectionInput, ys as SupervisorConnectionPhase, za as environmentMismatchError, zo as credentialStore_d_exports } 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 { As as SshConnectionTarget, Cs as ConnectionBlockedReason, Do as mapRemoteEnvironmentError, Ds as PersistedConnectionTarget, Eo as mapManagedRelayError, Es as ConnectionTransientReason, Fa as EnvironmentNotRegisteredError, Ia as EnvironmentRegistry, Ja as ConnectionDriver, La as PlatformEnvironmentRemovalError, Oo as profileMissingError, Os as PrimaryConnectionTarget, Qa as profileStore_exports, Ra as EnvironmentSupervisor, Sa as updateBearerConnection, Ss as ConnectionBlockedError, To as environmentMismatchError, Ts as ConnectionTransientError, Va as wakeups_exports, Za as ConnectionResolver, _a as prepareBearerConnectionUpdate, _s as SshConnectionRegistration, aa as connectionCatalogDisplayUrl, as as credentialStore_exports, ba as registerPairingConnection, bs as AVAILABLE_CONNECTION_STATE, ca as connectionStatusTitle, cs as BearerConnectionProfile, da as layer_exports, ds as ConnectionProfile, fs as ConnectionRegistration, ga as ConnectionOnboarding, gs as SshConnectionProfile, hs as RelayConnectionRegistration, js as connectionProjectionPhase, ks as RelayConnectionTarget, la as presentConnectionState, ls as BearerConnectionRegistration, ms as PrimaryConnectionRegistration, oa as connectionPhaseMessage, os as connectivity_exports, ps as PlatformConnectionRegistration, sa as connectionStatusText, ss as BearerConnectionCredential, ua as presentEnvironmentConnection, us as ConnectionCredential, va as preparePairingRegistration, vs as connectionRegistrationCatalogEntry, wo as credentialMissingError, ws as ConnectionTarget, xa as registerSshConnection, xs as BearerConnectionTarget, ya as prepareSshRegistration, ys as connectionRegistrationTarget } 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 { An as normalizeHttpBaseUrl, Dn as classifyHostedHttpsCompatibility, Ek as ProjectId, En as CreateAdvertisedEndpointInput, Nk as ThreadId, On as createAdvertisedEndpoint, kn as deriveWsBaseUrl, lO as ScopedProjectRef, no as RemoteEnvironmentRequestError, rO as ExecutionEnvironmentDescriptor, uO as ScopedThreadRef, vk as EnvironmentId } from "../shared.js";
 import * as Effect from "effect/Effect";
 //#region upstream-t3code/packages/client-runtime/src/environment/descriptor.d.ts
 declare const fetchRemoteEnvironmentDescriptor: (input: {
@@ -15,9 +15,15 @@ declare const fetchRemoteEnvironmentDescriptor: (input: {
   readonly capabilities: {
     readonly repositoryIdentity: boolean;
     readonly connectionProbe?: boolean;
+    readonly pullRequests?: 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 agentActivityPublishing?: 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 { Co as fetchRemoteEnvironmentDescriptor, Jo as createAdvertisedEndpoint, Ko as environmentEndpointUrl, Xo as normalizeHttpBaseUrl, Yo as deriveWsBaseUrl, _i as scopedProjectKey, bi as attachEnvironmentDescriptor, gi as scopeThreadRef, hi as scopeProjectRef, mi as parseScopedThreadKey, pi as parseScopedProjectKey, qo as classifyHostedHttpsCompatibility, vi as scopedRefKey, xi as createKnownEnvironment, yi as scopedThreadKey } 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 { Ha 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 buildProjectCreateCommand, G as AddProjectCloneFlow, J as AddProjectRemoteSourceReadiness, K as AddProjectRemoteProviderKind, Q as buildAddProjectRemoteSourceReadiness, X as addProjectRemoteSourcePathHint, Y as addProjectRemoteSourceLabel, Z as addProjectRemoteSourceProvider, et as canCreateProjectInEnvironment, it as sortAddProjectProviderSources, nt as getAddProjectInitialQuery, q as AddProjectRemoteSource, rt as resolveAddProjectPath, tt as findExistingAddProject } 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 buildProjectCreateCommand, $t as unarchiveThread, At as UnarchiveThreadInput, Bt as deleteThread, Ct as RevertThreadCheckpointInput, Dt as SnoozeThreadInput, Et as SettleThreadInput, Ft as UpdateThreadMetadataInput, G as AddProjectCloneFlow, Gt as respondToThreadUserInput, Ht as pinThread, It as archiveThread, J as AddProjectRemoteSourceReadiness, Jt as setThreadRuntimeMode, K as AddProjectRemoteProviderKind, Kt as revertThreadCheckpoint, Lt as createProject, Mt as UnsettleThreadInput, Nt as UnsnoozeThreadInput, Ot as StartThreadTurnInput, Pt as UpdateProjectInput, Q as buildAddProjectRemoteSourceReadiness, Qt as stopThreadSession, Rt as createThread, St as RespondToThreadUserInputInput, Tt as SetThreadRuntimeModeInput, Ut as reorderPinnedThread, Vt as interruptThreadTurn, Wt as respondToThreadApproval, X as addProjectRemoteSourcePathHint, Xt as snoozeThread, Y as addProjectRemoteSourceLabel, Yt as settleThread, Z as addProjectRemoteSourceProvider, Zt as startThreadTurn, _t as DeleteThreadInput, bt as ReorderPinnedThreadInput, en as unpinThread, et as canCreateProjectInEnvironment, gt as DeleteProjectInput, ht as CreateThreadInput, in as updateThreadMetadata, it as sortAddProjectProviderSources, jt as UnpinThreadInput, kt as StopThreadSessionInput, mt as CreateProjectInput, nn as unsnoozeThread, nt as getAddProjectInitialQuery, pt as ArchiveThreadInput, q as AddProjectRemoteSource, qt as setThreadInteractionMode, rn as updateProject, rt as resolveAddProjectPath, tn as unsettleThread, tt as findExistingAddProject, vt as InterruptThreadTurnInput, wt as SetThreadInteractionModeInput, xt as RespondToThreadApprovalInput, yt as PinThreadInput, zt as deleteProject } 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 { Fa as ConnectionTargetStore, Fo as ProvisionedSshEnvironment, Ho as BearerConnectionProfile, Ia as EnvironmentCacheStore, Io as RelayDeviceIdentity, La as EnvironmentOwnedDataCleanup, Lo as SshEnvironmentGateway, Mo as CloudSession, Na as ConnectionPersistenceError, No as PreparedSshEnvironment, Pa as ConnectionRegistrationStore, Po as PrimaryEnvironmentAuth, Vo as BearerConnectionCredential, Zo as SshConnectionProfile, _s as RelayConnectionTarget, cs as ConnectionTarget, ga as PlatformConnectionSource, jo as ClientPresentation, ns as BearerConnectionTarget, qo as ConnectionRegistration, vs as SshConnectionTarget, yo as RemoteDpopAccessToken } 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 { Dk as ArraySchema, Ds as PersistedConnectionTarget, Ga as ConnectionTargetStore, Ka as EnvironmentCacheStore, Lk as String, Mk as Literal, Rk as Struct, So as SshEnvironmentGateway, Ua as ConnectionPersistenceError, Wa as ConnectionRegistrationStore, bo as PrimaryEnvironmentAuth, ds as ConnectionProfile, eo as RemoteDpopAccessToken, ha as PlatformConnectionSource, qa as EnvironmentOwnedDataCleanup, us as ConnectionCredential, vo as ClientPresentation, xo as RelayDeviceIdentity, yo as CloudSession } 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 { Ao as managedRelay_d_exports, Co as ManagedRelayDpopKeyLoadError, Do as ManagedRelayRequestTimeoutError, Eo as ManagedRelayRequestProofCreationError, Oo as ManagedRelayTokenProofCreationError, Ro as RelayClientEnvironmentRecord, So as ManagedRelayClient, To as ManagedRelayRequestFailedError, ha as discovery_d_exports, ko as ManagedRelayUrlInvalidError, vk as EnvironmentId, xo as ManagedRelayAccessTokenScopesUnexpectedError } from "../shared.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Cause from "effect/Cause";
@@ -45,6 +45,11 @@ declare function createManagedRelaySession(input: ManagedRelaySessionInput): Man
 declare function setManagedRelaySession(registry: AtomRegistry.AtomRegistry, input: ManagedRelaySessionInput | null): void;
 declare function managedRelayAccountChanges(registry: AtomRegistry.AtomRegistry): Stream.Stream<string | null>;
 declare const waitForManagedRelayClerkToken: (registry: AtomRegistry.AtomRegistry) => Effect.Effect<string, ManagedRelaySessionError, never>;
+/** Removes an environment from the signed-in account without contacting that environment. */
+declare const deregisterManagedRelayEnvironment: (registry: AtomRegistry.AtomRegistry, input: {
+  readonly accountId: string;
+  readonly environmentId: EnvironmentId;
+}) => Effect.Effect<undefined, ManagedRelayAccessTokenScopesUnexpectedError | ManagedRelayDpopKeyLoadError | ManagedRelayRequestFailedError | ManagedRelayRequestProofCreationError | ManagedRelayRequestTimeoutError | ManagedRelaySessionError | ManagedRelayTokenProofCreationError | ManagedRelayUrlInvalidError, ManagedRelayClient>;
 declare function readManagedRelaySnapshotState<A>(result: AsyncResult.AsyncResult<A, unknown>): ManagedRelaySnapshotState<A>;
 declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<ManagedRelayClient>, options?: {
   readonly staleTimeMs?: number;
@@ -102,9 +107,15 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
       readonly capabilities: {
         readonly repositoryIdentity: boolean;
         readonly connectionProbe?: boolean;
+        readonly pullRequests?: 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 agentActivityPublishing?: boolean;
       };
     } | undefined;
     readonly error?: string | undefined;
@@ -118,4 +129,4 @@ declare function createManagedRelayQueryManager(runtime: Atom.AtomRuntime<Manage
   }): void;
 };
 //#endregion
-export { discovery_d_exports as Discovery, managedRelay_d_exports as ManagedRelay, ManagedRelayQueryEvent, ManagedRelaySession, ManagedRelaySessionError, ManagedRelaySessionInput, ManagedRelaySnapshotError, ManagedRelaySnapshotState, createManagedRelayQueryManager, createManagedRelaySession, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };
+export { discovery_d_exports as Discovery, managedRelay_d_exports as ManagedRelay, ManagedRelayQueryEvent, ManagedRelaySession, ManagedRelaySessionError, ManagedRelaySessionInput, ManagedRelaySnapshotError, ManagedRelaySnapshotState, createManagedRelayQueryManager, createManagedRelaySession, deregisterManagedRelayEnvironment, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };

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 { BM as currentTimeMillis, CM as sync, FA as drop, Gj as flatMap, Gr as keepAlive, HM as TaggedError, JM as squash, Jr as swr, Kj as fn, Kr as make, Lb as RelayEnvironmentConnectScope, OM as tryPromise, Pj as callback, Pn as findErrorTraceId, Qj as gen, RN as getOrNull, Rb as RelayEnvironmentStatusScope, UA as map, Uj as fail, Wr as family, Yr as withLabel, Zr as toStream, cM as onExit, ei as value, io as managedRelay_exports, jA as changes, ma as discovery_exports, mo as decodeRelayJwt, no as ManagedRelayClient, qr as setIdleTTL, xM as succeed } 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;
@@ -100,6 +100,16 @@ const waitForManagedRelayClerkToken = fn("clientRuntime.managedRelaySession.wait
 		return sync(() => unsubscribe?.());
 	});
 });
+/** Removes an environment from the signed-in account without contacting that environment. */
+const deregisterManagedRelayEnvironment = fn("clientRuntime.managedRelaySession.deregisterEnvironment")(function* (registry, input) {
+	const session = registry.get(managedRelaySessionAtom);
+	if (!session || session.accountId !== input.accountId) return yield* new ManagedRelaySessionError({ message: "Sign in to T3 Connect before deregistering an environment." });
+	const clerkToken = yield* readSessionClerkToken(session);
+	yield* (yield* ManagedRelayClient).unlinkEnvironment({
+		clerkToken,
+		environmentId: input.environmentId
+	});
+});
 function requireClerkToken(get, accountId) {
 	const session = get(managedRelaySessionAtom);
 	if (!session || session.accountId !== accountId) return fail(new ManagedRelaySessionError({ message: "Sign in to T3 Connect before loading relay data." }));
@@ -242,4 +252,4 @@ function createManagedRelayQueryManager(runtime, options) {
 	};
 }
 //#endregion
-export { discovery_exports as Discovery, managedRelay_exports as ManagedRelay, ManagedRelaySessionError, ManagedRelaySnapshotError, createManagedRelayQueryManager, createManagedRelaySession, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };
+export { discovery_exports as Discovery, managedRelay_exports as ManagedRelay, ManagedRelaySessionError, ManagedRelaySnapshotError, createManagedRelayQueryManager, createManagedRelaySession, deregisterManagedRelayEnvironment, managedRelayAccountChanges, managedRelaySessionAtom, readManagedRelaySnapshotState, setManagedRelaySession, waitForManagedRelayClerkToken };

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 RemoteEnvironmentAuthInvalidJsonError, Cn as runStream, Qa as RemoteEnvironmentAuthFetchError, Sn as request, Tn as subscribeDynamic, _n as EnvironmentStreamRpcTag, an as EnvironmentRpcFailure, ao as makeEnvironmentHttpApiUrlBuilder, bn as config, cn as EnvironmentRpcRequestObserver, dn as EnvironmentRpcSubscriptionObservation, do as RpcSessionFactory, eo as RemoteEnvironmentAuthTimeoutError, fn as EnvironmentRpcSubscriptionObserver, fo as WsRpcProtocolClient, gn as EnvironmentStreamCommandRpcTag, hn as EnvironmentRpcUnavailableError, io as makeEnvironmentHttpApiClient, ln as EnvironmentRpcStreamFailure, mn as EnvironmentRpcTag, no as RemoteEnvironmentRequestError, on as EnvironmentRpcInput, oo as remoteHttpClientLayer, pn as EnvironmentRpcSuccess, po as makeWsRpcProtocolClient, ro as executeEnvironmentHttpRequest, sn as EnvironmentRpcRequestObservation, to as RemoteEnvironmentAuthUndeclaredStatusError, un as EnvironmentRpcStreamValue, uo as RpcSession, vn as EnvironmentSubscriptionRpcTag, wn as subscribe, xn as isRpcClientError, yn as EnvironmentUnaryRpcTag } 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, makeEnvironmentHttpApiUrlBuilder, 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 RemoteEnvironmentAuthUndeclaredStatusError, Ho as makeEnvironmentHttpApiClient, Lo as RemoteEnvironmentAuthFetchError, Ro as RemoteEnvironmentAuthInvalidJsonError, Uo as makeEnvironmentHttpApiUrlBuilder, Vo as executeEnvironmentHttpRequest, Wo as remoteHttpClientLayer, Xa as makeWsRpcProtocolClient, Ya as RpcSessionFactory, ai as isRpcClientError, ci as subscribe, ii as config, li as subscribeDynamic, ni as EnvironmentRpcSubscriptionObserver, oi as request, ri as EnvironmentRpcUnavailableError, si as runStream, ti as EnvironmentRpcRequestObserver, zo as RemoteEnvironmentAuthTimeoutError } from "../shared.js";
+export { EnvironmentRpcRequestObserver, EnvironmentRpcSubscriptionObserver, EnvironmentRpcUnavailableError, RemoteEnvironmentAuthFetchError, RemoteEnvironmentAuthInvalidJsonError, RemoteEnvironmentAuthTimeoutError, RemoteEnvironmentAuthUndeclaredStatusError, RpcSessionFactory, config, executeEnvironmentHttpRequest, isRpcClientError, makeEnvironmentHttpApiClient, makeEnvironmentHttpApiUrlBuilder, 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 { $C as AssetWorkspacePathValidationError, $O as EnvironmentAuthorizationError, BC as AssetAttachmentNotFoundError, GC as AssetProjectFaviconNotFoundError, JC as AssetSigningKeyLoadError, KC as AssetProjectFaviconResolutionError, Oa as EnvironmentRegistry, QC as AssetWorkspaceContextResolutionError, UC as AssetPreviewTypeValidationError, WC as AssetProjectFaviconInspectionError, XC as AssetWorkspaceAssetNotFoundError, YC as AssetWorkspaceAssetInspectionError, ZC as AssetWorkspaceContextNotFoundError, ew as AssetWorkspaceResolutionError, hn as EnvironmentRpcUnavailableError, qC as AssetResource, tw as AssetWorkspaceRootNormalizationError, vk as EnvironmentId } 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 { Bk as Tuple, Dk as ArraySchema, Kk as decodeUnknownSync, Kr as make, Lk as String, ME as EnvironmentId, Wr as family, Yr as withLabel, kk as Defect, lc as WS_METHODS, qr as setIdleTTL, vr as createEnvironmentRpcQueryAtomFamily, yd as AssetResource, zk as TaggedErrorClass } 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 { $O as EnvironmentAuthorizationError, Oa as EnvironmentRegistry, bO as AuthAccessStreamEvent, gO as AuthAccessSnapshot, vk as EnvironmentId, yO as AuthAccessStreamError } 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 { WA as mapAccum, ci as subscribe, lc as WS_METHODS, xr 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 { By as changes, Dr as followStreamInEnvironment, Gj as flatMap, Ia as EnvironmentRegistry, Kr as make, LN as getOrElse, Ra as EnvironmentSupervisor, Sr as createRuntimeCommand, UA as map$1, Wr as family, Yr as withLabel, bs as AVAILABLE_CONNECTION_STATE, ei as value, mr as createAtomCommandScheduler, rM as map, sj as unwrap } 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 { lO as ScopedProjectRef, uO as ScopedThreadRef } 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 { $O as EnvironmentAuthorizationError, Oa as EnvironmentRegistry, hn as EnvironmentRpcUnavailableError, nw as FilesystemBrowseEntry, ra as EnvironmentConnectionPhase, rw as FilesystemBrowseError, vk as EnvironmentId } 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, lc as WS_METHODS, vr 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 { $O as EnvironmentAuthorizationError, Da as EnvironmentNotRegisteredError, Hw as GitCommandError, Oa as EnvironmentRegistry, UD as SourceControlProviderError, Uw as GitManagerError, f as AtomCommand, hn as EnvironmentRpcUnavailableError, qw as GitPullRequestMaterializationError, rT as TextGenerationError, vk as EnvironmentId } 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;
@@ -37,6 +37,7 @@ declare function createGitEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<Envir
     };
     readonly branch: string;
     readonly worktreePath: string | null;
+    readonly isOnPullRequestHead: boolean;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | GitCommandError | GitManagerError | GitPullRequestMaterializationError | import("effect/unstable/rpc/RpcClientError").RpcClientError | SourceControlProviderError | TextGenerationError>;
 };
 //#endregion

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, _r as createEnvironmentRpcCommand, lc as WS_METHODS, vr as createEnvironmentRpcQueryAtomFamily, 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 EnvironmentMessage, ct as EnvironmentThreadShell, dt as scopeThreadShell, ft as selectEnvironmentThreadShell, lt as scopeProject, ot as EnvironmentProject, st as EnvironmentThread, ut as scopeThread } 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 scopeThread, fr as scopeThreadShell, pr as selectEnvironmentThreadShell, ur as scopeProject } 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 { $O as EnvironmentAuthorizationError, Ly as OrchestrationGetSnapshotError, Oa as EnvironmentRegistry, Py as OrchestrationGetFullThreadDiffError, Ry as OrchestrationGetTurnDiffError, Vy as OrchestrationGetWorkflowScriptError, eb as OrchestrationSearchThreadsError, hn as EnvironmentRpcUnavailableError, vk as EnvironmentId } 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>>;