@trygocode/notify 0.6.3 → 0.6.5

package/README.md

@@ -513,6 +513,7 @@ been written. Most issues below are diagnosable from that output.
 | **No push arrives** even though `test` exits 0 | The send is fire-and-forget and exits 0 even on failure — check `~/.gocode/notify.log` for the real error. Also confirm push permissions are granted in the GoCode app and the device token is registered (re-open the app once after signing in). |
 | **Double pings** (two notifications per event) | The agent is calling the `gocode_notify` MCP tool *and* the runtime hook is firing. Re-run `setup` so the anti-double-ping rule/skill is installed; it tells the agent not to notify for automatic done/idle/error events. |
 | **Hook doesn't fire** in Cursor / Claude Code / OpenCode | Re-run `setup` and check `status` shows "config written" for that runtime. Restart the agent app so it reloads `~/.cursor/hooks.json` / `~/.claude/settings.json` / `~/.config/opencode/plugin/gocode-notify.js`. The hooks are merged, never clobbered — your existing hooks are preserved. |
+| `doctor` says Claude hooks are missing but GoCode Sync is installed | Expected and accurate: Sync's `Stop` hook uploads transcripts; it is not a Notify hook and cannot deliver completion pushes. Run `gocode-notify setup` to install Notify's separate `Stop` + `Notification` hooks. |
 | **Pushes queue up while offline** then arrive later | Expected. Sends made while the server is unreachable are enqueued to `~/.gocode/outbox/` (size-capped, drop-oldest) and flushed best-effort on the next `send`. A missed "done" ping is acceptable; a blocked agent is not. |
 | **`npx @trygocode/notify` can't find the package** | Until it's published to npm, run from a local tarball: `npm pack` in `tools/gocode-notify/`, then `npx ./gocode-notify-*.tgz <command>`. See [`docs/GOCODE_NOTIFY_MANUAL_STEPS.md`](../../docs/GOCODE_NOTIFY_MANUAL_STEPS.md). |
 | **Want it gone** | `gocode-notify uninstall` removes exactly the hook/MCP/rule entries this tool added (nothing else). Delete `~/.gocode/` to also drop the stored credentials, and revoke the key from the app's **"Connected agents"** screen. |
@@ -529,6 +530,32 @@ npm publish, real-device E2E), see
 
 ## Changelog
 
+### 0.6.5
+
+- **Fixed Cursor lifecycle notifications on current Cursor releases.** The
+  installer now writes `postToolUse` using Cursor's direct
+  `{ "command": "...", "matcher": "..." }` schema. Versions 0.5.0–0.6.4 wrote
+  a Claude-style nested `hooks` array, causing Cursor to reject the entire user
+  hooks file—silencing completion, error, and question notifications. Re-running
+  setup migrates the malformed legacy entry in place while preserving user hooks.
+- **Restored standalone Claude Code completion + question notifications without
+  duplicating Cursor.** Claude `Stop` and `Notification` hooks are installed
+  normally. When Cursor's third-party compatibility layer imports the Claude
+  `Stop` hook, the dispatcher detects Cursor's documented `cursor_version` stdin
+  field and suppresses only that embedded duplicate. A real standalone Claude
+  payload has no `cursor_version` and continues to send.
+- **No silent completion when auto-push has nothing to do.** If auto-push returns
+  `clean-tree` (or another non-notifying no-op), `on-stop` now sends the normal
+  completion fallback. A non-notifying commit failure sends an error fallback.
+- **Doctor no longer confuses GoCode Sync with GoCode Notify.** A valid hook must
+  carry both the runtime source marker and a Notify package/command marker.
+- **Hook commands stay silent for Cursor's JSON protocol.** Installed Cursor and
+  Claude lifecycle hooks use `--quiet`, so a successful human-readable
+  `✓ on-stop …` line is never misparsed by Cursor as an invalid JSON hook
+  response.
+- Run `npx -y @trygocode/notify@latest setup` after upgrading, then restart
+  Cursor and any standalone Claude Code process so both reload their hooks.
+
 ### 0.6.1
 
 - **Banner now reliably POPS top-right (not just history).** The signed helper

package/dist/src/claude.js

@@ -50,8 +50,9 @@ export const MCP_SERVER_ENTRY = {
  * plain `finished` ping — exactly one notification per turn. The pre-T-C6 form
  * was `send --kind finished --source claude_code …`; both old and new commands
  * contain the {@link HOOK_MARKERS} tokens, so old installs upgrade idempotently
- * and uninstall cleanly. `Notification` stays on the plain `send` (it is not a
- * turn-completion event and never auto-pushes).
+ * and uninstall cleanly. `Notification` uses the small `on-notification`
+ * dispatcher: standalone Claude questions forward to `awaiting_input`, while a
+ * Cursor-imported Claude hook is suppressed using Cursor's stdin marker.
  *
  * We intentionally register ONLY `Stop` + `Notification`. `SubagentStop` is NOT
  * here on purpose — see {@link SUBAGENT_STOP_EVENT}.
@@ -62,8 +63,8 @@ export const MCP_SERVER_ENTRY = {
 // fixes without ever clearing their npx cache by hand. Matchers below key on the
 // `@trygocode/notify` substring, which `@latest` preserves.
 export const CLAUDE_HOOK_COMMANDS = {
-    Stop: 'npx -y @trygocode/notify@latest on-stop --source claude_code --dedupe-key "$CLAUDE_SESSION_ID-stop" || true',
-    Notification: 'npx -y @trygocode/notify@latest send --kind awaiting_input --source claude_code --title "Agent needs you" --dedupe-key "$CLAUDE_SESSION_ID-notify" || true',
+    Stop: 'npx -y @trygocode/notify@latest on-stop --source claude_code --dedupe-key "$CLAUDE_SESSION_ID-stop" --quiet || true',
+    Notification: 'npx -y @trygocode/notify@latest on-notification --source claude_code --dedupe-key "$CLAUDE_SESSION_ID-notify" --quiet || true',
 };
 /**
  * The Claude event we DELIBERATELY do not register and actively scrub on every

package/dist/src/cli.js

@@ -20,7 +20,7 @@ import { serveStdio } from "./mcp.js";
 import { setup } from "./setup.js";
 import { uninstall } from "./uninstall.js";
 import { cmdConfig } from "./config.js";
-import { onStop, clickTarget, projectLabel } from "./on_stop.js";
+import { onStop, isClaudeHookImportedByCursor, parseCursorStopStatus, cursorStopStatusToKind, clickTarget, projectLabel, } from "./on_stop.js";
 import { notifyDesktop, requestDesktopPermission, desktopDisabledByEnv, } from "./desktop_notify.js";
 import { resolveNotifySettings } from "./config.js";
 import { deriveRepoIdentity } from "./repo_key.js";
@@ -39,6 +39,7 @@ export const COMMANDS = [
     "uninstall",
     "config",
     "on-stop",
+    "on-notification",
     "launch",
 ];
 /** Aliases that route to a canonical command in {@link runAsync}. */
@@ -102,6 +103,7 @@ export function printHelp() {
         "  uninstall  Remove entries this tool added",
         "  config     Get/set Notify settings (get | set <key> <value> | pull)",
         "  on-stop    End-of-turn dispatcher (auto-push or finished ping)",
+        "  on-notification  Needs-input hook dispatcher (embedded-Cursor aware)",
         "  launch     Hand a big task off to your GoCode server (alias: autopilot)",
         "",
         "  -h, --help       Show this help",
@@ -323,13 +325,14 @@ export async function fireSendDesktop(payload, deps) {
 export async function cmdSend(args, deps = {}) {
     const flags = parseFlags(args);
     const agent = isAgentDriven(flags);
+    const quiet = flagBool(flags, "quiet");
     const sink = deps.sink ?? stdoutSink;
     const kind = flagString(flags, "kind");
     if (kind === undefined) {
         const detail = `--kind is required (one of: ${NOTIFY_KINDS.join(", ")})`;
         if (agent)
             sink({ step: "validate", ok: false, detail });
-        else
+        else if (!quiet)
             console.error(`gocode-notify send: ${detail}`);
         return 2;
     }
@@ -337,7 +340,7 @@ export async function cmdSend(args, deps = {}) {
         const detail = `invalid --kind "${kind}" (expected one of: ${NOTIFY_KINDS.join(", ")})`;
         if (agent)
             sink({ step: "validate", ok: false, detail });
-        else
+        else if (!quiet)
             console.error(`gocode-notify send: ${detail}`);
         return 2;
     }
@@ -390,7 +393,7 @@ export async function cmdSend(args, deps = {}) {
             : "";
         if (agent)
             sink({ step: "send", ok: true, detail: `sent ${payload.kind}${where}` });
-        else
+        else if (!quiet)
             console.log(`✓ Sent ${payload.kind}${where}.`);
     }
     else {
@@ -399,7 +402,7 @@ export async function cmdSend(args, deps = {}) {
         const detail = `${payload.kind} not delivered (${result.error}); queued for retry`;
         if (agent)
             sink({ step: "send", ok: false, detail });
-        else
+        else if (!quiet)
             console.error(`gocode-notify send: ${detail}.`);
     }
     // PRD §4.4: a failed notification must NEVER block a hook — always exit 0.
@@ -692,6 +695,7 @@ export async function cmdMcp(args, deps = {}) {
 export async function cmdOnStop(args, deps = {}) {
     const flags = parseFlags(args);
     const agent = isAgentDriven(flags);
+    const quiet = flagBool(flags, "quiet");
     const sink = deps.sink ?? stdoutSink;
     // Read the hook's stdin JSON (T-CUR1 / PRD §8.5). The Cursor `stop` hook pipes
     // its event data to the process stdin; we consume it here so on-stop can map
@@ -723,6 +727,7 @@ export async function cmdOnStop(args, deps = {}) {
         : result.mode === "send"
             ? result.send?.ok === true
             : undefined;
+    const fallbackKind = cursorStopStatusToKind(parseCursorStopStatus(hookStdin));
     const detail = result.mode === "push"
         ? `auto-push: ${result.push?.outcome ?? "unknown"}${delivered ? " (notified)" : ""}`
         : result.mode === "dry-run-send"
@@ -731,16 +736,50 @@ export async function cmdOnStop(args, deps = {}) {
                 ? "deduped: another source already notified for this run"
                 : result.mode === "autopilot-suppressed"
                     ? "autopilot-suppressed: an Autopilot loop owns this turn's ping"
-                    : `finished ${delivered ? "delivered" : "not delivered"}`;
+                    : result.mode === "embedded-claude-suppressed"
+                        ? "embedded-claude-suppressed: native Cursor hook owns this turn"
+                        : `${fallbackKind} ${delivered ? "delivered" : "not delivered"}`;
     if (agent) {
         sink({ step: "on-stop", ok: true, detail });
     }
-    else {
+    else if (!quiet) {
         console.log(`✓ on-stop (${result.mode}): ${detail}`);
     }
     // PRD §0.5 / §4.4: a stop hook must NEVER block the turn — always exit 0.
     return 0;
 }
+/**
+ * Handle Claude Code's `Notification` hook while avoiding Cursor's third-party
+ * import duplicate. Standalone Claude payloads are forwarded to the normal
+ * awaiting-input send. Cursor-imported payloads carry `cursor_version` and are
+ * ignored because Cursor does not support the Claude Notification event and its
+ * native question hook is authoritative when available.
+ */
+export async function cmdOnNotification(args, deps = {}) {
+    const flags = parseFlags(args);
+    const source = flagString(flags, "source") ?? "claude_code";
+    const hookStdin = deps.hookStdin !== undefined
+        ? deps.hookStdin
+        : await (deps.readStdin ?? readStdinIfPipe)();
+    if (isClaudeHookImportedByCursor(source, hookStdin))
+        return 0;
+    const forwarded = [
+        "--kind",
+        "awaiting_input",
+        "--source",
+        source,
+        "--title",
+        "Agent needs you",
+        "--quiet",
+    ];
+    const dedupeKey = flagString(flags, "dedupe-key");
+    if (dedupeKey)
+        forwarded.push("--dedupe-key", dedupeKey);
+    const server = flagString(flags, "server");
+    if (server)
+        forwarded.push("--server", server);
+    return (deps.sendCommandImpl ?? cmdSend)(forwarded, deps);
+}
 /**
  * Handle `gocode-notify launch "<task>" [--repo owner/repo] [--branch suffix]
  * [--prd-file path.md] [--model "Profile"] [--runner-kind K] [--server URL]
@@ -878,6 +917,8 @@ export async function runAsync(argv) {
         return cmdConfig(argv.slice(1));
     if (cmd === "on-stop")
         return cmdOnStop(argv.slice(1));
+    if (cmd === "on-notification")
+        return cmdOnNotification(argv.slice(1));
     if (cmd === "launch" || cmd === "autopilot")
         return cmdLaunch(argv.slice(1));
     return run(argv);

package/dist/src/cursor.js

@@ -60,7 +60,7 @@ export const MCP_SERVER_ENTRY = {
 // ~/.npm/_npx by hand. Pinning `@latest` forces npx to resolve the newest
 // 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";
+export const CURSOR_STOP_COMMAND = "npx -y @trygocode/notify@latest on-stop --source cursor --dedupe-key cursor-stop --quiet || 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
@@ -68,15 +68,10 @@ export const CURSOR_STOP_COMMAND = "npx -y @trygocode/notify@latest on-stop --so
  * 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.
+ * Historically dormant (2026-06-18): Cursor skipped tool hooks for AskQuestion.
+ * Keep this hook installed in the current direct schema because newer releases
+ * may fire it; on older releases it remains a harmless no-op and `stop` supplies
+ * the completion fallback.
  *
  * Cursor question detection has no other path: Cursor exposes NO `Notification`
  * event (docs: `Notification | - | No`), and the `stop` hook's
@@ -87,7 +82,7 @@ export const CURSOR_STOP_COMMAND = "npx -y @trygocode/notify@latest on-stop --so
  * 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';
+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 --quiet || 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
@@ -200,22 +195,28 @@ function isOurStopHook(h) {
     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`.
+ * True when a `postToolUse` entry is one we wrote. Current Cursor uses the same
+ * direct shape as every other Cursor event (`{ command, matcher? }`). Releases
+ * through 0.6.4 accidentally wrote Claude Code's nested
+ * `{ matcher, hooks: [{ command }] }` shape, which makes Cursor reject the
+ * ENTIRE user hooks file. Recognise BOTH shapes so setup/uninstall migrate the
+ * malformed legacy entry without touching user hooks.
  */
-function isOurToolHookGroup(g) {
-    if (!isRecord(g) || !Array.isArray(g.hooks))
+function isOurToolHookEntry(entry) {
+    if (!isRecord(entry))
         return false;
-    return g.hooks.some((h) => isRecord(h) && typeof h.command === "string" && isOurCommand(h.command));
+    if (typeof entry.command === "string" && isOurCommand(entry.command))
+        return true;
+    if (!Array.isArray(entry.hooks))
+        return false;
+    return entry.hooks.some((hook) => isRecord(hook) && typeof hook.command === "string" && isOurCommand(hook.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));
+    const kept = entries.filter((entry) => !isOurToolHookEntry(entry));
     return { entries: kept, removed: kept.length !== entries.length };
 }
 /**
@@ -246,13 +247,13 @@ function mergeStopHook(config) {
 /**
  * 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
+ * entry (idempotent / version-safe) then appends a single fresh entry 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 }] }`.
+ * place. Cursor's current hook schema requires `command` DIRECTLY on every
+ * event entry: `{ command, matcher }`.
  *
- * 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.
+ * On Cursor versions that still skip AskQuestion tool hooks, this entry remains
+ * a harmless no-op; on versions that fire it, questions notify immediately.
  */
 function mergeAskQuestionHook(config) {
     if (typeof config.version !== "number")
@@ -261,8 +262,8 @@ function mergeAskQuestionHook(config) {
     const existing = Array.isArray(hooks.postToolUse) ? hooks.postToolUse : [];
     const preserved = stripOurToolHooks(existing).entries;
     preserved.push({
+        command: CURSOR_ASK_QUESTION_COMMAND,
         matcher: CURSOR_ASK_QUESTION_MATCHER,
-        hooks: [{ type: "command", command: CURSOR_ASK_QUESTION_COMMAND }],
     });
     hooks.postToolUse = preserved;
     config.hooks = hooks;
@@ -305,10 +306,7 @@ export async function writeCursorConfig(runtime, opts) {
             runtime: name,
             written,
             skipped: false,
-            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).",
+            detail: "merged current-schema stop + postToolUse(AskQuestion) hooks + MCP entry; wrote rule",
         };
     }
     catch (err) {

package/dist/src/doctor.js

@@ -28,10 +28,16 @@ export { UNPAIRED_WARNING } from "./status.js";
 // We detect our hook entries by looking for these stable tokens in the command
 // strings.  The same tokens are used by claude.ts / cursor.ts for idempotent
 // install / uninstall (kept in sync via the HOOK_SOURCE comments there).
-/** Tokens that identify a gocode-notify Claude Code hook in settings.json. */
-const CLAUDE_HOOK_TOKEN = "--source claude_code";
+/** Tokens that together identify OUR hook command (not @trygocode/sync). */
+const NOTIFY_HOOK_NAME_TOKENS = ["@trygocode/notify", "gocode-notify", "notify send"];
+const CLAUDE_HOOK_SOURCE_TOKEN = "--source claude_code";
 /** Token that identifies our Cursor stop hook in hooks.json. */
 const CURSOR_HOOK_TOKEN = "--source cursor";
+/** True only for a GoCode Notify command for the requested runtime source. */
+function isNotifyHookCommand(command, sourceToken) {
+    return (command.includes(sourceToken) &&
+        NOTIFY_HOOK_NAME_TOKENS.some((token) => command.includes(token)));
+}
 // ─── Helpers ───────────────────────────────────────────────────────────────
 function resolveHomeDir(opts) {
     return opts.home ?? process.env.HOME ?? process.env.USERPROFILE ?? "~";
@@ -162,7 +168,7 @@ export async function gatherDoctor(opts = {}) {
         "Stop" in claudeHooks
         ? claudeHooks.Stop
         : null);
-    const claudeStopInstalled = claudeStopCommands.some((c) => c.includes(CLAUDE_HOOK_TOKEN));
+    const claudeStopInstalled = claudeStopCommands.some((c) => isNotifyHookCommand(c, CLAUDE_HOOK_SOURCE_TOKEN));
     checks.push({
         key: "hook:claude-stop",
         label: "Claude Code Stop hook installed?",
@@ -180,7 +186,7 @@ export async function gatherDoctor(opts = {}) {
         "Notification" in claudeHooks
         ? claudeHooks.Notification
         : null);
-    const claudeNotifyInstalled = claudeNotifyCommands.some((c) => c.includes(CLAUDE_HOOK_TOKEN));
+    const claudeNotifyInstalled = claudeNotifyCommands.some((c) => isNotifyHookCommand(c, CLAUDE_HOOK_SOURCE_TOKEN));
     checks.push({
         key: "hook:claude-notification",
         label: "Claude Code Notification hook installed?",
@@ -220,7 +226,7 @@ export async function gatherDoctor(opts = {}) {
             ? flattenHookCommands(cursorRoot.stop)
             : []),
     ];
-    const cursorStopInstalled = cursorStopEntries.some((c) => c.includes(CURSOR_HOOK_TOKEN));
+    const cursorStopInstalled = cursorStopEntries.some((c) => isNotifyHookCommand(c, CURSOR_HOOK_TOKEN));
     checks.push({
         key: "hook:cursor-stop",
         label: "Cursor stop hook installed?",

package/dist/src/on_stop.js

@@ -120,6 +120,33 @@ export function cursorStopStatusToKind(status) {
 export function shouldSuppressAbortedStop(source, status) {
     return source === "cursor" && status === "aborted";
 }
+/**
+ * True when Cursor's third-party compatibility layer is executing a Claude Code
+ * hook. Cursor imports `~/.claude/settings.json` hooks and maps `Stop` to its own
+ * `stop` event, but keeps the Claude command's `--source claude_code`. Without
+ * this payload-aware gate, enabling standalone Claude hooks causes both Cursor's
+ * native stop hook and the imported Claude Stop hook to notify for one Cursor
+ * turn.
+ *
+ * Cursor documents `cursor_version` on every hook payload; standalone Claude
+ * Code does not emit it. That is the narrow, positive discriminator. We do not
+ * infer Cursor from paths, environment, or model names, so a real Claude CLI
+ * turn keeps notifying even when launched from a terminal inside Cursor.
+ */
+export function isClaudeHookImportedByCursor(source, hookStdin) {
+    if (source !== "claude_code" || !hookStdin || hookStdin.trim() === "")
+        return false;
+    try {
+        const parsed = JSON.parse(hookStdin);
+        if (!parsed || typeof parsed !== "object")
+            return false;
+        const cursorVersion = parsed.cursor_version;
+        return typeof cursorVersion === "string" && cursorVersion.trim() !== "";
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Human-readable label for a notification kind, used in the desktop banner body
  * (PRD §3). Mirrors the phone notification's tone so the computer banner reads
@@ -604,6 +631,20 @@ export async function onStop(opts = {}) {
         }
     };
     try {
+        // ── Step -0.5: suppress Claude hooks imported by Cursor. ──
+        // Cursor automatically loads Claude Code hooks from ~/.claude/settings.json.
+        // Keep those hooks installed for the standalone Claude CLI, but when their
+        // stdin carries Cursor's documented `cursor_version`, let the native Cursor
+        // hook be the single owner of the turn. This replaces the stale machine-wide
+        // GOCODE_NOTIFY_SKIP_RUNTIMES policy without silencing standalone Claude.
+        if (isClaudeHookImportedByCursor(source, opts.hookStdin)) {
+            await logLine(`Cursor-imported Claude hook → suppressed ${source} duplicate (native Cursor hook is authoritative)`);
+            return {
+                mode: "embedded-claude-suppressed",
+                settingsSource: "default",
+                detail: "Cursor imported the Claude hook — native Cursor hook owns the turn",
+            };
+        }
         // ── Step 0: Autopilot-owns-turn gate (T-N7 / PRD §3.2). ──
         // When an Autopilot loop has marked that it owns this turn, it sends its OWN
         // loop_completed/loop_halted Autopilot ping, so ANY per-turn stop-hook ping
@@ -674,10 +715,62 @@ export async function onStop(opts = {}) {
                 home: opts.home,
             });
             await logLine(`auto-push path → ${push.outcome} (source: ${source}, settings: ${resolved.source})`);
-            // Branded desktop banner mirroring the push notification (PRD §3). Only
-            // fire when the push flow actually notified the phone (i.e. it pushed,
-            // hit a conflict, or was rejected) — not on no-op outcomes (disabled /
-            // not-a-repo / clean-tree / protected-skip) where the phone got nothing.
+            // A push flow owns the turn only if it actually emitted a notification.
+            // `clean-tree` and other no-op/failure outcomes can return notified!==true;
+            // in that case send the normal completion/error fallback so enabling
+            // auto-push never makes an otherwise valid end-of-turn notification vanish.
+            if (push.notified !== true && !opts.dryRun) {
+                const fallbackKind = push.outcome === "commit-failed" || push.outcome === "push-rejected" ||
+                    push.outcome === "conflict-aborted"
+                    ? "error"
+                    : cursorStopStatusToKind(earlyHookStatus);
+                const fallbackPayload = { kind: fallbackKind, source };
+                const fallbackProject = projectLabel(repo, cwd);
+                if (fallbackProject)
+                    fallbackPayload.project = fallbackProject;
+                if (opts.dedupeKey)
+                    fallbackPayload.dedupe_key = opts.dedupeKey;
+                const ideChatId = ideChatIdFromHookStdin(source, cwd, opts.hookStdin);
+                if (ideChatId)
+                    fallbackPayload.ide_chat_id = ideChatId;
+                const chatTitle = await chatTitleFromHookStdin(opts.hookStdin);
+                if (chatTitle)
+                    fallbackPayload.chat = chatTitle;
+                const fallbackBody = fallbackKind === "error" && push.detail
+                    ? push.detail
+                    : undefined;
+                if (fallbackBody)
+                    fallbackPayload.body = fallbackBody;
+                const desktopBanner = {
+                    title: decorateTitle({
+                        kind: fallbackKind,
+                        source,
+                        project: fallbackProject,
+                    }),
+                    body: decorateBody({
+                        kind: fallbackKind,
+                        body: fallbackBody,
+                        project: fallbackProject,
+                        chat: chatTitle,
+                    }),
+                    kind: fallbackKind,
+                };
+                const [sent, desktop] = await Promise.all([
+                    sendImpl(fallbackPayload),
+                    fireDesktop(settings, desktopBanner, source, ideChatId),
+                ]);
+                await logLine(`auto-push ${push.outcome} produced no notification → ${fallbackKind} fallback ${sent.ok ? "delivered" : "failed"}`);
+                return {
+                    mode: "send",
+                    settingsSource: resolved.source,
+                    push,
+                    send: sent,
+                    desktop,
+                    repo,
+                    detail: push.detail,
+                };
+            }
+            // Branded desktop banner mirroring the push notification (PRD §3).
             let desktop;
             if (push.notified === true) {
                 const project = projectLabel(repo, cwd);

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Single source of truth for the CLI version. Keep in sync with package.json.
-export const VERSION = "0.6.3";
+export const VERSION = "0.6.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trygocode/notify",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "Free phone + branded desktop notifications for any coding agent (Cursor, Claude Code, OpenCode, Ralph/Homer) via the GoCode app.",
   "license": "MIT",
   "type": "module",