@trygocode/notify 0.3.4 → 0.5.0

package/README.md

@@ -1,12 +1,14 @@
 # @trygocode/notify
 
-Free phone notifications for any coding agent — **Cursor, Claude Code, OpenCode,
-or any Ralph/Homer loop** — delivered to your phone via the
-[GoCode](https://oh.jeltechsolutions.com) app + FCM.
+Free phone **and branded desktop** notifications for any coding agent — **Cursor,
+Claude Code, OpenCode, or any Ralph/Homer loop** — delivered to your phone via the
+[GoCode](https://oh.jeltechsolutions.com) app + FCM, and to your computer as a
+native **"GoCode"** banner.
 
-You get an automatic push when your agent **finishes a turn**, **goes idle
+You get an automatic notification when your agent **finishes a turn**, **goes idle
 waiting for you**, **errors out**, or when an overnight **loop completes / halts**
-— so you can walk away and let your phone tell you when it needs you.
+— on your phone AND on the computer you're working on (on by default) — so you can
+walk away and let either device tell you when it needs you.
 
 ## Contents
 
@@ -126,14 +128,14 @@ The installed rule/skill tells the agent **not** to call the MCP tool for
 done/idle/error pings — those are owned by the deterministic hook (A), so you
 never get double-pinged.
 
-> **Cursor `stop.status` → kind mapping (since 0.3.0).** Cursor's `stop` hook
-> carries a `status` field in its stdin JSON. The `on-stop` dispatcher maps it
-> to the right notification kind automatically:
+> **Cursor `stop.status` → kind mapping (since 0.3.0; `aborted` corrected 0.4.0).**
+> Cursor's `stop` hook carries a `status` field in its stdin JSON. The `on-stop`
+> dispatcher maps it to the right notification kind automatically:
 >
 > | Cursor `stop.status` | Notification kind | Meaning |
 > |---|---|---|
 > | `completed` | `finished` | Agent turned cleanly (default — same as before 0.3.0) |
-> | `aborted` | `awaiting_input` | Agent yielded back to you — may need your input |
+> | `aborted` | _(suppressed — no notification)_ | You pressed **Stop** to interrupt the turn — a manual stop sends nothing |
 > | `error` | `error` | Agent hit an error |
 > | absent / unrecognised | `finished` | Back-compatible fallback |
 >
@@ -141,6 +143,28 @@ never get double-pinged.
 > did. The status mapping requires no hook re-installation — run
 > `gocode-notify setup --force` once to apply the updated hook command.
 
+> **Question detection — "Agent needs you" (since 0.5.0).** When the agent
+> **pauses to ask you a question** (as opposed to finishing its work), the
+> package fires an `awaiting_input` ping titled **"Agent needs you"** instead of
+> a misleading `finished`. The available signal differs per runtime:
+>
+> | Runtime | Question signal | Status |
+> |---|---|---|
+> | **Claude Code** | dedicated `Notification` hook → `awaiting_input` | ✅ Live — questions show as questions |
+> | **OpenCode** | `permission.asked` plugin event → `awaiting_input` | ✅ Live — OpenCode genuinely exposes a "needs you" signal |
+> | **Cursor** | `postToolUse` hook scoped to the `AskQuestion` tool → `awaiting_input` | ⏳ Installed but **dormant** — see note |
+>
+> **Cursor caveat:** Cursor currently exposes **no** "agent needs input" event
+> (its docs list `Notification` as unsupported), and there is a
+> [confirmed-open Cursor bug](https://forum.cursor.com/t/askquestion-tool-does-not-trigger-cursor-hooks/152230)
+> where the `AskQuestion` tool fires **zero** hooks. So a Cursor question is
+> indistinguishable from a completion at the only signal we get (the `stop`
+> hook), and you'll receive `finished` until Cursor ships their fix. We install
+> the `postToolUse(AskQuestion)` hook **now** so that the moment Cursor fixes
+> the bug, question detection **auto-activates with no new install** for everyone
+> already running `@trygocode/notify@latest`. Run `gocode-notify setup --force`
+> once to wire it in.
+
 > **OpenCode's hook (A)** is a small `session.idle` plugin written to
 > `~/.config/opencode/plugin/gocode-notify.js`; on each `session.idle` event it
 > fire-and-forgets `gocode-notify on-stop --source opencode` (the same
@@ -157,6 +181,69 @@ never get double-pinged.
 > `setup`/`setup --force`. `send` and `test` remain callable on their own for
 > scripts and power users.
 
+## Desktop notifications (branded, on by default)
+
+GoCode Notify also raises a **real, branded "GoCode" banner on the computer you're
+working on** — the same instant your phone gets pinged — so you're told whether
+you're at your desk or away. It's **ON by default** once the package is installed
+and is controlled by the **same server-synced settings** as the phone push, so a
+toggle in the app or the terminal flips the computer banner everywhere.
+
+**Word-for-word identical to the phone.** The banner reads exactly the same as the
+push you'd get on your phone — same status emoji, IDE/source label, project, and
+per-kind copy (e.g. `✅ Cursor · openhandapp — Agent finished`). The wording is a
+faithful mirror of the server's notification decoration and the Flutter client's,
+pinned by a cross-check test (`notify_copy.test.ts`) so the three surfaces can't
+drift.
+
+**Click to open your IDE (macOS).** Clicking the banner opens the **IDE window for
+that project** — the same editor that raised the turn (Cursor / VS Code), focused
+on the project you were working in. This is best-effort: when the IDE/project
+can't be named the banner is simply display-only (never a dead or mis-routed
+click). It opens the project *window*, not a specific past chat — IDEs don't
+expose reliable per-chat deep links.
+
+| OS | How it's shown | Branded as |
+|---|---|---|
+| **macOS** | A one-time `osacompile`d `GoCode.app` helper under `~/.gocode/desktop/` raises the banner via the system | **"GoCode"** + the GoCode icon |
+| **Windows** | A WinRT `ToastGeneric` toast bound to a one-time Start-Menu shortcut carrying the `GoCode.Notify` AppUserModelID | **"GoCode"** |
+| **Linux** | `notify-send -a GoCode -i <icon>` | **"GoCode"** + icon |
+
+**Zero new dependencies.** It uses only tools that ship with the OS (`osacompile`/
+`osascript`/`sips` on macOS, PowerShell + WinRT on Windows, `notify-send` on Linux)
+— so the **one-line install does not change at all**. The first banner builds a tiny
+branded helper once and caches it; every banner after that just fires it.
+
+### Control it
+
+From the **GoCode app** (Settings → **GoCode Notify** → *Desktop notifications*),
+or from the terminal:
+
+```bash
+gocode-notify config set desktop.enabled false   # silence the computer banner
+gocode-notify config set desktop.sound   false   # keep the banner, drop the sound
+```
+
+The phone push is unaffected — `desktop.*` only governs the local banner.
+
+### Try it right now
+
+```bash
+# Fire a branded test banner on THIS computer (independent of the phone push):
+gocode-notify test --desktop
+```
+
+You should see a **"GoCode"** notification appear on your screen. On a headless
+box / CI / SSH session where a banner makes no sense, set
+`GOCODE_NOTIFY_NO_DESKTOP=1` to hard-disable local banners for that machine.
+
+> **macOS branding note.** A bare `osascript` banner is attributed to "Script
+> Editor". To brand it "GoCode", the package compiles a minimal AppleScript app
+> bundle (`~/.gocode/desktop/GoCode.app`) once with `osacompile` (ships with
+> every Mac — no Xcode/Swift) and drops the GoCode icon into it via `sips`. If
+> that one-time setup ever fails, the banner still fires (unbranded) rather than
+> blocking your turn.
+
 ## Hand off to your server — `launch` / `autopilot`
 
 > **New in 0.2.0.** Notify can now do more than ping your phone — it can **hand a
@@ -344,6 +431,8 @@ Valid keys (mirror of the canonical schema):
 | `commit_message.mode` | `auto` \| `ai` \| `deterministic` | Commit-message strategy |
 | `commit_message.command` | string \| null | Explicit local summariser command |
 | `commit_message.max_diff_bytes` | int > 0 | Diff byte cap fed to the summariser (default 61440) |
+| `desktop.enabled` | bool | Branded desktop banner on this computer (**ON by default**) |
+| `desktop.sound` | bool | Play a sound with the desktop banner (default true) |
 
 ```bash
 # Examples
@@ -440,6 +529,61 @@ npm publish, real-device E2E), see
 
 ## Changelog
 
+### 0.5.0
+
+- **Question detection across ALL IDEs — "Agent needs you" vs "finished".** When
+  the agent **pauses to ask you a question**, you now get an `awaiting_input`
+  ("Agent needs you") notification instead of a misleading `finished`, on every
+  supported runtime that exposes a question signal:
+  - **Claude Code** — already wired (`Notification` hook); unchanged.
+  - **OpenCode** — NEW: the plugin now listens to `permission.asked` (the moment
+    the agent raises a request) and fires `awaiting_input`. OpenCode genuinely
+    exposes a "the agent needs the user" signal via permission events. (We listen
+    to `permission.asked` only, not `permission.updated`/`replied`, which also
+    fire after the user answers.)
+  - **Cursor** — NEW (dormant): installs a `postToolUse` hook scoped to the
+    `AskQuestion` / `AskUserQuestion` tool. Cursor has a
+    [confirmed-open bug](https://forum.cursor.com/t/askquestion-tool-does-not-trigger-cursor-hooks/152230)
+    where that tool fires zero hooks, and Cursor exposes no `Notification` event,
+    so the hook is dormant today — but it **auto-activates with no new install**
+    the moment Cursor ships their fix. Until then, Cursor keeps its `finished`
+    fallback.
+- **Corrected the documented Cursor `aborted` mapping.** The README table
+  previously (incorrectly) showed `aborted → awaiting_input`; the actual
+  behaviour (since the 0.4.0 fix) is that a manual **Stop** press (`aborted`)
+  sends **no notification at all**. A user force-stop is now clearly
+  distinguished from a genuine IDE question.
+- Run `gocode-notify setup --force` once to wire the new hooks into Cursor +
+  OpenCode.
+
+### 0.4.0
+
+- **New: branded desktop notifications (on by default).** Every event that pings
+  your phone now also raises a native, **GoCode-branded** banner on the computer
+  you're working on — macOS (a one-time `osacompile`d `GoCode.app` helper +
+  `sips` icon), Windows (a WinRT `ToastGeneric` toast bound to a one-time
+  Start-Menu shortcut with the `GoCode.Notify` AppUserModelID), and Linux
+  (`notify-send -a GoCode`). **Zero new dependencies** — OS-native tools only,
+  so the one-line install is unchanged. Controlled by the same server-synced
+  settings as the phone push via the new `desktop.enabled` / `desktop.sound`
+  keys (both default ON); toggle from the app or `gocode-notify config set
+  desktop.enabled false`. Try it with `gocode-notify test --desktop`. Hard-
+  disable per machine with `GOCODE_NOTIFY_NO_DESKTOP=1` (headless / CI / SSH).
+  Best-effort + non-blocking: a failed banner never blocks or fails your turn.
+- **Word-for-word match with the phone push.** The desktop banner now reads
+  EXACTLY like the phone notification — same status emoji + IDE/source label +
+  project + per-kind title/body (e.g. `✅ Cursor · openhandapp — Agent
+  finished`). New `src/notify_copy.ts` mirrors the server's `_decorated_title` /
+  `_decorated_body` + `_DEFAULT_TITLES` / `_DEFAULT_BODIES` and the Flutter
+  client's `decorateNotificationTitle` / `sourceLabelFor`, pinned by a
+  cross-check test so the CLI/server/app surfaces can't drift.
+- **Click to open the IDE window for the project (macOS).** Clicking the banner
+  opens the IDE that raised the turn (Cursor / VS Code) focused on the project
+  directory. Implemented zero-dependency: the branded AppleScript applet handles
+  the click re-run (documented macOS behaviour) and `open -a <ide> <project>`.
+  Best-effort — display-only when the IDE/project can't be named. Opens the
+  project *window*, not a specific chat (IDEs lack reliable per-chat deep links).
+
 ### 0.3.0
 
 - **New: Cursor `stop.status` → kind mapping (T-CUR1/T-CUR4).** The `on-stop`
@@ -510,6 +654,9 @@ Zero runtime dependencies beyond the MCP SDK (Node built-in `fetch`/`fs`/
 | `src/setup.ts` | Installer orchestration (pair → detect → write configs) |
 | `src/claude.ts` / `src/cursor.ts` / `src/opencode.ts` | Per-client config writers (hooks + MCP + rule/skill); hooks call the `on-stop` dispatcher. OpenCode uses a `session.idle` plugin instead of a hooks file |
 | `src/send.ts` / `src/login.ts` / `src/mcp.ts` | Core send, pairing, and MCP server (incl. `gocode_launch_autopilot`) |
+| `src/desktop_notify.ts` | Branded native desktop banners (macOS `GoCode.app` / Windows WinRT toast / Linux `notify-send`); zero-dep, best-effort; macOS click-through opens the IDE window |
+| `src/notify_copy.ts` | Banner wording mirror — reproduces the server/Flutter title/body decoration so the desktop banner reads word-for-word like the phone |
+| `assets/gocode-icon.{png,ico}` | Bundled GoCode icon used to brand desktop banners |
 | `src/launch.ts` | Shared `launch()` core behind the `launch`/`autopilot` command + the MCP tool |
 | `src/push.ts` | Auto-push flow behind the `on-stop` dispatcher — git add/commit/push, FF-only |
 | `src/commit_message.ts` | AI commit-message resolution chain + deterministic fallback |

package/dist/src/cli.js

@@ -21,6 +21,7 @@ import { setup } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { cmdConfig } from "./config.js";
 import { onStop } from "./on_stop.js";
+import { notifyDesktop } from "./desktop_notify.js";
 import { gatherDoctor, formatDoctor } from "./doctor.js";
 /** Subcommands the finished CLI will expose (see PRD §4.1). */
 export const COMMANDS = [
@@ -88,7 +89,7 @@ export function printHelp() {
         "Commands:",
         "  login      Pair this machine with your GoCode account",
         "  send       Send a single push notification",
-        "  test       Send a canned test push",
+        "  test       Send a canned test push (add --desktop for a local banner)",
         "  setup      Pair + detect runtimes + write configs",
         "  status     Report credentials / server / detected runtimes",
         "  doctor     Self-diagnostic checklist with exact fix commands",
@@ -313,6 +314,32 @@ export async function cmdTest(args, deps = {}) {
     const flags = parseFlags(args);
     const agent = isAgentDriven(flags);
     const sink = deps.sink ?? stdoutSink;
+    // `--desktop`: fire a BRANDED local desktop banner so the user can verify the
+    // computer-notification path (and its GoCode branding) works during install,
+    // independent of the phone push (GOCODE_NOTIFY_DESKTOP PRD §3). Unlike the
+    // fire-and-forget hook path, this interactive probe reports the real outcome
+    // and exits non-zero on failure so the human/agent sees it.
+    if (flagBool(flags, "desktop")) {
+        const desk = await notifyDesktop({
+            title: "GoCode test",
+            body: "If you can read this banner, GoCode desktop notifications work.",
+            kind: "finished",
+            sound: true,
+        }, { home: deps.home, timeoutMs: deps.timeoutMs, timestamp: deps.timestamp });
+        if (desk.ok) {
+            if (agent)
+                sink({ step: "test-desktop", ok: true, detail: `desktop banner shown (${desk.platform})` });
+            else
+                console.log(`✓ Desktop banner shown (${desk.platform}). Look for the GoCode notification on your screen.`);
+            return 0;
+        }
+        const detail = `desktop banner not shown (${desk.error ?? "unknown"})`;
+        if (agent)
+            sink({ step: "test-desktop", ok: false, detail });
+        else
+            console.error(`gocode-notify test --desktop: ${detail}.`);
+        return 1;
+    }
     const server = await resolveServerUrl(flagString(flags, "server"), deps);
     const sendOpts = {
         home: deps.home,

package/dist/src/cursor.js

@@ -2,11 +2,15 @@
 // Cursor. It does three things, all idempotently and without clobbering the
 // user's existing config:
 //
-//   1. MERGE a fire-and-forget `stop` hook into `~/.cursor/hooks.json`:
-//        stop → "finished" (the agent completed a turn).
-//      The command shells out to `gocode-notify send … || true` so a failed push
+//   1. MERGE two fire-and-forget hooks into `~/.cursor/hooks.json`:
+//        stop                       → "finished"       (the agent completed a turn)
+//        postToolUse(AskQuestion)   → "awaiting_input" (the agent asked a question)
+//      The commands shell out to `gocode-notify … || true` so a failed push
 //      NEVER blocks the agent's turn (PRD §4.4, §5.4). The file's `version` is
-//      preserved (or set to 1 when creating it fresh).
+//      preserved (or set to 1 when creating it fresh). The postToolUse question
+//      hook is DORMANT until Cursor fixes their AskQuestion tool-hook-skip bug
+//      (forum 152230/161836) — installing it now means it auto-activates with no
+//      new install once upstream lands. See CURSOR_ASK_QUESTION_COMMAND.
 //   2. MERGE an `mcpServers` entry into `~/.cursor/mcp.json` pointing at
 //      `npx -y @trygocode/notify mcp`.
 //   3. WRITE the on-demand rule to `~/.cursor/rules/gocode-notify.md` (the
@@ -57,6 +61,48 @@ export const MCP_SERVER_ENTRY = {
 // version on every turn, so users self-update seamlessly. (Matchers below key on
 // the `@trygocode/notify` substring, which `@latest` preserves.)
 export const CURSOR_STOP_COMMAND = "npx -y @trygocode/notify@latest on-stop --source cursor --dedupe-key cursor-stop || true";
+/**
+ * The Cursor `postToolUse` question hook (T-CUR3) — the ONLY available signal for
+ * "the Cursor agent asked the user a question and is now waiting." It fires a
+ * plain `awaiting_input` ping ("Agent needs you"), the SAME kind Claude Code's
+ * dedicated `Notification` hook fires, so a real question surfaces as a QUESTION
+ * notification on the phone/desktop instead of a misleading `finished`.
+ *
+ * ⚠️ DORMANT-BY-NECESSITY (2026-06-18): Cursor has a CONFIRMED-OPEN upstream bug
+ * where the `AskQuestion` / `AskUserQuestion` tool fires ZERO hooks — `preToolUse`
+ * and `postToolUse` are documented to fire "for all tools" but are skipped for
+ * this one tool specifically (Cursor staff confirmed, no workaround; forum
+ * threads 152230 + 161836). So today this hook will simply never fire, and the
+ * `stop`-hook `finished` fallback remains the user's notification. The moment
+ * Cursor ships their fix this hook AUTO-ACTIVATES with NO new install — every
+ * user already running `@trygocode/notify@latest` gets correct question
+ * detection for free. We install it now so we're ahead of the fix.
+ *
+ * Cursor question detection has no other path: Cursor exposes NO `Notification`
+ * event (docs: `Notification | - | No`), and the `stop` hook's
+ * `status: completed|aborted|error` cannot distinguish "asked a question" from
+ * "finished the work." This dormant tool hook is the best available approximation
+ * and becomes a real signal once upstream lands.
+ *
+ * Ends in `|| true` so a failed push NEVER blocks the turn; carries a distinct
+ * `--dedupe-key` so it coalesces with itself but not with the `stop` ping.
+ */
+export const CURSOR_ASK_QUESTION_COMMAND = 'npx -y @trygocode/notify@latest send --kind awaiting_input --source cursor --title "Agent needs you" --dedupe-key cursor-ask-question || true';
+/**
+ * Tool names that mean "the agent is asking the user a question." Used as the
+ * `postToolUse` matcher (a regex alternation). Cursor maps Claude Code tool
+ * names to Cursor names, and the question tool has shipped under several names
+ * across versions/runtimes (`AskQuestion` in the IDE, `AskUserQuestion` in some
+ * builds, `ask_question` in the CLI). We match ALL of them so the hook works the
+ * instant Cursor wires any of them to `postToolUse`.
+ */
+export const CURSOR_ASK_QUESTION_TOOLS = [
+    "AskQuestion",
+    "AskUserQuestion",
+    "ask_question",
+];
+/** The `matcher` regex string written into the `postToolUse` entry. */
+export const CURSOR_ASK_QUESTION_MATCHER = `^(${CURSOR_ASK_QUESTION_TOOLS.join("|")})$`;
 /**
  * Substrings that together identify a `stop` hook entry as OURS. Used for
  * idempotent merge (replace, don't duplicate) and for surgical uninstall (remove
@@ -143,12 +189,34 @@ async function writeJsonFile(file, value) {
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(value, null, 2) + "\n");
 }
+/** True when a command string is one of ours (BOTH a name token AND the source). */
+function isOurCommand(cmd) {
+    return cmd.includes(HOOK_SOURCE_TOKEN) && HOOK_NAME_TOKENS.some((t) => cmd.includes(t));
+}
 /** True when a single `stop` hook entry (`{ command }`) is one we wrote. */
 function isOurStopHook(h) {
     if (!isRecord(h) || typeof h.command !== "string")
         return false;
-    const cmd = h.command;
-    return cmd.includes(HOOK_SOURCE_TOKEN) && HOOK_NAME_TOKENS.some((t) => cmd.includes(t));
+    return isOurCommand(h.command);
+}
+/**
+ * True when a `postToolUse` group (`{ matcher?, hooks: [{ command }] }`) is one
+ * we wrote — its `hooks` array contains a command carrying OUR markers. Cursor's
+ * tool-hook shape nests commands one level deeper than the flat `stop` array, so
+ * we look inside `hooks[].command`.
+ */
+function isOurToolHookGroup(g) {
+    if (!isRecord(g) || !Array.isArray(g.hooks))
+        return false;
+    return g.hooks.some((h) => isRecord(h) && typeof h.command === "string" && isOurCommand(h.command));
+}
+/**
+ * Strip OUR groups out of a `postToolUse` array. Returns the cleaned array plus
+ * whether anything of ours was removed. Never mutates the input.
+ */
+function stripOurToolHooks(entries) {
+    const kept = entries.filter((g) => !isOurToolHookGroup(g));
+    return { entries: kept, removed: kept.length !== entries.length };
 }
 /**
  * Strip OUR entries out of the `stop` array. Returns the cleaned array plus
@@ -175,6 +243,30 @@ function mergeStopHook(config) {
     hooks.stop = preserved;
     config.hooks = hooks;
 }
+/**
+ * Merge our `postToolUse` AskQuestion hook into the hooks config (T-CUR3),
+ * preserving the user's own `postToolUse` groups. Strips any prior copy of OUR
+ * group (idempotent / version-safe) then appends a single fresh group scoped to
+ * the question tools via {@link CURSOR_ASK_QUESTION_MATCHER}. Mutates `config` in
+ * place. Cursor's tool-hook shape is `{ matcher, hooks: [{ type, command }] }`.
+ *
+ * This hook is dormant until Cursor fixes the AskQuestion tool-hook-skip bug (see
+ * {@link CURSOR_ASK_QUESTION_COMMAND}) — installing it now means it auto-activates
+ * with no new install once upstream lands.
+ */
+function mergeAskQuestionHook(config) {
+    if (typeof config.version !== "number")
+        config.version = 1;
+    const hooks = isRecord(config.hooks) ? config.hooks : {};
+    const existing = Array.isArray(hooks.postToolUse) ? hooks.postToolUse : [];
+    const preserved = stripOurToolHooks(existing).entries;
+    preserved.push({
+        matcher: CURSOR_ASK_QUESTION_MATCHER,
+        hooks: [{ type: "command", command: CURSOR_ASK_QUESTION_COMMAND }],
+    });
+    hooks.postToolUse = preserved;
+    config.hooks = hooks;
+}
 /** Merge our MCP server entry into `mcp.mcpServers`. Mutates in place. */
 function mergeMcp(mcp) {
     const servers = isRecord(mcp.mcpServers) ? mcp.mcpServers : {};
@@ -197,6 +289,7 @@ export async function writeCursorConfig(runtime, opts) {
         const hooksPath = cursorHooksPath(opts);
         const hooksConfig = (await readJsonObject(hooksPath)) ?? {};
         mergeStopHook(hooksConfig);
+        mergeAskQuestionHook(hooksConfig);
         await writeJsonFile(hooksPath, hooksConfig);
         written.push(hooksPath);
         const mcpPath = cursorMcpPath(opts);
@@ -212,7 +305,10 @@ export async function writeCursorConfig(runtime, opts) {
             runtime: name,
             written,
             skipped: false,
-            detail: "merged stop hook + MCP entry; wrote rule",
+            detail: "merged stop + postToolUse(AskQuestion) hooks + MCP entry; wrote rule. " +
+                "NOTE: the AskQuestion question hook is DORMANT — Cursor currently fires no " +
+                "hooks for the AskQuestion tool (upstream bug), so question notifications " +
+                "fall back to 'finished' until Cursor ships their fix (auto-activates then).",
         };
     }
     catch (err) {
@@ -250,6 +346,16 @@ export async function uninstallCursorConfig(opts) {
                         delete hooks.stop;
                 }
             }
+            if (Array.isArray(hooks.postToolUse)) {
+                const { entries: kept, removed: r } = stripOurToolHooks(hooks.postToolUse);
+                if (r) {
+                    changed = true;
+                    if (kept.length > 0)
+                        hooks.postToolUse = kept;
+                    else
+                        delete hooks.postToolUse;
+                }
+            }
             if (Object.keys(hooks).length === 0)
                 delete hooksConfig.hooks;
             if (changed) {