diff --git a/packages/notch-mod/.claude-plugin/plugin.json b/packages/notch-mod/.claude-plugin/plugin.json
index 0143e49..25d1e89 100644
--- a/packages/notch-mod/.claude-plugin/plugin.json
+++ b/packages/notch-mod/.claude-plugin/plugin.json
@@ -1,14 +1,14 @@
 {
-  "name": "switchboard-notch",
-  "version": "0.1.4",
-  "description": "Claude's questions drop from your Mac's notch as a native card. Pick with 1-4, type your own answer, or press esc to answer in Claude Code as usual.",
+  "name": "ask-notch",
+  "version": "0.3.0",
+  "description": "Claude's questions drop from your Mac's notch as a card. Click an option, pick with 1-4, type your own answer, or press esc to answer in Claude Code as usual.",
   "author": {
     "name": "sameeeeeeep",
     "url": "https://github.com/sameeeeeeep/switchboard"
   },
-  "displayName": "Switchboard Notch",
-  "homepage": "https://thelastprompt.ai/switchboard",
-  "repository": "https://github.com/sameeeeeeep/switchboard-notch",
+  "displayName": "Ask Notch",
+  "homepage": "https://github.com/sameeeeeeep/ask-notch",
+  "repository": "https://github.com/sameeeeeeep/ask-notch",
   "license": "MIT",
   "keywords": [
     "notch",
@@ -18,7 +18,7 @@
     "AskUserQuestion"
   ],
   "icon": "./assets/icon.png",
-  "documentationUrl": "https://github.com/sameeeeeeep/switchboard-notch#readme",
-  "supportUrl": "https://github.com/sameeeeeeep/switchboard-notch/issues",
-  "privacyPolicyUrl": "https://github.com/sameeeeeeep/switchboard-notch#privacy"
+  "documentationUrl": "https://github.com/sameeeeeeep/ask-notch#readme",
+  "supportUrl": "https://github.com/sameeeeeeep/ask-notch/issues",
+  "privacyPolicyUrl": "https://github.com/sameeeeeeep/ask-notch#privacy"
 }
diff --git a/packages/notch-mod/README.md b/packages/notch-mod/README.md
index ab68248..01c83fa 100644
--- a/packages/notch-mod/README.md
+++ b/packages/notch-mod/README.md
@@ -1,7 +1,7 @@
-# Switchboard Notch
+# Ask Notch
 
-When Claude asks you something, the question drops from your Mac's notch as a native card, so you
-can answer without switching back to the terminal.
+When Claude asks you something, the question drops from your Mac's notch as a card, so you can
+answer without switching back to the terminal.
 
 ![A question from Claude shown as a card at the Mac notch, with three numbered options and a text box](assets/card-light.png)
 
@@ -14,14 +14,15 @@ can answer without switching back to the terminal.
 
 Needs macOS 13+ and Claude Code **v2.1.287** or later (`claude --version`). It is a Claude Code
 [mod](https://code.claude.com/docs/en/plugins/mods/overview): it hooks Claude's `AskUserQuestion`
-tool and nothing else.
+tool and nothing else. Nothing is compiled: the card is a JavaScript file that macOS's own
+`osascript` runs.
 
 ## Try it for one session
 
 Nothing is installed and nothing is written to your settings:
 
 ```sh
-claude --plugin-url https://github.com/sameeeeeeep/switchboard-notch/releases/latest/download/switchboard-notch.zip
+claude --plugin-url https://github.com/sameeeeeeep/ask-notch/releases/latest/download/ask-notch.zip
 ```
 
 Ask Claude something that makes it ask you back, or run `/notch test`.
@@ -31,32 +32,46 @@ Ask Claude something that makes it ask you back, or run `/notch test`.
 In Claude Code (v2.1.275+ adds the marketplace and installs in one step):
 
 ```text
-/plugin install switchboard-notch --marketplace sameeeeeeep/switchboard-notch
+/plugin install ask-notch --marketplace sameeeeeeep/ask-notch
 ```
 
-Updates: `claude plugin update switchboard-notch@switchboard-notch`.
+Updates: `claude plugin update ask-notch@ask-notch`.
 
 ## Settings
 
+Say what you want after `/notch`, in your own words: `/notch put it by my mouse`, `/notch pause for now`,
+`/notch bring the cat`, `/notch show me one`. Claude reads it and changes the setting. On its own, `/notch`
+shows the current settings. The words below skip Claude and take effect instantly:
+
 | Command | Effect |
 | --- | --- |
 | `/notch cursor` | Open cards beside the pointer instead of at the notch |
 | `/notch notch` | Back to the notch |
+| `/notch companion cat` | A small painted cat hops out beside the card and waits with you |
+| `/notch companion off` | No companion (the default) |
 | `/notch off` / `/notch on` | Use Claude Code's own dialog / the card |
 | `/notch test` | Show a test card |
 
 Multi-select, free-text and number questions always use Claude Code's own form.
 
+## Choices come to you
+
+While cards are on, Claude asks with `AskUserQuestion` whenever it would otherwise list options in its reply
+("A or B?", "go ahead?"), so those choices arrive as a card at the notch. The plugin adds one short paragraph saying
+so to Claude's system prompt while cards are on (none while they're off), and ships the same guidance as a skill,
+`ask-at-the-notch`.
+
 ## Examples
 
 Any request where Claude stops to ask you a question shows the card. Three to try:
 
 1. **A design choice.** "Add a settings page to this app. Ask me which layout to use before you
-   build it." The card shows the layouts Claude proposes, with its pick highlighted. Press **1–4** or **↵**.
+   build it." The card shows the layouts Claude proposes, with its pick highlighted. Click one, or
+   click the card and press **1–4** or **↵**.
 2. **A risky step.** "Clean up the old migration files, but ask me before deleting anything." Claude's
    question lands at the notch while you work in another app; answer it there and Claude carries on.
-3. **Your own answer.** "Help me name this CLI tool and ask me to choose." Ignore the options, type
-   a name in the card's text box, and press **↵**. Claude receives exactly what you typed.
+3. **Your own answer.** "Help me name this CLI tool and ask me to choose." Ignore the options, click
+   the card's text box, type a name, and press **↵**. Claude receives exactly what you typed.
 
 `/notch test` shows a sample card without asking Claude anything.
 
@@ -71,46 +86,64 @@ as usual.
 ## Troubleshooting
 
 - **No card appears.** Run `claude --version` (needs v2.1.287+), then `/plugin` and look for
-  `switchboard-notch` in the `mods active` line under the tabs. Run `/notch test`. If `/notch` is off, run `/notch on`.
+  `ask-notch` in the `mods active` line under the tabs. Run `/notch test`. If `/notch` is off, run `/notch on`.
 - **The card opens on the wrong screen.** Run `/notch cursor` to open it beside the pointer.
 - **You'd rather answer in the terminal.** Press **esc** on any card, or run `/notch off`.
 
 ## What it does on your machine
 
-Everything the mod does is in [`hooks/register.js`](hooks/register.js) (about 90 lines):
+The mod is [`hooks/register.js`](hooks/register.js) (about 100 lines) and the card is
+[`helper/card.js`](helper/card.js) (about 600 lines). Both are plain JavaScript you can read; the
+plugin ships no compiled code.
 
 - **Which tool it answers, and when.** It handles only Claude Code's `AskUserQuestion` tool, and
   only single-choice questions. When you pick or type an answer in the card, the mod returns that
   answer in place of Claude Code's own question dialog, in the same shape the dialog returns. If you
   press esc, the card times out (9 minutes), the question is multi-select, text or number, or the
   card can't start, it hands the question back to Claude Code's dialog unchanged.
-- **The one program it starts, and why.** It runs `helper/sb-card` (in this plugin) to draw the card,
-  with one argument: a JSON object holding the question, its options, and where to show the card.
-  It starts nothing else and runs no shell.
-- **What it reads, and where that goes.** It reads the question Claude is asking (part of your
-  conversation) and passes it to `helper/sb-card` as that argument. `helper/sb-card` prints your
-  answer and exits, and the mod gives the answer back to Claude. Nothing is sent anywhere else: the
-  mod makes no network requests, and neither does `helper/sb-card`.
-- **What it stores.** Only your `/notch` setting (on or off, notch or cursor), in Claude Code's
-  local storage for this plugin.
-
-`helper/sb-card` is a small native macOS program built from
-[`helper/sb-card.swift`](helper/sb-card.swift) (about 230 lines of AppKit and SwiftUI). It needs no
-permissions and writes no files. It is signed with Developer ID (STAYOFT VENTURES PRIVATE LIMITED,
-55354KFTHU) and notarized by Apple. To list the mod's hooks and calls yourself, run
-`claude plugin validate` on this directory.
+- **The one program it starts, and why.** It always runs the same fixed command,
+  `/usr/bin/osascript -l JavaScript helper/card.js`, from this plugin's own folder. `osascript` is
+  macOS's built-in script runner; the plugin needs it because a Claude Code mod can only draw inside
+  Claude Code's window, and the card has to appear at the Mac's notch. The question, its options,
+  where to show the card and, if you turned one on, the companion's folder go to the card on its
+  **standard input** as one JSON object. It starts nothing else and runs no shell.
+- **What the card does.** `helper/card.js` uses macOS's JavaScript bridge to AppKit to draw one
+  window, reads the pointer position (for `/notch cursor`) and, with a companion, the pictures in
+  `assets/companion/`. It prints your answer as one line of JSON and exits. It makes no network
+  requests, writes no files, reads no environment variables and needs no permissions. It refuses
+  the keyboard until you click it, and appears without activating, so it can't take keystrokes
+  meant for the app you're using.
+- **What it reads, and where it sends it.** It reads the question Claude is asking (part of your
+  conversation) and sends it to exactly one place: the local `osascript` process above, on its
+  standard input. The card prints your answer on standard output and exits, and the mod gives the
+  answer back to Claude. Nothing leaves your Mac: no network requests, no files written, no
+  credentials or environment variables read.
+- **Standing in for a tool.** The mod answers `AskUserQuestion` in place of Claude Code's dialog
+  only when you answer on the card; every other case calls through to Claude Code's own dialog.
+- **Settings in plain words.** `/notch` followed by words it doesn't recognise sends Claude one
+  prompt that quotes them. Claude then changes the setting through the plugin's own tool,
+  `mcp__ask-notch__settings` (on/off, notch/cursor, companion, test card). The tool reads and writes
+  only the settings below.
+- **The system prompt note and the skill.** While cards are on, the mod adds one fixed paragraph to
+  Claude's system prompt (`CHOICES_NOTE` in `hooks/register.js`) asking it to put choices to you
+  with `AskUserQuestion`. `skills/ask-at-the-notch/SKILL.md` says the same at length. Both are plain
+  text and run nothing.
+- **What it stores.** Only your `/notch` settings (on or off, notch or cursor, companion), in
+  Claude Code's local storage for this plugin.
+
+To list the mod's hooks and calls yourself, run `claude plugin validate` on this directory.
 
 ## Privacy
 
-Switchboard Notch collects nothing. The question, its options and your answer pass only between
-Claude Code and `helper/sb-card` on your Mac. There is no network access, no analytics and no
-account. The only thing saved is your `/notch` setting (on or off, notch or cursor), in Claude
-Code's local storage for this plugin; uninstalling the plugin removes it.
+Ask Notch collects nothing. The question, its options and your answer pass only between Claude Code
+and `osascript` running `helper/card.js` on your Mac. There is no network access, no analytics and
+no account. The only thing saved is your `/notch` settings (on or off, notch or cursor, companion),
+in Claude Code's local storage for this plugin; uninstalling the plugin removes it.
 
 ## Support
 
 Report problems or ask questions at
-[github.com/sameeeeeeep/switchboard-notch/issues](https://github.com/sameeeeeeep/switchboard-notch/issues).
+[github.com/sameeeeeeep/ask-notch/issues](https://github.com/sameeeeeeep/ask-notch/issues).
 For security issues, email [sameeeeeeep@gmail.com](mailto:sameeeeeeep@gmail.com) instead of opening a public issue.
 
 ## Develop
@@ -119,6 +152,6 @@ The source lives in [`packages/notch-mod`](https://github.com/sameeeeeeep/switch
 in the Switchboard repo, which also holds the build and release scripts; this repo is a mirror.
 
 ```sh
-claude --plugin-dir "$PWD"          # load a checkout for one session; edits hot-reload
+claude --plugin-dir /path/to/ask-notch   # load a checkout for one session; edits hot-reload
 claude plugin test                   # unit tests (no session needed)
 ```
diff --git a/packages/notch-mod/assets/card-dark.png b/packages/notch-mod/assets/card-dark.png
index 57d24a9..7a53366 100644
Binary files a/packages/notch-mod/assets/card-dark.png and b/packages/notch-mod/assets/card-dark.png differ
diff --git a/packages/notch-mod/assets/card-light.png b/packages/notch-mod/assets/card-light.png
index 7201942..5c36037 100644
Binary files a/packages/notch-mod/assets/card-light.png and b/packages/notch-mod/assets/card-light.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-01.png b/packages/notch-mod/assets/companion/cat/intro-01.png
new file mode 100644
index 0000000..9f5711b
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-01.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-02.png b/packages/notch-mod/assets/companion/cat/intro-02.png
new file mode 100644
index 0000000..db21b32
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-02.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-03.png b/packages/notch-mod/assets/companion/cat/intro-03.png
new file mode 100644
index 0000000..9682113
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-03.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-04.png b/packages/notch-mod/assets/companion/cat/intro-04.png
new file mode 100644
index 0000000..e9a7c2c
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-04.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-05.png b/packages/notch-mod/assets/companion/cat/intro-05.png
new file mode 100644
index 0000000..3081164
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-05.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-06.png b/packages/notch-mod/assets/companion/cat/intro-06.png
new file mode 100644
index 0000000..f87f1c7
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-06.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-07.png b/packages/notch-mod/assets/companion/cat/intro-07.png
new file mode 100644
index 0000000..b0db25f
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-07.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-08.png b/packages/notch-mod/assets/companion/cat/intro-08.png
new file mode 100644
index 0000000..87fb7c6
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-08.png differ
diff --git a/packages/notch-mod/assets/companion/cat/intro-09.png b/packages/notch-mod/assets/companion/cat/intro-09.png
new file mode 100644
index 0000000..740273b
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/intro-09.png differ
diff --git a/packages/notch-mod/assets/companion/cat/settle-1.png b/packages/notch-mod/assets/companion/cat/settle-1.png
new file mode 100644
index 0000000..b9ab7d7
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/settle-1.png differ
diff --git a/packages/notch-mod/assets/companion/cat/settle-2.png b/packages/notch-mod/assets/companion/cat/settle-2.png
new file mode 100644
index 0000000..ca7cb97
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/settle-2.png differ
diff --git a/packages/notch-mod/assets/companion/cat/sit.png b/packages/notch-mod/assets/companion/cat/sit.png
new file mode 100644
index 0000000..1c85cde
Binary files /dev/null and b/packages/notch-mod/assets/companion/cat/sit.png differ
diff --git a/packages/notch-mod/assets/companion/clawd/README.md b/packages/notch-mod/assets/companion/clawd/README.md
new file mode 100644
index 0000000..7f984f4
--- /dev/null
+++ b/packages/notch-mod/assets/companion/clawd/README.md
@@ -0,0 +1,24 @@
+# Clawd companion: placeholder (art pending the owner's decision)
+
+**Status: no art here on purpose.** `/notch companion clawd` is a hidden option (not in the README or
+the directory listing). With this folder holding no `sequence.json`, the card shows no companion, so
+the option is a safe no-op until a decision is made.
+
+Why it's empty: Clawd is Anthropic's character. Whether Ask Notch ships a Clawd companion in its
+Claude directory submission is the owner's call (trademark and review risk), so no Clawd artwork has
+been copied from anywhere into this repo. `build.sh` and `publish.sh` leave this folder out of the
+published plugin.
+
+## To fill the slot (only after the decision)
+
+Use the same contract as `../cat/` (see `listing/make-companion.py`, which builds it):
+
+- `sequence.json`: `canvas` `[w, h]` in points; `overlap` (points of the canvas that sit behind the
+  card's right edge); `intro` `{ delay_ms, frames: [[file, ms], ...] }` played when the card appears;
+  `idle` (file shown while waiting); `settle` `{ after_s, frames }` played once after `after_s`.
+- Frames: transparent PNGs at 2× the canvas size, all the same size, feet on the canvas's ground line,
+  so the card only swaps pictures. File names: letters, digits, `.`, `-`, `_`, ending in `.png`.
+- Keep the folder small (the cat is about 220 KB).
+
+Then remove the `-x 'assets/companion/clawd/*'` exclusion in `build.sh`, the matching `rm` in
+`publish.sh`, and document `/notch companion clawd` in the README and listing.
diff --git a/packages/notch-mod/build.sh b/packages/notch-mod/build.sh
index 5a48f29..a379c8c 100755
--- a/packages/notch-mod/build.sh
+++ b/packages/notch-mod/build.sh
@@ -1,28 +1,14 @@
 #!/bin/sh
-# Build helper/sb-card as a universal binary, sign it with Developer ID, notarize it, and package
-# dist/switchboard-notch.zip for `claude --plugin-url`.
-# Set SKIP_NOTARIZE=1 for a local build.
+# Package dist/ask-notch.zip for `claude --plugin-url`. Nothing is compiled or signed: the card is
+# helper/card.js, run by macOS's own /usr/bin/osascript.
 set -eu
 cd "$(dirname "$0")"
 
-IDENTITY="Developer ID Application: STAYOFT VENTURES PRIVATE LIMITED (55354KFTHU)"
-TMP=$(mktemp -d)
-trap 'rm -rf "$TMP"' EXIT
-
-for arch in arm64 x86_64; do
-  swiftc -O -target "$arch-apple-macos13" -o "$TMP/sb-card-$arch" helper/sb-card.swift \
-    -framework AppKit -framework SwiftUI
-done
-lipo -create -output helper/sb-card "$TMP/sb-card-arm64" "$TMP/sb-card-x86_64"
-codesign --force --options runtime --timestamp --identifier ai.thelastprompt.sb-card \
-  --sign "$IDENTITY" helper/sb-card
-
-if [ "${SKIP_NOTARIZE:-0}" != 1 ]; then
-  ditto -c -k helper/sb-card "$TMP/sb-card.zip"
-  xcrun notarytool submit "$TMP/sb-card.zip" --keychain-profile relay-notary --wait
-fi
-
+claude plugin validate "$PWD" >/dev/null
 mkdir -p dist
-rm -f dist/switchboard-notch.zip
-zip -qr dist/switchboard-notch.zip .claude-plugin/plugin.json hooks helper/sb-card assets README.md
-echo "built dist/switchboard-notch.zip"
+rm -f dist/ask-notch.zip
+# Leave out macOS/Windows system files (the directory's validator blocks them) and the Clawd companion
+# slot, which holds no art until the owner decides (assets/companion/clawd/README.md).
+zip -qr dist/ask-notch.zip .claude-plugin/plugin.json hooks helper skills assets README.md \
+  -x '*.DS_Store' -x '*Thumbs.db' -x '*desktop.ini' -x '__MACOSX/*' -x 'assets/companion/clawd/*'
+echo "built dist/ask-notch.zip ($(du -h dist/ask-notch.zip | cut -f1))"
diff --git a/packages/notch-mod/helper/card.js b/packages/notch-mod/helper/card.js
new file mode 100644
index 0000000..fac3579
--- /dev/null
+++ b/packages/notch-mod/helper/card.js
@@ -0,0 +1,603 @@
+// Ask Notch card: one question as a native card at the Mac notch (or beside the pointer).
+//
+// Plain JavaScript for macOS's built-in script runner (JavaScript for Automation, with its bridge to
+// AppKit). Nothing is compiled; this file is the whole program:
+//
+//   /usr/bin/osascript -l JavaScript helper/card.js '<json>'
+//   json:   { title?, question, options:[{label, detail?, recommended?}], at?: "notch"|"cursor",
+//             source?, timeout?: seconds, appearance?: "light"|"dark", companion?: {name, dir},
+//             debug?: true }        (tests also use at: "offscreen", a window on no display)
+//   stdout: {"answer":"<label>","index":n} | {"answer":"<typed>","typed":true}
+//           | {"cancelled":true,"reason":"esc"|"timeout"}
+//
+// It draws one window, reads the pointer position and (with a companion) a few pictures from the
+// plugin's assets folder, prints the answer and exits. It makes no network requests, writes no
+// files, reads no environment, and needs no permissions.
+//
+// The card never takes the keyboard when it appears, so typing in another app can't answer it: the
+// window refuses to become the key window until you click it. Clicking an option answers. Clicking
+// the card enables its keys: 1-4 pick · ↑↓ move · ⏎ confirm · esc cancels. Clicking the text box
+// lets you type your own answer (digits are text there).
+
+ObjC.import('AppKit')
+ObjC.import('QuartzCore')
+ObjC.import('stdlib')
+
+// Claude's design language: warm ivory / warm charcoal surfaces, terracotta accent, serif voice.
+var PALETTES = {
+  light: { bg: 0xFAF9F5, raised: 0xF0EEE6, border: 0xE3E0D5, text: 0x141413, muted: 0x6B6A65, accent: 0xD97757 },
+  dark: { bg: 0x262624, raised: 0x30302E, border: 0x3E3E3A, text: 0xFAF9F5, muted: 0xA3A29C, accent: 0xD97757 },
+}
+var CARD_W = 440
+var PAD_X = 18, PAD_Y = 14, GAP = 12
+var DEFAULT_TIMEOUT_S = 540
+
+function color(hex, alpha) {
+  return $.NSColor.colorWithSRGBRedGreenBlueAlpha(((hex >> 16) & 255) / 255, ((hex >> 8) & 255) / 255,
+    (hex & 255) / 255, alpha === undefined ? 1 : alpha)
+}
+
+function sysFont(size, weight) { return $.NSFont.systemFontOfSizeWeight(size, weight || 0) }
+function serifFont(size) {
+  var d = $.NSFont.systemFontOfSize(size).fontDescriptor.fontDescriptorWithDesign('NSCTFontUIFontDesignSerif')
+  return d.isNil() ? $.NSFont.systemFontOfSize(size) : $.NSFont.fontWithDescriptorSize(d, size)
+}
+var W_MEDIUM = 0.23, W_SEMIBOLD = 0.3, W_BOLD = 0.4
+
+function attrs(font, col, lineSpacing) {
+  var d = $.NSMutableDictionary.dictionary
+  d.setObjectForKey(font, $.NSFontAttributeName)
+  if (col) d.setObjectForKey(col, $.NSForegroundColorAttributeName)
+  if (lineSpacing) {
+    var p = $.NSMutableParagraphStyle.alloc.init
+    p.lineSpacing = lineSpacing
+    d.setObjectForKey(p, $.NSParagraphStyleAttributeName)
+  }
+  return d
+}
+var LM = null
+// One line of text, as SwiftUI sizes it: ascent + descent + leading, rounded up to a whole point
+// (the serif face is rounded to the nearest point, which is what SwiftUI's layout came to).
+function lineHeight(font) {
+  var h = font.ascender - font.descender + font.leading
+  return font.fontName.js.indexOf('NewYork') >= 0 ? Math.round(h) : Math.ceil(h - 0.001)
+}
+function textWidth(s, a) { return $(s).sizeWithAttributes(a).width }
+// Rounded up to the pixel grid (half points), as SwiftUI sizes text.
+function px(v) { return Math.ceil(v * 2 - 0.001) / 2 }
+// Height of text wrapped to `width`: whole lines of lineHeight, plus the paragraph's line spacing.
+function textHeight(s, a, width, font, spacing) {
+  if (!LM) LM = $.NSLayoutManager.alloc.init
+  spacing = spacing || 0
+  var raw = $(s).boundingRectWithSizeOptionsAttributes($.NSMakeSize(width, 100000), 3, a).size.height
+  var lines = Math.max(1, Math.round((raw + spacing) / (LM.defaultLineHeightForFont(font) + spacing)))
+  return lines * lineHeight(font) + (lines - 1) * spacing
+}
+
+// ── layout: every rect in card points, origin top-left ──
+function layoutCard(spec, dark) {
+  var p = PALETTES[dark ? 'dark' : 'light']
+  var L = { p: p, w: CARD_W, rows: [], hints: [] }
+  var innerW = CARD_W - PAD_X * 2
+  var y = PAD_Y
+
+  L.fonts = {
+    star: sysFont(13, W_BOLD), title: sysFont(11.5, W_MEDIUM), source: sysFont(10.5),
+    question: serifFont(16), label: sysFont(13, W_MEDIUM), badge: sysFont(11, W_SEMIBOLD),
+    rec: sysFont(9.5, W_MEDIUM), detail: sysFont(11.5), field: sysFont(12.5),
+    hintKey: sysFont(9.5, W_MEDIUM), hint: sysFont(10),
+  }
+  var F = L.fonts
+
+  // Header: ✻ · title ……… source
+  var headH = Math.max(lineHeight(F.star), lineHeight(F.title), lineHeight(F.source))
+  L.header = { y: y, h: headH, title: spec.title || 'Claude has a question', source: spec.source || '' }
+  y += headH + GAP
+
+  // Question (serif), wrapped to the card's inner width.
+  var qa = attrs(F.question, color(p.text), 2)
+  var qh = textHeight(spec.question, qa, innerW, F.question, 2)
+  L.question = { x: PAD_X, y: y, w: innerW, h: Math.max(qh, lineHeight(F.question)) }
+  y += L.question.h + GAP
+
+  // Options: badge 20×20, then label (+ Recommended) over the detail; padding 10×8.
+  var opts = spec.options || []
+  var textW = innerW - 20 - 20 - 10
+  for (var i = 0; i < opts.length; i++) {
+    var o = opts[i]
+    var recW = o.recommended ? Math.ceil(textWidth('Recommended', attrs(F.rec))) + 10 : 0
+    var labelW = textW - (recW ? recW + 6 : 0)
+    var lh = Math.max(lineHeight(F.label), textHeight(String(o.label), attrs(F.label), labelW, F.label))
+    var dh = o.detail ? textHeight(String(o.detail), attrs(F.detail), textW, F.detail) : 0
+    var contentH = lh + (o.detail ? 2 + dh : 0)
+    var h = 8 + Math.max(20, contentH) + 8
+    L.rows.push({ x: PAD_X, y: y, w: innerW, h: h, labelH: lh, labelW: labelW, detailH: dh, recW: recW })
+    y += h + 6
+  }
+  if (opts.length) y += -6 + GAP
+
+  // Text box.
+  var fh = lineHeight(F.field)
+  L.field = { x: PAD_X, y: y, w: innerW, h: fh + 16, lineH: fh }
+  y += L.field.h + GAP
+
+  // Key hints.
+  var keyH = lineHeight(F.hintKey) + 2
+  var hintH = Math.max(keyH, lineHeight(F.hint))
+  var hx = PAD_X
+  var defs = [['click', 'for keys'], ['1–' + Math.max(1, opts.length), 'choose'], ['↵', 'confirm'], ['esc', 'dismiss']]
+  for (var k = 0; k < defs.length; k++) {
+    var kw = px(textWidth(defs[k][0], attrs(F.hintKey))) + 8
+    var tw = px(textWidth(defs[k][1], attrs(F.hint)))
+    L.hints.push({ key: defs[k][0], what: defs[k][1], x: hx, kw: kw, tw: tw })
+    hx += kw + 4 + tw + 10
+  }
+  L.hintY = y; L.hintH = hintH; L.keyH = keyH
+  y += hintH + PAD_Y
+
+  L.h = Math.round(y)
+  return L
+}
+
+// ── drawing ──
+function roundedRect(x, y, w, h, r) {
+  return $.NSBezierPath.bezierPathWithRoundedRectXRadiusYRadius($.NSMakeRect(x, y, w, h), r, r)
+}
+// The card: square-ish top corners (it grows out of the notch), round bottom corners.
+function cardPath(w, h, top, bottom) {
+  var b = $.NSBezierPath.bezierPath
+  b.moveToPoint($.NSMakePoint(top, 0))
+  b.lineToPoint($.NSMakePoint(w - top, 0))
+  b.appendBezierPathWithArcFromPointToPointRadius($.NSMakePoint(w, 0), $.NSMakePoint(w, top), top)
+  b.lineToPoint($.NSMakePoint(w, h - bottom))
+  b.appendBezierPathWithArcFromPointToPointRadius($.NSMakePoint(w, h), $.NSMakePoint(w - bottom, h), bottom)
+  b.lineToPoint($.NSMakePoint(bottom, h))
+  b.appendBezierPathWithArcFromPointToPointRadius($.NSMakePoint(0, h), $.NSMakePoint(0, h - bottom), bottom)
+  b.lineToPoint($.NSMakePoint(0, top))
+  b.appendBezierPathWithArcFromPointToPointRadius($.NSMakePoint(0, 0), $.NSMakePoint(top, 0), top)
+  b.closePath
+  return b
+}
+function fill(path, c) { c.setFill; path.fill }
+function stroke(path, c) { c.setStroke; path.lineWidth = 1; path.stroke }
+function drawText(s, x, y, w, h, a) {
+  $(s).drawWithRectOptionsAttributes($.NSMakeRect(x, y, w, h), 3, a)
+}
+
+// Paints the card for `state` ({selected, typed}) into a bitmap at `scale` pixels per point.
+function paintCard(spec, L, state, scale) {
+  var p = L.p, F = L.fonts, W = L.w, H = L.h
+  var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBytesPerRowBitsPerPixel(
+    null, Math.round(W * scale), Math.round(H * scale), 8, 4, true, false, 'NSCalibratedRGBColorSpace', 0, 0)
+  rep = rep.bitmapImageRepByRetaggingWithColorSpace($.NSColorSpace.sRGBColorSpace)
+  rep.size = $.NSMakeSize(W, H)
+  var base = $.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep)
+  $.NSGraphicsContext.saveGraphicsState
+  $.NSGraphicsContext.setCurrentContext(base)
+  // Flip so y runs down, as in the layout.
+  var t = $.NSAffineTransform.transform
+  t.translateXByYBy(0, H); t.scaleXByYBy(1, -1); t.concat
+  $.NSGraphicsContext.setCurrentContext($.NSGraphicsContext.graphicsContextWithCGContextFlipped(base.CGContext, true))
+
+  var card = cardPath(W, H, 12, 20)
+  fill(card, color(p.bg)); stroke(card, color(p.border))
+
+  // Header.
+  var hy = L.header.y, hh = L.header.h
+  var starA = attrs(F.star, color(p.accent))
+  var starW = px(textWidth('✻', starA))
+  drawText('✻', PAD_X, hy + (hh - lineHeight(F.star)) / 2, starW + 2, lineHeight(F.star), starA)
+  var srcW = 0
+  if (L.header.source) {
+    var sa = attrs(F.source, color(p.muted, 0.8))
+    srcW = Math.min(Math.ceil(textWidth(L.header.source, sa)), 160)
+    drawText(L.header.source, W - PAD_X - srcW, hy + (hh - lineHeight(F.source)) / 2, srcW, lineHeight(F.source), sa)
+  }
+  var ta = attrs(F.title, color(p.muted))
+  var tx = PAD_X + starW + 6
+  drawText(L.header.title, tx, hy + (hh - lineHeight(F.title)) / 2, W - PAD_X - tx - srcW - 8, lineHeight(F.title), ta)
+
+  // Question.
+  var q = L.question
+  drawText(spec.question, q.x, q.y, q.w, q.h + 4, attrs(F.question, color(p.text), 2))
+
+  // Options.
+  var opts = spec.options || []
+  for (var i = 0; i < opts.length; i++) {
+    var o = opts[i], r = L.rows[i], on = i === state.selected
+    var box = roundedRect(r.x, r.y, r.w, r.h, 11)
+    if (on) fill(box, color(p.raised))
+    stroke(box, on ? color(p.accent, 0.55) : color(p.border))
+    var bx = r.x + 10, by = r.y + 8
+    var badge = roundedRect(bx, by, 20, 20, 6)
+    fill(badge, on ? color(p.accent) : color(p.bg))
+    if (!on) stroke(badge, color(p.border))
+    var na = attrs(F.badge, on ? $.NSColor.whiteColor : color(p.muted))
+    var nw = textWidth(String(i + 1), na), nh = lineHeight(F.badge)
+    drawText(String(i + 1), bx + Math.ceil((20 - nw) - 0.5) / 2, by + Math.floor((20 - nh) / 2), nw + 2, nh, na)
+    var cx = bx + 20 + 10
+    drawText(String(o.label), cx, by, r.labelW, r.labelH, attrs(F.label, color(p.text)))
+    if (o.recommended) {
+      var la = attrs(F.label)
+      var lw = Math.min(Math.ceil(textWidth(String(o.label), la)), r.labelW)
+      var rh = lineHeight(F.rec) + 2
+      var rx = cx + lw + 6, ry = by + (lineHeight(F.label) - rh) / 2
+      fill(roundedRect(rx, ry, r.recW, rh, rh / 2), color(p.accent, 0.12))
+      drawText('Recommended', rx + 5, ry + 1, r.recW, rh, attrs(F.rec, color(p.accent)))
+    }
+    if (o.detail) drawText(String(o.detail), cx, by + r.labelH + 2, r.w - 50, r.detailH + 2, attrs(F.detail, color(p.muted)))
+  }
+
+  // Text box, with its own placeholder (the system one is dimmed to near-invisible while the card
+  // isn't key).
+  var f = L.field
+  var fb = roundedRect(f.x, f.y, f.w, f.h, 10)
+  fill(fb, color(p.bg)); stroke(fb, color(p.border))
+  if (!state.typed) {
+    drawText('Something else? Type it here', f.x + 11, f.y + 8, f.w - 22, f.lineH, attrs(F.field, color(p.muted, 0.8)))
+  }
+
+  // Key hints.
+  for (var k = 0; k < L.hints.length; k++) {
+    var hn = L.hints[k]
+    var ky = L.hintY + (L.hintH - L.keyH) / 2
+    stroke(roundedRect(hn.x, ky, hn.kw, L.keyH, 4), color(p.border))
+    drawText(hn.key, hn.x + 4, ky + 1, hn.kw, L.keyH, attrs(F.hintKey, color(p.muted)))
+    drawText(hn.what, hn.x + hn.kw + 4, L.hintY + (L.hintH - lineHeight(F.hint)) / 2 - 0.5, hn.tw + 2, lineHeight(F.hint), attrs(F.hint, color(p.muted)))
+  }
+
+  $.NSGraphicsContext.restoreGraphicsState
+  return rep
+}
+
+function imageOf(rep, w, h) {
+  var img = $.NSImage.alloc.initWithSize($.NSMakeSize(w, h))
+  img.addRepresentation(rep)
+  return img
+}
+
+// Frame list for each companion (the PNGs live in assets/companion/<name>/). Painted by the plugin author.
+var COMPANION_SEQUENCES = {"cat": {"canvas": [120, 60], "overlap": 48, "intro": {"delay_ms": 180, "frames": [["intro-01.png", 130], ["intro-02.png", 60], ["intro-03.png", 60], ["intro-04.png", 60], ["intro-05.png", 60], ["intro-06.png", 70], ["intro-07.png", 70], ["intro-08.png", 70], ["intro-09.png", 70]]}, "idle": "sit.png", "settle": {"after_s": 20, "frames": [["settle-1.png", 240], ["settle-2.png", 0]]}}}
+
+// ── companion: a small animated character beside the card ──
+// COMPANION_SEQUENCES lists the frames; an unknown name means no companion.
+function loadCompanion(c) {
+  if (!c || typeof c.dir !== 'string') return null
+  var seq = COMPANION_SEQUENCES[c.name]
+  if (!seq) return null
+  var images = {}
+  function frame(name) {
+    if (!/^[\w.-]+\.png$/.test(name)) return null
+    if (!images[name]) {
+      var img = $.NSImage.alloc.initWithContentsOfFile(c.dir + '/' + name)
+      if (img.isNil()) return null
+      img.size = $.NSMakeSize(seq.canvas[0], seq.canvas[1])
+      images[name] = img
+    }
+    return images[name]
+  }
+  function frames(list) {
+    var out = []
+    for (var i = 0; i < (list || []).length; i++) {
+      var img = frame(list[i][0])
+      if (img) out.push({ img: img, ms: list[i][1] || 0 })
+    }
+    return out
+  }
+  var idle = frame(seq.idle)
+  if (!idle || !seq.canvas) return null
+  return {
+    w: seq.canvas[0], h: seq.canvas[1], overlap: seq.overlap || 0, idle: idle,
+    introDelay: (seq.intro && seq.intro.delay_ms) || 0, intro: frames(seq.intro && seq.intro.frames),
+    settleAfter: (seq.settle && seq.settle.after_s) || 0, settle: frames(seq.settle && seq.settle.frames),
+  }
+}
+
+// ── output ──
+function emit(obj) {
+  var s = $(JSON.stringify(obj) + '\n')
+  $.NSFileHandle.fileHandleWithStandardOutput.writeData(s.dataUsingEncoding(4))
+  $.exit(0)
+}
+function log(line) {
+  $.NSFileHandle.fileHandleWithStandardError.writeData($(line + '\n').dataUsingEncoding(4))
+}
+
+// ── the window ──
+function main(spec) {
+  var app = $.NSApplication.sharedApplication
+  // Never take the keyboard on appear. When the app you're using started this program (your
+  // terminal, through Claude Code), macOS hands it activation as its first window appears. So the
+  // card appears as a background-only app, which can't be activated, and only then becomes an
+  // accessory app (no Dock icon), which activates when you click it.
+  var previous = $.NSWorkspace.sharedWorkspace.frontmostApplication
+  app.setActivationPolicy(2)                    // prohibited (background-only)
+
+  var dark = spec.appearance ? spec.appearance === 'dark'
+    : app.effectiveAppearance.bestMatchFromAppearancesWithNames($(['NSAppearanceNameAqua', 'NSAppearanceNameDarkAqua'])).js === 'NSAppearanceNameDarkAqua'
+  var opts = spec.options || []
+  var L = layoutCard(spec, dark)
+  var state = { selected: 0, typed: '', armed: false, pressed: -1, wantField: false }
+  for (var i = 0; i < opts.length; i++) if (opts[i].recommended) { state.selected = i; break }
+
+  function pick(i) { emit({ answer: String(opts[i].label), index: i }) }
+  function submit() {
+    var t = String(field.stringValue.js || '').trim()
+    if (t) emit({ answer: t, typed: true })
+    if (opts.length) pick(state.selected)
+  }
+
+  var comp = loadCompanion(spec.companion)
+  var extraW = comp ? Math.max(0, comp.w - comp.overlap) : 0
+  var winW = L.w + extraW, winH = Math.max(L.h, comp ? comp.h : 0)
+
+  // Notch: the screen with a top safe-area inset (the notch), else the main screen; flush to its top
+  // edge so the card reads as the notch growing down. Cursor: just below-right of the pointer.
+  var mouse = $.NSEvent.mouseLocation
+  var screens = $.NSScreen.screens, screen = null
+  for (var s = 0; s < screens.count; s++) {
+    var sc = screens.objectAtIndex(s), fr = sc.frame
+    if (spec.at === 'cursor') {
+      if (mouse.x >= fr.origin.x && mouse.x < fr.origin.x + fr.size.width &&
+          mouse.y >= fr.origin.y && mouse.y < fr.origin.y + fr.size.height) { screen = sc; break }
+    } else if (sc.safeAreaInsets.top > 0) { screen = sc; break }
+  }
+  if (!screen) screen = $.NSScreen.mainScreen
+  var sf = screen.frame, ox, oy
+  if (spec.at === 'cursor') {
+    var vf = screen.visibleFrame
+    ox = mouse.x + 14; oy = mouse.y - 18 - winH
+    ox = Math.min(Math.max(ox, vf.origin.x + 8), vf.origin.x + vf.size.width - winW - 8)
+    oy = Math.min(Math.max(oy, vf.origin.y + 8), vf.origin.y + vf.size.height - winH - 8)
+  } else if (spec.at === 'offscreen') {   // tests: a real window that is never on any display
+    ox = -20000; oy = -20000
+  } else {
+    ox = sf.origin.x + sf.size.width / 2 - L.w / 2; oy = sf.origin.y + sf.size.height - winH
+  }
+  var scale = screen.backingScaleFactor || 2
+
+  // The panel refuses to become key until it is clicked: macOS can't hand it the keyboard on its own.
+  ObjC.registerSubclass({
+    name: 'AskNotchPanel', superclass: 'NSPanel',
+    methods: {
+      'canBecomeKeyWindow': { types: ['bool', []], implementation: function () { return state.armed } },
+      'canBecomeMainWindow': { types: ['bool', []], implementation: function () { return false } },
+      'becomeKeyWindow': {
+        types: ['void', []],
+        implementation: function () {
+          ObjC.super(this).becomeKeyWindow
+          // Becoming key focuses the text box, which would turn 1-4 into typed text: only a click on
+          // the box itself should focus it.
+          this.makeFirstResponder(state.wantField ? field : $())
+          if (spec.debug) log('became-key')
+        },
+      },
+      'sendEvent:': {
+        types: ['void', ['id']],
+        implementation: function (ev) {
+          var handled = false
+          try { handled = onEvent(ev) } catch (e) { log('card: ' + e) }
+          if (!handled) ObjC.super(this).sendEvent(ev)
+          if (Number(ev.type) === 10) syncPlaceholder()
+        },
+      },
+    },
+  })
+  ObjC.registerSubclass({
+    name: 'AskNotchHover', superclass: 'NSObject',
+    methods: {
+      'mouseMoved:': { types: ['void', ['id']], implementation: function (ev) { hover(ev) } },
+      'mouseEntered:': { types: ['void', ['id']], implementation: function (ev) { hover(ev) } },
+      'mouseExited:': { types: ['void', ['id']], implementation: function (ev) {} },
+    },
+  })
+
+  var panel = $.AskNotchPanel.alloc.initWithContentRectStyleMaskBackingDefer(
+    $.NSMakeRect(ox, oy, winW, winH), 1 << 7 /* borderless, non-activating panel */, 2 /* buffered */, false)
+  panel.opaque = false
+  panel.backgroundColor = $.NSColor.clearColor
+  panel.hasShadow = true
+  panel.level = 101                                   // pop-up menu level: above the menu bar, so it can sit in the notch
+  panel.collectionBehavior = 1 | 256 | 8            // all Spaces · over full-screen apps · transient
+  panel.movableByWindowBackground = false
+  panel.becomesKeyOnlyIfNeeded = false
+  panel.hidesOnDeactivate = false
+  panel.releasedWhenClosed = false
+  panel.appearance = $.NSAppearance.appearanceNamed(dark ? 'NSAppearanceNameDarkAqua' : 'NSAppearanceNameAqua')
+
+  var content = $.NSView.alloc.initWithFrame($.NSMakeRect(0, 0, winW, winH))
+  content.wantsLayer = true
+  panel.contentView = content
+
+  // Layer-hosting view: the companion behind, the card in front.
+  var stage = $.NSView.alloc.initWithFrame($.NSMakeRect(0, 0, winW, winH))
+  var root = $.CALayer.layer
+  stage.layer = root
+  stage.wantsLayer = true
+  content.addSubview(stage)
+
+  var compLayer = null
+  if (comp) {
+    compLayer = $.CALayer.layer
+    compLayer.frame = $.NSMakeRect(L.w - comp.overlap, winH - L.h, comp.w, comp.h)
+    compLayer.contentsGravity = 'resize'
+    compLayer.actions = $({ contents: $.NSNull.null })
+    root.addSublayer(compLayer)
+  }
+
+  var cardLayer = $.CALayer.layer
+  cardLayer.anchorPoint = $.NSMakePoint(0.5, 1)
+  cardLayer.bounds = $.NSMakeRect(0, 0, L.w, L.h)
+  cardLayer.position = $.NSMakePoint(L.w / 2, winH)
+  cardLayer.contentsScale = scale
+  cardLayer.actions = $({ contents: $.NSNull.null })
+  root.addSublayer(cardLayer)
+  function repaint() { cardLayer.contents = imageOf(paintCard(spec, L, state, scale), L.w, L.h) }
+  repaint()
+
+  // The text box: an ordinary borderless field over the painted box. It draws only typed text.
+  var f = L.field
+  var fieldH = Math.ceil(L.field.lineH) + 2
+  var field = $.NSTextField.alloc.initWithFrame($.NSMakeRect(f.x + 11 - 2, winH - (f.y + (f.h + fieldH) / 2), f.w - 22 + 4, fieldH))
+  field.bordered = false
+  field.bezeled = false
+  field.drawsBackground = false
+  field.focusRingType = 1                            // none
+  field.font = L.fonts.field
+  field.textColor = color(L.p.text)
+  field.cell.usesSingleLineMode = true
+  field.cell.scrollable = true
+  content.addSubview(field)
+  var fieldRect = { x: f.x, y: f.y, w: f.w, h: f.h }
+
+  // Where an event lands, in card points (y down); null when outside the card.
+  function at(ev) {
+    var pt = ev.locationInWindow
+    var x = pt.x, y = winH - pt.y
+    return (x >= 0 && x < L.w && y >= 0 && y < L.h) ? { x: x, y: y } : null
+  }
+  function rowAt(pt) {
+    if (!pt) return -1
+    for (var i = 0; i < L.rows.length; i++) {
+      var r = L.rows[i]
+      if (pt.x >= r.x && pt.x < r.x + r.w && pt.y >= r.y && pt.y < r.y + r.h) return i
+    }
+    return -1
+  }
+  function inField(pt) {
+    return pt && pt.x >= fieldRect.x && pt.x < fieldRect.x + fieldRect.w && pt.y >= fieldRect.y && pt.y < fieldRect.y + fieldRect.h
+  }
+  function select(i) { if (i >= 0 && i !== state.selected) { state.selected = i; repaint() } }
+  function hover(ev) { select(rowAt(at(ev))) }
+  function fieldFocused() { return !field.currentEditor.isNil() }
+  function syncPlaceholder() {
+    var t = field.stringValue.js || ''
+    if ((t === '') !== (state.typed === '')) { state.typed = t; repaint() } else state.typed = t
+  }
+  // Clicking the card is the user choosing it, so only then does it take the keyboard. macOS
+  // delivers keys to the active app, so activate as well as becoming key. When the card closes,
+  // focus returns to the previous app.
+  function takeKeys() {
+    if (state.armed && panel.keyWindow && app.active) return
+    state.armed = true
+    app.setActivationPolicy(1)
+    app.activateIgnoringOtherApps(true)
+    panel.makeKeyWindow
+  }
+
+  var T = { down: 1, up: 2, key: 10 }
+  function onEvent(ev) {
+    var type = Number(ev.type)                       // the bridge hands enums over as strings
+    if (type === T.down) {
+      var pt = at(ev), row = rowAt(pt)
+      if (row >= 0) { state.pressed = row; select(row); return true }   // one click answers (on release)
+      if (!pt) return false
+      state.wantField = inField(pt)
+      takeKeys()
+      if (!state.wantField) { panel.makeFirstResponder($()); return true }
+      panel.makeFirstResponder(field)                   // a click on the box types there, even the first one
+      return false
+    }
+    if (type === T.up && state.pressed >= 0) {
+      var r = rowAt(at(ev)), was = state.pressed
+      state.pressed = -1
+      if (r === was) pick(r)
+      return true
+    }
+    if (type === T.key) {
+      var code = Number(ev.keyCode)
+      if (code === 53) emit({ cancelled: true, reason: 'esc' })
+      if (code === 125) { select(Math.min(state.selected + 1, Math.max(0, opts.length - 1))); return true }
+      if (code === 126) { select(Math.max(state.selected - 1, 0)); return true }
+      if (fieldFocused()) {
+        if (code === 36 || code === 76) { submit(); return true }
+        return false                                   // the text box types it
+      }
+      if ((code === 36 || code === 76) && opts.length) pick(state.selected)
+      var c = ev.charactersIgnoringModifiers.js
+      var n = parseInt(c, 10)
+      if (/^[1-9]$/.test(c) && n >= 1 && n <= opts.length) pick(n - 1)
+      return false
+    }
+    return false
+  }
+
+  var hoverOwner = $.AskNotchHover.alloc.init
+  content.addTrackingArea($.NSTrackingArea.alloc.initWithRectOptionsOwnerUserInfo(
+    $.NSMakeRect(0, 0, winW, winH),
+    0x01 | 0x02 | 0x80 | 0x200,                        // entered/exited · moved · even when inactive · whole view
+    hoverOwner, $()))
+
+  // Show without taking focus or activating, then drop in: scale up from the top edge with a spring.
+  panel.orderFrontRegardless
+  panel.makeFirstResponder($())
+  after(0.2, function () { if (!state.armed) app.setActivationPolicy(1) })   // accessory
+  var spring = function (keyPath, from, to) {
+    var a = $.CASpringAnimation.animationWithKeyPath(keyPath)
+    a.mass = 1; a.stiffness = 385.6; a.damping = 32.2     // SwiftUI .spring(response: 0.32, dampingFraction: 0.82)
+    a.fromValue = $(from); a.toValue = $(to)
+    a.duration = a.settlingDuration
+    return a
+  }
+  cardLayer.addAnimationForKey(spring('transform.scale', 0.92, 1), 'drop')
+  cardLayer.addAnimationForKey(spring('opacity', 0, 1), 'fade')
+  after(0.6, function () { panel.invalidateShadow })
+
+  // Companion: hop in once the card has landed, sit while waiting, settle down after a while.
+  if (comp) {
+    function play(frames, done) {
+      var i = 0
+      ;(function next() {
+        if (i >= frames.length) return done && done()
+        var fr = frames[i++]
+        compLayer.contents = fr.img
+        after(fr.ms / 1000, next)
+      })()
+    }
+    after(comp.introDelay / 1000, function () {
+      play(comp.intro, function () {
+        compLayer.contents = comp.idle
+        if (comp.settle.length && comp.settleAfter > 0) after(comp.settleAfter, function () { play(comp.settle) })
+      })
+    })
+  }
+
+  // Safety net: if macOS activates the card anyway before it's clicked, hand activation straight
+  // back to the app you were using.
+  $.NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(
+    'NSApplicationDidBecomeActiveNotification', app, $(), function () {
+      if (spec.debug) log('became-active armed=' + state.armed)
+      if (!state.armed && previous && !previous.isNil()) previous.activateWithOptions(0)
+    })
+  if (spec.debug) {
+    after(0.05, function () { log('t=0.05 active=' + app.active + ' key=' + panel.keyWindow) })
+    after(1, function () { log('t=1 active=' + app.active + ' key=' + panel.keyWindow) })
+  }
+  var timeout = typeof spec.timeout === 'number' && spec.timeout > 0 ? spec.timeout : DEFAULT_TIMEOUT_S
+  after(timeout, function () { emit({ cancelled: true, reason: 'timeout' }) })
+
+  app.run
+}
+
+function after(seconds, fn) {
+  $.NSTimer.scheduledTimerWithTimeIntervalRepeatsBlock(Math.max(0, seconds), false, function () {
+    try { fn() } catch (e) { log('card: ' + e) }
+  })
+}
+
+// The question arrives as JSON on standard input (the mod writes it there); an argument works too.
+function readStdin() {
+  var data = $.NSFileHandle.fileHandleWithStandardInput.readDataToEndOfFile
+  var str = $.NSString.alloc.initWithDataEncoding(data, 4)
+  return str.isNil() ? '' : str.js
+}
+
+function run(argv) {
+  var spec
+  try { spec = JSON.parse(argv && argv[0] ? argv[0] : readStdin()) } catch (e) { spec = null }
+  if (!spec || typeof spec.question !== 'string') {
+    log("usage: echo '<json>' | osascript -l JavaScript card.js")
+    $.exit(2)
+  }
+  main(spec)
+}
diff --git a/packages/notch-mod/helper/sb-card b/packages/notch-mod/helper/sb-card
deleted file mode 100755
index 1bda2d3..0000000
Binary files a/packages/notch-mod/helper/sb-card and /dev/null differ
diff --git a/packages/notch-mod/helper/sb-card.swift b/packages/notch-mod/helper/sb-card.swift
deleted file mode 100644
index fec681b..0000000
--- a/packages/notch-mod/helper/sb-card.swift
+++ /dev/null
@@ -1,266 +0,0 @@
-// sb-card — one-shot native card for the Switchboard notch mod.
-//
-// Shows ONE question as a Dynamic-Island-style card dropped from the notch (or beside the cursor),
-// waits for the answer, prints it as JSON on stdout, and exits. No daemon, no Switchboard.app,
-// no TCC permissions: it only draws its own window and reads the public mouse position.
-//
-//   sb-card '<json>'
-//   json: { title?, question, options:[{label, detail?, recommended?}], at?: "notch"|"cursor",
-//           source?, timeout?: seconds }
-//   stdout: {"answer":"<label>","index":n} | {"answer":"<typed>","typed":true}
-//           | {"cancelled":true,"reason":"esc"|"timeout"}
-//
-// The card never takes the keyboard when it appears, so typing in another app can't answer it.
-// Clicking an option answers. Clicking the card enables its keys: 1-4 pick · ↑↓ move · ⏎ confirm ·
-// esc cancels. Clicking the text box lets you type your own answer (digits are text there).
-
-import AppKit
-import SwiftUI
-
-struct CardOption: Decodable { let label: String; let detail: String?; let recommended: Bool? }
-struct CardSpec: Decodable {
-    let title: String?; let question: String; let options: [CardOption]
-    let at: String?; let source: String?; let timeout: Double?
-    let appearance: String?   // "light" | "dark"; omitted = follow the system
-    let debug: Bool?          // tests: report focus changes on stderr
-}
-
-// Claude's design language: warm ivory / warm charcoal surfaces, terracotta accent, serif voice.
-struct Palette {
-    let bg, raised, border, text, muted, accent: Color
-    static func hex(_ v: UInt32) -> Color {
-        Color(red: Double((v >> 16) & 0xFF) / 255, green: Double((v >> 8) & 0xFF) / 255, blue: Double(v & 0xFF) / 255)
-    }
-    static let light = Palette(bg: hex(0xFAF9F5), raised: hex(0xF0EEE6), border: hex(0xE3E0D5),
-                               text: hex(0x141413), muted: hex(0x6B6A65), accent: hex(0xD97757))
-    static let dark = Palette(bg: hex(0x262624), raised: hex(0x30302E), border: hex(0x3E3E3A),
-                              text: hex(0xFAF9F5), muted: hex(0xA3A29C), accent: hex(0xD97757))
-}
-
-func emit(_ obj: [String: Any]) -> Never {
-    let data = (try? JSONSerialization.data(withJSONObject: obj)) ?? Data("{}".utf8)
-    FileHandle.standardOutput.write(data)
-    FileHandle.standardOutput.write(Data("\n".utf8))
-    exit(0)
-}
-
-final class Model: ObservableObject {
-    let spec: CardSpec
-    @Published var selected: Int
-    @Published var typed = ""
-    @Published var shown = false
-    @Published var fieldFocused = false
-    init(_ spec: CardSpec) {
-        self.spec = spec
-        selected = spec.options.firstIndex { $0.recommended == true } ?? 0
-    }
-    func pick(_ i: Int) { emit(["answer": spec.options[i].label, "index": i]) }
-    func submit() {
-        let t = typed.trimmingCharacters(in: .whitespacesAndNewlines)
-        if !t.isEmpty { emit(["answer": t, "typed": true]) }
-        if !spec.options.isEmpty { pick(selected) }
-    }
-}
-
-struct CardView: View {
-    @ObservedObject var m: Model
-    let dark: Bool
-    @FocusState var fieldFocused: Bool
-    var p: Palette { dark ? .dark : .light }
-    var shape: UnevenRoundedRectangle {
-        UnevenRoundedRectangle(topLeadingRadius: 12, bottomLeadingRadius: 20,
-                               bottomTrailingRadius: 20, topTrailingRadius: 12)
-    }
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: 12) {
-            HStack(spacing: 6) {
-                Text("✻").font(.system(size: 13, weight: .bold)).foregroundColor(p.accent)
-                Text(m.spec.title ?? "Claude has a question")
-                    .font(.system(size: 11.5, weight: .medium)).foregroundColor(p.muted)
-                Spacer()
-                if let s = m.spec.source {
-                    Text(s).font(.system(size: 10.5)).foregroundColor(p.muted.opacity(0.8)).lineLimit(1)
-                }
-            }
-            Text(m.spec.question)
-                .font(.system(size: 16, weight: .regular, design: .serif)).foregroundColor(p.text)
-                .lineSpacing(2).fixedSize(horizontal: false, vertical: true)
-            VStack(spacing: 6) {
-                ForEach(Array(m.spec.options.enumerated()), id: \.offset) { i, o in row(i, o) }
-            }
-            // Our own placeholder: the system one is dimmed to near-invisible while the card isn't key.
-            TextField("", text: $m.typed)
-                .textFieldStyle(.plain).font(.system(size: 12.5)).foregroundColor(p.text)
-                .background(alignment: .leading) {
-                    if m.typed.isEmpty {
-                        Text("Something else? Type it here").font(.system(size: 12.5))
-                            .foregroundColor(p.muted.opacity(0.8)).allowsHitTesting(false)
-                    }
-                }
-                .padding(.horizontal, 11).padding(.vertical, 8)
-                .background(RoundedRectangle(cornerRadius: 10).fill(p.bg))
-                .overlay(RoundedRectangle(cornerRadius: 10).stroke(p.border, lineWidth: 1))
-                .focused($fieldFocused)
-                .onSubmit { m.submit() }
-            HStack(spacing: 10) {
-                hint("click", "for keys")
-                hint("1–\(max(1, m.spec.options.count))", "choose")
-                hint("↵", "confirm")
-                hint("esc", "dismiss")
-            }
-        }
-        .padding(.horizontal, 18).padding(.top, 14).padding(.bottom, 14)
-        .frame(width: 440)
-        .background(shape.fill(p.bg))
-        .overlay(shape.stroke(p.border, lineWidth: 1))
-        .scaleEffect(m.shown ? 1 : 0.92, anchor: .top)
-        .opacity(m.shown ? 1 : 0)
-        .onChange(of: fieldFocused) { f in m.fieldFocused = f }   // macOS 13 form
-    }
-
-    func hint(_ key: String, _ what: String) -> some View {
-        HStack(spacing: 4) {
-            Text(key).font(.system(size: 9.5, weight: .medium)).foregroundColor(p.muted)
-                .padding(.horizontal, 4).padding(.vertical, 1)
-                .background(RoundedRectangle(cornerRadius: 4).stroke(p.border, lineWidth: 1))
-            Text(what).font(.system(size: 10)).foregroundColor(p.muted)
-        }
-    }
-
-    func row(_ i: Int, _ o: CardOption) -> some View {
-        let on = i == m.selected
-        return Button { m.pick(i) } label: {
-            HStack(alignment: .top, spacing: 10) {
-                Text("\(i + 1)")
-                    .font(.system(size: 11, weight: .semibold))
-                    .foregroundColor(on ? .white : p.muted)
-                    .frame(width: 20, height: 20)
-                    .background(RoundedRectangle(cornerRadius: 6).fill(on ? p.accent : p.bg))
-                    .overlay(RoundedRectangle(cornerRadius: 6).stroke(on ? .clear : p.border, lineWidth: 1))
-                VStack(alignment: .leading, spacing: 2) {
-                    HStack(spacing: 6) {
-                        Text(o.label).font(.system(size: 13, weight: .medium)).foregroundColor(p.text)
-                        if o.recommended == true {
-                            Text("Recommended").font(.system(size: 9.5, weight: .medium))
-                                .foregroundColor(p.accent)
-                                .padding(.horizontal, 5).padding(.vertical, 1)
-                                .background(Capsule().fill(p.accent.opacity(0.12)))
-                        }
-                    }
-                    if let d = o.detail, !d.isEmpty {
-                        Text(d).font(.system(size: 11.5)).foregroundColor(p.muted)
-                            .fixedSize(horizontal: false, vertical: true)
-                    }
-                }
-                Spacer(minLength: 0)
-            }
-            .padding(.horizontal, 10).padding(.vertical, 8)
-            .frame(maxWidth: .infinity, alignment: .leading)
-            .background(RoundedRectangle(cornerRadius: 11).fill(on ? p.raised : .clear))
-            .overlay(RoundedRectangle(cornerRadius: 11).stroke(on ? p.accent.opacity(0.55) : p.border, lineWidth: 1))
-            .contentShape(Rectangle())
-        }
-        .buttonStyle(.plain)
-        .onHover { if $0 { m.selected = i } }
-    }
-}
-
-final class CardPanel: NSPanel {
-    override var canBecomeKey: Bool { true }
-    // Clicking the card is the user choosing it, so only then does it take the keyboard: macOS
-    // delivers keys to the active app, so activate as well as becoming key. 1-4, arrows, return
-    // and esc work from then on. When the card closes, focus returns to the previous app.
-    override func sendEvent(_ event: NSEvent) {
-        if event.type == .leftMouseDown, !(isKeyWindow && NSApp.isActive) {
-            NSApp.activate(ignoringOtherApps: true)
-            makeKey()
-            // Becoming key auto-focuses the text box, which would turn 1-4 into typed text. Clear
-            // it; if this click is on the text box, super.sendEvent focuses it again.
-            makeFirstResponder(nil)
-        }
-        super.sendEvent(event)
-    }
-}
-
-// The card isn't key when it appears, so without this the first click would only focus it and a
-// second click would be needed to pick an option.
-final class CardHost<Content: View>: NSHostingView<Content> {
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
-}
-
-// ── main ──
-guard CommandLine.arguments.count > 1,
-      let spec = try? JSONDecoder().decode(CardSpec.self, from: Data(CommandLine.arguments[1].utf8)) else {
-    FileHandle.standardError.write(Data("usage: sb-card '<json>'\n".utf8)); exit(2)
-}
-
-let app = NSApplication.shared
-app.setActivationPolicy(.accessory)
-// Light or dark: the spec can force one (for screenshots); otherwise follow the system.
-let isDark = spec.appearance.map { $0 == "dark" }
-    ?? (app.effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua)
-
-let model = Model(spec)
-let host = CardHost(rootView: CardView(m: model, dark: isDark))
-host.layoutSubtreeIfNeeded()
-let size = host.fittingSize
-
-// Notch: the screen with a top safe-area inset (the notch), else the main screen; flush to its top
-// edge so the black card reads as the notch growing down. Cursor: just below-right of the pointer.
-let mouse = NSEvent.mouseLocation
-let atCursor = spec.at == "cursor"
-let screen: NSScreen = atCursor
-    ? (NSScreen.screens.first { NSMouseInRect(mouse, $0.frame, false) } ?? NSScreen.main!)
-    : (NSScreen.screens.first { $0.safeAreaInsets.top > 0 } ?? NSScreen.main!)
-var origin: NSPoint
-if atCursor {
-    origin = NSPoint(x: mouse.x + 14, y: mouse.y - 18 - size.height)
-    let f = screen.visibleFrame
-    origin.x = min(max(origin.x, f.minX + 8), f.maxX - size.width - 8)
-    origin.y = min(max(origin.y, f.minY + 8), f.maxY - size.height - 8)
-} else {
-    origin = NSPoint(x: screen.frame.midX - size.width / 2, y: screen.frame.maxY - size.height)
-}
-
-let panel = CardPanel(contentRect: NSRect(origin: origin, size: size),
-                      styleMask: [.borderless, .nonactivatingPanel], backing: .buffered, defer: false)
-panel.contentView = host
-panel.isOpaque = false
-panel.backgroundColor = .clear
-panel.hasShadow = true
-panel.level = .popUpMenu                      // above the menu bar, so it can sit in the notch
-panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .transient]
-panel.isMovableByWindowBackground = false
-panel.becomesKeyOnlyIfNeeded = false           // a click anywhere on the card makes it key
-panel.orderFrontRegardless()                   // show without taking focus or activating
-if spec.debug == true {
-    NotificationCenter.default.addObserver(forName: NSWindow.didBecomeKeyNotification, object: panel, queue: .main) { _ in
-        FileHandle.standardError.write(Data("became-key\n".utf8))
-    }
-}
-DispatchQueue.main.async {
-    withAnimation(.spring(response: 0.32, dampingFraction: 0.82)) { model.shown = true }
-}
-
-// Keys reach the card only after it's clicked (it's key then). Outside the text box: digits pick,
-// arrows move, return confirms. In the text box, digits and return belong to the field (onSubmit).
-NSEvent.addLocalMonitorForEvents(matching: .keyDown) { ev in
-    switch ev.keyCode {
-    case 53: emit(["cancelled": true, "reason": "esc"])
-    case 125: model.selected = min(model.selected + 1, max(0, spec.options.count - 1)); return nil
-    case 126: model.selected = max(model.selected - 1, 0); return nil
-    default: break
-    }
-    if model.fieldFocused { return ev }
-    if ev.keyCode == 36 || ev.keyCode == 76, !spec.options.isEmpty { model.pick(model.selected) }
-    if let c = ev.charactersIgnoringModifiers, let n = Int(c), n >= 1, n <= spec.options.count {
-        model.pick(n - 1)
-    }
-    return ev
-}
-
-let timeout = spec.timeout ?? 540
-DispatchQueue.main.asyncAfter(deadline: .now() + timeout) { emit(["cancelled": true, "reason": "timeout"]) }
-
-app.run()
diff --git a/packages/notch-mod/hooks/hooks.json b/packages/notch-mod/hooks/hooks.json
index 7c4fe5e..95ad768 100644
--- a/packages/notch-mod/hooks/hooks.json
+++ b/packages/notch-mod/hooks/hooks.json
@@ -1,5 +1,5 @@
 {
-  "description": "Routes AskUserQuestion to the native notch card (helper/sb-card)",
+  "description": "Routes AskUserQuestion to the notch card (helper/card.js, run by macOS's osascript)",
   "modules": ["./register.js"],
   "hooks": {}
 }
diff --git a/packages/notch-mod/hooks/register.js b/packages/notch-mod/hooks/register.js
index ed86f9d..bb60deb 100644
--- a/packages/notch-mod/hooks/register.js
+++ b/packages/notch-mod/hooks/register.js
@@ -1,41 +1,69 @@
-// switchboard-notch — Claude's questions as a native card at the notch.
+// Ask Notch: Claude's questions as a native card at the notch.
 //
-// Claude's AskUserQuestion is answered from helper/sb-card, a one-shot native window that drops from
-// the notch (or opens beside the cursor). Esc at the card, a timeout, or a missing helper falls back
-// to Claude Code's own dialog, so a question is never lost.
+// Claude's AskUserQuestion is answered from helper/card.js, a one-shot window drawn by macOS's
+// built-in script runner (osascript, JavaScript for Automation). Esc at the card, a timeout, or a
+// card that can't start falls back to Claude Code's own dialog, so a question is never lost.
 
 const CARD_TIMEOUT_S = 540
+const COMPANIONS = ['cat', 'off']
+// Added to Claude's system prompt while cards are on (the ask-at-the-notch skill says the same at length).
+const CHOICES_NOTE = '# Ask Notch\nAsk Notch is installed and on: an AskUserQuestion call shows as a card at the top of the person\'s screen, answered with one click from any app. So whenever your reply would offer the person two or more options to pick from (approaches, designs, names, which way to go) or end by asking which they prefer, do not write that list. Call AskUserQuestion instead: one single-choice question, 2-4 options with short labels, your pick first with " (Recommended)" at the end of its label, the reasoning and trade-off in each option\'s description. Then continue with the answer. This applies even when they ask you to help them decide: give your pick as the recommended option. Only skip the card when there is truly one sensible way to do it.'
 
 export function register(on) {
   on('session.start', async ($, e, next) => {
     try {
       await $.command.register({
         name: 'notch',
-        description: 'Claude questions at the notch: on · off · notch · cursor · test',
-        argumentHint: '[on|off|notch|cursor|test]',
+        description: 'Claude questions at the notch. Say what you want: "put it by my cursor", "pause", "bring the cat", "test"',
+        argumentHint: '[anything, e.g. "put it by my cursor"]',
         immediate: true,
       })
+      // Claude reads whatever follows /notch and changes the setting through this tool.
+      await $.tool.register({
+        name: 'settings',
+        description: 'Read or change Ask Notch, the plugin that shows your AskUserQuestion questions as a card at the Mac\'s notch. Every field is optional; leave all out to read the current settings. on: false sends questions to Claude Code\'s own dialog instead. at: where the card opens, "notch" (drops from the top of the screen) or "cursor" (beside the mouse pointer). companion: "cat" shows an animated cat beside the card, "off" hides it. test: true shows a sample card so the person can see it working. Returns the settings after the change.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            on: { type: 'boolean' },
+            at: { type: 'string', enum: ['notch', 'cursor'] },
+            companion: { type: 'string', enum: COMPANIONS },
+            test: { type: 'boolean' },
+          },
+        },
+      })
     } catch {}
     return next(e)
   })
 
+  // While cards are on, Claude asks its choices with AskUserQuestion, so they arrive at the notch.
+  on('prompt.compose', async ($, e, next) => {
+    const r = await next(e)
+    const cfg = await loadCfg($)
+    if (!cfg.on) return r
+    return { sections: [...r.sections, { id: 'ask-notch:choices', text: CHOICES_NOTE, scope: 'session' }] }
+  })
+
   on('command.run', { command: 'notch' }, async ($, e) => {
+    const said = (e.args || '').trim()
     const cfg = await loadCfg($)
-    const arg = (e.args || '').trim()
-    if (arg === 'on' || arg === 'off') cfg.on = arg === 'on'
-    else if (arg === 'notch' || arg === 'cursor') cfg.at = arg
-    else if (arg === 'test') {
-      const r = await showCard($, {
-        question: 'Notch cards are working. Keep Claude\'s questions here?',
-        options: [
-          { label: 'Keep them here', detail: 'Questions drop from the notch', recommended: true },
-          { label: 'Beside the cursor', detail: 'Card opens where you are pointing' },
-        ],
-      }, cfg.at)
-      return { text: 'test card → ' + JSON.stringify(r) }
+    if (!said) return { text: describe(cfg) + ' · say what you want, e.g. /notch put it by my cursor' }
+    // The exact words still work instantly; anything else is read by Claude.
+    const exact = parseExact(said)
+    if (exact) {
+      const r = await apply($, cfg, exact)
+      return { text: describe(r.cfg) + (r.test ? ' · test card → ' + JSON.stringify(r.test) : '') }
     }
-    await $.store.set('cfg', cfg)
-    return { text: 'Notch cards ' + (cfg.on ? 'on' : 'off') + ' · at ' + cfg.at }
+    // A command.run hook can't submit (it holds the turn); queue it to run just after the command returns.
+    $.clock.after(50, () => $.prompt.submit({
+      text: 'The person typed `/notch ' + said + '`. Read it as a change to Ask Notch and make it with the mcp__ask-notch__settings tool, then reply in one short line with what changed. If it asks for something the settings cannot do, say so in one line and leave them as they are. Current: ' + describe(cfg) + '.',
+    }))
+    return { text: 'asking Claude: "' + said + '"…' }
+  })
+
+  on('tool.call', { tool: 'mcp__ask-notch__settings' }, async ($, e) => {
+    const r = await apply($, await loadCfg($), e)
+    return { result: describe(r.cfg) + (r.test ? ' · test card answered: ' + JSON.stringify(r.test) : '') }
   })
 
   on('tool.call', { tool: 'AskUserQuestion' }, async ($, e, next) => {
@@ -55,8 +83,8 @@ export function register(on) {
           detail: o.description,
           recommended: /\(recommended\)\s*$/i.test(String(o.label)),
         })),
-      }, cfg.at)
-      // Dismissed, timed out, or helper failed: hand the whole question set to Claude Code's dialog.
+      }, cfg)
+      // Dismissed, timed out, or the card failed: hand the whole question set to Claude Code's dialog.
       if (!r || r.cancelled || !r.answer) return next(e)
       answers[q.question] = r.answer
     }
@@ -64,18 +92,57 @@ export function register(on) {
   })
 }
 
+// The fixed words /notch has always taken: on, off, notch, cursor, companion cat|off, test.
+function parseExact(said) {
+  const [arg, value, extra] = said.toLowerCase().split(/\s+/)
+  if (extra !== undefined) return null
+  if ((arg === 'on' || arg === 'off') && !value) return { on: arg === 'on' }
+  if ((arg === 'notch' || arg === 'cursor') && !value) return { at: arg }
+  if (arg === 'companion' && COMPANIONS.includes(value)) return { companion: value }
+  if (arg === 'test' && !value) return { test: true }
+  return null
+}
+
+async function apply($, cfg, change) {
+  if (typeof change.on === 'boolean') cfg.on = change.on
+  if (change.at === 'notch' || change.at === 'cursor') cfg.at = change.at
+  if (COMPANIONS.includes(change.companion)) cfg.companion = change.companion
+  await $.store.set('cfg', cfg)
+  let test
+  if (change.test) {
+    test = await showCard($, {
+      question: 'Notch cards are working. Keep Claude\'s questions here?',
+      options: [
+        { label: 'Keep them here', detail: 'Questions drop from the notch', recommended: true },
+        { label: 'Beside the cursor', detail: 'Card opens where you are pointing' },
+      ],
+    }, cfg)
+  }
+  return { cfg, test }
+}
+
+function describe(cfg) {
+  return 'Notch cards ' + (cfg.on ? 'on' : 'off') + ' · at ' + cfg.at + ' · companion ' + cfg.companion
+}
+
 async function loadCfg($) {
   const saved = await $.store.get('cfg')
-  return { on: true, at: 'notch', ...(saved || {}) }
+  const cfg = { on: true, at: 'notch', companion: 'off', ...(saved || {}) }
+  if (!COMPANIONS.includes(cfg.companion)) cfg.companion = 'off'
+  return cfg
 }
 
-async function showCard($, spec, at) {
-  $.ui.status('question waiting at the ' + at)
+async function showCard($, spec, cfg) {
+  const companion = cfg.companion === 'cat' ? { name: 'cat', dir: 'assets/companion/cat' } : undefined
+  $.ui.status('question waiting at the ' + cfg.at)
   try {
-    const r = await $.process.run(
-      [$.plugin.root + '/helper/sb-card', JSON.stringify({ ...spec, at, source: 'Claude Code', timeout: CARD_TIMEOUT_S })],
-      { timeoutMs: (CARD_TIMEOUT_S + 15) * 1000 },
-    )
+    // Always the same command: macOS's own osascript running this plugin's helper/card.js. The question
+    // goes to it on standard input; its answer comes back on standard output. Nothing leaves the Mac.
+    const r = await $.process.run(['/usr/bin/osascript', '-l', 'JavaScript', 'helper/card.js'], {
+      cwd: $.plugin.root,
+      stdin: JSON.stringify({ ...spec, at: cfg.at, source: 'Claude Code', timeout: CARD_TIMEOUT_S, companion }),
+      timeoutMs: (CARD_TIMEOUT_S + 15) * 1000,
+    })
     const line = r.stdout.trim().split('\n').pop()
     return line ? JSON.parse(line) : null
   } catch {
diff --git a/packages/notch-mod/listing/LISTING.md b/packages/notch-mod/listing/LISTING.md
index 957d485..fca749b 100644
--- a/packages/notch-mod/listing/LISTING.md
+++ b/packages/notch-mod/listing/LISTING.md
@@ -1,98 +1,127 @@
-# Switchboard Notch: directory listing draft
+# Ask Notch: directory listing (new submission, 0.2.0)
 
-Portal: https://claude.ai/directory/manage → **Submit new** → **Plugin bundle**.
-For plugins, the portal reads the listing from `.claude-plugin/plugin.json` and `README.md`. You don't
-type most of it into a form: to change a field, edit the file, run `./publish.sh`, and **Re-validate**.
-Everything below is either already in those files, or is an answer you give in the form.
+Ask Notch replaces the **switchboard-notch** submission (portal id `ce733ea6-f8b8-4e94-bcbf-836559d96e85`,
+v0.1.3, in human review). It is a new plugin name, so it is a **new submission**, not a version of the old one.
+
+Portal: https://claude.ai/directory/manage. For plugins, the portal reads the listing from
+`.claude-plugin/plugin.json` and `README.md`. To change a field, edit the file, run `./build.sh && ./publish.sh`,
+and **Re-validate**. Everything below is either already in those files or is an answer you give in the form.
+
+## What changed vs switchboard-notch
+
+| | switchboard-notch 0.1.x | Ask Notch 0.2.0 |
+| --- | --- | --- |
+| Name | `switchboard-notch` / Switchboard Notch | `ask-notch` / Ask Notch |
+| The card | `helper/sb-card`, a compiled Swift binary (signed + notarized) | `helper/card.js`, plain JavaScript run by macOS's own `/usr/bin/osascript -l JavaScript` |
+| Directory scan | "ships code the scan can't read" (the binary) | no compiled code; every file is readable text or a PNG |
+| Look and behaviour | Claude design language card | the same card, pixel-matched (see `compare-0.2.0.jpg`) |
+| Keyboard on appear | could be handed activation when the app that started it was frontmost | appears as a background-only app, refuses to become key until clicked, hands activation back if macOS gives it anyway |
+| Settings | `/notch on\|off\|notch\|cursor\|test` | the same, plus `/notch companion cat\|off` (off by default) |
+| Repo / install | `sameeeeeeep/switchboard-notch` | `sameeeeeeep/ask-notch` |
 
 ## Source step (typed in the portal)
 
 | Field | Value |
 | --- | --- |
-| Repository | `sameeeeeeep/switchboard-notch` |
+| Repository | `sameeeeeeep/ask-notch` |
 | Plugin path | leave empty (the plugin is at the repository root) |
 | Branch or tag | leave empty (follows `main`) |
 
-Submit the small mirror repo, not `sameeeeeeep/switchboard` with path `packages/notch-mod`. In a subfolder,
-the validator also holds `hooks/register.js` ("Scripts the validator couldn't follow"), and `packages/` holds
-other plugins.
+Submit the small mirror repo, not `sameeeeeeep/switchboard` with path `packages/notch-mod`.
 
 ## Listing details (read from plugin.json and README.md)
 
-| Field | Value | Source | Status |
-| --- | --- | --- | --- |
-| Name (permanent) | `switchboard-notch` | plugin.json `name` | set |
-| Display name | Switchboard Notch | plugin.json `displayName` | set |
-| Short description | Claude's questions drop from your Mac's notch as a native card. Pick with 1-4, type your own answer, or press esc to answer in Claude Code as usual. | plugin.json `description` | set |
-| Long description | The README, shown as the listing description | `README.md` | set (about 690 words outside code blocks; 40 needed) |
-| Icon | `./assets/icon.png` (512×512 PNG, the Switchboard lime dot mark) | plugin.json `icon` | set; reaches GitHub on the next `./publish.sh` |
-| Version | 0.1.0 | plugin.json `version` | set |
-| Author / publisher | sameeeeeeep | plugin.json `author.name` | set (consider `Sameep Rehlan` or `The Last Prompt` if you want a recognisable publisher) |
-| License | MIT | plugin.json `license` + `LICENSE` file | set |
-| Homepage | https://thelastprompt.ai/switchboard | plugin.json `homepage` | live (200) |
-| Repository | https://github.com/sameeeeeeep/switchboard-notch | plugin.json `repository` | live |
-| Documentation URL | https://github.com/sameeeeeeep/switchboard-notch#readme | plugin.json `documentationUrl` | live |
-| Support URL | https://github.com/sameeeeeeep/switchboard-notch/issues | plugin.json `supportUrl` | live (issues enabled) |
-| Privacy policy URL | https://github.com/sameeeeeeep/switchboard-notch#privacy | plugin.json `privacyPolicyUrl` | **NOT LIVE YET**: the `## Privacy` README section exists only locally until `./publish.sh` runs. The existing https://thelastprompt.ai/switchboard/privacy covers the browser extension and daemon only, not this plugin, so it isn't used. |
-| Terms of service URL | not set | plugin.json `termsOfServiceUrl` | optional; there is no thelastprompt.ai terms page (404) |
-| Keywords | notch, macos, mod, questions, AskUserQuestion | plugin.json `keywords` | set |
-| Category | not asked for plugins in the current docs (only connectors have "one to five categories"). If the form asks, pick **Developer tools**, then **Productivity**. | portal | n/a |
-| Supported surfaces | Claude Code only (macOS). The portal works this out from the components. Hooks are "Ignored" in Chat, so the listing will show it doing nothing in claude.ai chat. | derived | expected |
-
-### Short description, alternatives if you want a different one (edit plugin.json `description`)
-
-- Current: "Claude's questions drop from your Mac's notch as a native card. Pick with 1-4, type your own answer, or press esc to answer in Claude Code as usual."
-- Shorter: "Answer Claude Code's questions from a native card at your Mac's notch."
-
-### Long description
-
-This is the README. Its sections: what it does (with screenshot) · Try it for one session · Keep it · Settings ·
-Examples (3 use cases, which Directory Policy 3.E asks for) · Where it works · Troubleshooting · What it does on your
-machine · Privacy · Support · Develop.
+| Field | Value | Source |
+| --- | --- | --- |
+| Name (permanent) | `ask-notch` | plugin.json `name` |
+| Display name | Ask Notch | plugin.json `displayName` |
+| Short description | Claude's questions drop from your Mac's notch as a card. Click an option, pick with 1-4, type your own answer, or press esc to answer in Claude Code as usual. | plugin.json `description` |
+| Long description | The README | `README.md` |
+| Icon | `./assets/icon.png` (512×512; still the Switchboard dot mark, replace if Ask Notch gets its own) | plugin.json `icon` |
+| Version | 0.2.0 | plugin.json `version` |
+| Author / publisher | sameeeeeeep | plugin.json `author.name` |
+| License | MIT | plugin.json `license` + `LICENSE` (copied by publish.sh) |
+| Homepage | https://github.com/sameeeeeeep/ask-notch | plugin.json `homepage` (live once the repo exists) |
+| Repository | https://github.com/sameeeeeeep/ask-notch | plugin.json `repository` |
+| Documentation URL | https://github.com/sameeeeeeep/ask-notch#readme | plugin.json `documentationUrl` |
+| Support URL | https://github.com/sameeeeeeep/ask-notch/issues | plugin.json `supportUrl` (enable issues on the new repo) |
+| Privacy policy URL | https://github.com/sameeeeeeep/ask-notch#privacy | plugin.json `privacyPolicyUrl` |
+| Keywords | notch, macos, mod, questions, AskUserQuestion | plugin.json `keywords` |
+| Category | if asked: **Developer tools**, then **Productivity** | portal |
+| Supported surfaces | Claude Code only (macOS). Hooks are "Ignored" in Chat. | derived |
+
+## Three working examples (Directory Policy 3.E, also in the README)
+
+1. "Add a settings page to this app. Ask me which layout to use before you build it." → the card shows the
+   layouts, with Claude's pick highlighted; click one, or click the card and press 1–4 or ↵.
+2. "Clean up the old migration files, but ask me before deleting anything." → the confirmation question
+   appears at the notch while you're in another app; answer it there and Claude carries on.
+3. "Help me name this CLI tool and ask me to choose." → click the card's text box, type your own name and
+   press ↵; Claude receives exactly what you typed.
 
 ## Data handling step (answer in the form)
 
 | Question | Answer |
 | --- | --- |
-| Does the plugin read or store personal data? | **No.** It reads the text of Claude's `AskUserQuestion` call to draw the card. It stores only the `/notch` setting (on/off, notch/cursor) in Claude Code's local mod storage. |
-| Does it send data to services other than its declared connectors? | **No.** It has no connectors and makes no network requests. `helper/sb-card` is a local, one-shot window that prints the answer to stdout. |
-| How long does it keep data? | It keeps no data. The setting stays until the plugin is uninstalled. |
+| Does the plugin read or store personal data? | **No.** It reads the text of Claude's `AskUserQuestion` call to draw the card. It stores only the `/notch` settings (on/off, notch/cursor, companion) in Claude Code's local mod storage. |
+| Does it send data to services other than its declared connectors? | **No.** It has no connectors and makes no network requests. The card is `osascript` running `helper/card.js`, a local one-shot window that prints the answer to stdout. |
+| How long does it keep data? | It keeps no data. The settings stay until the plugin is uninstalled. |
 | Is it intended for people under 18? | **No.** |
 
+## Privacy (the README's Privacy section, for reference)
+
+Ask Notch collects nothing. The question, its options and your answer pass only between Claude Code and
+`osascript` running `helper/card.js` on your Mac. No network access, no analytics, no account. The only thing
+saved is your `/notch` settings, in Claude Code's local storage for this plugin; uninstalling removes it.
+
 ## Compliance step
 
-1. Check that the prefilled contact email is one you read. Anthropic emails it about the submission.
-   Security contact: sameeeeeeep@gmail.com (also in the README Support section).
+1. Check that the prefilled contact email is one you read. Security contact: sameeeeeeep@gmail.com.
 2. Select all four acknowledgements (Directory Terms and Directory Policy).
 
 ## Review and submit step
 
-- **How new versions reach the directory**: keep **GitHub push webhook**, then select **Set up push updates**
-  (needs admin on the mirror repo). `./publish.sh` pushes to `main`, so each publish becomes a new directory version.
-- **Auto-publish passing versions**: leave it off for the first submission. A reviewer publishes the first version anyway.
+- **How new versions reach the directory**: keep **GitHub push webhook**, then **Set up push updates**
+  (needs admin on `sameeeeeeep/ask-notch`). `./publish.sh` pushes to `main`.
+- **Auto-publish passing versions**: leave off for the first submission.
 - Select **Submit for review**.
 
-## Reviewer notes (paste if the form has a notes box, or keep for a reply to a hold)
-
-> Switchboard Notch is a Claude Code mod (hooks/register.js, Claude Code v2.1.287+) that handles only the
-> `AskUserQuestion` tool call. For single-choice questions it runs `helper/sb-card`, a native macOS window,
-> and returns the picked label in the same shape as Claude Code's own dialog. Esc, a 9-minute timeout,
-> multi-select, or any helper failure falls through to Claude Code's own dialog (`next(e)`), so a question is
-> never lost. `helper/sb-card` is a universal Mach-O built from `helper/sb-card.swift` (in the repo, about 230
-> lines, AppKit + SwiftUI). It is signed with Developer ID (STAYOFT VENTURES PRIVATE LIMITED, 55354KFTHU) and
-> notarized. You can rebuild it with `./build.sh`. It makes no network requests and writes no files.
-> `claude plugin validate` lists every hook and call. No test account is needed. To test: install,
-> run `/notch test` on a Mac, or ask Claude "ask me which layout to use for a settings page".
-
-## Three working examples (Directory Policy 3.E, also in the README)
-
-1. "Add a settings page to this app. Ask me which layout to use before you build it." → the card shows the layouts, with Claude's pick highlighted.
-2. "Clean up the old migration files, but ask me before deleting anything." → the confirmation question appears at the notch while you're in another app.
-3. "Help me name this CLI tool and ask me to choose." → type your own name in the card's text box and press ↵.
-
-## Assets in this folder
-
-- `card-light.png`, `card-dark.png`: 880×624 captures of the real card (`SB_CARD_APPEARANCE=light|dark helper/sb-card ...`).
-  Plugin listings don't take screenshots in the current docs; only MCP Apps have a carousel. The light one is
-  embedded in the README from `assets/card-light.png`, which is the published copy.
-- The icon is `../assets/icon.png`, rendered from `landing/public/favicon.svg`.
+## Reviewer notes (paste if the form has a notes box)
+
+> Ask Notch is a Claude Code mod (hooks/register.js, Claude Code v2.1.287+) that handles only the
+> `AskUserQuestion` tool call. For single-choice questions it runs macOS's built-in
+> `/usr/bin/osascript -l JavaScript helper/card.js '<json>'`, a readable script (JavaScript for Automation,
+> AppKit bridge) that draws one window and prints the picked label, which the mod returns in the same shape as
+> Claude Code's own dialog. Esc, a 9-minute timeout, multi-select, or any card failure falls through to Claude
+> Code's own dialog (`next(e)`), so a question is never lost. The plugin ships no compiled code. The card makes
+> no network requests, writes no files, reads no environment and needs no permissions; it appears without
+> activating and refuses the keyboard until clicked. Optional `/notch companion cat` shows small PNGs from
+> `assets/companion/cat/` (the author's own painted art). `claude plugin validate` lists every hook and call.
+> No test account is needed. To test: install, run `/notch test` on a Mac, or ask Claude "ask me which layout
+> to use for a settings page". This replaces our earlier submission switchboard-notch (withdrawn).
+
+## Owner's portal checklist
+
+Nothing below has been run. In order:
+
+1. Review and merge branch `ask-notch-0.2.0` in `sameeeeeeep/switchboard` (relay repo).
+2. Human test card on your Mac (the one thing not automated): `claude --plugin-dir "$PWD"` in
+   `packages/notch-mod`, run `/notch test`; while typing in another app the card must not take keys; click
+   an option (answers in one click); run it again, click the card, press `2`; again, click the text box and type
+   `2 apples` ↵; again with `/notch cursor` and `/notch companion cat`. Optional: `sh tests/card-selftest.sh`.
+3. Create the mirror: `gh repo create sameeeeeeep/ask-notch --public` (enable Issues).
+4. `cd packages/notch-mod && ./build.sh && ./publish.sh` (pushes the mirror, creates release v0.2.0 with
+   `ask-notch.zip`).
+5. Portal → switchboard-notch submission `ce733ea6-f8b8-4e94-bcbf-836559d96e85` → **Withdraw**.
+6. Portal → **Submit new** → **Plugin bundle** → repository `sameeeeeeep/ask-notch`, then the steps above
+   (data handling, compliance, push webhook, reviewer notes) → **Submit for review**.
+7. Optional: archive `sameeeeeeep/switchboard-notch` or point its README at ask-notch.
+
+## Assets in this folder (not shipped in the plugin)
+
+- `card-light.png`, `card-dark.png`: 880×624 renders of the card (also `../assets/card-*.png`, the README image).
+- `card-cat-light.png`, `card-cat-dark.png`: the card with `/notch companion cat`.
+- `compare-0.2.0.jpg`: old sb-card vs new card.js, light and dark, the pixel difference, the cat, and two real
+  on-screen window captures (notch + cat, cursor mode).
+- `render-card.js`: paints the card to a PNG with card.js's own painter, without opening a window.
+- `make-companion.py`: builds `../assets/companion/cat/` from the painted orange cat.
diff --git a/packages/notch-mod/listing/card-cat-dark.png b/packages/notch-mod/listing/card-cat-dark.png
new file mode 100644
index 0000000..b57a811
Binary files /dev/null and b/packages/notch-mod/listing/card-cat-dark.png differ
diff --git a/packages/notch-mod/listing/card-cat-light.png b/packages/notch-mod/listing/card-cat-light.png
new file mode 100644
index 0000000..32efe8d
Binary files /dev/null and b/packages/notch-mod/listing/card-cat-light.png differ
diff --git a/packages/notch-mod/listing/card-dark.png b/packages/notch-mod/listing/card-dark.png
index 57d24a9..7a53366 100644
Binary files a/packages/notch-mod/listing/card-dark.png and b/packages/notch-mod/listing/card-dark.png differ
diff --git a/packages/notch-mod/listing/card-light.png b/packages/notch-mod/listing/card-light.png
index 7201942..5c36037 100644
Binary files a/packages/notch-mod/listing/card-light.png and b/packages/notch-mod/listing/card-light.png differ
diff --git a/packages/notch-mod/listing/compare-0.2.0.jpg b/packages/notch-mod/listing/compare-0.2.0.jpg
new file mode 100644
index 0000000..987530b
Binary files /dev/null and b/packages/notch-mod/listing/compare-0.2.0.jpg differ
diff --git a/packages/notch-mod/listing/make-companion.py b/packages/notch-mod/listing/make-companion.py
new file mode 100644
index 0000000..58349ec
--- /dev/null
+++ b/packages/notch-mod/listing/make-companion.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Maintainer tool (not part of the plugin): build assets/companion/cat/ from the painted orange cat.
+
+The art is the owner's own (visuals/livewall/scenes/art/sprites/cats/orange). Every frame is drawn
+onto the same transparent canvas (2x pixels) with the cat's feet on the ground line, so the card
+only swaps pictures and never positions anything.
+
+    python3 listing/make-companion.py [path/to/cats/orange]
+"""
+import json, os, sys
+from PIL import Image, ImageDraw, ImageFilter
+
+SRC = sys.argv[1] if len(sys.argv) > 1 else os.path.expanduser(
+    '~/Documents/Projects/visuals/livewall/scenes/art/sprites/cats/orange')
+OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'assets', 'companion', 'cat')
+S = 2                      # pixels per point
+W, H = 120, 60             # canvas, points; its left 48 pt sit behind the card's right edge
+EDGE = 48                  # the card's right edge, in canvas points
+GROUND = H - 3             # feet line, points (the canvas bottom is the card's bottom)
+SIT_H = 46                 # sitting height, points
+
+k_ss = SIT_H / 233         # stand-sit strip: its last frame is the sitting pose (233 px tall)
+k_jump = 0.9 * 347 * k_ss / 294   # jump strip: crouch about as long as the standing cat
+k_sleep = SIT_H / 265      # sit-sleep strip: its first frame is the sitting pose (265 px tall)
+
+# name, source, scale, centre x (canvas points), lift (points above the ground)
+FRAMES = [
+    ('intro-01.png', 't/jump-1.png', k_jump, EDGE + 14 - 294 * k_jump / 2, 0),   # crouched, peeking out
+    ('intro-02.png', 't/jump-2.png', k_jump, EDGE + 4, 3),
+    ('intro-03.png', 't/jump-3.png', k_jump, EDGE + 18, 12),
+    ('intro-04.png', 't/jump-4.png', k_jump, EDGE + 30, 5),
+    ('intro-05.png', 't/jump-5.png', k_jump, EDGE + 32, 0),
+    ('intro-06.png', 't/stand-sit-1.png', k_ss, EDGE + 30, 0),
+    ('intro-07.png', 't/stand-sit-2.png', k_ss, EDGE + 29, 0),
+    ('intro-08.png', 't/stand-sit-3.png', k_ss, EDGE + 27, 0),
+    ('intro-09.png', 't/stand-sit-4.png', k_ss, EDGE + 25, 0),
+    ('sit.png', 't/stand-sit-5.png', k_ss, EDGE + 24, 0),
+    ('settle-1.png', 't/sit-sleep-2.png', k_sleep, EDGE + 26, 0),             # turns to the card
+    ('settle-2.png', 't/sit-sleep-3.png', k_sleep, EDGE + 28, 0),             # lies down, drowsy
+]
+
+
+def shadow(canvas, cx, w, lift):
+    """A soft contact shadow on the ground, fainter and smaller while the cat is in the air."""
+    fade = max(0.35, 1 - lift / 16)
+    layer = Image.new('RGBA', canvas.size, (0, 0, 0, 0))
+    d = ImageDraw.Draw(layer)
+    rw, rh = w * 0.36 * fade * S, 2.2 * S
+    d.ellipse([cx * S - rw, GROUND * S - rh, cx * S + rw, GROUND * S + rh], fill=(0, 0, 0, int(70 * fade)))
+    canvas.alpha_composite(layer.filter(ImageFilter.GaussianBlur(2.2 * S)))
+
+
+def main():
+    os.makedirs(OUT, exist_ok=True)
+    for name, src, k, cx, lift in FRAMES:
+        im = Image.open(os.path.join(SRC, src)).convert('RGBA')
+        im = im.crop(im.getbbox())
+        w, h = im.width * k, im.height * k
+        sprite = im.resize((round(w * S), round(h * S)), Image.LANCZOS)
+        canvas = Image.new('RGBA', (W * S, H * S), (0, 0, 0, 0))
+        shadow(canvas, cx, w, lift)
+        x, y = round((cx - w / 2) * S), round((GROUND - lift - h) * S)
+        assert x >= 0 and x + sprite.width <= canvas.width and y >= 0, (name, x, y)
+        canvas.alpha_composite(sprite, (x, y))
+        canvas.save(os.path.join(OUT, name), optimize=True)
+    seq = {
+        'about': 'Orange cat, painted by the plugin author. Frames share one canvas; feet on the ground line.',
+        'canvas': [W, H], 'overlap': EDGE,
+        'intro': {'delay_ms': 180, 'frames': [['intro-01.png', 130]] +
+                  [['intro-%02d.png' % i, 60] for i in range(2, 6)] +
+                  [['intro-%02d.png' % i, 70] for i in range(6, 10)]},
+        'idle': 'sit.png',
+        'settle': {'after_s': 20, 'frames': [['settle-1.png', 240], ['settle-2.png', 0]]},
+    }
+    with open(os.path.join(OUT, 'sequence.json'), 'w') as f:
+        json.dump(seq, f, indent=2)
+        f.write('\n')
+    print('wrote', len(FRAMES), 'frames to', os.path.normpath(OUT))
+
+
+main()
diff --git a/packages/notch-mod/listing/render-card.js b/packages/notch-mod/listing/render-card.js
new file mode 100644
index 0000000..79efffa
--- /dev/null
+++ b/packages/notch-mod/listing/render-card.js
@@ -0,0 +1,41 @@
+// Maintainer tool (not part of the plugin): paint the card to a PNG without opening a window, so
+// screenshots never touch the screen or the keyboard. Uses helper/card.js's own layout and painter.
+//
+//   osascript -l JavaScript listing/render-card.js <card.js> <out.png> '<spec json>' [companion frame]
+//
+// With a companion frame (a file name from assets/companion/<name>/), the frame is drawn where the card
+// shows it, and the PNG grows to the card's window size.
+
+ObjC.import('AppKit')
+
+function run(argv) {
+  var src = $.NSString.stringWithContentsOfFileEncodingError(argv[0], 4, null).js
+  // eval: loads this repo's own helper/card.js (a trusted local file) into a private scope to reuse its painter.
+  var api = (function () { eval(src); return { layoutCard: layoutCard, paintCard: paintCard, loadCompanion: loadCompanion } })()
+  var spec = JSON.parse(argv[2])
+  var scale = 2
+  var L = api.layoutCard(spec, spec.appearance === 'dark')
+  var state = { selected: 0, typed: '' }
+  for (var i = 0; i < (spec.options || []).length; i++) if (spec.options[i].recommended) { state.selected = i; break }
+  var card = api.paintCard(spec, L, state, scale)
+  var out = card
+  var comp = argv[3] ? api.loadCompanion(spec.companion) : null
+  if (comp) {
+    var winW = L.w + Math.max(0, comp.w - comp.overlap), winH = Math.max(L.h, comp.h)
+    var rep = $.NSBitmapImageRep.alloc.initWithBitmapDataPlanesPixelsWidePixelsHighBitsPerSampleSamplesPerPixelHasAlphaIsPlanarColorSpaceNameBytesPerRowBitsPerPixel(
+      null, winW * scale, winH * scale, 8, 4, true, false, 'NSCalibratedRGBColorSpace', 0, 0)
+    rep = rep.bitmapImageRepByRetaggingWithColorSpace($.NSColorSpace.sRGBColorSpace)
+    rep.size = $.NSMakeSize(winW, winH)
+    $.NSGraphicsContext.saveGraphicsState
+    $.NSGraphicsContext.setCurrentContext($.NSGraphicsContext.graphicsContextWithBitmapImageRep(rep))
+    var frame = $.NSImage.alloc.initWithContentsOfFile(spec.companion.dir + '/' + argv[3])
+    // Window coordinates are y-up; the card hangs from the top, the companion sits on its bottom line.
+    frame.drawInRectFromRectOperationFraction($.NSMakeRect(L.w - comp.overlap, winH - L.h, comp.w, comp.h), $.NSZeroRect, 2, 1)
+    var img = $.NSImage.alloc.initWithSize($.NSMakeSize(L.w, L.h)); img.addRepresentation(card)
+    img.drawInRectFromRectOperationFraction($.NSMakeRect(0, winH - L.h, L.w, L.h), $.NSZeroRect, 2, 1)
+    $.NSGraphicsContext.restoreGraphicsState
+    out = rep
+  }
+  out.representationUsingTypeProperties(4, $()).writeToFileAtomically(argv[1], true)
+  return argv[1] + ' ' + L.w + 'x' + L.h
+}
diff --git a/packages/notch-mod/publish.sh b/packages/notch-mod/publish.sh
index 0bc1ac2..421f27a 100755
--- a/packages/notch-mod/publish.sh
+++ b/packages/notch-mod/publish.sh
@@ -1,20 +1,21 @@
 #!/bin/sh
-# Mirror this plugin to its own small repo, github.com/sameeeeeeep/switchboard-notch, and release it.
+# Mirror this plugin to its own small repo, github.com/sameeeeeeep/ask-notch, and release it.
+# (Create the empty repo first: gh repo create sameeeeeeep/ask-notch --public)
 #
 # The source of truth stays here. The small repo exists so `/plugin install ... --marketplace
-# sameeeeeeep/switchboard-notch` clones ~1 MB instead of the whole switchboard repo, which can pass
+# sameeeeeeep/ask-notch` clones ~1 MB instead of the whole switchboard repo, which can pass
 # Claude Code's 120 s clone limit on slow connections.
 #
 #   ./build.sh && ./publish.sh          # bump .claude-plugin/plugin.json "version" first
 set -eu
 cd "$(dirname "$0")"
 
-REPO=sameeeeeeep/switchboard-notch
+REPO=sameeeeeeep/ask-notch
 VERSION=$(python3 -c 'import json; print(json.load(open(".claude-plugin/plugin.json"))["version"])')
 TMP=$(mktemp -d)
 trap 'rm -rf "$TMP"' EXIT
 
-[ -f dist/switchboard-notch.zip ] || { echo "run ./build.sh first" >&2; exit 1; }
+[ -f dist/ask-notch.zip ] || { echo "run ./build.sh first" >&2; exit 1; }
 
 gh repo clone "$REPO" "$TMP/repo" -- -q
 cd "$TMP/repo"
@@ -22,22 +23,24 @@ git rm -rq --ignore-unmatch . >/dev/null
 cd - >/dev/null
 
 # Plugin files, plus a marketplace file so the repo is its own marketplace.
-# build.sh and publish.sh stay here: they use the maintainer's notary and GitHub credentials.
-cp -R .claude-plugin hooks helper tests assets README.md .gitignore "$TMP/repo/"
+# build.sh, publish.sh and listing/ stay here: they are the maintainer's release tools.
+cp -R .claude-plugin hooks helper skills assets README.md .gitignore "$TMP/repo/"
+mkdir -p "$TMP/repo/tests" && cp tests/notch.test.ts "$TMP/repo/tests/"   # the real-window self-test stays here (maintainer tool)
 rm -rf "$TMP/repo/.claude-plugin/types"
+rm -rf "$TMP/repo/assets/companion/clawd"   # placeholder slot, no art until the owner decides
 # The directory's validator blocks macOS/Windows system files anywhere in the plugin folder.
 find "$TMP/repo" \( -name .DS_Store -o -name Thumbs.db -o -name desktop.ini -o -name __MACOSX \) -prune -exec rm -rf {} +
 cp ../../LICENSE "$TMP/repo/LICENSE"
 cat > "$TMP/repo/.claude-plugin/marketplace.json" <<'EOF'
 {
-  "name": "switchboard-notch",
-  "description": "Claude's questions as a native card at the Mac notch.",
+  "name": "ask-notch",
+  "description": "Claude's questions as a card at the Mac notch.",
   "owner": { "name": "sameeeeeeep", "url": "https://github.com/sameeeeeeep/switchboard" },
   "plugins": [
     {
-      "name": "switchboard-notch",
+      "name": "ask-notch",
       "source": "./",
-      "description": "Claude's questions drop from your Mac's notch as a native card. A Claude Code mod (v2.1.287+, macOS 13+)."
+      "description": "Claude's questions drop from your Mac's notch as a card. A Claude Code mod (v2.1.287+, macOS 13+)."
     }
   ]
 }
@@ -49,17 +52,17 @@ git add -A
 if git diff --cached --quiet; then
   echo "no changes to publish"
 else
-  git commit -qm "switchboard-notch $VERSION (mirrored from sameeeeeeep/switchboard packages/notch-mod)"
+  git commit -qm "ask-notch $VERSION (mirrored from sameeeeeeep/switchboard packages/notch-mod)"
   git push -q origin HEAD:main
 fi
 cd - >/dev/null
 
 if gh release view "v$VERSION" -R "$REPO" >/dev/null 2>&1; then
-  gh release upload "v$VERSION" dist/switchboard-notch.zip -R "$REPO" --clobber
+  gh release upload "v$VERSION" dist/ask-notch.zip -R "$REPO" --clobber
 else
-  gh release create "v$VERSION" dist/switchboard-notch.zip -R "$REPO" --title "Switchboard Notch $VERSION" \
-    --notes "Try for one session: \`claude --plugin-url https://github.com/$REPO/releases/latest/download/switchboard-notch.zip\`
+  gh release create "v$VERSION" dist/ask-notch.zip -R "$REPO" --title "Ask Notch $VERSION" \
+    --notes "Try for one session: \`claude --plugin-url https://github.com/$REPO/releases/latest/download/ask-notch.zip\`
 
-Keep it, in Claude Code: \`/plugin install switchboard-notch --marketplace $REPO\`"
+Keep it, in Claude Code: \`/plugin install ask-notch --marketplace $REPO\`"
 fi
 echo "published $REPO v$VERSION"
diff --git a/packages/notch-mod/skills/ask-at-the-notch/SKILL.md b/packages/notch-mod/skills/ask-at-the-notch/SKILL.md
new file mode 100644
index 0000000..cc7df8c
--- /dev/null
+++ b/packages/notch-mod/skills/ask-at-the-notch/SKILL.md
@@ -0,0 +1,29 @@
+---
+name: ask-at-the-notch
+description: Use whenever you are about to offer the person a choice, such as two or more approaches, designs, names, or next steps, or need a yes/no or pick-one decision before you continue. Ask it with the AskUserQuestion tool instead of listing the options in your reply, so Ask Notch shows it as a card at the Mac's notch and they answer with one click.
+---
+
+# Ask at the notch
+
+Ask Notch shows every `AskUserQuestion` call as a card at the top of the screen. The person answers it with
+one click, even when Claude Code isn't the app in front of them. A choice written out in your reply means they
+have to come back to Claude Code, read it and type an answer. So when the next step is theirs to pick, ask
+with the tool.
+
+## When
+
+- You would otherwise write "Option A … Option B … which do you prefer?"
+- You need a go-ahead before something that is hard to undo.
+- You are blocked on a preference you cannot work out from the request, the code or a sensible default.
+
+Don't ask when you can decide for yourself. Pick the obvious option, say which one you picked, and keep going.
+
+## How
+
+- Ask one question per call where you can. The card shows one question at a time.
+- Give 2 to 4 options. Keep each label to a few words and put the trade-off in its `description`.
+- Put your pick first and end its label with ` (Recommended)`. The card highlights it.
+- Keep `multiSelect: false`. The card answers single-choice questions only. A multi-select question still works,
+  but it opens in Claude Code's own dialog instead.
+- The person can type their own answer at the card. Treat a typed answer as the decision.
+- If they press esc, the question goes to Claude Code's own dialog, so nothing is lost.
diff --git a/packages/notch-mod/tests/card-selftest.js b/packages/notch-mod/tests/card-selftest.js
new file mode 100644
index 0000000..870b74d
--- /dev/null
+++ b/packages/notch-mod/tests/card-selftest.js
@@ -0,0 +1,85 @@
+// Drives helper/card.js with clicks and keys handed to the card's OWN process (never posted to the
+// system, so nothing can reach the app you're using), on a window placed off every display.
+//
+//   osascript -l JavaScript tests/card-selftest.js <card.js> <scenario>
+//   scenarios: click-row · click-card-then-digit · click-card-then-return · click-card-then-down-return
+//              · click-card-then-esc · type-in-box · no-click-no-key · timeout
+//
+// Prints the card's answer line (stdout) like the real card. tests/run-card-selftest.sh checks them.
+
+ObjC.import('AppKit')
+
+function run(argv) {
+  var src = $.NSString.stringWithContentsOfFileEncodingError(argv[0], 4, null).js
+  // The card activates itself when clicked; a test must never take focus from the app you're using.
+  src = src.replace('app.activateIgnoringOtherApps(true)', 'void 0 /* self-test: no activation */')
+  // eval: loads this repo's own helper/card.js (a trusted local file) into a private scope.
+  var card = (function () { eval(src); return { main: main, layoutCard: layoutCard } })()
+  var scenario = argv[1]
+  var spec = {
+    title: 'Claude asks · Layout', question: 'Which layout?', at: 'offscreen', timeout: 3,
+    appearance: 'light', source: 'Claude Code',
+    options: [{ label: 'Sidebar', detail: 'Left rail', recommended: true }, { label: 'Tabs', detail: 'Top' }, { label: 'Single page' }],
+  }
+  if (scenario === 'timeout') spec.timeout = 0.5
+  var L = card.layoutCard(spec, false)
+
+  var steps = []
+  function at(x, y) { return { x: x, y: L.h - y } }      // card points (y down) → window points (y up)
+  function rowCenter(i) { var r = L.rows[i]; return at(r.x + r.w / 2, r.y + r.h / 2) }
+  var header = at(200, L.header.y + 6)
+  var box = at(L.field.x + 40, L.field.y + L.field.h / 2)
+  function click(p) { steps.push(['mouse', 1, p], ['mouse', 2, p]) }
+  function key(ch, code) { steps.push(['key', ch, code]) }
+
+  if (scenario === 'click-row') click(rowCenter(1))
+  if (scenario === 'click-card-then-digit') { click(header); key('3', 20) }
+  if (scenario === 'click-card-then-return') { click(header); key('\r', 36) }
+  if (scenario === 'click-card-then-down-return') { click(header); key('', 125); key('\r', 36) }
+  if (scenario === 'click-card-then-esc') { click(header); key('\u001b', 53) }
+  if (scenario === 'type-in-box') {
+    click(box)
+    var t = '2 apples'
+    for (var i = 0; i < t.length; i++) key(t[i], t[i] === ' ' ? 49 : t[i] === '2' ? 19 : 0)
+    key('\r', 36)
+  }
+  // 'no-click-no-key': nothing happens; the card must still not be key or active, then time out.
+
+  $.NSTimer.scheduledTimerWithTimeIntervalRepeatsBlock(0.4, false, function () {
+    var win = null, ws = $.NSApp.windows
+    for (var i = 0; i < ws.count; i++) if (ws.objectAtIndex(i).className.js === 'AskNotchPanel') win = ws.objectAtIndex(i)
+    var log = function (s) { $.NSFileHandle.fileHandleWithStandardError.writeData($(s + '\n').dataUsingEncoding(4)) }
+    log('before: key=' + win.keyWindow + ' active=' + $.NSApp.active)
+    // Clicks first; keys a moment later, as a person's would (the card becomes key asynchronously).
+    var post = function (s) {
+      var ev
+      if (s[0] === 'mouse') {
+        // A synthetic event sometimes resolves its window late and reads its point as a screen point;
+        // make it again until it carries the window point it was given.
+        for (var n = 0; n < 20; n++) {
+          ev = $.NSEvent.mouseEventWithTypeLocationModifierFlagsTimestampWindowNumberContextEventNumberClickCountPressure(
+            s[1], s[2], 0, 0, win.windowNumber, null, 0, 1, s[1] === 1 ? 1 : 0)
+          var p = ev.locationInWindow
+          if (Math.abs(p.x - s[2].x) < 1 && Math.abs(p.y - s[2].y) < 1) break
+        }
+      } else {
+        ev = $.NSEvent.keyEventWithTypeLocationModifierFlagsTimestampWindowNumberContextCharactersCharactersIgnoringModifiersIsARepeatKeyCode(
+          10, $.NSMakePoint(0, 0), 0, 0, win.windowNumber, null, s[1], s[1], false, s[2])
+      }
+      // Clicks go through the app's queue (and so through the card's own window routing); keys go
+      // straight to the card's window, since an inactive test app has no key window to route them to.
+      if (s[0] === 'mouse') $.NSApp.postEventAtStart(ev, false)
+      else win.sendEvent(ev)
+    }
+    steps.filter(function (s) { return s[0] === 'mouse' }).forEach(post)
+    $.NSTimer.scheduledTimerWithTimeIntervalRepeatsBlock(0.25, false, function () {
+      steps.filter(function (s) { return s[0] === 'key' }).forEach(post)
+    })
+    if (scenario === 'no-click-no-key') {
+      $.NSTimer.scheduledTimerWithTimeIntervalRepeatsBlock(1, false, function () {
+        log('after 1.4s: key=' + win.keyWindow + ' active=' + $.NSApp.active)
+      })
+    }
+  })
+  card.main(spec)
+}
diff --git a/packages/notch-mod/tests/card-selftest.sh b/packages/notch-mod/tests/card-selftest.sh
new file mode 100644
index 0000000..cf1e8d8
--- /dev/null
+++ b/packages/notch-mod/tests/card-selftest.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+# Real-window checks for helper/card.js (macOS). The card opens off every display, and clicks and
+# keys are posted to the card's own event queue only, so nothing reaches the app you're using.
+#   sh tests/card-selftest.sh
+cd "$(dirname "$0")/.."
+fail=0
+tmp=$(mktemp)
+trap 'rm -f "$tmp"' EXIT
+check() {
+  out=$(/usr/bin/osascript -l JavaScript tests/card-selftest.js helper/card.js "$1" 2>"$tmp")
+  err=$(cat "$tmp")
+  case "$out" in
+    "$2") echo "ok   $1 → $out" ;;
+    *) echo "FAIL $1 → $out (wanted $2)"; echo "$err"; fail=1 ;;
+  esac
+  # Without a click the card must never become the key window or the active app.
+  if [ "$1" = no-click-no-key ]; then
+    case "$err" in *"key=true"*|*"active=true"*|*"became-key"*) echo "FAIL $1 took the keyboard: $err"; fail=1 ;; esac
+  fi
+}
+check click-row '{"answer":"Tabs","index":1}'
+check click-card-then-digit '{"answer":"Single page","index":2}'
+check click-card-then-return '{"answer":"Sidebar","index":0}'
+check click-card-then-down-return '{"answer":"Tabs","index":1}'
+check click-card-then-esc '{"cancelled":true,"reason":"esc"}'
+check type-in-box '{"answer":"2 apples","typed":true}'
+check no-click-no-key '{"cancelled":true,"reason":"timeout"}'
+check timeout '{"cancelled":true,"reason":"timeout"}'
+exit $fail
diff --git a/packages/notch-mod/tests/notch.test.ts b/packages/notch-mod/tests/notch.test.ts
index 71ff3cd..81ddae9 100644
--- a/packages/notch-mod/tests/notch.test.ts
+++ b/packages/notch-mod/tests/notch.test.ts
@@ -1,4 +1,4 @@
-import { expect, test } from 'claude-code/testing'
+import { expect, mock, test } from 'claude-code/testing'
 
 const ask = {
   tool: 'AskUserQuestion',
@@ -8,20 +8,39 @@ const ask = {
   }],
 }
 
-function base(on: any) {
-  on('store.get', () => ({ value: undefined }))
+// A store that keeps what the plugin saves, so a /notch setting reaches the next card.
+function base(on: any, saved?: unknown) {
+  let cfg = saved
+  on('store.get', () => ({ value: cfg }))
+  on('store.set', (_$: any, e: any) => { cfg = e.value; return { value: undefined } })
   on('ui.status', () => ({ value: undefined }))
 }
 
 test('a picked card answers the question without Claude Code\'s dialog', async ($, on) => {
   base(on)
   let argv: string[] = []
-  on('process.run', (_$, e) => { argv = e.argv; return { value: { exitCode: 0, stdout: '{"answer":"Compact","index":1}\n', stderr: '' } } })
+  let stdin = ''
+  on('process.run', (_$, e) => { argv = e.argv; stdin = e.init?.stdin ?? ''; return { value: { exitCode: 0, stdout: '{"answer":"Compact","index":1}\n', stderr: '' } } })
   on('tool.call', () => ({ result: 'DIALOG' }))
   const r = await $.tool.call(ask as any)
   expect((r.result as any).answers).toEqual({ 'Which layout?': 'Compact' })
-  const spec = JSON.parse(argv[1])
+  // The card is a readable script run by macOS's own osascript, not a compiled helper.
+  expect(argv.slice(0, 3)).toEqual(['/usr/bin/osascript', '-l', 'JavaScript'])
+  expect(argv[3]).toBe('helper/card.js')
+  const spec = JSON.parse(stdin)
   expect(spec.options[0]).toEqual({ label: 'Spacious', detail: 'More room', recommended: true })
+  expect(spec.title).toBe('Claude asks · Layout')
+  expect(spec.at).toBe('notch')
+  expect(spec.timeout).toBe(540)
+  expect(spec.companion).toBeUndefined()
+})
+
+test('a typed answer is returned as typed', async ($, on) => {
+  base(on)
+  on('process.run', () => ({ value: { exitCode: 0, stdout: '{"answer":"Roomy, but denser","typed":true}\n', stderr: '' } }))
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  const r = await $.tool.call(ask as any)
+  expect((r.result as any).answers).toEqual({ 'Which layout?': 'Roomy, but denser' })
 })
 
 test('esc at the card falls back to Claude Code\'s dialog', async ($, on) => {
@@ -31,6 +50,13 @@ test('esc at the card falls back to Claude Code\'s dialog', async ($, on) => {
   expect((await $.tool.call(ask as any)).result).toBe('DIALOG')
 })
 
+test('a card that cannot start falls back to Claude Code\'s dialog', async ($, on) => {
+  base(on)
+  on('process.run', () => ({ value: { exitCode: 1, stdout: '', stderr: 'execution error' } }))
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  expect((await $.tool.call(ask as any)).result).toBe('DIALOG')
+})
+
 test('multi-select skips the card', async ($, on) => {
   base(on)
   let ran = false
@@ -40,3 +66,81 @@ test('multi-select skips the card', async ($, on) => {
   expect((await $.tool.call(multi as any)).result).toBe('DIALOG')
   expect(ran).toBe(false)
 })
+
+test('/notch off hands questions to Claude Code', async ($, on) => {
+  base(on)
+  let ran = false
+  on('process.run', () => { ran = true; return { value: { exitCode: 0, stdout: '', stderr: '' } } })
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  const { text } = await $.command.run({ command: 'notch', args: 'off' })
+  expect(text).toContain('off')
+  expect((await $.tool.call(ask as any)).result).toBe('DIALOG')
+  expect(ran).toBe(false)
+})
+
+test('/notch companion cat puts the cat beside the card', async ($, on) => {
+  base(on)
+  let argv: string[] = []
+  let stdin = ''
+  on('process.run', (_$, e) => { argv = e.argv; stdin = e.init?.stdin ?? ''; return { value: { exitCode: 0, stdout: '{"answer":"Compact","index":1}\n', stderr: '' } } })
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  const { text } = await $.command.run({ command: 'notch', args: 'companion cat' })
+  expect(text).toContain('companion cat')
+  await $.tool.call(ask as any)
+  const spec = JSON.parse(stdin)
+  expect(spec.companion.name).toBe('cat')
+  expect(spec.companion.dir).toBe('assets/companion/cat')
+})
+
+test('/notch companion off and unknown companions', async ($, on) => {
+  base(on, { on: true, at: 'cursor', companion: 'cat' })
+  let argv: string[] = []
+  let stdin = ''
+  on('process.run', (_$, e) => { argv = e.argv; stdin = e.init?.stdin ?? ''; return { value: { exitCode: 0, stdout: '{"answer":"Compact","index":1}\n', stderr: '' } } })
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  await $.command.run({ command: 'notch', args: 'companion off' })
+  await $.tool.call(ask as any)
+  const spec = JSON.parse(stdin)
+  expect(spec.companion).toBeUndefined()
+  expect(spec.at).toBe('cursor')
+})
+
+test('/notch in plain words is handed to Claude, who changes it through the settings tool', async ($, on) => {
+  base(on)
+  const clock = mock.clock(on)
+  let asked = ''
+  let stdin = ''
+  on('prompt.submit', (_$: any, e: any) => { asked = e.text; return { drop: 'captured by the test' } })
+  on('process.run', (_$, e) => { stdin = e.init?.stdin ?? ''; return { value: { exitCode: 0, stdout: '{"answer":"Compact","index":1}\n', stderr: '' } } })
+  on('tool.call', () => ({ result: 'DIALOG' }))
+
+  const { text } = await $.command.run({ command: 'notch', args: 'put it by my mouse and bring the kitty' })
+  expect(text).toContain('asking Claude')
+  await clock.advance(60)
+  expect(asked).toContain('/notch put it by my mouse and bring the kitty')
+  expect(asked).toContain('mcp__ask-notch__settings')
+
+  // What Claude would then call: the change lands on the next card.
+  const r = await $.tool.call({ tool: 'mcp__ask-notch__settings', at: 'cursor', companion: 'cat' } as any)
+  expect(String(r.result)).toContain('at cursor · companion cat')
+  await $.tool.call(ask as any)
+  const spec = JSON.parse(stdin)
+  expect(spec.at).toBe('cursor')
+  expect(spec.companion.name).toBe('cat')
+})
+
+test('bare /notch reads the settings and the tool with no fields changes nothing', async ($, on) => {
+  base(on, { on: false, at: 'notch', companion: 'off' })
+  on('tool.call', () => ({ result: 'DIALOG' }))
+  expect((await $.command.run({ command: 'notch', args: '' })).text).toContain('Notch cards off')
+  expect(String((await $.tool.call({ tool: 'mcp__ask-notch__settings' } as any)).result)).toContain('Notch cards off · at notch')
+})
+
+test('while cards are on, Claude is told to ask its choices at the notch; off, it is not', async ($, on) => {
+  base(on)
+  on('prompt.compose', () => ({ sections: [{ id: 'intro', text: 'You are Claude.', scope: 'shared' }] }))
+  const ids = async () => (await $.prompt.compose({ model: 'claude-opus-5-5', promptModel: 'claude-opus-5-5', surfaces: ['terminal'], tools: [], outputStyle: null, traits: [] } as any)).sections.map((x: any) => x.id)
+  expect(await ids()).toEqual(['intro', 'ask-notch:choices'])
+  await $.command.run({ command: 'notch', args: 'off' })
+  expect(await ids()).toEqual(['intro'])
+})