diff --git a/DESIGN.md b/DESIGN.md
index a000c05..9181eb1 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -315,10 +315,10 @@ shadow is reserved for things genuinely *above* the page. Nothing has a resting
 itself, and the window only exists under `?frame`.
 
 ### Shadow Vocabulary
-- **Drawer / card** (`0 0 0 1px var(--line), 0 10px 26px -12px oklch(0.25 0.03 262 / 0.30)`): an open unit row and a compose card — the two things that lift out of a list in place.
+- **Drawer / card** (`0 0 0 1px var(--line), 0 10px 26px -12px oklch(0.25 0.03 262 / 0.30)`): an open unit row and the *request* card — the two things that lift out of a list in place. The goal composer is not one of them: it belongs to no list, so it is a modal.
 - **Popover / menu** (`0 2px 6px oklch(0.25 0.03 262 / 0.10), 0 18px 40px -10px oklch(0.25 0.03 262 / 0.34)`): the ⊕ menu and the account popover.
 - **Floating action** (`0 2px 4px oklch(0.25 0.03 262 / 0.20), 0 10px 22px -6px oklch(0.35 0.12 264 / 0.45)`): the ⊕, whose shadow carries the accent hue because the button is accent-filled.
-- **Modal** (`0 2px 6px …, 0 24px 60px -14px oklch(0.25 0.03 262 / 0.4)`): the space picker over its scrim.
+- **Modal** (`0 2px 6px …, 0 24px 60px -14px oklch(0.25 0.03 262 / 0.4)`): the space picker and the goal composer, each over its scrim.
 - **Window** (`0 1px 1px …, 0 18px 34px -14px …, 0 44px 90px -30px …`): the framed app and the sign-in card, on the desk.
 
 In dark mode every one of these gives way to a single deeper, softer shadow and the work is done by tone
@@ -378,19 +378,30 @@ fill *is* the state (a pressed version button, an "on" auto-review switch).
 
 ### The ⊕ (signature component)
 A 46px accent disc pinned to the pane's bottom-right with an accent-tinted shadow; it lifts 1.5px on hover
-and rotates its cross 135° into an ✕ when its menu is open. It makes an item of the list you are in — a
-goal on a project's list, a request everywhere else — and on a smart list it is absent rather than inert.
-Its menu is generated from the space's own registry records, so what it offers is data rather than markup.
-`⌘N` is the same button.
+and rotates its cross 135° into an ✕ when its menu is open. It is present on every view of an open space,
+and its menu always opens with **New goal** — a goal is the one record a human writes from scratch, and
+one that could only be written from a project's own goal list was one seven of the ten views had no way
+to write at all. Below that, separated by a hairline, it still makes an item of the list you are in: on a
+goal, a request of one of the registry's goal-scoped types; on System, a project-scoped one. That section
+is generated from the space's own registry records, so what it offers is data rather than markup. `⌘N` is
+the same button — and `n` is the goal item alone, from anywhere.
+
+The rule this replaces was "it makes an item of the list you are in, and on a smart list it is absent
+rather than inert". It was coherent and it cost the product its one authored record: on `/me`, on the
+Logbook, on `/space`, there was no ⊕ and so no way to write down the thing you had just thought of. The
+goal is now the constant and the list's own item is the variable.
 
 ### The keyboard map
-`/` puts the caret in quick find, `⌘N` is the ⊕ of the view being shown, Escape closes one layer per
+`/` puts the caret in quick find, `n` writes a goal from anywhere, `⌘N` is the ⊕ of the view being shown,
+Escape closes one layer per
 press — and `?` draws the map itself, over whatever is already open. It is the picker's paper card on
 the same scrim: a group heading per surface, a sans keycap per chord (`Esc` is a label printed on a key,
 not a machine identifier, so keycaps are never mono), and one plain sentence beside each. The pane bar
 carries a keyboard button next to the appearance toggle, titled with the key it stands for — a shortcut
 nobody can find is a shortcut nobody has. While the map is up it holds the keyboard: nothing behind it
-answers a key, and Escape takes the map away before it takes anything else.
+answers a key, and Escape takes the map away before it takes anything else. The same rule makes `n` inert
+under the space picker, and inert while a card already open has something typed into it — a bare letter is
+reachable by accident, and opening a second card is how the first one is abandoned.
 
 ### The URI chip
 Mono, 11.5px, sunk, 4px radius, `cursor: copy`, flashing sage on copy. It is how a record's identity stays
diff --git a/packages/ui/src/app.css b/packages/ui/src/app.css
index aef0221..93ef490 100644
--- a/packages/ui/src/app.css
+++ b/packages/ui/src/app.css
@@ -625,8 +625,10 @@ select.sl { resize: none; cursor: pointer; padding-right: 8px; }
   animation: pop 300ms var(--ease-out);
 }
 @keyframes pop { from { opacity: 0; transform: translateY(-6px) scale(0.995); } }
-.newreq h3 { margin: 0 0 3px; font-size: 14px; font-weight: 600; display: flex; align-items: center; gap: 8px; }
-.newreq .hint { margin: 0 0 11px; font-size: 12.5px; line-height: 1.5; color: var(--ink-2); }
+/* The goal composer is a modal (`.scrim .newgoal`) rather than a card in the page, but it is the same
+   object saying the same things, so the heading and the hint under it are drawn once for both. */
+.newreq h3, .newgoal h3 { margin: 0 0 3px; font-size: 14px; font-weight: 600; display: flex; align-items: center; gap: 8px; }
+.newreq .hint, .newgoal .hint { margin: 0 0 11px; font-size: 12.5px; line-height: 1.5; color: var(--ink-2); }
 /* Not scoped to the card: the space composer lives inside the picker, which is already a raised
    surface, so it borrows these fields and none of the card's chrome. */
 .fields { display: grid; gap: 9px; }
@@ -826,7 +828,11 @@ select.sl { resize: none; cursor: pointer; padding-right: 8px; }
   position: fixed; inset: 0; z-index: 50; display: grid; place-items: center;
   padding: 24px; background: oklch(0.2 0.03 262 / 0.34); overflow-y: auto;
 }
-.scrim .picker {
+/* Two cards on the one scrim: the space picker, and the goal composer. The composer is here rather
+   than in a page because the ⊕ offers a goal on every view of a space — and because a card injected
+   into a goal list shoves every row under it down as it opens, which was the visible bug. Off the
+   flow, nothing behind it moves. */
+.scrim .picker, .scrim .newgoal {
   width: min(560px, 100%); max-width: none; background: var(--paper);
   border: 1px solid var(--line); border-radius: 13px; padding: 24px 26px 26px;
   box-shadow: 0 2px 6px oklch(0.25 0.03 262 / 0.10), 0 24px 60px -14px oklch(0.25 0.03 262 / 0.4);
diff --git a/packages/ui/src/lib/components/NewGoal.svelte b/packages/ui/src/lib/components/NewGoal.svelte
index 1649099..0388f81 100644
--- a/packages/ui/src/lib/components/NewGoal.svelte
+++ b/packages/ui/src/lib/components/NewGoal.svelte
@@ -1,9 +1,15 @@
 <script lang="ts">
-  import type { ProjectView } from '@radial/core'
   import { goto } from '$app/navigation'
   import { account } from '$lib/auth.svelte.js'
-  import { closeDraft } from '$lib/compose.svelte.js'
-  import { goalUriHref, type Space } from '$lib/space.js'
+  import { closeDraft, holdDraft } from '$lib/compose.svelte.js'
+  import {
+    defaultGoalProject,
+    goalProjects,
+    lastGoalProject,
+    newGoalArgs,
+    rememberGoalProject,
+  } from '$lib/goal.js'
+  import { goalUriHref, projectByUri, SPACE_HREF, type Space } from '$lib/space.js'
   import { ui } from '$lib/ui.svelte.js'
   import { write } from '$lib/write.js'
   import Glyph from './Glyph.svelte'
@@ -11,41 +17,82 @@
   // A goal is the one thing a human writes from scratch; everything else is requested against one.
   // The card does not say so — the asymmetry shows up in what the ⊕ offers, and a paragraph
   // restating it on every create form is the kind of copy this app does without.
+  //
+  // It is a modal over a scrim rather than a card injected at the top of a goal list, for two
+  // reasons that are the same reason: a card in page flow moves everything under it when it opens —
+  // press the ⊕ three screens down and every row slides — and a card a route has to draw can only be
+  // opened where a route drew it. Off the flow, it opens identically on every view of the space,
+  // which is what lets the ⊕ offer a goal everywhere (DESIGN.md, The ⊕).
   interface Props {
-    project: ProjectView
     space: Space
+    /** The project the ⊕ was pressed on, when the view it was pressed on had one. */
+    here?: string | undefined
   }
-  const { project, space }: Props = $props()
+  const { space, here }: Props = $props()
 
   const writable = $derived(!space.fixture && account.status === 'signed-in')
 
+  // Both of these are read once, at open, and that is deliberate rather than an oversight — hence the
+  // suppressions. The card is mounted for as long as one goal is being written; a poll landing
+  // mid-compose must not reorder the select under the caret, and a preselection is a starting point
+  // rather than a derivation, so recomputing it would overwrite a choice the reader had just made.
+  // svelte-ignore state_referenced_locally
+  const eligible = goalProjects(space.index)
+
+  // svelte-ignore state_referenced_locally
+  const preselected = defaultGoalProject(space.index, { here, remembered: lastGoalProject() }) ?? ''
+  /** Nothing could be preselected and there is a choice to make, so that is the question to open on. */
+  const asks = preselected === '' && eligible.length > 1
+
+  let project = $state(preselected)
   let title = $state('')
   let body = $state('')
   let busy = $state(false)
   let error = $state('')
   let first = $state<HTMLInputElement | null>(null)
+  let chooser = $state<HTMLSelectElement | null>(null)
 
+  const named = $derived(project ? projectByUri(space.index, project) : undefined)
+
+  // The caret goes to the first thing the card actually needs, which is Title everywhere the project
+  // is already known — the ⊕ on a project, the sole-project space, the profile that has written one
+  // before. It is only the cold profile in a space with several projects that has to answer the
+  // question above it first, and putting the caret in a field whose Create button is disabled would
+  // be the card asking for a title and then refusing it.
   $effect(() => {
-    first?.focus()
+    if (asks) chooser?.focus()
+    else first?.focus()
   })
 
+  /** Something has been typed, so there is something a stray dismissal would cost. */
+  const holding = $derived(title.trim() !== '' || body.trim() !== '')
+
+  // Said out loud, because the bare `n` that opens this card can also replace it, and it asks first
+  // (`compose.svelte.ts`). The card is the only thing that knows what is in its fields.
+  $effect(() => holdDraft(holding))
+
+  /**
+   * The scrim is a way out, not a way to lose what was typed — the rule Escape already follows
+   * (`keys.ts`): a half-written goal is exactly the thing a stray click outside must not discard.
+   * An empty card has nothing to protect, so clicking away from one closes it. Cancel is always
+   * there and always closes, so the reader is never held by this.
+   */
+  function backdrop(event: MouseEvent): void {
+    if (event.target !== event.currentTarget) return
+    if (holding) return
+    closeDraft()
+  }
+
   async function submit(event: SubmitEvent): Promise<void> {
     event.preventDefault()
-    if (busy || title.trim() === '') return
+    if (busy || project === '' || title.trim() === '') return
     busy = true
     error = ''
     try {
-      const result = await write([
-        'goal',
-        'create',
-        '--project',
-        project.target.uri,
-        '--title',
-        title.trim(),
-        // A goal often starts as a title and nothing else; the body is the thing that gets written
-        // once the shape is clearer, so passing the flag at all is conditional on having something.
-        ...(body.trim() === '' ? [] : ['--body', body.trim()]),
-      ])
+      const result = await write(newGoalArgs({ project, title, body }))
+      // Remembered only now: a project chosen in a card that was cancelled is not a decision, and
+      // the next ⊕ pressed on a smart list starts from where the reader last actually wrote.
+      rememberGoalProject(project)
       closeDraft()
       // `write` has already re-read the author's repo, so the goal is in the index this navigates
       // into — no empty page waiting for the next tick.
@@ -58,56 +105,97 @@
   }
 </script>
 
-<div class="newreq">
-  <h3><span style="color:var(--accent)"><Glyph name="goal" size={16} /></span> New goal in {project.name}</h3>
-  {#if !writable}
-    <!-- The card still opens, and says why it cannot be filled in. Hiding ⊕ instead would leave the
-         goal list with no visible way to make a goal, which is a worse answer to the same question. -->
-    {#if space.fixture}
-      <p class="hint">The fixture has no repo behind it. Open a live space to write one.</p>
+<!-- The scrim is the click target, not a control: Escape is the keyboard's way out and Cancel is the
+     pointer's, so there is nothing here for a key handler to add.
+     It is not `aria-modal`, and it does not trap Tab, on the same terms as the keyboard map
+     (`Shortcuts.svelte`) and for the reason `focus.ts` gives: the app traps focus nowhere, and
+     claiming modality in ARIA without the trap to back it would tell a screen reader the page behind
+     is inert when Tab still reaches it. -->
+<!-- svelte-ignore a11y_click_events_have_key_events, a11y_no_static_element_interactions -->
+<div class="scrim" onclick={backdrop}>
+  <div class="newgoal" role="dialog" aria-labelledby="goal-head">
+    <h3 id="goal-head">
+      <span style="color:var(--accent)"><Glyph name="goal" size={16} /></span>
+      New goal{named ? ` in ${named.name}` : ''}
+    </h3>
+    {#if eligible.length === 0}
+      <!-- The ⊕ offers a goal on every view, so this is a card that opens over a space with nowhere
+           to put one. Saying so beats a select with no options in it — and which of the two ways a
+           space gets there matters, since a new space has never had a project to archive. -->
+      {#if space.index.projects.length === 0}
+        <p class="hint">
+          This space has no projects yet. An admin writes the first one, on
+          <a href={SPACE_HREF} onclick={closeDraft}>the space's own page</a>.
+        </p>
+      {:else}
+        <p class="hint">
+          Every project in this space is archived.
+          <a href={SPACE_HREF} onclick={closeDraft}>Add one on the space's own page</a>.
+        </p>
+      {/if}
+      <div class="acts"><button class="btn" type="button" onclick={closeDraft}>Close</button></div>
+    {:else if !writable}
+      <!-- The card still opens, and says why it cannot be filled in. Hiding ⊕ instead would leave the
+           goal list with no visible way to make a goal, which is a worse answer to the same question. -->
+      {#if space.fixture}
+        <p class="hint">The fixture has no repo behind it. Open a live space to write one.</p>
+      {:else}
+        <p class="hint">
+          <button class="linkish" type="button" onclick={() => (ui.accountOpen = true)}>Sign in</button>
+          to write a goal.
+        </p>
+      {/if}
+      <div class="acts"><button class="btn" type="button" onclick={closeDraft}>Close</button></div>
     {:else}
-      <p class="hint">
-        <button class="linkish" type="button" onclick={() => (ui.accountOpen = true)}>Sign in</button>
-        to write a goal.
-      </p>
-    {/if}
-    <div class="acts"><button class="btn" type="button" onclick={closeDraft}>Close</button></div>
-  {:else}
-    <form onsubmit={submit}>
-      <div class="fields">
-        <div>
-          <label for="goal-title">Title</label>
-          <input
-            bind:this={first}
-            bind:value={title}
-            class="ti"
-            id="goal-title"
-            disabled={busy}
-            placeholder="Ship the thing that is currently missing"
-          />
+      <form onsubmit={submit}>
+        <div class="fields">
+          {#if eligible.length > 1}
+            <div>
+              <label for="goal-project">
+                Project <span class="plain">— where the goal lands</span>
+              </label>
+              <select bind:this={chooser} bind:value={project} class="sl" id="goal-project" disabled={busy}>
+                <option value="">Choose a project…</option>
+                {#each eligible as candidate (candidate.target.uri)}
+                  <option value={candidate.target.uri}>{candidate.name}</option>
+                {/each}
+              </select>
+            </div>
+          {/if}
+          <div>
+            <label for="goal-title">Title</label>
+            <input
+              bind:this={first}
+              bind:value={title}
+              class="ti"
+              id="goal-title"
+              disabled={busy}
+              placeholder="Ship the thing that is currently missing"
+            />
+          </div>
+          <div>
+            <label for="goal-body">
+              What done looks like <span class="plain">— optional; every turn on this goal starts from it</span>
+            </label>
+            <textarea
+              bind:value={body}
+              class="ta"
+              id="goal-body"
+              disabled={busy}
+              placeholder="What is in scope, and what is not."
+            ></textarea>
+          </div>
         </div>
-        <div>
-          <label for="goal-body">
-            What done looks like <span class="plain">— optional; every turn on this goal starts from it</span>
-          </label>
-          <textarea
-            bind:value={body}
-            class="ta"
-            id="goal-body"
-            disabled={busy}
-            placeholder="What is in scope, and what is not."
-          ></textarea>
+        <div class="acts" style="margin-top:13px">
+          <button class="btn btn-p" type="submit" disabled={busy || project === '' || title.trim() === ''}>
+            {busy ? 'Creating…' : 'Create goal'}
+          </button>
+          <button class="btn" type="button" disabled={busy} onclick={closeDraft}>Cancel</button>
         </div>
-      </div>
-      <div class="acts" style="margin-top:13px">
-        <button class="btn btn-p" type="submit" disabled={busy || title.trim() === ''}>
-          {busy ? 'Creating…' : 'Create goal'}
-        </button>
-        <button class="btn" type="button" disabled={busy} onclick={closeDraft}>Cancel</button>
-      </div>
-    </form>
-    {#if error}
-      <p class="write-error" role="alert">{error}</p>
+      </form>
+      {#if error}
+        <p class="write-error" role="alert">{error}</p>
+      {/if}
     {/if}
-  {/if}
+  </div>
 </div>
diff --git a/packages/ui/src/lib/components/NewRequest.svelte b/packages/ui/src/lib/components/NewRequest.svelte
index ff9e2b6..a076d7b 100644
--- a/packages/ui/src/lib/components/NewRequest.svelte
+++ b/packages/ui/src/lib/components/NewRequest.svelte
@@ -2,7 +2,7 @@
   import { artifactTypes, durabilityOf } from '@radial/core'
   import { goto } from '$app/navigation'
   import { account } from '$lib/auth.svelte.js'
-  import { closeDraft } from '$lib/compose.svelte.js'
+  import { closeDraft, holdDraft } from '$lib/compose.svelte.js'
   import {
     capableAgents,
     captureBasis,
@@ -75,11 +75,24 @@
   let busy = $state(false)
   let error = $state('')
   let first = $state<HTMLTextAreaElement | null>(null)
+  let card = $state<HTMLDivElement | null>(null)
 
+  // This card stays in the page — it belongs to the view it lands in, and quotes the exact versions
+  // it is built on — so it is the one composer that can still move the page under the reader. Focus
+  // without scrolling, then bring the card into view by its own top edge: the browser's default is to
+  // scroll the *field* into view, which over `smooth` scrolling is the visible jump. A card opened
+  // from a drawer button is already on screen, and `nearest` leaves it alone.
   $effect(() => {
-    first?.focus()
+    first?.focus({ preventScroll: true })
+    card?.scrollIntoView({ block: 'nearest' })
   })
 
+  // A brief in progress, or an assignee narrowed to — the bare `n` that writes a goal from anywhere
+  // replaces whatever card is open, and this is what stops it doing that to a brief somebody is
+  // halfway through (`compose.svelte.ts`). Escape leaves the field without discarding it, which is
+  // exactly the state a stray letter key would otherwise land in.
+  $effect(() => holdDraft(brief.trim() !== '' || assignee !== ''))
+
   async function submit(event: SubmitEvent): Promise<void> {
     event.preventDefault()
     if (busy) return
@@ -114,7 +127,7 @@
   }
 </script>
 
-<div class="newreq">
+<div class="newreq" bind:this={card}>
   <h3>
     <span style="color:{draft.scope === 'project' ? 'var(--teal)' : 'var(--accent)'}">
       <Glyph name={draft.type} size={16} />
diff --git a/packages/ui/src/lib/components/PlusMenu.svelte b/packages/ui/src/lib/components/PlusMenu.svelte
index 838d2f4..3630190 100644
--- a/packages/ui/src/lib/components/PlusMenu.svelte
+++ b/packages/ui/src/lib/components/PlusMenu.svelte
@@ -2,44 +2,52 @@
   import { openDraft } from '$lib/compose.svelte.js'
   import { focusStranded, keepFocus } from '$lib/focus.js'
   import { registerPrimary } from '$lib/keys.js'
+  import { goalProjects } from '$lib/goal.js'
   import { requestableTypes } from '$lib/requests.js'
-  import type { Space } from '$lib/space.js'
+  import { type Space } from '$lib/space.js'
   import { closeMenu, ui } from '$lib/ui.svelte.js'
   import { typeLabel } from '$lib/units.js'
   import Glyph from './Glyph.svelte'
 
-  // ⊕ makes an item of the list you are in. On a project's goal list that is a goal — the one record
-  // a human writes from scratch — and everywhere else it is a *request*, generated from the registry
+  // ⊕ always offers a new goal, and additionally makes an item of the list you are in.
+  //
+  // It used to be only the second of those, which meant the one record a human writes from scratch
+  // could only be written from a project's own goal list — seven of the ten routes had no ⊕ at all,
+  // and of the three that did, one offered a goal. So the goal is now the first item of every menu, on
+  // every view of an open space, and the *rest* of the menu is still generated from the registry
   // (`com.disnetdev.radial.artifactType` records, scoped by the view) and from nothing else. That is
   // the product's core claim as a piece of UI: an admin writes a registry record and a button
   // appears, with no deploy and no schema change.
-  type Action =
-    | { kind: 'goal'; project: string }
-    | { kind: 'types'; scope: 'goal' | 'project'; target: string; where: string }
-
   interface Props {
     space: Space
-    action: Action
+    /** The project this view belongs to, if it belongs to one — what a new goal starts on. */
+    here?: string | undefined
+    /** The registry section, on the views that have things to request. */
+    types?: { scope: 'goal' | 'project'; target: string; where: string } | undefined
   }
-  const { space, action }: Props = $props()
+  const { space, here, types }: Props = $props()
 
   let menu = $state<HTMLDivElement | null>(null)
   let plus = $state<HTMLButtonElement | null>(null)
 
   const open = $derived(ui.menuOpen)
-  const types = $derived(action.kind === 'types' ? requestableTypes(space.index, action.scope) : [])
+  const offered = $derived(types ? requestableTypes(space.index, types.scope) : [])
+  // Looked up among the projects a goal may actually be written into, not among all of them: the card
+  // drops an archived `here` and asks instead (`goal.ts:defaultGoalProject`), and `/space` links
+  // archived projects like any other. An unfiltered lookup would let this item promise "New goal in
+  // radial-site" and then open a card headed something else.
+  const project = $derived(
+    here ? goalProjects(space.index).find((candidate) => candidate.target.uri === here) : undefined,
+  )
 
   function toggle(): void {
-    if (action.kind === 'goal') {
-      // Nothing to choose between: the list holds one kind of thing, so ⊕ opens the card directly.
-      openDraft({ kind: 'goal', project: action.project })
-      return
-    }
     ui.menuOpen = !ui.menuOpen
   }
 
-  // ⌘N is this button, whatever this button happens to mean on this view. Registered rather than
-  // handled here, so the map lives in one table (`keys.ts`) and a view with no ⊕ has no ⌘N.
+  // ⌘N is this button. Registered rather than handled here, so the map lives in one table
+  // (`keys.ts`). Most browsers keep ⌘N for a new window and never deliver it, which is why a plain
+  // `n` — registered in the table itself, so it does not depend on this being mounted — is the one
+  // that always lands.
   $effect(() => registerPrimary(toggle))
 
   // The menu is opened to be chosen from, so the first item takes focus. Dismissing it — Escape, a
@@ -74,11 +82,11 @@
 <button
   bind:this={plus}
   class="plus"
-  aria-expanded={action.kind === 'types' ? open : undefined}
-  aria-haspopup={action.kind === 'types' ? 'menu' : undefined}
+  aria-expanded={open}
+  aria-haspopup="menu"
   aria-keyshortcuts="Meta+N Control+N"
-  aria-label={action.kind === 'goal' ? 'Write a goal' : 'Request an artifact'}
-  title={action.kind === 'goal' ? 'Write a goal — ⌘N' : 'Request an artifact — ⌘N'}
+  aria-label="New goal or request an artifact"
+  title="New goal or request an artifact — ⌘N"
   onclick={toggle}
 >
   <svg width="21" height="21" viewBox="0 0 22 22" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round">
@@ -86,20 +94,39 @@
   </svg>
 </button>
 
-{#if action.kind === 'types'}
-  <div class="menu" role="menu" aria-label="Artifact types" hidden={!open} bind:this={menu}>
-    <div class="menu-head">Request an artifact — {action.where}</div>
-    {#each types as { name, value } (name)}
+<div class="menu" role="menu" aria-label="New goal or artifact types" hidden={!open} bind:this={menu}>
+  <button
+    class="menu-item"
+    role="menuitem"
+    aria-keyshortcuts="N"
+    onclick={() => {
+      // Same contract as the type items below: the item that was chosen goes away with the menu, so
+      // the card's way back is the ⊕, and `chose` is what stops the effect above pulling the caret
+      // out of the field the card has just put it in.
+      chose = true
+      closeMenu()
+      openDraft({ kind: 'goal', ...(here ? { project: here } : {}) }, plus ?? undefined)
+    }}
+  >
+    <span class="glyph" style="color:var(--accent)"><Glyph name="goal" /></span>
+    <span class="mtxt">
+      <span class="mname">New goal{project ? ` in ${project.name}` : ''}</span>
+      <span class="mdesc">The one record a human writes from scratch — press <b>n</b> anywhere</span>
+    </span>
+  </button>
+  {#if types}
+    <div class="menu-rule"></div>
+    <div class="menu-head">Request an artifact — {types.where}</div>
+    {#each offered as { name, value } (name)}
       <button
         class="menu-item"
         role="menuitem"
         onclick={() => {
           chose = true
           closeMenu()
-          if (action.kind !== 'types') return
           // The item that was chosen goes away with the menu, so the card's way back is the ⊕.
           openDraft(
-            { kind: 'request', target: action.target, scope: action.scope, type: name },
+            { kind: 'request', target: types.target, scope: types.scope, type: name },
             plus ?? undefined,
           )
         }}
@@ -111,10 +138,10 @@
         </span>
       </button>
     {/each}
-    {#if types.length === 0}
+    {#if offered.length === 0}
       <div class="menu-head" style="font-weight:400;line-height:1.4">
-        This space has no {action.scope}-scoped types in its registry yet.
+        This space has no {types.scope}-scoped types in its registry yet.
       </div>
     {/if}
-  </div>
-{/if}
+  {/if}
+</div>
diff --git a/packages/ui/src/lib/compose.svelte.ts b/packages/ui/src/lib/compose.svelte.ts
index 18bdd32..c128134 100644
--- a/packages/ui/src/lib/compose.svelte.ts
+++ b/packages/ui/src/lib/compose.svelte.ts
@@ -1,10 +1,11 @@
 // What is being written right now.
 //
-// A compose card belongs to the view it writes into — a goal card at the top of a project's list, a
-// request card at the top of the goal it is asked against — but the ⊕ that opens one lives in the
-// pane, next to the rail and outside every route, and so does the button in a drawer six rows down.
-// So "there is a draft" is per-tab state rather than a prop, and this is the smallest place to keep
-// it.
+// A request card belongs to the view it writes into — at the top of the goal it is asked against —
+// but the ⊕ that opens one lives in the pane, next to the rail and outside every route, and so does
+// the button in a drawer six rows down. A goal card belongs to no view at all: it is a modal drawn
+// from the layout, because the ⊕ offers a goal on every view of an open space and a card the route
+// had to draw could only exist where a route drew it. So "there is a draft" is per-tab state rather
+// than a prop, and this is the smallest place to keep it.
 //
 // One draft at a time, deliberately: two half-written requests on one screen is a state nobody asked
 // for, and opening a second card is how you abandon the first.
@@ -12,7 +13,12 @@
 import { focusIsLoose, keepFocus, type Focusable } from './focus.js'
 import type { RequestDraft } from './requests.js'
 
-export type Draft = { kind: 'goal'; project: string } | RequestDraft
+/**
+ * `project` is what the ⊕ knew when it was pressed — the project whose list, System page or goal the
+ * reader was on — and it is optional because a ⊕ pressed on a smart list knows nothing. It is a hint
+ * rather than the answer: the card resolves its own project (`goal.ts:defaultGoalProject`).
+ */
+export type Draft = { kind: 'goal'; project?: string } | RequestDraft
 
 export const compose = $state({
   draft: undefined as Draft | undefined,
@@ -21,6 +27,21 @@ export const compose = $state({
 /** Where the card was opened from — a drawer's button, six rows down — so closing it goes back there. */
 let opener: (() => boolean) | undefined
 
+/**
+ * Whether the card that is open has anything in it worth keeping.
+ *
+ * The fields belong to the card, so the card is the only thing that knows — and the answer is needed
+ * one layer out, by the bare `n` that writes a goal from anywhere (`keys.ts`). "Opening a second card
+ * is how you abandon the first" was a decision while every way to open one was a deliberate click on
+ * a menu item; a letter key is reachable by accident, from a card whose Escape has only blurred the
+ * field, so it asks this before it replaces anything. It is the same question the goal composer's
+ * scrim asks before it closes on a click.
+ *
+ * Plain module state rather than `$state`, like `opener` above: it is read from a key handler, and a
+ * reactive read there would be a dependency on nothing in particular.
+ */
+let content = false
+
 /**
  * `from` names where to go back to when the control that opened the card is about to stop being a
  * place — a ⊕ menu item disappears with the menu it is in, so that menu passes the ⊕ itself. A button
@@ -36,6 +57,10 @@ export function openDraft(draft: Draft, from?: Focusable): void {
       }
     : keepFocus()
   compose.draft = draft
+  // The card that is arriving is empty until it says otherwise, and it says so from an effect that
+  // has not run yet. Reset here rather than trusting the card that is leaving to clean up: one that
+  // unmounts without a word must not leave the app holding a brief that is gone.
+  content = false
 }
 
 export function closeDraft(): void {
@@ -44,10 +69,19 @@ export function closeDraft(): void {
   // opening one would immediately re-run the effect that closes it. `opener` is plain module state
   // and answers the same question ("was anything open?") without being reactive.
   compose.draft = undefined
+  content = false
   opener?.()
   opener = undefined
 }
 
+/** Said by the card, on every keystroke it takes. */
+export function holdDraft(has: boolean): void {
+  content = has
+}
+
+/** Asked before a draft is replaced by something the reader may not have meant to open. */
+export const draftHolds = (): boolean => content
+
 /**
  * The draft this view should be drawing, if the one that is open belongs to it.
  *
diff --git a/packages/ui/src/lib/goal.test.ts b/packages/ui/src/lib/goal.test.ts
new file mode 100644
index 0000000..63c82ea
--- /dev/null
+++ b/packages/ui/src/lib/goal.test.ts
@@ -0,0 +1,165 @@
+import type { MaterializedIndex, ProjectView } from '@radial/core'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { buildFixtureSpace } from './fixture.js'
+import {
+  defaultGoalProject,
+  goalProjects,
+  lastGoalProject,
+  newGoalArgs,
+  rememberGoalProject,
+} from './goal.js'
+
+// The ⊕ offers a goal from every view, so the card can be opened somewhere that names no project at
+// all. Everything here is that one consequence: which projects it may offer, which of them it starts
+// on, and what it writes.
+
+const space = buildFixtureSpace()
+
+const uriOf = (name: string): string => {
+  const found = space.index.projects.find((project) => project.name === name)
+  if (!found) throw new Error(`fixture project missing: ${name}`)
+  return found.target.uri
+}
+
+const NG = uriOf('radial-ng')
+const SITE = uriOf('radial-site')
+
+/** The fixture's index with one project archived — the state that has to fall through, not be offered. */
+const withArchived = (name: string): MaterializedIndex => ({
+  ...space.index,
+  projects: space.index.projects.map((project): ProjectView =>
+    project.name === name ? { ...project, archived: true } : project,
+  ),
+})
+
+/** The fixture's index cut down to one live project: the case with no choice to offer. */
+const only = (name: string): MaterializedIndex => ({
+  ...space.index,
+  projects: space.index.projects.filter((project) => project.name === name),
+})
+
+/** `localStorage`, as much of it as this needs. The node test environment has none. */
+function fakeStorage(initial: Record<string, string> = {}): Storage {
+  const map = new Map(Object.entries(initial))
+  return {
+    getItem: (key: string) => map.get(key) ?? null,
+    setItem: (key: string, value: string) => void map.set(key, value),
+    removeItem: (key: string) => void map.delete(key),
+    clear: () => map.clear(),
+    key: (index: number) => [...map.keys()][index] ?? null,
+    get length() {
+      return map.size
+    },
+  } as Storage
+}
+
+const store = (initial?: Record<string, string>): Storage => {
+  const fake = fakeStorage(initial)
+  Object.defineProperty(globalThis, 'localStorage', { value: fake, configurable: true })
+  return fake
+}
+
+beforeEach(() => {
+  store()
+})
+
+afterEach(() => {
+  Reflect.deleteProperty(globalThis, 'localStorage')
+})
+
+describe('goalProjects', () => {
+  it('is what the rail lists — the space’s live projects', () => {
+    expect(goalProjects(space.index).map((project) => project.name)).toEqual([
+      'radial-ng',
+      'radial-site',
+    ])
+  })
+
+  it('leaves out an archived project: agents skip it, so a goal written there is never picked up', () => {
+    expect(goalProjects(withArchived('radial-site')).map((project) => project.name)).toEqual([
+      'radial-ng',
+    ])
+  })
+})
+
+describe('defaultGoalProject', () => {
+  it('prefers where the reader already is', () => {
+    expect(defaultGoalProject(space.index, { here: SITE, remembered: NG })).toBe(SITE)
+  })
+
+  it('falls back to the project this profile last wrote into', () => {
+    expect(defaultGoalProject(space.index, { remembered: SITE })).toBe(SITE)
+  })
+
+  it('asks rather than guessing, on a cold profile in a space with several projects', () => {
+    expect(defaultGoalProject(space.index, {})).toBeUndefined()
+    expect(defaultGoalProject(space.index)).toBeUndefined()
+  })
+
+  it('takes the sole live project: there is no choice to make', () => {
+    expect(defaultGoalProject(only('radial-ng'), {})).toBe(NG)
+  })
+
+  it('ignores a URI this space will not accept — another space’s project, or one since archived', () => {
+    expect(
+      defaultGoalProject(space.index, { remembered: 'at://did:plc:elsewhere/x/y' }),
+    ).toBeUndefined()
+    // …and a hint that has been archived falls through to the one project that is left.
+    expect(defaultGoalProject(withArchived('radial-site'), { here: SITE })).toBe(NG)
+  })
+
+  it('returns nothing at all when every project is archived', () => {
+    const none: MaterializedIndex = {
+      ...space.index,
+      projects: space.index.projects.map((project): ProjectView => ({ ...project, archived: true })),
+    }
+    expect(defaultGoalProject(none, { here: NG })).toBeUndefined()
+  })
+})
+
+describe('newGoalArgs', () => {
+  it('is the vector a shell takes', () => {
+    expect(newGoalArgs({ project: NG, title: 'Ship it', body: '' })).toEqual([
+      'goal',
+      'create',
+      '--project',
+      NG,
+      '--title',
+      'Ship it',
+    ])
+  })
+
+  it('passes --body only when there is one, and trims both', () => {
+    expect(newGoalArgs({ project: NG, title: '  Ship it  ', body: '  what done looks like  ' })).toEqual([
+      'goal',
+      'create',
+      '--project',
+      NG,
+      '--title',
+      'Ship it',
+      '--body',
+      'what done looks like',
+    ])
+    // Whitespace is not a body: the flag is dropped rather than passed empty.
+    expect(newGoalArgs({ project: NG, title: 'Ship it', body: '   \n ' })).not.toContain('--body')
+  })
+})
+
+describe('the remembered project', () => {
+  it('is nothing on a cold profile, and what was last written after that', () => {
+    expect(lastGoalProject()).toBeUndefined()
+    rememberGoalProject(SITE)
+    expect(lastGoalProject()).toBe(SITE)
+  })
+
+  it('reads back through storage rather than from memory', () => {
+    store({ 'radial:goal-project': NG })
+    expect(lastGoalProject()).toBe(NG)
+  })
+
+  it('still writes goals in a profile that refuses storage; it just forgets', () => {
+    Reflect.deleteProperty(globalThis, 'localStorage')
+    expect(() => rememberGoalProject(NG)).not.toThrow()
+    expect(lastGoalProject()).toBeUndefined()
+  })
+})
diff --git a/packages/ui/src/lib/goal.ts b/packages/ui/src/lib/goal.ts
new file mode 100644
index 0000000..198769e
--- /dev/null
+++ b/packages/ui/src/lib/goal.ts
@@ -0,0 +1,98 @@
+// Writing a goal, from anywhere.
+//
+// A goal is the one record a human writes from scratch, and until now the only place to write one was
+// a project's own goal list — the route supplied the project, so the card never had to ask. The ⊕ now
+// offers a goal on every view of an open space (DESIGN.md, The ⊕), which means the card can be opened
+// from `/me`, from the Logbook, from a bare `n` with nothing in particular on screen. So the project
+// stops being implied by the route and becomes something the card resolves, remembers and says out
+// loud.
+//
+// All of that is here rather than in the component for the usual reason: it is the part with rules —
+// which projects are eligible, which of them is preselected, what the write actually is — and rules
+// are worth testing without a browser.
+
+import type { MaterializedIndex, ProjectView } from '@radial/core'
+import { liveProjects } from './space.js'
+
+/**
+ * Where a goal may be written: live projects only.
+ *
+ * The same list the rail draws (`space.ts:liveProjects`). An archived project is one agents skip and
+ * people do too, so offering it here would be offering a goal nothing will ever pick up.
+ */
+export const goalProjects = (index: MaterializedIndex): ProjectView[] => liveProjects(index)
+
+export interface ProjectHints {
+  /** The project the ⊕ was pressed on, or the project of the goal being read. */
+  here?: string | undefined
+  /** The last project this browser profile wrote a goal into. */
+  remembered?: string | undefined
+}
+
+/**
+ * Which project the card starts on, or nothing when the reader has to choose.
+ *
+ * Context first, then habit, then the degenerate case: a space with one project has no choice to
+ * offer. Every candidate is checked against `goalProjects` before it is taken, so a URI remembered
+ * from another space — or one whose project has since been archived — falls through to the next
+ * answer rather than preselecting something this space will not accept.
+ */
+export function defaultGoalProject(
+  index: MaterializedIndex,
+  hints: ProjectHints = {},
+): string | undefined {
+  const eligible = goalProjects(index)
+  const known = (uri: string | undefined): string | undefined =>
+    uri && eligible.some((project) => project.target.uri === uri) ? uri : undefined
+  return known(hints.here) ?? known(hints.remembered) ?? (eligible.length === 1 ? eligible[0]?.target.uri : undefined)
+}
+
+/**
+ * The argument vector `radial goal create` takes at a shell — the whole of what the card produces,
+ * exactly as `requests.ts:requestArgs` is for a request.
+ *
+ * A goal often starts as a title and nothing else; the body is what gets written once the shape is
+ * clearer, so passing the flag at all is conditional on having something.
+ */
+export function newGoalArgs(fields: { project: string; title: string; body: string }): string[] {
+  const body = fields.body.trim()
+  return [
+    'goal',
+    'create',
+    '--project',
+    fields.project,
+    '--title',
+    fields.title.trim(),
+    ...(body === '' ? [] : ['--body', body]),
+  ]
+}
+
+const KEY = 'radial:goal-project'
+
+/** A browser that refuses storage still writes goals; it just forgets. Same bargain as the rail width. */
+function storage(): Storage | undefined {
+  try {
+    return globalThis.localStorage ?? undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The project this profile last wrote a goal into. Deliberately not validated here — which projects
+ * are legal is a fact about the space that happens to be open, and this module is asked that question
+ * one `defaultGoalProject` later, against the index the card is actually drawing from.
+ */
+export function lastGoalProject(): string | undefined {
+  const raw = storage()?.getItem(KEY)
+  return raw === null || raw === undefined || raw === '' ? undefined : raw
+}
+
+/** Remember it, once the write has landed: a project chosen but not written into is not a decision. */
+export function rememberGoalProject(uri: string): void {
+  try {
+    storage()?.setItem(KEY, uri)
+  } catch {
+    // Quota, private mode, a profile with storage off — the goal is still written where they chose.
+  }
+}
diff --git a/packages/ui/src/lib/keys.test.ts b/packages/ui/src/lib/keys.test.ts
index 9a7c72e..b73de6f 100644
--- a/packages/ui/src/lib/keys.test.ts
+++ b/packages/ui/src/lib/keys.test.ts
@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { compose, openDraft } from './compose.svelte.js'
+import { closeDraft, compose, holdDraft, openDraft } from './compose.svelte.js'
+import { buildFixtureSpace } from './fixture.js'
 import { onKeydown, registerPrimary, registerQuickFind, SHORTCUTS, type KeyPress } from './keys.js'
 import { session } from './session.svelte.js'
 import { ui } from './ui.svelte.js'
@@ -26,7 +27,12 @@ beforeEach(() => {
   ui.menuOpen = false
   ui.helpOpen = false
   session.picking = false
+  // `n` writes a goal into the space that is open, so the table asks whether there is one. The
+  // fixture is the cheapest honest answer — the same one every other test here draws from.
+  session.space = buildFixtureSpace()
   compose.draft = undefined
+  // Whether the open card is holding anything is module state beside the draft, so it is reset with it.
+  holdDraft(false)
   registerQuickFind(quickFind)
   registerPrimary(() => {})
 })
@@ -57,7 +63,7 @@ describe('⌘N', () => {
     expect(primary).toHaveBeenCalledTimes(2)
   })
 
-  it('does nothing on a view with no ⊕ — a smart list is somebody else’s list', () => {
+  it('does nothing where no ⊕ is mounted — the picker, before there is a space', () => {
     const primary = vi.fn()
     const forget = registerPrimary(primary)
     forget()
@@ -74,7 +80,7 @@ describe('⌘N', () => {
     expect(primary).not.toHaveBeenCalled()
   })
 
-  it('leaves an unmodified n alone', () => {
+  it('leaves an unmodified n to the goal composer rather than to this view’s ⊕', () => {
     const primary = vi.fn()
     registerPrimary(primary)
     onKeydown(press('n').event)
@@ -82,6 +88,94 @@ describe('⌘N', () => {
   })
 })
 
+describe('n', () => {
+  it('writes a goal from anywhere — no modifier, no ⊕ required', () => {
+    const { event, preventDefault } = press('n')
+    onKeydown(event)
+    expect(compose.draft).toEqual({ kind: 'goal' })
+    expect(preventDefault).toHaveBeenCalled()
+  })
+
+  it('is a letter when a letter is being typed', () => {
+    for (const tag of ['INPUT', 'TEXTAREA', 'SELECT']) {
+      onKeydown(press('n', { target: field(tag) }).event)
+    }
+    onKeydown(press('n', { target: { tagName: 'DIV', isContentEditable: true } }).event)
+    expect(compose.draft).toBeUndefined()
+  })
+
+  it('leaves a capital N alone: somebody typing one is not asking for a card', () => {
+    onKeydown(press('N').event)
+    expect(compose.draft).toBeUndefined()
+  })
+
+  // The menu goes with it, so Escape still unwinds exactly one thing per press — the card, and then
+  // nothing, rather than the card and a menu still open behind it.
+  it('takes the ⊕ menu with it', () => {
+    ui.menuOpen = true
+    onKeydown(press('n').event)
+    expect(ui.menuOpen).toBe(false)
+    expect(compose.draft).toEqual({ kind: 'goal' })
+  })
+
+  it('does nothing before there is a space to write into', () => {
+    session.space = undefined
+    const { event, preventDefault } = press('n')
+    onKeydown(event)
+    expect(compose.draft).toBeUndefined()
+    expect(preventDefault).not.toHaveBeenCalled()
+  })
+
+  it('is behind the map, like everything else', () => {
+    ui.helpOpen = true
+    onKeydown(press('n').event)
+    expect(compose.draft).toBeUndefined()
+  })
+
+  // The picker covers the whole shell, so a card opened under it is a form the reader cannot see and
+  // two Escapes to get back from — the first of which looks like it did nothing.
+  it('is inert while the space picker is up', () => {
+    session.picking = true
+    const { event, preventDefault } = press('n')
+    onKeydown(event)
+    expect(compose.draft).toBeUndefined()
+    expect(preventDefault).not.toHaveBeenCalled()
+  })
+
+  it('takes the account popover with it, the way it takes the menu', () => {
+    ui.accountOpen = true
+    onKeydown(press('n').event)
+    expect(ui.accountOpen).toBe(false)
+    expect(compose.draft).toEqual({ kind: 'goal' })
+  })
+
+  // The sequence the map itself teaches: type a brief, press Escape once to get the page back — which
+  // deliberately keeps the draft — and then press a letter. Replacing the card there would discard a
+  // brief nobody asked to throw away.
+  it('does not replace a card that has something in it', () => {
+    openDraft({ kind: 'request', target: 'at://goal', scope: 'goal', type: 'plan' })
+    holdDraft(true)
+    const { event, preventDefault } = press('n')
+    onKeydown(event)
+    expect(compose.draft?.kind).toBe('request')
+    expect(preventDefault).not.toHaveBeenCalled()
+  })
+
+  it('replaces an empty one, which is nothing to lose', () => {
+    openDraft({ kind: 'request', target: 'at://goal', scope: 'goal', type: 'plan' })
+    onKeydown(press('n').event)
+    expect(compose.draft).toEqual({ kind: 'goal' })
+  })
+
+  it('starts every card empty, whatever the last one was holding', () => {
+    openDraft({ kind: 'request', target: 'at://goal', scope: 'goal', type: 'plan' })
+    holdDraft(true)
+    closeDraft()
+    onKeydown(press('n').event)
+    expect(compose.draft).toEqual({ kind: 'goal' })
+  })
+})
+
 describe('?', () => {
   it('shows the map, and shows it away again', () => {
     onKeydown(press('?').event)
@@ -114,7 +208,10 @@ describe('?', () => {
 
   it('lists the keys the map actually answers to', () => {
     const listed = SHORTCUTS.flatMap((group) => group.items).flatMap((item) => item.keys)
-    for (const chord of ['/', '⌘N', '?', 'Esc']) expect(listed).toContain(chord)
+    for (const chord of ['/', 'n', '⌘N', '?', 'Esc']) expect(listed).toContain(chord)
+    // Every keycap in the table is the character that works, which for the goal is the lowercase one:
+    // the handler ignores `N`, so advertising it would be a row that does nothing when pressed.
+    expect(listed).not.toContain('N')
   })
 })
 
diff --git a/packages/ui/src/lib/keys.ts b/packages/ui/src/lib/keys.ts
index 0b4f194..178ae80 100644
--- a/packages/ui/src/lib/keys.ts
+++ b/packages/ui/src/lib/keys.ts
@@ -10,10 +10,16 @@
 // themselves. Escape dismisses exactly one layer per press, outermost surface first.
 //
 //   /        focus quick find
-//   ⌘N/^N    the ⊕ of the view being shown — a goal on a project's list, a request everywhere else
+//   n        write a goal, from anywhere
+//   ⌘N/^N    the ⊕ of this view, which always offers a goal and additionally what the list holds
 //   ?        show the map itself
 //   Esc      leave the field, or close the topmost thing that is open
 //
+// `n` is here rather than registered by a component, and that is the point of it: the composer is a
+// modal drawn from the layout, so writing a goal does not depend on which ⊕ happens to be mounted.
+// It is also the only one of the two that always lands — most browsers keep ⌘N for a new window and
+// never deliver it to the page.
+//
 // The third of those is why `SHORTCUTS` sits here rather than in the component that draws it: a list
 // of keys maintained anywhere but beside the handlers is a list that goes stale the first time a
 // binding moves. The table below is the one the reader sees, next to the code it describes.
@@ -21,7 +27,7 @@
 // Nothing here reaches for the DOM: `isField` reads a tag name and the two registries hold whatever
 // was handed to them, so the whole map is exercised in `keys.test.ts` without a browser.
 
-import { closeDraft, compose } from './compose.svelte.js'
+import { closeDraft, compose, draftHolds, openDraft } from './compose.svelte.js'
 import type { Focusable } from './focus.js'
 import { session } from './session.svelte.js'
 import { closeMenu, ui } from './ui.svelte.js'
@@ -47,8 +53,8 @@ export function registerQuickFind(input: (Focusable & { blur(): void }) | null):
 }
 
 /**
- * What ⌘N means here, registered by the ⊕ itself. A view with no ⊕ — a smart list is somebody else's
- * list — registers nothing, and ⌘N does nothing rather than making an item in a list you are not in.
+ * What ⌘N means here, registered by the ⊕ itself. Every view of an open space has one, so this is
+ * live wherever a space is; the solo shell — the picker, before there is a space — registers nothing.
  */
 export function registerPrimary(action: () => void): () => void {
   primary = action
@@ -81,9 +87,11 @@ export const SHORTCUTS: readonly ShortcutGroup[] = [
     title: 'Anywhere',
     items: [
       { keys: ['/'], what: 'Put the caret in quick find, which filters this view' },
+      // Lowercase, because the handler is: capital N is left to the browser.
+      { keys: ['n'], what: 'Write a goal, from anywhere — it opens over the page rather than in it' },
       {
         keys: ['⌘N', 'Ctrl N'],
-        what: 'Make an item of this list — a goal on a project, a request everywhere else',
+        what: 'Open the ⊕ of this view: a new goal, plus the artifact types you can ask for here',
       },
       { keys: ['?'], what: 'Show this list' },
       { keys: ['Esc'], what: 'Leave the field, or close the topmost thing that is open' },
@@ -181,6 +189,33 @@ export function onKeydown(event: KeyPress): void {
     return
   }
 
+  // A bare letter, on the same terms as the bare `/` above: fields were excluded three lines up, so
+  // this only fires where the reader is driving the page rather than typing into it. Lowercase only
+  // — `N` is Shift+n and somebody about to type a capital is not asking for a card. The menu it may
+  // have been opened from goes with it, so Escape still unwinds one thing per press.
+  //
+  // Gated on there being a space, because the card is drawn from the layout's `{#if space}` branch:
+  // without it this would open a draft nothing renders, and the next Escape would be swallowed by a
+  // card the reader cannot see. The same reason `/` and ⌘N are inert on the picker.
+  if (event.key === 'n' && event.metaKey !== true && event.ctrlKey !== true) {
+    if (!session.space) return
+    // Behind the picker this would be answering with a card under somebody else's scrim — the reason
+    // the map itself is dropped while the help is up, and the picker covers the shell the same way.
+    if (session.picking) return
+    // `openDraft` replaces whatever is open, and that is how a card is abandoned. A click on a menu
+    // item is a decision to abandon one; a letter key pressed after a single Escape — which
+    // deliberately leaves the field without discarding the brief — is not. So a card with something
+    // in it holds the key: close it, or finish it, and `n` is there again (`compose.svelte.ts`).
+    if (draftHolds()) return
+    event.preventDefault()
+    closeMenu()
+    // The account popover is a surface this card is about to be drawn over, and one Escape between
+    // two open things is the state this table exists to avoid.
+    ui.accountOpen = false
+    openDraft({ kind: 'goal' })
+    return
+  }
+
   if ((event.key === 'n' || event.key === 'N') && (event.metaKey === true || event.ctrlKey === true)) {
     if (!primary) return
     event.preventDefault()
diff --git a/packages/ui/src/routes/+layout.svelte b/packages/ui/src/routes/+layout.svelte
index 49f0d18..29932f5 100644
--- a/packages/ui/src/routes/+layout.svelte
+++ b/packages/ui/src/routes/+layout.svelte
@@ -4,12 +4,13 @@
   import { goto } from '$app/navigation'
   import { page } from '$app/state'
   import { initAuth } from '$lib/auth.svelte.js'
-  import { closeDraft } from '$lib/compose.svelte.js'
+  import { closeDraft, compose } from '$lib/compose.svelte.js'
   import { keepFocus } from '$lib/focus.js'
   import { watchJoin } from '$lib/join.svelte.js'
   import { onKeydown } from '$lib/keys.js'
   import { rail } from '$lib/rail.svelte.js'
   import Diagnostics from '$lib/components/Diagnostics.svelte'
+  import NewGoal from '$lib/components/NewGoal.svelte'
   import PaneBar from '$lib/components/PaneBar.svelte'
   import PlusMenu from '$lib/components/PlusMenu.svelte'
   import Rail from '$lib/components/Rail.svelte'
@@ -108,39 +109,56 @@
     return [{ label: spaceName }]
   })
 
-  // ⊕ makes an item of the list you are in. On a project's goal list that is a goal; on a goal it is
-  // a request of one of the registry's goal-scoped types; on System, one of its project-scoped ones.
-  // A smart list is somebody else's list, so there it is absent rather than inert.
-  const plus = $derived.by(() => {
+  // Which project the view being shown belongs to, if it belongs to one. The ⊕ offers a goal
+  // everywhere, so this is what makes that goal land where the reader already is rather than asking
+  // a question the route has already answered.
+  const here = $derived.by(() => {
+    if (!space) return undefined
+    if (route.startsWith('/p/')) {
+      return projectByName(space.index, page.params.project ?? '')?.target.uri
+    }
+    if (route.startsWith('/g/')) {
+      const goal = goalByRoute(space.index, page.params.did ?? '', page.params.rkey ?? '')
+      return goal ? projectOf(space.index, goal)?.target.uri : undefined
+    }
+    return undefined
+  })
+
+  // ⊕ additionally makes an item of the list you are in: on a goal that is a request of one of the
+  // registry's goal-scoped types, on System one of its project-scoped ones. A smart list is somebody
+  // else's list, and a project's settings are not a list at all — the things authored there are the
+  // space's shape rather than its work — so on those the menu is the goal alone.
+  const types = $derived.by(() => {
     if (!space) return undefined
     if (route.startsWith('/g/')) {
       const goal = goalByRoute(space.index, page.params.did ?? '', page.params.rkey ?? '')
       return goal
         ? ({
-            kind: 'types',
             scope: 'goal',
             target: goal.target.uri,
             where: `against “${goal.target.value.title}”`,
           } as const)
         : undefined
     }
-    if (route.startsWith('/p/')) {
+    if (route.startsWith('/p/') && route.endsWith('/system')) {
       const project = projectByName(space.index, page.params.project ?? '')
-      if (!project) return undefined
-      // A project's settings are not a list, so there is no item for ⊕ to make. The things authored
-      // there — a registry entry, an auto-review switch — are the space's shape rather than its work.
-      if (route.endsWith('/settings')) return undefined
-      return route.endsWith('/system')
+      return project
         ? ({
-            kind: 'types',
             scope: 'project',
             target: project.target.uri,
             where: `for ${project.name} — lands in System`,
           } as const)
-        : ({ kind: 'goal', project: project.target.uri } as const)
+        : undefined
     }
     return undefined
   })
+
+  // The goal composer is drawn over the whole shell, so the rail's narrow-viewport drawer must not be
+  // left open behind its scrim: two overlays with one Escape between them is the state the keyboard
+  // table exists to avoid.
+  $effect(() => {
+    if (compose.draft?.kind === 'goal') ui.railOpen = false
+  })
 </script>
 
 <!-- The whole keyboard map, listening once. Every shortcut used to be handled by whichever component
@@ -180,12 +198,16 @@
           <Diagnostics {space} />
         </div>
       </div>
-      {#if plus}
-        <PlusMenu {space} action={plus} />
-      {/if}
+      <PlusMenu {space} {here} {types} />
       <Toast />
     </main>
   </div>
+  <!-- Outside `.app`, beside the picker and for the same reason: it is drawn over the whole shell
+       rather than into a page, which is what stops it moving anything on the page behind it — and
+       what lets the ⊕ offer a goal on views that have nowhere to put a card. -->
+  {#if compose.draft?.kind === 'goal'}
+    <NewGoal {space} here={compose.draft.project} />
+  {/if}
   {#if session.picking}
     <div class="scrim">
       <SpacePicker overlay />
diff --git a/packages/ui/src/routes/p/[project]/+page.svelte b/packages/ui/src/routes/p/[project]/+page.svelte
index bae8000..864a128 100644
--- a/packages/ui/src/routes/p/[project]/+page.svelte
+++ b/packages/ui/src/routes/p/[project]/+page.svelte
@@ -3,8 +3,6 @@
   import Badge from '$lib/components/Badge.svelte'
   import GoalRow from '$lib/components/GoalRow.svelte'
   import Glyph from '$lib/components/Glyph.svelte'
-  import NewGoal from '$lib/components/NewGoal.svelte'
-  import { compose } from '$lib/compose.svelte.js'
   import { currentSpace } from '$lib/session.svelte.js'
   import { goalsOf, isClosed, projectByName, settingsHref } from '$lib/space.js'
   import { matches, ui } from '$lib/ui.svelte.js'
@@ -67,10 +65,6 @@
     </p>
   </div>
 
-  {#if compose.draft?.kind === 'goal' && compose.draft.project === project.target.uri}
-    <NewGoal {project} {space} />
-  {/if}
-
   {#if active.length > 0}
     <div class="sec-head">Goals <span class="n">{active.length}</span></div>
     <ul class="list">