Add environment-aware new thread picker

apps/server/src/keybindings.test.ts

@@ -201,6 +201,8 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
       assert.equal(defaultsByCommand.get("sidebar.toggle"), "mod+b");
       assert.equal(defaultsByCommand.get("rightPanel.toggle"), "mod+alt+b");
       assert.equal(defaultsByCommand.get("terminal.splitVertical"), "mod+shift+d");
+      assert.equal(defaultsByCommand.get("chat.newEnvironment"), "mod+shift+n");
+      assert.isFalse(defaultsByCommand.has("chat.newLocal"));
       assert.equal(defaultsByCommand.get("modelPicker.jump.1"), "mod+1");
       assert.equal(defaultsByCommand.get("modelPicker.jump.9"), "mod+9");
     }),
@@ -301,6 +303,55 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
       }).pipe(Effect.provide(makeKeybindingsLayer())),
   );
 
+  it.effect("migrates the previous new-local default to the environment picker", () =>
+    Effect.gen(function* () {
+      const { keybindingsConfigPath } = yield* ServerConfig.ServerConfig;
+      yield* writeKeybindingsConfig(keybindingsConfigPath, [
+        {
+          key: "mod+shift+n",
+          command: "chat.newLocal",
+          when: "!terminalFocus",
+        },
+        {
+          key: "mod+shift+l",
+          command: "chat.newLocal",
+          when: "!terminalFocus",
+        },
+      ]);
+
+      yield* Effect.gen(function* () {
+        const keybindings = yield* Keybindings.Keybindings;
+        yield* keybindings.syncDefaultKeybindingsOnStartup;
+      });
+
+      const persisted = yield* readKeybindingsConfig(keybindingsConfigPath);
+      assert.isTrue(
+        persisted.some(
+          (entry) =>
+            entry.command === "chat.newEnvironment" &&
+            entry.key === "mod+shift+n" &&
+            entry.when === "!terminalFocus",
+        ),
+      );
+      assert.isFalse(
+        persisted.some(
+          (entry) =>
+            entry.command === "chat.newLocal" &&
+            entry.key === "mod+shift+n" &&
+            entry.when === "!terminalFocus",
+        ),
+      );
+      assert.isTrue(
+        persisted.some(
+          (entry) =>
+            entry.command === "chat.newLocal" &&
+            entry.key === "mod+shift+l" &&
+            entry.when === "!terminalFocus",
+        ),
+      );
+    }).pipe(Effect.provide(makeKeybindingsLayer())),
+  );
+
   it.effect("skips conflicting default keybindings on startup and logs a detailed warning", () => {
     const messages: string[] = [];
     const logger = Logger.make(({ message }) => {

apps/server/src/keybindings.ts

@@ -109,6 +109,17 @@ function isSameKeybindingRule(left: KeybindingRule, right: KeybindingRule): bool
   );
 }
 
+const LEGACY_NEW_LOCAL_DEFAULT: KeybindingRule = {
+  key: "mod+shift+n",
+  command: "chat.newLocal",
+  when: "!terminalFocus",
+};
+const NEW_ENVIRONMENT_DEFAULT: KeybindingRule = {
+  key: "mod+shift+n",
+  command: "chat.newEnvironment",
+  when: "!terminalFocus",
+};
+
 function keybindingShortcutContext(rule: KeybindingRule): string | null {
   const parsed = parseKeybindingShortcut(rule.key);
   if (!parsed) return null;
@@ -493,7 +504,16 @@ const make = Effect.gen(function* () {
         yield* Cache.invalidate(resolvedConfigCache, resolvedConfigCacheKey);
         return;
       }
-      const customConfig = runtimeConfig.keybindings;
+      const shouldMigrateNewEnvironmentDefault =
+        !runtimeConfig.keybindings.some((entry) => entry.command === "chat.newEnvironment") &&
+        runtimeConfig.keybindings.some((entry) =>
+          isSameKeybindingRule(entry, LEGACY_NEW_LOCAL_DEFAULT),
+        );
+      const customConfig = shouldMigrateNewEnvironmentDefault
+        ? runtimeConfig.keybindings.map((entry) =>
+            isSameKeybindingRule(entry, LEGACY_NEW_LOCAL_DEFAULT) ? NEW_ENVIRONMENT_DEFAULT : entry,
+          )
+        : runtimeConfig.keybindings;
       const existingCommands = new Set(customConfig.map((entry) => entry.command));
       const missingDefaults: KeybindingRule[] = [];
       const shortcutConflictWarnings: Array<{
@@ -530,7 +550,7 @@ const make = Effect.gen(function* () {
           reason: "shortcut context already used by existing rule",
         });
       }
-      if (missingDefaults.length === 0) {
+      if (missingDefaults.length === 0 && !shouldMigrateNewEnvironmentDefault) {
         yield* Cache.invalidate(resolvedConfigCache, resolvedConfigCacheKey);
         return;
       }

apps/web/src/commandPaletteBus.ts

@@ -3,7 +3,7 @@
 const COMMAND_PALETTE_OPEN_EVENT = "t3code:open-command-palette";
 
 export interface CommandPaletteOpenDetail {
-  readonly open?: "add-project" | "new-thread-in";
+  readonly open?: "add-project" | "new-thread-in" | "new-thread-on";
 }
 
 export function openCommandPalette(detail?: CommandPaletteOpenDetail): void {

apps/web/src/components/CommandPalette.logic.test.ts

@@ -5,8 +5,38 @@ import {
   buildThreadActionItems,
   enumerateCommandPaletteItems,
   filterCommandPaletteGroups,
+  resolveNewThreadOnIntent,
   type CommandPaletteGroup,
 } from "./CommandPalette.logic";
+import { reduceCommandPaletteUiState } from "./CommandPalette";
+
+describe("resolveNewThreadOnIntent", () => {
+  it("distinguishes loading from a loaded-empty environment list", () => {
+    expect(
+      resolveNewThreadOnIntent({ isActive: false, isLoaded: false, environmentItemCount: 0 }),
+    ).toBe("ignore");
+    expect(
+      resolveNewThreadOnIntent({ isActive: true, isLoaded: false, environmentItemCount: 0 }),
+    ).toBe("defer");
+    expect(
+      resolveNewThreadOnIntent({ isActive: true, isLoaded: true, environmentItemCount: 0 }),
+    ).toBe("clear");
+    expect(
+      resolveNewThreadOnIntent({ isActive: true, isLoaded: true, environmentItemCount: 1 }),
+    ).toBe("open");
+  });
+});
+
+describe("reduceCommandPaletteUiState", () => {
+  it("closes and clears a deferred open intent when no targets are available", () => {
+    expect(
+      reduceCommandPaletteUiState(
+        { open: true, openIntent: { kind: "new-thread-on" } },
+        { _tag: "SetOpen", open: false },
+      ),
+    ).toEqual({ open: false, openIntent: null });
+  });
+});
 
 describe("enumerateCommandPaletteItems", () => {
   it("assigns positional jump shortcuts to the first nine displayed items", () => {

apps/web/src/components/CommandPalette.logic.ts

@@ -15,6 +15,16 @@ export const RECENT_THREAD_LIMIT = 12;
 export const ITEM_ICON_CLASS = "size-4 text-muted-foreground/80";
 export const ADDON_ICON_CLASS = "size-4";
 
+export function resolveNewThreadOnIntent(input: {
+  isActive: boolean;
+  isLoaded: boolean;
+  environmentItemCount: number;
+}): "ignore" | "defer" | "clear" | "open" {
+  if (!input.isActive) return "ignore";
+  if (!input.isLoaded) return "defer";
+  return input.environmentItemCount > 0 ? "open" : "clear";
+}
+
 export interface CommandPaletteItem {
   readonly kind: "action" | "submenu";
   readonly value: string;