@devries-cameron20 / t3code-1 / commits / c9359f6535
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

fix(mobile): project picker starts a chat in an open copy, not an archived one (#38984)

Co-authored-by: Grok 4.7 <noreply@x.ai> Co-authored-by: Julius Marminge <julius0216@outlook.com>

Wout Stiens committed Nov 19, 2026 at 10:12 UTC c9359f6535f8f5abdc54d2ce0b13357433b91082
7 files changed +154 -43
apps/mobile/src/features/threads/new-task-project-selection.test.ts
+24 -1
@@ -2,7 +2,7 @@ import { EnvironmentId, ProjectId } from "@t3tools/contracts";
2 import { describe, expect, it } from "vite-plus/test";
3
4 import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
5 -import type { HomeProjectScope } from "../home/homeThreadList";
5 +import { buildHomeProjectScopes, type HomeProjectScope } from "../home/homeThreadList";
6 import {
7 getProjectScopeSelectionTarget,
8 isSameRepository,
@@ -60,6 +60,29 @@ function makeScope(projects: ReadonlyArray<EnvironmentProject>): HomeProjectScop
60 }
61
62 describe("getProjectScopeSelectionTarget", () => {
63 + it("chooses an open copy of a repository over an archived copy on the preferred machine", () => {
64 + const repo = { repositoryKey: "github.com/t3tools/t3code" };
65 + const archived = {
66 + ...makeProject("archived-copy", "mac", repo),
67 + archivedAt: "2026-07-02T00:00:00.000Z",
68 + };
69 + const open = makeProject("open-copy", "server", repo);
70 + const [scope] = buildHomeProjectScopes({
71 + projects: [archived, open],
72 + environmentId: null,
73 + projectGroupingMode: "repository",
74 + });
75 + if (!scope || scope.archived) throw new Error("Expected a pickable repository group");
76 +
77 + expect(
78 + getProjectScopeSelectionTarget(
79 + scope,
80 + archived.environmentId,
81 + new Set([archived.environmentId, open.environmentId]),
82 + ).id,
83 + ).toBe(open.id);
84 + });
85 +
86 it("prefers a connected copy of a project that spans environments", () => {
87 const mac = makeProject("t3code", "mac");
88 const server = makeProject("t3code", "server");
apps/mobile/src/features/threads/new-task-project-selection.ts
+38 -27
@@ -1,34 +1,54 @@
1 import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
2 import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects";
3 +import { isPickableProjectMember } from "@t3tools/client-runtime/state/project-grouping";
4 import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
5 import { repositoryGroupingKeyOf, type EnvironmentId, type ServerConfig } from "@t3tools/contracts";
6
7 import { scopedProjectKey } from "../../lib/scopedEntities";
8 import type { HomeProjectScope } from "../home/homeThreadList";
9
10 +type ProjectRef = { readonly environmentId: string; readonly projectId: string };
11 +
12 type DraftProjectSelectionResolution =
13 | { readonly kind: "preserve" }
14 | { readonly kind: "select"; readonly project: EnvironmentProject }
15 | { readonly kind: "pick" }
16 | { readonly kind: "dismiss" };
17
15 -/**
16 - * The copy of a project a new thread starts in: the preferred environment's, then the
17 - * representative. A connected copy wins over a disconnected one.
18 - */
19 -export function getProjectScopeSelectionTarget(
18 +function selectOpenProjectScopeMember(
19 scope: HomeProjectScope,
20 preferredEnvironmentId: EnvironmentId | null,
21 connectedEnvironmentIds: ReadonlySet<EnvironmentId>,
23 -): EnvironmentProject {
22 + lastProject?: ProjectRef,
23 +): EnvironmentProject | undefined {
24 + const open = scope.projects.filter(isPickableProjectMember);
25 + const remembered =
26 + lastProject &&
27 + open.find(
28 + (project) =>
29 + project.environmentId === lastProject.environmentId && project.id === lastProject.projectId,
30 + );
31 + if (remembered) return remembered;
32 +
33 const rank = (project: EnvironmentProject) =>
34 project.environmentId === preferredEnvironmentId ? 0 : project === scope.representative ? 1 : 2;
26 - const ordered = [...scope.projects].sort((left, right) => rank(left) - rank(right));
27 - return (
28 - ordered.find((project) => connectedEnvironmentIds.has(project.environmentId)) ??
29 - ordered[0] ??
30 - scope.representative
35 + open.sort((left, right) => rank(left) - rank(right));
36 + return open.find((project) => connectedEnvironmentIds.has(project.environmentId)) ?? open[0];
37 +}
38 +
39 +/** Picker scopes have an open copy; prefer a connected one, then the selected environment. */
40 +export function getProjectScopeSelectionTarget(
41 + scope: HomeProjectScope,
42 + preferredEnvironmentId: EnvironmentId | null,
43 + connectedEnvironmentIds: ReadonlySet<EnvironmentId>,
44 +): EnvironmentProject {
45 + const project = selectOpenProjectScopeMember(
46 + scope,
47 + preferredEnvironmentId,
48 + connectedEnvironmentIds,
49 );
50 + if (!project) throw new Error("A pickable project group must have an open workspace");
51 + return project;
52 }
53
54 export function filterProjectScopes(
@@ -174,8 +194,6 @@ export function resolveDraftProjectSelection(
194 return onlyScope ? { kind: "select", project: onlyScope.representative } : { kind: "pick" };
195 }
196
177 -type ProjectRef = { readonly environmentId: string; readonly projectId: string };
178 -
197 /** The live copy of the thread list's filtered project a new thread starts in: the remembered one if it is a copy. */
198 export function newTaskFilteredProject(
199 scope: HomeProjectScope,
@@ -183,20 +201,13 @@ export function newTaskFilteredProject(
201 connectedEnvironmentIds: ReadonlySet<EnvironmentId>,
202 lastProject: ProjectRef | undefined,
203 ): ProjectRef | undefined {
186 - const live = scope.projects.filter((project) => project.archivedAt == null);
187 - if (live.length === 0) return undefined;
188 - const project =
189 - live.find(
190 - (candidate) =>
191 - candidate.environmentId === lastProject?.environmentId &&
192 - candidate.id === lastProject.projectId,
193 - ) ??
194 - getProjectScopeSelectionTarget(
195 - { ...scope, projects: live },
196 - preferredEnvironmentId,
197 - connectedEnvironmentIds,
198 - );
199 - return { environmentId: project.environmentId, projectId: project.id };
204 + const project = selectOpenProjectScopeMember(
205 + scope,
206 + preferredEnvironmentId,
207 + connectedEnvironmentIds,
208 + lastProject,
209 + );
210 + return project && { environmentId: project.environmentId, projectId: project.id };
211 }
212
213 export function newTaskDestination(options: {
apps/web/src/components/CommandPalette.browser.test.tsx
+42
@@ -15,6 +15,7 @@ import { CommandPalette } from "./CommandPalette";
15 const entities = vi.hoisted(() => ({
16 projects: [] as ReadonlyArray<Project>,
17 threads: [] as ReadonlyArray<Thread>,
18 + activeThread: undefined as Thread | undefined,
19 delegatedUnderParent: new Set<string>() as ReadonlySet<string>,
20 handleNewThread: vi.fn(async () => undefined),
21 }));
@@ -38,6 +39,7 @@ vi.mock("../hooks/useHandleNewThread", async (original) => {
39 ...actual,
40 useHandleNewThread: () => ({
41 ...actual.useHandleNewThread(),
42 + activeThread: entities.activeThread,
43 handleNewThread: entities.handleNewThread,
44 }),
45 };
@@ -56,6 +58,7 @@ function setup(state: Partial<typeof entities> = {}) {
58 useCommandPaletteStore.setState(useCommandPaletteStore.getInitialState(), true);
59 entities.projects = state.projects ?? [];
60 entities.threads = state.threads ?? [];
61 + entities.activeThread = state.activeThread;
62 entities.delegatedUnderParent = state.delegatedUnderParent ?? new Set();
63 entities.handleNewThread.mockClear();
64 }
@@ -248,6 +251,45 @@ describe("CommandPalette open intents", () => {
251 await vi.waitFor(() => expect(screen.router?.state.location.pathname).toBe("/local/parent"));
252 });
253
254 + it("starts a thread in an open copy when the current project's copy is archived", async () => {
255 + const repositoryIdentity = {
256 + canonicalKey: "github.com/example/acme",
257 + locator: {
258 + source: "git-remote" as const,
259 + remoteName: "origin",
260 + remoteUrl: "https://github.com/example/acme.git",
261 + },
262 + };
263 + const archived = {
264 + ...makeProject("acme"),
265 + repositoryIdentity,
266 + archivedAt: "2026-03-02T00:00:00.000Z",
267 + };
268 + const open = {
269 + ...makeProject("acme"),
270 + environmentId: EnvironmentId.make("remote"),
271 + repositoryIdentity,
272 + };
273 + setup({
274 + projects: [archived, open],
275 + activeThread: makeThreadFixture({
276 + environmentId: archived.environmentId,
277 + projectId: archived.id,
278 + }),
279 + });
280 + await using _screen = await render(<CommandPalette>{null}</CommandPalette>);
281 +
282 + openCommandPalette({ open: "new-thread-in" });
283 + await page.getByRole("option", { name: /acme/i }).click();
284 +
285 + await vi.waitFor(() =>
286 + expect(entities.handleNewThread).toHaveBeenCalledWith({
287 + environmentId: open.environmentId,
288 + projectId: open.id,
289 + }),
290 + );
291 + });
292 +
293 it("numbers filtered New thread in... rows from 1 and jumps to them", async () => {
294 using _platform = vi.spyOn(navigator, "platform", "get").mockReturnValue("Linux x86_64");
295 setup({ projects: [makeProject("server"), makeProject("lima")] });
apps/web/src/components/CommandPalette.tsx
+11 -7
@@ -277,7 +277,10 @@ import { suggestAppAccessForRemote } from "./sourceControlAppAccessToast";
277 import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
278 import { ComposerHandleContext, useComposerHandleContext } from "../composerHandleContext";
279 import type { ChatComposerHandle } from "./chat/ChatComposer";
280 -import { pickableProjectGroups } from "@t3tools/client-runtime/state/project-grouping";
280 +import {
281 + isPickableProjectMember,
282 + pickableProjectGroups,
283 +} from "@t3tools/client-runtime/state/project-grouping";
284 import { buildSidebarProjectPickerEntries } from "../sidebarProjectGrouping";
285 import { PullRequestGlyph } from "~/components/pullRequest/pullRequestIcons";
286 import { readPullRequestListPreferences } from "~/components/pullRequest/pullRequestListPreferences";
@@ -893,15 +896,16 @@ function OpenCommandPaletteDialog(props: {
896 pin: projectPin,
897 runProject: async (project) => {
898 const group = projectGroupByTargetKey.get(`${project.environmentId}:${project.id}`);
896 - const contextualRefBelongsToGroup =
899 + const contextualProjectIsEligible =
900 contextualProjectRef !== null &&
898 - group?.memberProjectRefs.some(
899 - (projectRef) =>
900 - projectRef.environmentId === contextualProjectRef.environmentId &&
901 - projectRef.projectId === contextualProjectRef.projectId,
901 + group?.memberProjects.some(
902 + (member) =>
903 + member.environmentId === contextualProjectRef.environmentId &&
904 + member.id === contextualProjectRef.projectId &&
905 + isPickableProjectMember(member),
906 );
907 await handleNewThread(
904 - contextualRefBelongsToGroup
908 + contextualProjectIsEligible
909 ? contextualProjectRef
910 : scopeProjectRef(project.environmentId, project.id),
911 );
apps/web/src/environmentGrouping.test.ts
+28
@@ -279,6 +279,34 @@ describe("environment grouping", () => {
279 });
280 });
281
282 + it("targets an open copy when the preferred project is archived", () => {
283 + const archived = makeProject({
284 + repositoryIdentity,
285 + archivedAt: "2026-01-02T00:00:00.000Z",
286 + });
287 + const open = makeProject({
288 + id: ProjectId.make("open-copy"),
289 + environmentId: remoteEnvironmentId,
290 + repositoryIdentity,
291 + });
292 + const groups = buildSidebarProjectSnapshots({
293 + projects: [archived, open],
294 + settings: defaultGroupingSettings,
295 + primaryEnvironmentId,
296 + resolveEnvironmentLabel: () => null,
297 + });
298 + const [entry] = buildSidebarProjectPickerEntries({
299 + groups: pickableProjectGroups(groups),
300 + preferredProjectRef: { environmentId: archived.environmentId, projectId: archived.id },
301 + });
302 +
303 + expect(entry?.targetProject).toMatchObject({ environmentId: open.environmentId, id: open.id });
304 + expect(entry?.group.memberProjectRefs).toContainEqual({
305 + environmentId: archived.environmentId,
306 + projectId: archived.id,
307 + });
308 + });
309 +
310 it("puts the preferred project before pinned projects", () => {
311 const project = (title: string, pinnedAt: string | null = null) =>
312 makeProject({
apps/web/src/sidebarProjectGrouping.ts
+6 -7
@@ -6,6 +6,7 @@ import type {
6 import {
7 buildProjectGroups,
8 derivePhysicalProjectKey,
9 + isPickableProjectMember,
10 resolveScratchProjectScopeKey,
11 type ProjectGroupingSettings,
12 } from "@t3tools/client-runtime/state/project-grouping";
@@ -221,6 +222,7 @@ export function buildSidebarProjectPickerEntries(input: {
222 }) {
223 const preferredProjectRef = input.preferredProjectRef;
224 const entries = input.groups.flatMap((group): SidebarProjectPickerEntry[] => {
225 + const members = group.memberProjects.filter(isPickableProjectMember);
226 const isPreferred = preferredProjectRef
227 ? group.memberProjectRefs.some(
228 (projectRef) =>
@@ -229,21 +231,18 @@ export function buildSidebarProjectPickerEntries(input: {
231 )
232 : false;
233 const preferredProject = preferredProjectRef
232 - ? (group.memberProjects.find(
234 + ? (members.find(
235 (project) =>
236 project.environmentId === preferredProjectRef.environmentId &&
237 project.id === preferredProjectRef.projectId,
236 - ) ??
237 - group.memberProjects.find(
238 - (project) => project.environmentId === preferredProjectRef.environmentId,
239 - ))
238 + ) ?? members.find((project) => project.environmentId === preferredProjectRef.environmentId))
239 : null;
240 const targetProject =
241 preferredProject ??
243 - group.memberProjects.find(
242 + members.find(
243 (project) => project.environmentId === group.environmentId && project.id === group.id,
244 ) ??
246 - group.memberProjects[0];
245 + members[0];
246 if (!targetProject) return [];
247
248 return [{ group, targetProject, isPreferred }];
packages/client-runtime/src/state/projectGrouping.ts
+5 -1
@@ -273,6 +273,10 @@ export function pickableProjectGroups<
273 return [...open.filter((group) => group.pinned), ...open.filter((group) => !group.pinned)];
274 }
275
276 +export function isPickableProjectMember(member: Pick<EnvironmentProject, "archivedAt">): boolean {
277 + return member.archivedAt == null;
278 +}
279 +
280 function projectFreshnessTime(project: EnvironmentProject): number {
281 const updatedAtTime = Date.parse(project.updatedAt);
282 if (Number.isFinite(updatedAtTime)) {
@@ -397,7 +401,7 @@ export function buildProjectGroups<TProject extends EnvironmentProject>(
401 members,
402 memberProjectRefs: projectRefsByLogicalKey.get(key) ?? [],
403 pinned: members.some((member) => member.project.pinnedAt != null),
400 - archived: members.every((member) => member.project.archivedAt != null),
404 + archived: !members.some(({ project }) => isPickableProjectMember(project)),
405 };
406 });
407 }