diff --git a/packages/ui/src/app/drafts.test.ts b/packages/ui/src/app/drafts.test.ts
index 232fe871c..f0b6f21a7 100644
--- a/packages/ui/src/app/drafts.test.ts
+++ b/packages/ui/src/app/drafts.test.ts
@@ -191,6 +191,11 @@ test('a draft names its project in the heading and the dropdown moves it to anot
   typeQuery('zzz');
   expect(shownValues()).toEqual([]);
   expect(query('[data-testid=draft-project-empty]').textContent).toContain('zzz');
+  // Enter on a query nothing answers takes nothing: the folder row is not its fallback.
+  search.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+  flushSync();
+  expect(store.projectPickerOpen).toBe(false);
+  expect(document.querySelector('[data-testid=draft-project-menu]')).not.toBeNull();
   typeQuery('BOI');
   expect(shownValues().map((value) => JSON.parse(value!)[1])).toEqual(['p-boite']);
 
@@ -210,6 +215,28 @@ test('a draft names its project in the heading and the dropdown moves it to anot
   expect(query('[data-testid=project][data-project-id=p-notes]').querySelector('[data-testid=draft-row]')).toBeNull();
   await waitFor(() => document.activeElement === document.querySelector('[data-testid=composer-input]'));
 
+  // The find chord opens the list from the composer, one word per field
+  // finds the row, and Escape twice gives the keyboard back to the composer.
+  const composer = query<HTMLTextAreaElement>('[data-testid=composer-input]');
+  composer.dispatchEvent(new KeyboardEvent('keydown', { key: 'f', code: 'KeyF', ctrlKey: true, bubbles: true, cancelable: true }));
+  await waitFor(() => document.activeElement === document.querySelector('[data-testid=draft-project-search]'));
+  const again = query<HTMLInputElement>('[data-testid=draft-project-search]');
+  // The list is modal: Tab stays in its search instead of reaching the page behind the scrim.
+  const tab = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true, cancelable: true });
+  again.dispatchEvent(tab);
+  expect(tab.defaultPrevented).toBe(true);
+  expect(document.activeElement).toBe(again);
+  again.value = 'note src';
+  again.dispatchEvent(new Event('input', { bubbles: true }));
+  flushSync();
+  expect(shownValues().map((value) => JSON.parse(value!)[1])).toEqual(['p-notes']);
+  again.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+  flushSync();
+  expect(again.value).toBe('');
+  again.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+  await waitFor(() => document.querySelector('[data-testid=draft-project-menu]') === null);
+  expect(document.activeElement).toBe(composer);
+
   // Focus back on the trigger, Escape still closes the list.
   const trigger = query<HTMLButtonElement>('[data-testid=draft-project]');
   trigger.click();
diff --git a/packages/ui/src/components/ChatView.svelte b/packages/ui/src/components/ChatView.svelte
index 423d96fbd..dcd6c3aa8 100644
--- a/packages/ui/src/components/ChatView.svelte
+++ b/packages/ui/src/components/ChatView.svelte
@@ -109,7 +109,7 @@
           <img src="./icons/icon.svg" alt="" width="42" height="42" />
           <h1>{strings.mobile.draftTitle}</h1>
           <p>{strings.mobile.draftHint}</p>
-          <span class="project-choice"><ProjectChoice {store} testid="mobile-draft-project">{#if project}<ProjectTile {project} {store} />{:else}<FolderOpen size={15} />{/if}<span class="project-label ui-label">{project ? projectName(project) : strings.drafts.name}</span><ChevronDown size={14} /></ProjectChoice></span>
+          <span class="project-choice"><ProjectChoice {store} testid="mobile-draft-project" phone>{#if project}<ProjectTile {project} {store} />{:else}<FolderOpen size={15} />{/if}<span class="project-label ui-label">{project ? projectName(project) : strings.drafts.name}</span><ChevronDown size={14} /></ProjectChoice></span>
           {#if draftChoice}<small>{modePhrase(draftChoice.permissionMode, draftProvider)}</small>{/if}
           {#if store.draft?.worktree}<small>{strings.thread.inWorktree}</small>{/if}
         </div>
diff --git a/packages/ui/src/components/CommandPalette.svelte b/packages/ui/src/components/CommandPalette.svelte
index a10dc551f..ee66dc927 100644
--- a/packages/ui/src/components/CommandPalette.svelte
+++ b/packages/ui/src/components/CommandPalette.svelte
@@ -1,15 +1,20 @@
 <script lang="ts">
   import { tick, untrack } from 'svelte';
-  import { Search } from '@lucide/svelte';
-  import type { ThreadSummary } from '@boite/contracts';
+  import { CornerDownLeft, Search } from '@lucide/svelte';
+  import type { Project, ProjectId, ThreadSummary } from '@boite/contracts';
   import { Closing } from '../lib/closing.svelte';
+  import { minuteClock } from '../lib/clock.svelte';
   import { appCommands, runCommand } from '../lib/commands.svelte';
-  import { focusedElement, restoreFocus } from '../lib/focus';
-  import { PALETTE_LIMIT, RECENT_THREADS, rankItems, type PaletteItem } from '../lib/palette';
+  import { focusComposer, focusedElement, restoreFocus } from '../lib/focus';
+  import { projectName } from '../lib/format';
+  import { PALETTE_LIMIT, RECENT_THREADS, rankItems, sectionRows, type PaletteItem } from '../lib/palette';
   import { strings } from '../lib/strings';
   import type { Store } from '../lib/store.svelte';
-  import { workspace } from '../lib/workspace.svelte';
+  import { workspace, type Machine } from '../lib/workspace.svelte';
+  import MachineIcon from './MachineIcon.svelte';
+  import ProjectTile from './ProjectTile.svelte';
   import StatusMark from './StatusMark.svelte';
+  import ThreadState from './ThreadState.svelte';
   import { threadTone } from '../lib/thread-state';
 
   let { store }: { store: Store } = $props();
@@ -24,6 +29,7 @@
   let previous: HTMLElement | null = null;
 
   const inShell = window.__TAURI_INTERNALS__ !== undefined;
+  const now = $derived(minuteClock.now);
 
   $effect(() => {
     if (!store.paletteOpen) {
@@ -43,32 +49,73 @@
     void tick().then(() => input?.focus({ preventScroll: true }));
   });
 
+  /** What a row or a heading draws beside its words: the thread, its project, its machine. */
+  interface Place {
+    machine: Machine;
+    project: Project | null;
+    thread: ThreadSummary | null;
+  }
+
+  let machines = $derived(workspace.machinesOr(store));
+  /** One machine names no machine. */
+  let several = $derived(workspace.machines.length > 1);
+
   /** Every live thread, most recent first; the list cuts it to the recents until something is typed. */
-  let threadItems = $derived.by((): PaletteItem[] =>
-    workspace.machinesOr(store).flatMap(machine => [...machine.store.threads]
-      .filter((t) => !t.archived && !t.incognito)
-      .map((t) => ({
-        id: `thread:${machine.store.threadKey(t.id)}`,
-        kind: 'thread' as const,
-        label: t.title,
-        // One machine names no machine.
-        hint: [machine.store.projects.find(p => p.id === t.projectId)?.name, workspace.machines.length > 1 ? machine.label : ''].filter(Boolean).join(' · '),
-        keywords: t.status,
-        at: t.lastUserMessageAt ?? t.createdAt
-      }))).sort((a,b) => b.at - a.at)
-  );
+  let threadData = $derived.by(() => {
+    const entries: { item: PaletteItem; at: number }[] = [];
+    const places = new Map<string, Place>();
+    for (const machine of machines) {
+      for (const thread of machine.store.threads) {
+        if (thread.archived || thread.incognito) continue;
+        const project = machine.store.projects.find(p => p.id === thread.projectId) ?? null;
+        const id = `thread:${machine.store.threadKey(thread.id)}`;
+        const section = `in:${machine.id}:${thread.projectId}`;
+        places.set(id, { machine, project, thread });
+        if (!places.has(section)) places.set(section, { machine, project, thread: null });
+        entries.push({ at: thread.lastUserMessageAt ?? thread.createdAt, item: {
+          id,
+          kind: 'thread',
+          label: thread.title,
+          // What a query may also land on: the project and the machine, never drawn on the row.
+          hint: [project ? projectName(project) : '', several ? machine.label : ''].filter(Boolean).join(' '),
+          keywords: thread.status,
+          section
+        } });
+      }
+    }
+    return { items: entries.sort((a, b) => b.at - a.at).map(entry => entry.item), places };
+  });
+
+  /** Every project, a new thread in it once picked: offered only to a query, nothing typed keeps the list short. */
+  let projectData = $derived.by(() => {
+    const items: PaletteItem[] = [];
+    const places = new Map<string, Place>();
+    for (const machine of machines) {
+      for (const project of machine.store.projects) {
+        if (project.archived) continue;
+        const id = `project:${JSON.stringify([machine.id, project.id])}`;
+        places.set(id, { machine, project, thread: null });
+        items.push({ id, kind: 'project', label: projectName(project), hint: [several ? machine.label : '', project.path].filter(Boolean).join(' '), keywords: strings.palette.newThreadWords });
+      }
+    }
+    return { items, places };
+  });
 
   let commandItems = $derived.by((): PaletteItem[] => appCommands(store, inShell));
 
   const snapshot = { rows: [] as PaletteItem[] };
-  /** Threads first, commands after: a query ranks across both, nothing typed shows the recents. */
-  let rows = $derived.by((): PaletteItem[] => {
+  /** The ranked rows, a project's threads, the projects and the commands mixed until `sections` cuts them. */
+  let ranked = $derived.by((): PaletteItem[] => {
     // Keep the exit animation's rows without subscribing a closed search to live updates.
     if (!store.paletteOpen) return snapshot.rows;
     const typed = query.trim().length > 0;
-    const threads = typed ? threadItems : threadItems.slice(0, RECENT_THREADS);
-    return snapshot.rows = rankItems(query, [...threads, ...commandItems], PALETTE_LIMIT);
+    const threads = typed ? threadData.items : threadData.items.slice(0, RECENT_THREADS);
+    const projects = typed ? projectData.items : [];
+    return snapshot.rows = rankItems(query, [...threads, ...projects, ...commandItems], PALETTE_LIMIT);
   });
+  let sections = $derived(sectionRows(ranked));
+  /** The rows in the order they are drawn: what the arrows walk. */
+  let rows = $derived(sections.flatMap(section => section.items));
 
   // The walk starts over on what the user typed, never on the list being
   // rebuilt: the core pushes a `thread.updated` a second per live agent, and
@@ -105,9 +152,26 @@
       else void store.open(item.id.slice('thread:'.length));
       return;
     }
+    if (item.kind === 'project') {
+      void newThreadIn(item.id);
+      return;
+    }
     runCommand(store, item.id, inShell);
   }
 
+  /** A fresh draft in that project on that machine, the keyboard in its composer. */
+  async function newThreadIn(id: string) {
+    const [machineId, projectId] = JSON.parse(id.slice('project:'.length)) as [string, ProjectId];
+    const target = machines.find(m => m.id === machineId)?.store ?? store;
+    if (workspace.machines.length) await workspace.select(target, undefined, projectId, { fresh: true });
+    else {
+      store.showChat();
+      store.startDraft(projectId, { fresh: true });
+    }
+    await tick();
+    focusComposer();
+  }
+
   /** On the whole dialog, so a key pressed with a row focused never reaches the window's Escape. */
   function onkeydown(event: KeyboardEvent) {
     if (event.key === 'Tab') {
@@ -123,6 +187,7 @@
       return;
     }
     if (event.key === 'Enter') {
+      if (event.isComposing || event.keyCode === 229) return;
       event.preventDefault();
       const item = rows[selected];
       if (item) pick(item);
@@ -137,21 +202,15 @@
     event.preventDefault();
   }
 
-  function threadOf(item: PaletteItem): ThreadSummary | null {
-    if (item.kind !== 'thread') return null;
-    const id = item.id.slice('thread:'.length);
-    const hosts = workspace.machinesOr(store).map(m => m.store);
-    for (const host of hosts) { const thread = host.threads.find(t => host.threadKey(t.id) === id); if (thread) return thread; }
-    return null;
+  function placeOf(id: string): Place | null {
+    return threadData.places.get(id) ?? projectData.places.get(id) ?? null;
   }
 
-  /** The heading before a row: only where the kind changes. */
-  function heading(index: number): string | null {
-    const item = rows[index];
-    if (!item) return null;
-    const previous = rows[index - 1];
-    if (previous && previous.kind === item.kind) return null;
-    return item.kind === 'thread' ? strings.palette.threads : strings.palette.commands;
+  /** The first row of a section, so the walk keeps one index across headings. */
+  function offset(at: number): number {
+    let count = 0;
+    for (let i = 0; i < at; i++) count += sections[i]!.items.length;
+    return count;
   }
 </script>
 
@@ -182,32 +241,51 @@
         <span class="kbd ui-label">Esc</span>
       </label>
       <div class="list" role="listbox" bind:this={list} data-testid="palette-list">
-        {#each rows as item, index (item.id)}
-          {@const thread = threadOf(item)}
-          {@const title = heading(index)}
-          {#if title}
-            <div class="section-label">{title}</div>
-          {/if}
-          <button
-            type="button"
-            class="row"
-            class:selected={index === selected}
-            role="option"
-            tabindex="-1"
-            aria-selected={index === selected}
-            data-index={index}
-            data-testid="palette-row"
-            data-palette-id={item.id}
-            onmousemove={() => (selected = index)}
-            onclick={() => pick(item)}
-          >
-            <!-- Empty for a command, so every label starts on the same line. -->
-            <span class="mark-slot">{#if thread}<StatusMark {...threadTone(thread.status, thread.unread)} />{/if}</span>
-            <span class="label ui-label">{item.label}</span>
-            {#if item.hint}
-              <span class="hint ui-label" class:kbd={item.kind === 'command'}>{item.hint}</span>
+        {#each sections as section, at (section.id)}
+          {@const first = offset(at)}
+          {@const heading = section.kind === 'thread' ? placeOf(section.id) : null}
+          <div class="section" data-testid="palette-section" data-section={section.id}>
+            {#if heading}
+              <div class="section-label project-label" data-testid="palette-project">
+                {#if heading.project}<ProjectTile project={heading.project} store={heading.machine.store} size={16} />{/if}
+                <span class="name ui-label">{heading.project ? projectName(heading.project) : strings.drafts.name}</span>
+                {#if several}<span class="machine ui-label"><MachineIcon icon={heading.machine.icon} os={heading.machine.store.core?.os} size={12} />{heading.machine.label}</span>{/if}
+              </div>
+            {:else}
+              <div class="section-label">{section.kind === 'project' ? strings.palette.projects : strings.palette.commands}</div>
             {/if}
-          </button>
+            {#each section.items as item, n (item.id)}
+              {@const index = first + n}
+              {@const place = placeOf(item.id)}
+              <button
+                type="button"
+                class="row"
+                class:selected={index === selected}
+                role="option"
+                tabindex="-1"
+                aria-selected={index === selected}
+                data-index={index}
+                data-testid="palette-row"
+                data-palette-id={item.id}
+                onmousemove={() => (selected = index)}
+                onclick={() => pick(item)}
+              >
+                <span class="mark-slot">
+                  {#if place?.thread}<StatusMark {...threadTone(place.thread.status, place.thread.unread)} />
+                  {:else if item.kind === 'project' && place?.project}<ProjectTile project={place.project} store={place.machine.store} size={16} />{/if}
+                </span>
+                <span class="label ui-label">{item.label}</span>
+                {#if place?.thread}
+                  <span class="state"><ThreadState thread={place.thread} {now} subagents={place.machine.store.subagents(place.thread.id)} away={place.machine.store.connection !== 'ready'} /></span>
+                {:else if item.kind === 'project' && place}
+                  <span class="meta ui-label">{#if several}<MachineIcon icon={place.machine.icon} os={place.machine.store.core?.os} size={12} />{place.machine.label}{' · '}{/if}{strings.palette.newThread}</span>
+                {:else if item.hint}
+                  <span class="kbd ui-label">{item.hint}</span>
+                {/if}
+                <span class="enter" aria-hidden="true"><CornerDownLeft size={13} strokeWidth={2} /></span>
+              </button>
+            {/each}
+          </div>
         {/each}
         {#if rows.length === 0}
           <p class="empty subtle">{strings.palette.empty}</p>
@@ -291,10 +369,42 @@
     padding: 6px;
   }
 
+  .section + .section {
+    margin-top: 4px;
+  }
+
   .section-label {
     padding: 8px 10px 4px;
   }
 
+  /* A project heading reads like the sidebar's: tile, name, then its machine. */
+  .project-label {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: 0;
+    text-transform: none;
+    letter-spacing: normal;
+    font-size: var(--text-sm);
+    font-weight: 600;
+    color: var(--color-foreground);
+  }
+
+  .project-label .name {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .machine {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    flex: none;
+    font-weight: 400;
+    color: var(--color-muted-foreground);
+  }
+
   .row {
     width: 100%;
     display: flex;
@@ -314,8 +424,22 @@
     background: transparent;
   }
 
+  /* The row Enter takes: the accent's wash, a bar on its edge and the Enter glyph, readable in both themes. */
   .row.selected {
-    background: var(--color-active);
+    background: var(--color-accent-soft);
+    box-shadow: inset 2px 0 0 var(--color-accent);
+  }
+
+  .enter {
+    display: inline-flex;
+    flex: none;
+    width: 13px;
+    color: var(--color-accent);
+    opacity: 0;
+  }
+
+  .row.selected .enter {
+    opacity: 1;
   }
 
   .row:active:not(:disabled) {
@@ -324,7 +448,7 @@
 
   .mark-slot {
     display: inline-flex;
-    width: 10px;
+    width: 16px;
     justify-content: center;
     flex: none;
   }
@@ -338,12 +462,20 @@
     font-weight: 400;
   }
 
-  .hint {
+  .state,
+  .meta {
     flex: none;
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
     font-size: var(--text-sm);
     color: var(--color-muted-foreground);
   }
 
+  .kbd {
+    flex: none;
+  }
+
   .empty {
     padding: 14px 10px;
     text-align: center;
diff --git a/packages/ui/src/components/CommandPalette.test.ts b/packages/ui/src/components/CommandPalette.test.ts
index e51d422bb..b25f03b5e 100644
--- a/packages/ui/src/components/CommandPalette.test.ts
+++ b/packages/ui/src/components/CommandPalette.test.ts
@@ -66,16 +66,52 @@ test('closed until asked, then the recents come first and the commands after the
   expect(document.querySelector('[data-testid=palette]')).not.toBeNull();
   expect(document.activeElement?.getAttribute('data-testid')).toBe('palette-input');
   const ids = rows();
-  // Every seeded thread first, then the commands; nothing typed.
+  // Every seeded thread first, then the commands; nothing typed, no project rows.
   expect([...ids.slice(0, 4)].sort()).toEqual(['thread:t-bench', 'thread:t-descriptors', 'thread:t-scheduler', 'thread:t-trace']);
   expect(ids).toContain('new-thread');
   expect(ids).toContain('settings');
+  expect(ids.some((id) => id.startsWith('project:'))).toBe(false);
   expect(ids.at(-1)).toBe('archive');
   expect(selectedId()).toBe(ids[0]);
-  expect(document.body.textContent).toContain('Threads');
+  // Each project's threads sit together under its name, the commands after them.
+  const sections = Array.from(document.querySelectorAll<HTMLElement>('[data-testid=palette-section]'));
+  const of = (section: HTMLElement) => Array.from(section.querySelectorAll('[data-testid=palette-row]')).map((row) => row.getAttribute('data-palette-id'));
+  expect(sections.map((section) => section.querySelector('[data-testid=palette-project] .name')?.textContent ?? 'commands')).toEqual(['notes', 'boite', 'commands']);
+  expect(of(sections[0]!)).toEqual(['thread:t-descriptors']);
+  expect(of(sections[1]!).sort()).toEqual(['thread:t-bench', 'thread:t-scheduler', 'thread:t-trace']);
+  // A row says what its thread is doing, the way the sidebar does.
+  expect(document.querySelector('[data-palette-id="thread:t-bench"]')?.textContent).toContain('Needs you');
   expect(document.body.textContent).toContain('Commands');
 });
 
+test('a query finds a project by its name and folder, and Enter starts a thread there with the keyboard in the composer', async () => {
+  const composer = document.createElement('textarea');
+  composer.dataset['testid'] = 'composer-input';
+  document.body.append(composer);
+  store.paletteOpen = true;
+  flushSync();
+  await tick();
+
+  // "boite src" lands one word on the name, the other on the folder.
+  await type('boite src');
+  const project = rows().find((id) => id.startsWith('project:'));
+  expect(project).toBe('project:["local","p-boite"]');
+  expect(rows()).not.toContain('project:["local","p-notes"]');
+  while (selectedId() !== project) key('ArrowDown');
+  // WebKit sends the Enter that confirms an IME candidate with keyCode 229.
+  const input = document.querySelector<HTMLInputElement>('[data-testid=palette-input]')!;
+  input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', keyCode: 229, bubbles: true, cancelable: true }));
+  flushSync();
+  expect(store.paletteOpen).toBe(true);
+  key('Enter');
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  await tick();
+  expect(store.paletteOpen).toBe(false);
+  expect(store.openThread).toBeNull();
+  expect(store.draft?.projectId).toBe('p-boite');
+  expect(document.activeElement).toBe(composer);
+});
+
 test('typing filters across threads and commands, the arrows move, Enter opens the thread', async () => {
   store.paletteOpen = true;
   flushSync();
diff --git a/packages/ui/src/components/ProjectChoice.svelte b/packages/ui/src/components/ProjectChoice.svelte
index fd1bca812..ab192d855 100644
--- a/packages/ui/src/components/ProjectChoice.svelte
+++ b/packages/ui/src/components/ProjectChoice.svelte
@@ -1,112 +1,118 @@
 <script lang="ts">
-  import { tick, type Snippet } from 'svelte';
+  import { tick, untrack, type Snippet } from 'svelte';
   import { Check, FolderOpen, Search } from '@lucide/svelte';
   import type { Project, ProjectId } from '@boite/contracts';
   import { Closing } from '../lib/closing.svelte';
-  import { floating } from '../lib/floating';
-  import { fitMenu } from '../lib/menu-fit';
-  import { projectName } from '../lib/format';
+  import { focusComposer } from '../lib/focus';
+  import { mobileOverlay } from '../lib/mobile-history';
+  import { homePath, projectName } from '../lib/format';
+  import { scoreFields, type SearchField } from '../lib/palette';
   import { fill, strings } from '../lib/strings';
   import type { Store } from '../lib/store.svelte';
-  import { workspace } from '../lib/workspace.svelte';
+  import { workspace, type Machine } from '../lib/workspace.svelte';
+  import MachineIcon from './MachineIcon.svelte';
   import ProjectTile from './ProjectTile.svelte';
 
   /**
    * The draft's project dropdown: a search field over every machine's drafts
    * and projects, grouped by machine when there are several, and for the owner
    * the way to open a folder. The keyboard stays in the field: the arrows move
-   * the highlighted row and Enter takes it.
+   * the highlighted row and Enter takes it. Typing ranks every machine's rows
+   * in one list, each word on the name, the machine or the folder ("boite m2"),
+   * and a pick hands the keyboard back to the composer. The find chord opens it
+   * on a draft (`store.projectChoiceRequest`).
    */
-  let { store, testid, children }: { store: Store; testid: string; children: Snippet } = $props();
+  /** `phone`: the copy the phone's welcome draws; the find chord opens the one the width shows. */
+  let { store, testid, phone = false, children }: { store: Store; testid: string; phone?: boolean; children: Snippet } = $props();
 
   const OPEN_FOLDER = 'open-folder';
 
   interface Row {
     id: string;
     label: string;
+    /** The folder, home folded to `~`: what tells two projects of one name apart. */
     hint: string;
+    /** The full folder or the drafts' explanation, under the pointer. */
+    title: string;
     active: boolean;
     tile: { project: Project; store: Store } | null;
-    /** Name, path and machine, lowercased without accents: what the search reads. */
-    haystack: string;
-    name: string;
+    machine: Machine;
+    /** What a query word may land on: the name, the machine, the folder. */
+    fields: SearchField[];
   }
 
   interface Group {
     /** The machine's id: two machines can carry the same label. */
     id: string;
-    label: string;
+    /** Null on one machine, or on a ranked list where every row names its own. */
+    machine: Machine | null;
     rows: Row[];
   }
 
   const popover = new Closing();
-  let root = $state<HTMLDivElement | undefined>(undefined);
+  /** One machine names no machine. */
+  let several = $derived(workspace.machines.length > 1);
   let trigger = $state<HTMLButtonElement | undefined>(undefined);
   let input = $state<HTMLInputElement | undefined>(undefined);
   let list = $state<HTMLDivElement | undefined>(undefined);
-  let panel = $state<HTMLDivElement | undefined>(undefined);
   const listId = `project-choice-${Math.random().toString(36).slice(2)}`;
   let query = $state('');
   let highlight = $state(0);
-
-  function fold(text: string): string {
-    return text.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
-  }
+  /** Opened by the find chord: the search takes the keys even on a phone, where a tap leaves the keyboard down. */
+  let byKeyboard = false;
 
   /** Every machine's drafts first, whether the core has made them yet or not, then its live projects. */
   let groups = $derived.by<Group[]>(() => {
     const machines = workspace.machinesOr(store);
-    const several = workspace.machines.length > 1;
-    return machines.map((machine) => {
+    // The machine on screen first: its projects are the likeliest pick.
+    const ordered = [...machines.filter((m) => m.store === store), ...machines.filter((m) => m.store !== store)];
+    const fields = (name: string, machine: Machine, path: string): SearchField[] => [
+      { text: name },
+      ...(several ? [{ text: machine.label, penalty: 5 }] : []),
+      ...(path ? [{ text: path, penalty: 15 }] : [])
+    ];
+    return ordered.map((machine) => {
       const here = machine.store === store;
       const drafts = machine.store.draftsProject;
-      const place = several ? machine.label : '';
       const rows: Row[] = [
         {
           id: JSON.stringify([machine.id, null]),
           label: strings.drafts.name,
-          hint: strings.drafts.hint,
+          hint: drafts ? homePath(drafts.path) : '',
+          title: strings.drafts.hint,
           active: here && store.draftInDrafts,
           tile: drafts ? { project: drafts, store: machine.store } : null,
-          haystack: fold(`${strings.drafts.name} ${place}`),
-          name: fold(strings.drafts.name)
+          machine,
+          fields: fields(strings.drafts.name, machine, '')
         },
         ...machine.store.projects
           .filter((entry) => entry.id !== drafts?.id && entry.archived !== true)
           .map((entry) => ({
             id: JSON.stringify([machine.id, entry.id]),
             label: projectName(entry),
-            hint: entry.path,
+            hint: homePath(entry.path),
+            title: entry.path,
             active: here && entry.id === store.draft?.projectId,
             tile: { project: entry, store: machine.store },
-            haystack: fold(`${projectName(entry)} ${entry.path} ${place}`),
-            name: fold(projectName(entry))
+            machine,
+            fields: fields(projectName(entry), machine, entry.path)
           }))
       ];
-      return { id: machine.id, label: place, rows };
+      return { id: machine.id, machine: several ? machine : null, rows };
     });
   });
 
-  /**
-   * Every word has to appear somewhere in the row. A name that starts with the
-   * query comes first, then a name that holds it, then a path or a machine.
-   */
+  /** Typed, one list over every machine, best first, the palette's ranking (`lib/palette.ts`). */
+  let typed = $derived(query.trim().length > 0);
   let shown = $derived.by<Group[]>(() => {
-    const words = fold(query).split(/\s+/).filter((word) => word.length > 0);
-    if (words.length === 0) return groups;
-    const whole = words.join(' ');
-    const rank = (row: Row) => (row.name.startsWith(whole) ? 0 : row.name.includes(whole) ? 1 : 2);
-    return groups
-      .map((group) => ({
-        id: group.id,
-        label: group.label,
-        rows: group.rows
-          .filter((row) => words.every((word) => row.haystack.includes(word)))
-          .map((row, at) => ({ row, at, rank: rank(row) }))
-          .sort((a, b) => a.rank - b.rank || a.at - b.at)
-          .map(({ row }) => row)
-      }))
-      .filter((group) => group.rows.length > 0);
+    if (!typed) return groups;
+    const ranked = groups
+      .flatMap((group) => group.rows)
+      .map((row, at) => ({ row, at, score: scoreFields(query, row.fields) }))
+      .filter((entry): entry is { row: Row; at: number; score: number } => entry.score !== null && entry.score >= 0)
+      .sort((a, b) => b.score - a.score || a.at - b.at)
+      .map((entry) => entry.row);
+    return ranked.length ? [{ id: 'ranked', machine: null, rows: ranked }] : [];
   });
 
   /** What the arrows walk: the rows in screen order, then opening a folder. */
@@ -118,37 +124,61 @@
     highlight = 0;
   });
 
+  /**
+   * The find chord on a draft: only the copy on screen opens, the phone's
+   * heading or the computer's. Each machine's store counts its own asks, so a
+   * draft moved to another machine starts from that one's count and opens nothing.
+   */
+  let seen = untrack(() => ({ store, request: store.projectChoiceRequest }));
+  $effect(() => {
+    const owner = store;
+    const request = owner.projectChoiceRequest;
+    if (seen.store !== owner || request === seen.request) {
+      seen = { store: owner, request };
+      return;
+    }
+    seen = { store: owner, request };
+    untrack(() => {
+      if (!trigger || window.matchMedia('(max-width: 720px)').matches !== phone) return;
+      if (popover.open) input?.focus({ preventScroll: true });
+      else open(true);
+    });
+  });
+
   /** The field takes the keyboard on a desktop; on a phone it would raise the keyboard over the list. */
   $effect(() => {
     if (!popover.open) return;
     void tick().then(() => {
-      // Typing shrinks the list: the popover keeps the height it opened at, so
-      // the field does not slide toward the trigger under the cursor.
-      if (panel) panel.style.minHeight = `${panel.offsetHeight}px`;
-      if (!window.matchMedia('(max-width: 720px)').matches) input?.focus({ preventScroll: true });
+      if (byKeyboard || !window.matchMedia('(max-width: 720px)').matches) input?.focus({ preventScroll: true });
       const at = order.findIndex((id) => shown.some((group) => group.rows.some((row) => row.id === id && row.active)));
       if (at >= 0) move(at);
     });
-    // A viewport that shrinks afterwards, a phone's keyboard or a shorter
-    // window, lowers the cap `floating` sets: the frozen height gives way to it.
-    const release = () => panel?.style.removeProperty('min-height');
-    window.addEventListener('resize', release);
-    window.visualViewport?.addEventListener('resize', release);
-    return () => {
-      window.removeEventListener('resize', release);
-      window.visualViewport?.removeEventListener('resize', release);
-    };
   });
 
-  function open() {
+  // A phone's Back closes the list, as it did when `floating` held it.
+  $effect(() => { if (popover.open) return mobileOverlay(() => close(false)); });
+
+  /**
+   * The list opens where the command palette does, under the title bar and
+   * centred, on `<body>`: from the heading it had only the space above it,
+   * three rows on a laptop.
+   */
+  function portal(node: HTMLElement) {
+    document.body.append(node);
+    return { destroy: () => node.remove() };
+  }
+
+  function open(keyboard = false) {
+    byKeyboard = keyboard;
     query = '';
     highlight = 0;
     popover.show();
   }
 
+  /** Closed from the keyboard, it gives the keys to the composer: the next thing typed is the prompt. */
   function close(refocus: boolean) {
     popover.hide();
-    if (refocus) trigger?.focus({ preventScroll: true });
+    if (refocus && !focusComposer()) trigger?.focus({ preventScroll: true });
   }
 
   function move(at: number) {
@@ -157,7 +187,7 @@
     list?.querySelector<HTMLElement>(`#${listId}-${at}`)?.scrollIntoView?.({ block: 'nearest' });
   }
 
-  function pick(id: string) {
+  async function pick(id: string) {
     popover.hide();
     if (id === OPEN_FOLDER) {
       store.projectPickerOpen = true;
@@ -166,14 +196,11 @@
     const [machineId, projectId] = JSON.parse(id) as [string, ProjectId | null];
     const target = workspace.machines.find((m) => m.id === machineId)?.store ?? store;
     if (target === store) store.setDraftProject(projectId);
-    else if (projectId !== null) void workspace.select(target, undefined, projectId);
-    else void workspace.select(target).then(() => target.startDraft(null));
-  }
-
-  function onWindowPointerdown(event: PointerEvent) {
-    if (!popover.open) return;
-    if (root && event.target instanceof Node && root.contains(event.target)) return;
-    popover.hide();
+    else if (projectId !== null) await workspace.select(target, undefined, projectId);
+    else await workspace.select(target).then(() => target.startDraft(null));
+    // Another machine draws its own composer: the focus waits for it.
+    await tick();
+    focusComposer();
   }
 
   function onTriggerKeydown(event: KeyboardEvent) {
@@ -184,10 +211,16 @@
     }
     if (popover.open || event.key !== 'ArrowDown') return;
     event.preventDefault();
-    open();
+    open(true);
   }
 
   function onkeydown(event: KeyboardEvent) {
+    if (event.key === 'Tab') {
+      // Modal: the page behind the scrim takes no keys. The rows are walked with the arrows.
+      event.preventDefault();
+      input?.focus({ preventScroll: true });
+      return;
+    }
     if (event.key === 'Escape') {
       event.stopPropagation();
       // A first Escape clears what was typed, the next one closes.
@@ -199,9 +232,10 @@
       // Enter also confirms an input method's candidate: that one is not a pick.
       if (event.isComposing || event.keyCode === 229) return;
       const id = order[highlight];
-      if (!id) return;
       event.preventDefault();
-      pick(id);
+      // A query nothing answers takes nothing: Enter is not a way to open a folder.
+      if (!id || (id === OPEN_FOLDER && typed && empty)) return;
+      void pick(id);
       return;
     }
     if (order.length === 0) return;
@@ -216,9 +250,7 @@
   const optionId = (id: string) => `${listId}-${order.indexOf(id)}`;
 </script>
 
-<svelte:window onpointerdown={onWindowPointerdown} />
-
-<div class="choice" bind:this={root}>
+<div class="choice">
   <button
     type="button"
     class="trigger"
@@ -235,17 +267,23 @@
   </button>
 
   {#if popover.shown}
+    <div
+      class="scrim"
+      class:closing={popover.closing}
+      role="presentation"
+      use:portal
+      use:popover.attach
+      onanimationend={popover.end}
+      onclick={(event) => { if (event.target === event.currentTarget) close(false); }}
+    >
     <div
       class="popover"
       class:closing={popover.closing}
       role="dialog"
+      aria-modal="true"
       aria-label={strings.thread.changeProject}
       tabindex="-1"
       {onkeydown}
-      bind:this={panel}
-      use:popover.attach
-      use:floating={{ anchor: () => trigger ?? null, placement: 'top', cap: 460, fit: fitMenu, dismiss: () => popover.hide() }}
-      onanimationend={popover.end}
       data-testid="{testid}-menu"
     >
       <label class="search">
@@ -270,7 +308,7 @@
 
       <div class="rows" role="listbox" id={listId} aria-label={strings.thread.changeProject} bind:this={list} data-testid="{testid}-list">
         {#each shown as group (group.id)}
-          {#if group.label}<div class="group ui-label" role="presentation">{group.label}</div>{/if}
+          {#if group.machine}<div class="group ui-label" role="presentation"><MachineIcon icon={group.machine.icon} os={group.machine.store.core?.os} size={12} />{group.machine.label}</div>{/if}
           {#each group.rows as row (row.id)}
             <button
               type="button"
@@ -283,16 +321,15 @@
               id={optionId(row.id)}
               data-row
               data-value={row.id}
-              title={row.hint}
+              title={row.title}
               onpointermove={() => (highlight = order.indexOf(row.id))}
-              onclick={() => pick(row.id)}
+              onclick={() => void pick(row.id)}
             >
-              {#if row.tile}<ProjectTile project={row.tile.project} store={row.tile.store} size={22} />{:else}<span class="blank" aria-hidden="true"><FolderOpen size={14} strokeWidth={1.75} /></span>{/if}
-              <span class="text">
-                <span class="name ui-label">{row.label}</span>
-                <span class="hint ui-label">{row.hint}</span>
-              </span>
-              {#if row.active}<span class="check" aria-hidden="true"><Check size={15} strokeWidth={2} /></span>{/if}
+              {#if row.tile}<ProjectTile project={row.tile.project} store={row.tile.store} size={20} />{:else}<span class="blank" aria-hidden="true"><FolderOpen size={14} strokeWidth={1.75} /></span>{/if}
+              <span class="name ui-label">{row.label}</span>
+              <span class="hint ui-label">{row.hint}</span>
+              {#if typed && several}<span class="machine ui-label"><MachineIcon icon={row.machine.icon} os={row.machine.store.core?.os} size={12} />{row.machine.label}</span>{/if}
+              <span class="check" aria-hidden="true">{#if row.active}<Check size={15} strokeWidth={2} />{/if}</span>
             </button>
           {/each}
         {/each}
@@ -303,19 +340,20 @@
         <button
           type="button"
           class="row folder"
-          class:highlight={order[highlight] === OPEN_FOLDER}
+          class:highlight={order[highlight] === OPEN_FOLDER && !(typed && empty)}
           tabindex="-1"
           id={optionId(OPEN_FOLDER)}
           data-row
           data-value={OPEN_FOLDER}
           onpointermove={() => (highlight = order.indexOf(OPEN_FOLDER))}
-          onclick={() => pick(OPEN_FOLDER)}
+          onclick={() => void pick(OPEN_FOLDER)}
         >
           <span class="blank" aria-hidden="true"><FolderOpen size={14} strokeWidth={1.75} /></span>
           <span class="name ui-label">{strings.drafts.pickFolder}</span>
         </button>
       {/if}
     </div>
+    </div>
   {/if}
 </div>
 
@@ -344,8 +382,26 @@
     background: var(--color-hover);
   }
 
+  .scrim {
+    position: fixed;
+    inset: 0;
+    z-index: 60;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding-top: min(14vh, 120px);
+    background: var(--color-scrim);
+    animation: fade var(--dur-2) var(--ease-out-quint);
+  }
+
+  .scrim.closing {
+    animation-name: fade-out;
+    pointer-events: none;
+  }
+
   .popover {
-    width: min(420px, calc(100vw - 24px));
+    width: min(520px, calc(100vw - 24px));
+    max-height: min(70vh, 520px);
     display: flex;
     flex-direction: column;
     padding: 6px;
@@ -359,10 +415,8 @@
     letter-spacing: normal;
     line-height: normal;
     text-align: left;
-    z-index: 40;
     overflow: hidden;
     animation: pop var(--dur-2) var(--ease-out-quint);
-    transform-origin: bottom left;
   }
 
   .popover.closing {
@@ -419,20 +473,24 @@
   }
 
   .group {
+    display: flex;
+    align-items: center;
+    gap: 6px;
     padding: 8px 8px 4px;
     color: var(--color-muted-foreground);
     font-size: var(--text-xs);
     font-weight: 500;
   }
 
+  /* One line a project: its tile, its name, its folder, then the machine and the mark. */
   .row {
     display: flex;
     align-items: center;
     gap: 10px;
     width: 100%;
     height: auto;
-    min-height: 44px;
-    padding: 6px 8px;
+    min-height: var(--row);
+    padding: 4px 8px;
     border: none;
     border-radius: var(--radius-sm);
     background: transparent;
@@ -441,8 +499,10 @@
     cursor: pointer;
   }
 
+  /* The row Enter takes, as in the command palette: the accent's wash and a bar on its edge. */
   .row.highlight {
-    background: var(--color-hover);
+    background: var(--color-accent-soft);
+    box-shadow: inset 2px 0 0 var(--color-accent);
   }
 
   .row:active {
@@ -453,6 +513,16 @@
   .check {
     flex: none;
     display: inline-flex;
+    width: 15px;
+    color: var(--color-accent);
+  }
+
+  .machine {
+    flex: none;
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    font-size: var(--text-xs);
     color: var(--color-muted-foreground);
   }
 
@@ -466,15 +536,9 @@
     color: var(--color-muted-foreground);
   }
 
-  .text {
-    flex: 1;
-    min-width: 0;
-    display: flex;
-    flex-direction: column;
-    gap: 5px;
-  }
-
   .name {
+    flex: none;
+    max-width: 55%;
     font-weight: 500;
     white-space: nowrap;
     overflow: hidden;
@@ -483,6 +547,7 @@
 
   .folder .name {
     flex: 1;
+    max-width: none;
     font-weight: 400;
     color: var(--color-muted-foreground);
   }
@@ -491,8 +556,10 @@
     color: var(--color-foreground);
   }
 
-  /* One line each: a long path ends in an ellipsis, the full one is in the title. */
+  /* After the name, filling the line: a long path ends in an ellipsis, the full one is in the title. */
   .hint {
+    flex: 1;
+    min-width: 0;
     font-size: var(--text-xs);
     color: var(--color-muted-foreground);
     white-space: nowrap;
@@ -526,6 +593,7 @@
   }
 
   @media (max-width: 720px) {
+    .scrim { padding-top: 12px; }
     .search { height: var(--control-touch); }
     .row { min-height: var(--touch-target); }
   }
diff --git a/packages/ui/src/lib/command-table.ts b/packages/ui/src/lib/command-table.ts
index 30e1d8ef4..0b9beb35f 100644
--- a/packages/ui/src/lib/command-table.ts
+++ b/packages/ui/src/lib/command-table.ts
@@ -64,7 +64,12 @@ export const commandTable: readonly CommandDefinition[] = [
   { id: 'terminal-next-command', label: () => strings.keyboard.commands.terminalNextCommand, ownerOnly: true },
   { id: 'reopen-thread', label: () => strings.keyboard.commands.reopenThread, run: (store) => { void reopenLastArchived(store); } },
   { id: 'copy-answer', label: () => strings.keyboard.commands.copyAnswer, run: (store) => { const open = store.openThread; if (open) { const text = lastAnswer(open.messages); if (text) void store.copy(text); } } },
-  { id: 'find', label: () => strings.keyboard.commands.find, run: (store) => { const open = store.openThread; if (open) { store.showChat(); store.findOpen = true; store.findRequest += 1; } } },
+  // A new thread has nothing to find in yet: there the same chord picks its project.
+  { id: 'find', label: () => strings.keyboard.commands.find, run: (store) => {
+    const open = store.openThread;
+    if (open) { store.showChat(); store.findOpen = true; store.findRequest += 1; }
+    else if (store.draft && store.page === 'chat') store.projectChoiceRequest += 1;
+  } },
   { id: 'subagents', run: (store) => { store.showChat(); store.panel.toggleKind('agents'); } },
   { id: 'task-manager', run: (store) => { store.showSettings('task-manager'); } },
   { id: 'archived', run: (store) => { store.showSettings('general', 'archived'); } },
diff --git a/packages/ui/src/lib/commands.svelte.ts b/packages/ui/src/lib/commands.svelte.ts
index d57dfe877..501bb2017 100644
--- a/packages/ui/src/lib/commands.svelte.ts
+++ b/packages/ui/src/lib/commands.svelte.ts
@@ -45,7 +45,7 @@ export function appCommands(store: Store, inShell: boolean): PaletteItem[] {
     items.push(row('pin', open.pinned ? strings.palette.unpin : strings.palette.pin, 'favourite top'));
     items.push(row('rename', strings.palette.rename, 'title'));
     items.push(row('retitle', strings.palette.retitle, 'title agent name'));
-    items.push(row('find', strings.keyboard.commands.find, 'search text ctrl+f'));
+    items.push(row('find', strings.palette.find, 'search text ctrl+f'));
     items.push(row('copy-answer', strings.keyboard.commands.copyAnswer, 'clipboard reply response'));
     items.push(row('panel', strings.palette.panel, 'browser surface'));
     // Following subagents and workflow runs is open to a paired device.
diff --git a/packages/ui/src/lib/format.ts b/packages/ui/src/lib/format.ts
index 8d9cdad82..eae2991cf 100644
--- a/packages/ui/src/lib/format.ts
+++ b/packages/ui/src/lib/format.ts
@@ -255,6 +255,11 @@ export function titleFrom(prompt: string, max = 60): string {
 }
 
 /** A project's name as the user reads it: the drafts in the app's own language, any other as the core named it. */
+/** A folder with the user's home folded to `~`, the part that tells two projects apart. */
+export function homePath(path: string): string {
+  return path.replace(/^(\/home\/[^/]+|\/Users\/[^/]+|[A-Za-z]:\\Users\\[^\\]+)(?=[/\\]|$)/, '~');
+}
+
 export function projectName(project: { name: string; kind?: 'drafts' } | null | undefined): string {
   if (!project) return '';
   return project.kind === 'drafts' ? strings.drafts.name : project.name;
diff --git a/packages/ui/src/lib/palette.test.ts b/packages/ui/src/lib/palette.test.ts
index 4d4b4f5b5..5c5d265cd 100644
--- a/packages/ui/src/lib/palette.test.ts
+++ b/packages/ui/src/lib/palette.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { rankItems, scoreMatch, type PaletteItem } from './palette';
+import { rankItems, scoreFields, scoreMatch, sectionRows, type PaletteItem } from './palette';
 
 describe('scoreMatch', () => {
   test('a prefix beats a word start, which beats a substring, which beats scattered letters', () => {
@@ -63,3 +63,36 @@ describe('rankItems', () => {
     expect(rankItems('boite', rows).map((item) => item.id)).toEqual(['b', 'a']);
   });
 });
+
+describe('scoreFields', () => {
+  const boite = [{ text: 'Boite' }, { text: 'm2', penalty: 5 }, { text: '/home/boite/projects/boite', penalty: 15 }];
+  const other = [{ text: 'Boite' }, { text: 'PC', penalty: 5 }, { text: 'D:/Dev/boite', penalty: 15 }];
+
+  test('each word may land on its own field: the name, then the machine', () => {
+    expect(scoreFields('boite m2', boite)).not.toBeNull();
+    expect(scoreFields('boite m2', other)).toBeNull();
+    expect(scoreFields('m2 boi', boite)).not.toBeNull();
+  });
+
+  test('the name outranks the machine and the folder, and every word has to land', () => {
+    expect(scoreFields('boite', boite)!).toBeGreaterThan(scoreFields('m2', boite)!);
+    expect(scoreFields('m2', boite)!).toBeGreaterThan(scoreFields('projects', boite)!);
+    expect(scoreFields('boite zzz', boite)).toBeNull();
+  });
+});
+
+describe('sectionRows', () => {
+  test('a section stands where its best row ranked and keeps its rows together', () => {
+    const ranked: PaletteItem[] = [
+      { id: 'a', kind: 'thread', label: 'A', section: 'boite' },
+      { id: 'cmd', kind: 'command', label: 'Command' },
+      { id: 'b', kind: 'thread', label: 'B', section: 'notes' },
+      { id: 'c', kind: 'thread', label: 'C', section: 'boite' }
+    ];
+    expect(sectionRows(ranked).map((section) => [section.id, section.items.map((item) => item.id)])).toEqual([
+      ['boite', ['a', 'c']],
+      ['command', ['cmd']],
+      ['notes', ['b']]
+    ]);
+  });
+});
diff --git a/packages/ui/src/lib/palette.ts b/packages/ui/src/lib/palette.ts
index 2b3da620c..b83924086 100644
--- a/packages/ui/src/lib/palette.ts
+++ b/packages/ui/src/lib/palette.ts
@@ -4,7 +4,7 @@
  * test and the component only draws.
  */
 
-export type PaletteKind = 'thread' | 'command';
+export type PaletteKind = 'thread' | 'project' | 'command';
 
 export interface PaletteItem {
   id: string;
@@ -16,6 +16,14 @@ export interface PaletteItem {
   keywords?: string;
   /** The second line a list may draw under the label. The palette draws none; the slash menu does. */
   description?: string;
+  /** The heading a row sits under: a thread's project on its machine. Rows without one group by kind. */
+  section?: string;
+}
+
+/** A text a query word may land on, and what landing there costs against the label. */
+export interface SearchField {
+  text: string;
+  penalty?: number;
 }
 
 /** Threads shown before any typing: the most recent ones, whatever the project. */
@@ -80,6 +88,43 @@ export function scoreMatch(query: string, text: string): number | null {
   return Math.max(1, 30 - gaps * 3 - Math.min(last, 10));
 }
 
+/**
+ * How well a row with these fields answers `query`, null when it does not. The
+ * whole query may land on one field ("port the" on a title); otherwise every
+ * word lands on its own field, the weakest decides, so "boite m2" finds the
+ * project boite on the machine m2 and "trace boite" a thread of boite.
+ */
+export function scoreFields(query: string, fields: readonly SearchField[]): number | null {
+  const best = (needle: string): number | null => {
+    let top: number | null = null;
+    for (const field of fields) {
+      const score = scoreMatch(needle, field.text);
+      if (score !== null) top = Math.max(top ?? -Infinity, score - (field.penalty ?? 0));
+    }
+    return top;
+  };
+  const whole = best(query);
+  const words = fold(query.trim()).split(/\s+/).filter(Boolean);
+  if (words.length < 2) return whole;
+  let worst: number | null = Infinity;
+  for (const word of words) {
+    const score = best(word);
+    if (score === null) { worst = null; break; }
+    worst = Math.min(worst, score);
+  }
+  if (worst === null) return whole;
+  return Math.max(whole ?? -Infinity, worst);
+}
+
+/** A row's fields: its label, then its keywords, then its hint, each a little weaker. */
+function itemFields(item: PaletteItem): SearchField[] {
+  return [
+    { text: item.label },
+    ...(item.keywords === undefined ? [] : [{ text: item.keywords, penalty: 5 }]),
+    ...(item.hint === undefined ? [] : [{ text: item.hint, penalty: 10 }])
+  ];
+}
+
 /**
  * The rows to draw for `query`: every item that matches, best first, ties in
  * the order given. With nothing typed, the items come back as given, cut at
@@ -89,12 +134,33 @@ export function rankItems(query: string, items: PaletteItem[], limit = PALETTE_L
   if (query.trim().length === 0) return items.slice(0, limit);
   const scored: { item: PaletteItem; score: number; order: number }[] = [];
   items.forEach((item, order) => {
-    const own = scoreMatch(query, item.label);
-    const hint = item.hint === undefined ? null : scoreMatch(query, item.hint);
-    const words = item.keywords === undefined ? null : scoreMatch(query, item.keywords);
-    const best = Math.max(own ?? -1, hint === null ? -1 : hint - 10, words === null ? -1 : words - 5);
-    if (best >= 0) scored.push({ item, score: best, order });
+    const score = scoreFields(query, itemFields(item));
+    if (score !== null && score >= 0) scored.push({ item, score, order });
   });
   scored.sort((a, b) => b.score - a.score || a.order - b.order);
   return scored.slice(0, limit).map((entry) => entry.item);
 }
+
+export interface PaletteSection {
+  /** The rows' `section`, or their kind for rows without one. */
+  id: string;
+  kind: PaletteKind;
+  items: PaletteItem[];
+}
+
+/**
+ * Ranked rows cut into the headings the palette draws: a project's threads
+ * together, then the projects, then the commands. A section stands where its
+ * best row ranked, its rows keep their order inside it, so typing still puts
+ * the best match first and the first row is always the best one.
+ */
+export function sectionRows(ranked: readonly PaletteItem[]): PaletteSection[] {
+  const sections = new Map<string, PaletteSection>();
+  for (const item of ranked) {
+    const id = item.section ?? item.kind;
+    const section = sections.get(id);
+    if (section) section.items.push(item);
+    else sections.set(id, { id, kind: item.kind, items: [item] });
+  }
+  return [...sections.values()];
+}
diff --git a/packages/ui/src/lib/store.svelte.ts b/packages/ui/src/lib/store.svelte.ts
index d961a2b8d..70abd453e 100644
--- a/packages/ui/src/lib/store.svelte.ts
+++ b/packages/ui/src/lib/store.svelte.ts
@@ -286,6 +286,8 @@ export class Store {
   set findOpen(value) { this.#ctx.layout.findOpen = value; }
   get findRequest() { return this.#ctx.layout.findRequest; }
   set findRequest(value) { this.#ctx.layout.findRequest = value; }
+  get projectChoiceRequest() { return this.#ctx.layout.projectChoiceRequest; }
+  set projectChoiceRequest(value) { this.#ctx.layout.projectChoiceRequest = value; }
   get page() { return this.#ctx.layout.page; }
   set page(value) { this.#ctx.layout.page = value; }
   get settingsTab() { return this.#ctx.layout.settingsTab; }
diff --git a/packages/ui/src/lib/store/layout.svelte.ts b/packages/ui/src/lib/store/layout.svelte.ts
index 1d68f6088..83312ff64 100644
--- a/packages/ui/src/lib/store/layout.svelte.ts
+++ b/packages/ui/src/lib/store/layout.svelte.ts
@@ -29,6 +29,8 @@ export class Layout {
   /** The find bar over the open thread, and a count each ask bumps so a second Ctrl+F refocuses it. */
   findOpen = $state(false);
   findRequest = $state(0);
+  /** Bumped to open the draft's project dropdown from the keyboard. */
+  projectChoiceRequest = $state(0);
   page = $state<Page>('chat');
   settingsTab = $state<SettingsTab>('home');
   /** A settings card requested before its lazy page exists, with a fresh key for repeated asks. */
diff --git a/packages/ui/src/lib/strings/en/keyboard.ts b/packages/ui/src/lib/strings/en/keyboard.ts
index 42ea226bb..e08cffe12 100644
--- a/packages/ui/src/lib/strings/en/keyboard.ts
+++ b/packages/ui/src/lib/strings/en/keyboard.ts
@@ -38,7 +38,7 @@ export const strings = {
       pin: 'Pin or unpin this thread',
       reopenThread: 'Reopen the thread archived last',
       copyAnswer: 'Copy the last answer',
-      find: 'Find in this thread',
+      find: 'Find in this thread, or pick a new thread\'s project',
       terminalNew: 'New terminal',
       terminalSplit: 'Split the terminal right',
       terminalSplitVertical: 'Split the terminal down',
diff --git a/packages/ui/src/lib/strings/en/palette.ts b/packages/ui/src/lib/strings/en/palette.ts
index e7f6ee613..03eb558c5 100644
--- a/packages/ui/src/lib/strings/en/palette.ts
+++ b/packages/ui/src/lib/strings/en/palette.ts
@@ -1,9 +1,12 @@
 export const strings = {
 
   palette: {
-    placeholder: 'Search threads, or type a command',
+    placeholder: 'Search threads, projects or commands',
+    projects: 'Projects',
+    /** Extra words a project row answers to: picking one starts a thread there. */
+    newThreadWords: 'new thread start draft',
+    find: 'Find in this thread',
     terminal: 'Show or hide the terminal',
-    threads: 'Threads',
     commands: 'Commands',
     empty: 'Nothing matches.',
     hint: 'Enter to open, Esc to close',
diff --git a/packages/ui/src/lib/strings/fr/keyboard.ts b/packages/ui/src/lib/strings/fr/keyboard.ts
index 3ed704ba3..ffd1c6b67 100644
--- a/packages/ui/src/lib/strings/fr/keyboard.ts
+++ b/packages/ui/src/lib/strings/fr/keyboard.ts
@@ -39,7 +39,7 @@ export const fr: Translation = {
       pin: 'Épingler ou désépingler cette conversation',
       reopenThread: 'Rouvrir la dernière conversation archivée',
       copyAnswer: 'Copier la dernière réponse',
-      find: 'Chercher dans cette conversation',
+      find: 'Chercher dans cette conversation, ou choisir le projet d\'une nouvelle',
       terminalNew: 'Nouveau terminal',
       terminalSplit: 'Diviser le terminal à droite',
       terminalSplitVertical: 'Diviser le terminal en bas',
diff --git a/packages/ui/src/lib/strings/fr/palette.ts b/packages/ui/src/lib/strings/fr/palette.ts
index ac3e0f4ca..9688638d0 100644
--- a/packages/ui/src/lib/strings/fr/palette.ts
+++ b/packages/ui/src/lib/strings/fr/palette.ts
@@ -3,9 +3,12 @@ import type { Translation } from '../../i18n.svelte';
 export const fr: Translation = {
 
   palette: {
-    placeholder: 'Cherchez une conversation, ou tapez une commande',
+    placeholder: 'Cherchez une conversation, un projet ou une commande',
+    projects: 'Projets',
+    /** Extra words a project row answers to: picking one starts a thread there. */
+    newThreadWords: 'nouvelle conversation démarrer brouillon new thread',
+    find: 'Chercher dans cette conversation',
     terminal: 'Afficher ou masquer le terminal',
-    threads: 'Conversations',
     commands: 'Commandes',
     empty: 'Rien ne correspond.',
     hint: 'Entrée pour ouvrir, Échap pour fermer',
diff --git a/tests/e2e/drafts-overlays.test.ts b/tests/e2e/drafts-overlays.test.ts
index d5ed63bab..57dc28f10 100644
--- a/tests/e2e/drafts-overlays.test.ts
+++ b/tests/e2e/drafts-overlays.test.ts
@@ -30,11 +30,11 @@ test('height-capped desktop popovers can scroll to their last action', async ()
       await escape(page);
       await page.waitFor(`!document.querySelector('[data-testid="${popup}"]')`);
     }
-    // Rows with a hint are taller than the minimum: capped, the list scrolls and none of them shrinks onto the next.
+    // Capped by a short window, the project list scrolls and none of its rows shrinks onto the next.
     // A label's ink room overflows its row by under 3px at rest; a squashed row lost 7px or more.
     await page.evaluate('globalThis.__boiteTest.workspace.active.startDraft(null)');
     await page.waitFor('document.querySelector("[data-testid=draft-project]")');
-    await page.send('Emulation.setDeviceMetricsOverride', { width: 1100, height: 330, deviceScaleFactor: 1, mobile: false });
+    await page.send('Emulation.setDeviceMetricsOverride', { width: 1100, height: 220, deviceScaleFactor: 1, mobile: false });
     await page.click('[data-testid=draft-project]');
     await page.waitFor('document.querySelector("[data-testid=draft-project-menu]")');
     await page.settleAnimations();
diff --git a/tests/e2e/recent-attention.test.ts b/tests/e2e/recent-attention.test.ts
index d5166def9..83be5437f 100644
--- a/tests/e2e/recent-attention.test.ts
+++ b/tests/e2e/recent-attention.test.ts
@@ -177,10 +177,36 @@ test('the draft project picker has its logo and dashed selection at desktop and
   expect(await page.evaluate(`getComputedStyle(document.querySelector('${id('mobile-draft-project')}').closest('.project-choice')).borderStyle`)).toBe('dashed');
   expect(await page.evaluate('document.documentElement.scrollWidth <= window.innerWidth')).toBe(true);
   await capture('recent-project-phone.png');
+  // The find chord opens the phone's copy with the keys in its search, and Back closes it.
+  await page.evaluate(`document.querySelector('${id('composer-input')}').focus()`);
+  const find = { key: 'f', code: 'KeyF', modifiers: 2, windowsVirtualKeyCode: 70 };
+  await page.send('Input.dispatchKeyEvent', { type: 'rawKeyDown', ...find });
+  await page.send('Input.dispatchKeyEvent', { type: 'keyUp', ...find });
+  await page.waitFor(`document.activeElement === document.querySelector('${id('mobile-draft-project-search')}')`);
+  expect(await page.evaluate(`!!document.querySelector('${id('draft-project-menu')}')`)).toBe(false);
+  await page.evaluate('history.back()');
+  await page.waitFor(`!document.querySelector('${id('mobile-draft-project-menu')}')`);
   await page.click(id('mobile-draft-project'));
   await page.evaluate(`Array.from(document.querySelectorAll('${id('mobile-draft-project-menu')} [data-value]')).find(e => e.dataset.value === ${JSON.stringify(JSON.stringify(['http://builder.test', 'p-notes']))}).click()`);
   await page.waitFor(`globalThis.__boiteTest.workspace.active.machineId === 'http://builder.test' && document.querySelector('${id('mobile-draft-project')} [data-tech=python]')`);
   expect(await page.evaluate('document.documentElement.scrollWidth <= window.innerWidth')).toBe(true);
+  // From the keyboard alone: the find chord on a draft opens the list, one
+  // word lands on the project and one on the machine, Enter moves the draft
+  // to the other machine and its composer takes the next keys.
+  await page.send('Emulation.setDeviceMetricsOverride', { width: 1280, height: 900, deviceScaleFactor: 1, mobile: false });
+  await page.waitFor(`document.querySelector('${id('composer-input')}')?.getClientRects().length`);
+  await page.evaluate(`document.querySelector('${id('composer-input')}').focus()`);
+  const chord = { key: 'f', code: 'KeyF', modifiers: 2, windowsVirtualKeyCode: 70 };
+  await page.send('Input.dispatchKeyEvent', { type: 'rawKeyDown', ...chord });
+  await page.send('Input.dispatchKeyEvent', { type: 'keyUp', ...chord });
+  await page.waitFor(`document.activeElement === document.querySelector('${id('draft-project-search')}')`);
+  // The machine's own name, in whatever language the page speaks.
+  const here = await page.evaluate<string>('globalThis.__boiteTest.workspace.machines[0].label');
+  await page.send('Input.insertText', { text: `boite ${here}` });
+  await page.waitFor(`Array.from(document.querySelectorAll('${id('draft-project-list')} [data-value]')).map(e => e.dataset.value).join('|') === ${JSON.stringify(JSON.stringify([main, 'p-boite']))}`);
+  await page.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', text: '\r', windowsVirtualKeyCode: 13 });
+  await page.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13 });
+  await page.waitFor(`globalThis.__boiteTest.workspace.active === globalThis.__boiteTest.workspace.machines[0].store && globalThis.__boiteTest.workspace.active.draft?.projectId === 'p-boite' && document.activeElement === document.querySelector('${id('composer-input')}')`);
   expect(page.errors()).toEqual([]);
   console.log('RECENT_PROJECT_PICKER_OK desktop=1280x900 phone=390x844');
 }, 20_000);