t3code-cli 0.14.1 → 0.15.0

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

@@ -1,4 +1,4 @@
-import { fr as createEnvironmentRpcQueryAtomFamily, ky as ORCHESTRATION_WS_METHODS } from "../../shared.js";
+import { XS as ORCHESTRATION_WS_METHODS, vr 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 { Id as KeybindingWhenNode, Su as ServerConfig, Wo as ConnectionCatalogEntry, aa as EnvironmentPresentation, bs as SupervisorConnectionState, ia as EnvironmentConnectionPresentation, u as EnvironmentCatalogState, vk as EnvironmentId } 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: {
@@ -22,9 +22,15 @@ declare function createEnvironmentPresentationAtoms<E>(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;
         };
       };
       readonly auth: {
@@ -36,7 +42,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 +107,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;
@@ -158,6 +165,10 @@ declare function createEnvironmentPresentationAtoms<E>(input: {
         };
       }[];
       readonly availableEditors: readonly ("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[];
+      readonly remoteOpenTargets?: readonly {
+        readonly kind: "mdns" | "tailscale";
+        readonly host: string;
+      }[];
       readonly observability: {
         readonly logsDirectoryPath: string;
         readonly localTracingEnabled: boolean;
@@ -167,7 +178,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 +280,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>>;

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

@@ -1,4 +1,4 @@
-import { Fk as getOrElse, Gr as family, Xr as withLabel, na as presentEnvironmentConnection, qr as make, ti as value, us as AVAILABLE_CONNECTION_STATE } from "../../shared.js";
+import { Kr as make, LN as getOrElse, Wr as family, Yr as withLabel, bs as AVAILABLE_CONNECTION_STATE, ei as value, ua as presentEnvironmentConnection } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/presentation.ts
 function mapsEqual(left, right) {
 	if (left.size !== right.size) return false;

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

@@ -1,4 +1,4 @@
-import { Ab as PreviewSessionLookupError, Hy as PreviewAutomationRemoteUnavailableError, Iy as PreviewAutomationNoAvailableHostError, Jy as PreviewAutomationResultTooLargeError, My as PreviewAutomationInvalidSelectorError, Ny as PreviewAutomationMalformedResponseError, Oy as PreviewAutomationExecutionError, Wy as PreviewAutomationRequestQueueClosedError, bT as EnvironmentAuthorizationError, bb as PreviewInvalidUrlError, f as AtomCommand, ha as EnvironmentRegistry, ib as PreviewAutomationTimeoutError, ma as EnvironmentNotRegisteredError, ob as PreviewAutomationUnavailableError, on as EnvironmentRpcUnavailableError, rb as PreviewAutomationTargetNotEditableError, sb as PreviewAutomationUnsupportedClientError, tb as PreviewAutomationTabNotFoundError, wy as PreviewAutomationControlInterruptedError, yy as PreviewAutomationClientDisconnectedError, zT as EnvironmentId } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Ax as PreviewAutomationControlInterruptedError, Da as EnvironmentNotRegisteredError, Hx as PreviewAutomationNoAvailableHostError, Jx as PreviewAutomationRemoteUnavailableError, Oa as EnvironmentRegistry, Px as PreviewAutomationExecutionError, Rx as PreviewAutomationInvalidSelectorError, Tx as PreviewAutomationClientDisconnectedError, Xx as PreviewAutomationRequestQueueClosedError, eS as PreviewAutomationResultTooLargeError, f as AtomCommand, fS as PreviewAutomationUnavailableError, hn as EnvironmentRpcUnavailableError, kS as PreviewInvalidUrlError, lS as PreviewAutomationTargetNotEditableError, pS as PreviewAutomationUnsupportedClientError, sS as PreviewAutomationTabNotFoundError, uS as PreviewAutomationTimeoutError, vk as EnvironmentId, zS as PreviewSessionLookupError, zx as PreviewAutomationMalformedResponseError } from "../../shared.js";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.d.ts
 declare const previewAutomationHostFocusConcurrencyKey: (value: {
@@ -11,9 +11,9 @@ declare const previewAutomationHostFocusConcurrencyKey: (value: {
 declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
   list: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly sessions: readonly {
       readonly threadId: string;
@@ -56,7 +56,7 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   events: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {};
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly threadId: string;
     readonly tabId: string;
@@ -207,7 +207,9 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   discoveredServers: (target: {
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{}>;
+    readonly input: {
+      readonly configuredUrls?: readonly string[] | undefined;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly servers: readonly {
       readonly host: string;
@@ -221,6 +223,7 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
       } | null;
     }[];
     readonly scannedAt: string;
+    readonly configuredUrlProbing?: true | undefined;
   }, E | EnvironmentAuthorizationError | import("effect/Cause").NoSuchElementError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   automationRequests: (target: {
     readonly environmentId: EnvironmentId;
@@ -333,20 +336,22 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   resize: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly viewport: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"fill", {}>, import("effect/Schema").Struct<{
-        readonly _tag: import("effect/Schema").tag<"freeform">;
-        readonly width: import("effect/Schema").Int;
-        readonly height: import("effect/Schema").Int;
-      }>, import("effect/Schema").Struct<{
-        readonly _tag: import("effect/Schema").tag<"preset">;
-        readonly width: import("effect/Schema").Int;
-        readonly height: import("effect/Schema").Int;
-        readonly presetId: import("effect/Schema").Literals<readonly ["iphone-se", "iphone-xr", "iphone-12-pro", "iphone-14-pro-max", "pixel-7", "samsung-galaxy-s8-plus", "samsung-galaxy-s20-ultra", "ipad-mini", "ipad-air", "ipad-pro", "surface-pro-7", "surface-duo", "galaxy-z-fold-5", "asus-zenbook-fold", "samsung-galaxy-a51-71", "nest-hub", "nest-hub-max", "desktop-1920x1080", "desktop-1440x900", "laptop-1366x768", "laptop-1280x800", "ipad-pro-11", "iphone-15-pro", "pixel-8", "galaxy-s24"]>;
-      }>]>;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+      readonly viewport: {
+        readonly _tag?: "fill";
+      } | {
+        readonly _tag?: "freeform";
+        readonly width: number;
+        readonly height: number;
+      } | {
+        readonly _tag?: "preset";
+        readonly width: number;
+        readonly height: number;
+        readonly presetId: "asus-zenbook-fold" | "desktop-1440x900" | "desktop-1920x1080" | "galaxy-s24" | "galaxy-z-fold-5" | "ipad-air" | "ipad-mini" | "ipad-pro" | "ipad-pro-11" | "iphone-12-pro" | "iphone-14-pro-max" | "iphone-15-pro" | "iphone-se" | "iphone-xr" | "laptop-1280x800" | "laptop-1366x768" | "nest-hub" | "nest-hub-max" | "pixel-7" | "pixel-8" | "samsung-galaxy-a51-71" | "samsung-galaxy-s20-ultra" | "samsung-galaxy-s8-plus" | "surface-duo" | "surface-pro-7";
+      };
+    };
   }, {
     readonly threadId: string;
     readonly tabId: string;
@@ -385,10 +390,10 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   refresh: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   close: AtomCommand<{
     readonly environmentId: EnvironmentId;
@@ -399,24 +404,29 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   reportStatus: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly threadId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ThreadId">;
-      readonly tabId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly navStatus: import("effect/Schema").Union<readonly [import("effect/Schema").TaggedStruct<"Idle", {}>, import("effect/Schema").TaggedStruct<"Loading", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-      }>, import("effect/Schema").TaggedStruct<"Success", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-      }>, import("effect/Schema").TaggedStruct<"LoadFailed", {
-        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-        readonly title: import("effect/Schema").String;
-        readonly code: import("effect/Schema").Int;
-        readonly description: import("effect/Schema").String;
-      }>]>;
-      readonly canGoBack: import("effect/Schema").Boolean;
-      readonly canGoForward: import("effect/Schema").Boolean;
-    }>;
+    readonly input: {
+      readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+      readonly tabId: string;
+      readonly navStatus: {
+        readonly _tag?: "Idle";
+      } | {
+        readonly _tag?: "Loading";
+        readonly url: string;
+        readonly title: string;
+      } | {
+        readonly _tag?: "Success";
+        readonly url: string;
+        readonly title: string;
+      } | {
+        readonly _tag?: "LoadFailed";
+        readonly url: string;
+        readonly title: string;
+        readonly code: number;
+        readonly description: string;
+      };
+      readonly canGoBack: boolean;
+      readonly canGoForward: boolean;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewInvalidUrlError | PreviewSessionLookupError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   respondToAutomation: AtomCommand<{
     readonly environmentId: EnvironmentId;
@@ -435,12 +445,12 @@ declare function createPreviewEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | PreviewAutomationClientDisconnectedError | PreviewAutomationControlInterruptedError | PreviewAutomationExecutionError | PreviewAutomationInvalidSelectorError | PreviewAutomationMalformedResponseError | PreviewAutomationNoAvailableHostError | PreviewAutomationRemoteUnavailableError | PreviewAutomationRequestQueueClosedError | PreviewAutomationResultTooLargeError | PreviewAutomationTabNotFoundError | PreviewAutomationTargetNotEditableError | PreviewAutomationTimeoutError | PreviewAutomationUnavailableError | PreviewAutomationUnsupportedClientError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   focusAutomationHost: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly clientId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly environmentId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "EnvironmentId">;
-      readonly connectionId: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly focused: import("effect/Schema").Boolean;
-    }>;
+    readonly input: {
+      readonly clientId: string;
+      readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
+      readonly connectionId: string;
+      readonly focused: boolean;
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
 };
 //#endregion

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

@@ -1,4 +1,4 @@
-import { Fs as WS_METHODS, dr as createEnvironmentRpcCommand, fr as createEnvironmentRpcQueryAtomFamily, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily } from "../../shared.js";
+import { _r as createEnvironmentRpcCommand, br as createEnvironmentRpcSubscriptionAtomFamily, lc as WS_METHODS, mr as createAtomCommandScheduler, vr as createEnvironmentRpcQueryAtomFamily } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/preview.ts
 const previewAutomationHostFocusConcurrencyKey = (value) => JSON.stringify([
 	value.environmentId,
@@ -25,7 +25,8 @@ function createPreviewEnvironmentAtoms(runtime) {
 		}),
 		discoveredServers: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:preview:discovered-servers",
-			tag: WS_METHODS.subscribeDiscoveredLocalServers
+			tag: WS_METHODS.subscribeDiscoveredLocalServers,
+			idleTtlMs: 0
 		}),
 		automationRequests: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:preview:automation-requests",

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

@@ -1,4 +1,4 @@
-import { jw as ScopedProjectRef, l_ as SidebarProjectGroupingMode, rt as EnvironmentProject, wg as ClientSettings } from "../../shared.js";
+import { $_ as ClientSettings, ey as SidebarProjectGroupingMode, lO as ScopedProjectRef, ot as EnvironmentProject, vk as EnvironmentId } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.d.ts
 interface ProjectGroupingSettings {
   readonly sidebarProjectGroupingMode: SidebarProjectGroupingMode;
@@ -22,5 +22,29 @@ declare function deriveProjectGroupLabel(input: {
   readonly representative: Pick<EnvironmentProject, "title" | "repositoryIdentity">;
   readonly members: ReadonlyArray<Pick<EnvironmentProject, "title" | "repositoryIdentity">>;
 }): string;
+interface ProjectGroupMember<TProject extends EnvironmentProject = EnvironmentProject> {
+  readonly physicalProjectKey: string;
+  readonly project: TProject;
+}
+interface ProjectGroup<TProject extends EnvironmentProject = EnvironmentProject> {
+  readonly key: string;
+  readonly label: string;
+  readonly representative: TProject;
+  readonly members: ReadonlyArray<ProjectGroupMember<TProject>>;
+  readonly memberProjectRefs: ReadonlyArray<ScopedProjectRef>;
+}
+/**
+ * Builds logical project groups without losing the physical projects that
+ * remain the actual navigation and task-creation targets.
+ *
+ * Presentation-specific metadata, filtering, and activity sorting stay in
+ * each client. Grouping modes, overrides, physical deduplication, labels, and
+ * member preservation live here so web and mobile cannot drift.
+ */
+declare function buildProjectGroups<TProject extends EnvironmentProject>(input: {
+  readonly projects: ReadonlyArray<TProject>;
+  readonly settings: ProjectGroupingSettings;
+  readonly preferredEnvironmentId?: EnvironmentId | null;
+}): ReadonlyArray<ProjectGroup<TProject>>;
 //#endregion
-export { ProjectGroupingMode, ProjectGroupingSettings, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };
+export { ProjectGroup, ProjectGroupMember, ProjectGroupingMode, ProjectGroupingSettings, buildProjectGroups, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };

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

@@ -1,4 +1,4 @@
-import { cn as normalizeProjectPathForComparison, li as scopedProjectKey, si as scopeProjectRef } from "../../shared.js";
+import { _i as scopedProjectKey, hi as scopeProjectRef, ln as normalizeProjectPathForComparison } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/projectGrouping.ts
 function selectProjectGroupingSettings(settings) {
 	return {
@@ -63,11 +63,91 @@ function deriveLogicalProjectKeyFromRef(projectRef, project, options) {
 	return project ? deriveLogicalProjectKey(project, options) : scopedProjectKey(projectRef);
 }
 function deriveProjectGroupLabel(input) {
+	const sharedTitles = uniqueNonEmptyValues(input.members.map((member) => member.title));
 	const sharedDisplayNames = uniqueNonEmptyValues(input.members.map((member) => member.repositoryIdentity?.displayName));
-	if (sharedDisplayNames.length === 1) return sharedDisplayNames[0];
 	const sharedRepositoryNames = uniqueNonEmptyValues(input.members.map((member) => member.repositoryIdentity?.name));
+	const sharedTitle = sharedTitles[0];
+	if (sharedTitles.length === 1 && sharedTitle !== void 0 && !sharedDisplayNames.includes(sharedTitle) && !sharedRepositoryNames.includes(sharedTitle)) return sharedTitle;
+	if (sharedDisplayNames.length === 1) return sharedDisplayNames[0];
 	if (sharedRepositoryNames.length === 1) return sharedRepositoryNames[0];
 	return input.representative.title;
 }
+function projectFreshnessTime(project) {
+	const updatedAtTime = Date.parse(project.updatedAt);
+	if (Number.isFinite(updatedAtTime)) return updatedAtTime;
+	const createdAtTime = Date.parse(project.createdAt);
+	return Number.isFinite(createdAtTime) ? createdAtTime : 0;
+}
+function shouldReplacePhysicalProjectWinner(existing, candidate) {
+	const freshnessDelta = projectFreshnessTime(candidate) - projectFreshnessTime(existing);
+	return freshnessDelta > 0 || freshnessDelta === 0 && candidate.id > existing.id;
+}
+function selectProjectIdentitySource(projects, winner) {
+	if (winner.repositoryIdentity !== null) return winner;
+	let freshestIdentifiedProject = null;
+	for (const project of projects) {
+		if (project.repositoryIdentity === null) continue;
+		if (freshestIdentifiedProject === null || shouldReplacePhysicalProjectWinner(freshestIdentifiedProject, project)) freshestIdentifiedProject = project;
+	}
+	return freshestIdentifiedProject ?? winner;
+}
+/**
+* Builds logical project groups without losing the physical projects that
+* remain the actual navigation and task-creation targets.
+*
+* Presentation-specific metadata, filtering, and activity sorting stay in
+* each client. Grouping modes, overrides, physical deduplication, labels, and
+* member preservation live here so web and mobile cannot drift.
+*/
+function buildProjectGroups(input) {
+	const projectsByPhysicalKey = /* @__PURE__ */ new Map();
+	for (const project of input.projects) {
+		const physicalProjectKey = derivePhysicalProjectKey(project);
+		const existing = projectsByPhysicalKey.get(physicalProjectKey);
+		if (existing) existing.push(project);
+		else projectsByPhysicalKey.set(physicalProjectKey, [project]);
+	}
+	const logicalKeyByPhysicalKey = /* @__PURE__ */ new Map();
+	const groupedMembers = /* @__PURE__ */ new Map();
+	for (const [physicalProjectKey, physicalProjects] of projectsByPhysicalKey) {
+		const winner = physicalProjects.reduce((current, candidate) => shouldReplacePhysicalProjectWinner(current, candidate) ? candidate : current);
+		const logicalKey = deriveLogicalProjectKey(selectProjectIdentitySource(physicalProjects, winner), { groupingMode: resolveProjectGroupingMode(winner, input.settings) });
+		logicalKeyByPhysicalKey.set(physicalProjectKey, logicalKey);
+		const member = {
+			physicalProjectKey,
+			project: winner
+		};
+		const existing = groupedMembers.get(logicalKey);
+		if (existing) existing.push(member);
+		else groupedMembers.set(logicalKey, [member]);
+	}
+	const projectRefsByLogicalKey = /* @__PURE__ */ new Map();
+	const seenProjectRefs = /* @__PURE__ */ new Set();
+	for (const project of input.projects) {
+		const physicalProjectKey = derivePhysicalProjectKey(project);
+		const logicalKey = logicalKeyByPhysicalKey.get(physicalProjectKey) ?? deriveLogicalProjectKeyFromSettings(project, input.settings);
+		const projectRefKey = scopedProjectKey(scopeProjectRef(project.environmentId, project.id));
+		if (seenProjectRefs.has(projectRefKey)) continue;
+		seenProjectRefs.add(projectRefKey);
+		const projectRef = scopeProjectRef(project.environmentId, project.id);
+		const existing = projectRefsByLogicalKey.get(logicalKey);
+		if (existing) existing.push(projectRef);
+		else projectRefsByLogicalKey.set(logicalKey, [projectRef]);
+	}
+	const preferredEnvironmentId = input.preferredEnvironmentId ?? null;
+	return Array.from(groupedMembers, ([key, members]) => {
+		const representative = (preferredEnvironmentId ? members.find((member) => member.project.environmentId === preferredEnvironmentId)?.project : null) ?? members[0].project;
+		return {
+			key,
+			label: members.length > 1 ? deriveProjectGroupLabel({
+				representative,
+				members: members.map((member) => member.project)
+			}) : representative.title,
+			representative,
+			members,
+			memberProjectRefs: projectRefsByLogicalKey.get(key) ?? []
+		};
+	});
+}
 //#endregion
-export { deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };
+export { buildProjectGroups, deriveLogicalProjectKey, deriveLogicalProjectKeyFromRef, deriveLogicalProjectKeyFromSettings, derivePhysicalProjectKey, derivePhysicalProjectKeyFromPath, deriveProjectGroupLabel, deriveProjectGroupingOverrideKey, getProjectOrderKey, resolveProjectGroupingMode, selectProjectGroupingSettings };

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

@@ -1,4 +1,4 @@
-import { Ot as UpdateProjectInput, _x as ProjectReadFileResult, bT as EnvironmentAuthorizationError, c as normalizeProjectPathForDispatch, cv as OrchestrationShellSnapshot, dt as CreateProjectInput, f as AtomCommand, fx as ProjectListEntriesError, ha as EnvironmentRegistry, hx as ProjectReadFileError, jw as ScopedProjectRef, ma as EnvironmentNotRegisteredError, on as EnvironmentRpcUnavailableError, pt as DeleteProjectInput, r as isExplicitRelativePath, rt as EnvironmentProject, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, vx as ProjectSearchEntriesError, xx as ProjectWriteFileError, zT as EnvironmentId, z_ as OrchestrationDispatchCommandError } from "../../shared.js";
+import { $O as EnvironmentAuthorizationError, Ay as OrchestrationDispatchCommandError, DC as ProjectReadFileError, Da as EnvironmentNotRegisteredError, IC as ProjectWriteFileError, NC as ProjectSearchEntriesError, Oa as EnvironmentRegistry, Pt as UpdateProjectInput, ab as OrchestrationShellSnapshot, c as normalizeProjectPathForDispatch, f as AtomCommand, gt as DeleteProjectInput, hn as EnvironmentRpcUnavailableError, kC as ProjectReadFileResult, lO as ScopedProjectRef, mt as CreateProjectInput, ot as EnvironmentProject, r as isExplicitRelativePath, s as normalizeProjectPathForComparison, u as EnvironmentCatalogState, vk as EnvironmentId, wC as ProjectListEntriesError } from "../../shared.js";
 import * as Crypto from "effect/Crypto";
 import { Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/projectCommands.d.ts
@@ -14,11 +14,13 @@ interface OptimisticProjectFileTarget {
 declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | Crypto.Crypto | R, E>): {
   searchEntries: (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 query: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly limit: import("effect/Schema").Int;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly query: string;
+      readonly limit: number;
+      readonly kind?: "directory" | "file" | undefined;
+      readonly imageOnly?: boolean | undefined;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly entries: readonly {
       readonly path: string;
@@ -28,9 +30,9 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectSearchEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   listEntries: (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 input: {
+      readonly cwd: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly entries: readonly {
       readonly path: string;
@@ -40,10 +42,10 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentRpcUnavailableError | Error | ProjectListEntriesError | import("effect/unstable/rpc/RpcClientError").RpcClientError>>;
   readFile: (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 relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly relativePath: string;
+    };
   }) => Atom.Atom<import("effect/unstable/reactivity/AsyncResult").AsyncResult<{
     readonly relativePath: string;
     readonly contents: string;
@@ -71,11 +73,11 @@ declare function createProjectEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<E
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | OrchestrationDispatchCommandError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
   writeFile: AtomCommand<{
     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 relativePath: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly contents: import("effect/Schema").String;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly relativePath: string;
+      readonly contents: string;
+    };
   }, {
     readonly relativePath: string;
   }, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | ProjectWriteFileError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
@@ -111,6 +113,8 @@ declare function createEnvironmentProjectAtoms(input: {
         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;
@@ -148,6 +152,8 @@ declare function createEnvironmentProjectAtoms(input: {
         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;

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

@@ -1,2 +1,2 @@
-import { Bt as inferProjectTitleFromPath, Ft as findProjectByPath, Ht as isUnsupportedWindowsProjectPath, It as getBrowseDirectoryPath, Lt as getBrowseLeafPathSegment, Mt as appendBrowsePathSegment, Nt as canNavigateUp, Pt as ensureBrowseDirectoryPath, Rt as getBrowseParentPath, Ut as resolveProjectPathForDispatch, Vt as isFilesystemBrowseQuery, Wt as createEnvironmentProjectAtoms, cn as normalizeProjectPathForComparison, in as isExplicitRelativePath, ln as normalizeProjectPathForDispatch, rn as createProjectEnvironmentAtoms, zt as hasTrailingPathSeparator } from "../../shared.js";
+import { Bt as hasTrailingPathSeparator, Ft as ensureBrowseDirectoryPath, Gt as createEnvironmentProjectAtoms, Ht as isFilesystemBrowseQuery, It as findProjectByPath, Lt as getBrowseDirectoryPath, Nt as appendBrowsePathSegment, Pt as canNavigateUp, Rt as getBrowseLeafPathSegment, Ut as isUnsupportedWindowsProjectPath, Vt as inferProjectTitleFromPath, Wt as resolveProjectPathForDispatch, an as isExplicitRelativePath, in as createProjectEnvironmentAtoms, ln as normalizeProjectPathForComparison, un as normalizeProjectPathForDispatch, zt as getBrowseParentPath } from "../../shared.js";
 export { appendBrowsePathSegment, canNavigateUp, createEnvironmentProjectAtoms, createProjectEnvironmentAtoms, ensureBrowseDirectoryPath, findProjectByPath, getBrowseDirectoryPath, getBrowseLeafPathSegment, getBrowseParentPath, hasTrailingPathSeparator, inferProjectTitleFromPath, isExplicitRelativePath as isExplicitRelativeProjectPath, isFilesystemBrowseQuery, isUnsupportedWindowsProjectPath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch, resolveProjectPathForDispatch };