@trygocode/notify 0.3.2 → 0.3.4

package/dist/src/claude.js

@@ -56,9 +56,14 @@ export const MCP_SERVER_ENTRY = {
  * We intentionally register ONLY `Stop` + `Notification`. `SubagentStop` is NOT
  * here on purpose — see {@link SUBAGENT_STOP_EVENT}.
  */
+// `@latest` is REQUIRED: bare `npx -y @trygocode/notify` caches the
+// first-resolved version forever and never auto-updates (npm/cli#6664). Pinning
+// `@latest` makes every hook fire the newest published version, so users get our
+// 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 on-stop --source claude_code --dedupe-key "$CLAUDE_SESSION_ID-stop" || true',
-    Notification: 'npx -y @trygocode/notify 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" || 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',
 };
 /**
  * The Claude event we DELIBERATELY do not register and actively scrub on every

package/dist/src/cursor.js

@@ -48,7 +48,15 @@ export const MCP_SERVER_ENTRY = {
  * both old and new commands contain the {@link HOOK_MARKERS} tokens, so an old
  * install still upgrades idempotently and uninstalls cleanly (PRD §2.2).
  */
-export const CURSOR_STOP_COMMAND = "npx -y @trygocode/notify on-stop --source cursor --dedupe-key cursor-stop || true";
+// `@latest` is REQUIRED, not cosmetic: bare `npx -y @trygocode/notify` caches the
+// first-resolved version FOREVER and never picks up a newer publish (documented
+// npx behaviour — npm/cli#6664; the whole `clear-npx-cache` package exists for
+// this). Without `@latest`, a user who installed an old version would keep
+// running it after we ship a fix, with no way to update short of wiping
+// ~/.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";
 /**
  * Substrings that together identify a `stop` hook entry as OURS. Used for
  * idempotent merge (replace, don't duplicate) and for surgical uninstall (remove

package/dist/src/on_stop.js

@@ -59,24 +59,65 @@ export function parseCursorStopStatus(stdin) {
     return undefined;
 }
 /**
- * Map a Cursor `stop` status to the appropriate {@link NotifyKind} (T-CUR1 / PRD §8.5):
- *   - `completed`  → `finished`          (agent turned cleanly)
- *   - `aborted`    → `awaiting_input`     (agent yielded back to the human)
- *   - `error`      → `error`              (agent hit an error)
- *   - `undefined`  → `finished`           (back-compat: absent/unrecognised)
+ * Map a Cursor `stop` status to the appropriate {@link NotifyKind} (T-CUR1 / PRD §8.5;
+ * `aborted` reclassified 2026-06-13):
+ *   - `completed`  → `finished`   (agent turned cleanly)
+ *   - `aborted`    → `finished`   (FALLBACK kind only — see note; the live path
+ *                                  SUPPRESSES aborted before it reaches a kind)
+ *   - `error`      → `error`      (agent hit an error)
+ *   - `undefined`  → `finished`   (back-compat: absent/unrecognised)
+ *
+ * WHY `aborted` is special:
+ * Cursor's `stop` hook fires `status: "aborted"` when the user **manually presses
+ * the Stop button** to interrupt a turn mid-prompt — a RELIABLE "the human stopped
+ * it on purpose" signal (distinct from `completed`). The original T-CUR1 design
+ * (2026-06-08) mapped `aborted → awaiting_input` as a stand-in for a needs-input
+ * event, which fired a false **"Agent needs you"** question push on every manual
+ * interrupt (2026-06-13 bug report). Per the user's follow-up, a manual stop must
+ * send **NO notification at all** — so {@link shouldSuppressAbortedStop} short-
+ * circuits the Cursor `aborted` case in {@link onStop} BEFORE this kind is used.
+ * This function therefore only returns `finished` for `aborted` as a defensive
+ * fallback (e.g. a caller that bypasses the suppression gate) — never a question.
+ *
+ * Real "agent needs you" pings are unaffected: Claude Code still fires its
+ * dedicated `Notification → awaiting_input` hook (a genuine needs-input signal),
+ * and the correct Cursor real-question signal is the future `AskQuestion`
+ * `postToolUse` hook (PRD §8.5 T-CUR3), NOT this `aborted` stand-in.
  */
 export function cursorStopStatusToKind(status) {
     switch (status) {
         case "completed":
             return "finished";
         case "aborted":
-            return "awaiting_input";
+            // Defensive fallback only — the live onStop path SUPPRESSES aborted before
+            // reaching here (shouldSuppressAbortedStop). Never a question. (2026-06-13)
+            return "finished";
         case "error":
             return "error";
         default:
             return "finished"; // back-compat: absent/unrecognised → finished
     }
 }
+/**
+ * True when this stop turn is a user-initiated interrupt we should send NO
+ * notification for (2026-06-13). Today this is ONLY the Cursor `stop` hook
+ * reporting `status: "aborted"` — the one runtime that gives a reliable
+ * "the human pressed Stop" discriminator distinct from a normal completion.
+ *
+ * Claude Code and OpenCode are intentionally NOT suppressible here: their
+ * end-of-turn hooks (`Stop` / `session.idle` / `session.status`) fire identically
+ * for a normal completion AND a manual stop with no field to tell them apart, so
+ * suppressing would also eat their legitimate `finished` pings. They keep the
+ * `finished` fallback (the user's explicit "if not possible, just send a DONE
+ * notification instead"). Real questions are unaffected on every runtime (Claude's
+ * separate `Notification` hook; the future Cursor `AskQuestion` hook).
+ *
+ * Pure — no I/O. Returns false for any non-Cursor source or any non-aborted
+ * status so a normal `completed`/`error`/absent turn always notifies as before.
+ */
+export function shouldSuppressAbortedStop(source, status) {
+    return source === "cursor" && status === "aborted";
+}
 /** Slice the merged settings down to what the push flow consumes. */
 function toPushSettings(settings) {
     return {
@@ -238,7 +279,17 @@ export function ideChatIdFromHookStdin(source, cwd, hookStdin) {
     const ideSessionId = str(p.conversation_id, p.conversationId, p.session_id, p.sessionId, sessionFromPath);
     if (!ideSessionId)
         return undefined;
-    const workspacePath = str(p.workspace_path, Array.isArray(p.workspaceRoots) ? p.workspaceRoots[0] : undefined, p.cwd, cwd);
+    // CRITICAL parity: the deep-link id hashes the workspace, and gocode-sync hashes
+    // the SAME workspace when it stores the chat — they MUST agree or a tapped push
+    // hits "Chat not found". gocode-sync resolves the workspace from Cursor's REAL
+    // field `workspace_roots` (snake_case), so we MUST read it here too. Reuse
+    // workspaceRootFromHookStdin (which already prefers workspace_roots and every
+    // spelling) so the two packages can never drift. Fall back to camelCase / cwd
+    // for older Cursor builds, then the process cwd.
+    const workspacePath = workspaceRootFromHookStdin(hookStdin) ??
+        str(p.workspace_path, Array.isArray(p.workspace_roots)
+            ? p.workspace_roots[0]
+            : undefined, Array.isArray(p.workspaceRoots) ? p.workspaceRoots[0] : undefined, p.cwd, cwd);
     if (!workspacePath)
         return undefined;
     // The capture side stores `source: "cursor" | "claude_code"`; the hook passes
@@ -458,6 +509,24 @@ export async function onStop(opts = {}) {
                 detail: "autopilot loop owns the turn — per-turn ping suppressed",
             };
         }
+        // ── Step 0.5: user-initiated-stop gate (2026-06-13). ──
+        // When the user manually presses Stop/interrupt on Cursor, the stop hook
+        // reports `status: "aborted"` — a reliable "the human stopped it on purpose"
+        // signal. The user wants NO notification for that (it is not a question, and
+        // not a turn they want pinged). Suppress entirely BEFORE any auto-push OR
+        // plain-send work, so a manual interrupt never fires a push/commit either.
+        // Only Cursor's `aborted` qualifies (the one runtime with a reliable manual-
+        // stop discriminator); Claude/OpenCode have no such signal and keep their
+        // `finished` fallback. Real questions are unaffected on every runtime.
+        const earlyHookStatus = parseCursorStopStatus(opts.hookStdin);
+        if (shouldSuppressAbortedStop(source, earlyHookStatus)) {
+            await logLine(`user-initiated stop (${source} aborted) → suppressed per-turn ping (not a question; manual interrupt)`);
+            return {
+                mode: "aborted-suppressed",
+                settingsSource: "default",
+                detail: "user pressed Stop/interrupt — per-turn ping suppressed",
+            };
+        }
         // ── Step 1: derive repo identity (never throws — local fallback on failure). ──
         let repo;
         try {
@@ -499,12 +568,13 @@ export async function onStop(opts = {}) {
         }
         // ── Step 3b: auto-push off → the plain notification (legacy flow). ──
         // Derive the notification kind from the Cursor stop hook's stdin JSON (T-CUR1
-        // / PRD §8.5). The status maps:
+        // / PRD §8.5; aborted handling 2026-06-13). The status maps:
         //   completed  → finished          (agent turned cleanly)
-        //   aborted    → awaiting_input    (agent yielded back to the human)
+        //   aborted    → (SUPPRESSED upstream at Step 0.5 for Cursor; finished fallback)
         //   error      → error             (agent hit an error)
         //   absent     → finished          (back-compat: no stdin or unrecognised status)
-        const hookStatus = parseCursorStopStatus(opts.hookStdin);
+        // Reuse the status already parsed at Step 0.5 (single parse per turn).
+        const hookStatus = earlyHookStatus;
         const sendKind = cursorStopStatusToKind(hookStatus);
         if (opts.dryRun) {
             await logLine(`dry-run: would send ${sendKind} (auto-push off, source: ${source}, settings: ${resolved.source})`);

package/dist/src/opencode.js

@@ -68,7 +68,10 @@ export const OPENCODE_MCP_ENTRY = {
  * Claude/Cursor. Ends in `|| true` so a failure can never block the session, and
  * carries a `--dedupe-key` so overlapping triggers coalesce server-side.
  */
-export const OPENCODE_STOP_COMMAND = "npx -y @trygocode/notify on-stop --source opencode --dedupe-key opencode-idle || true";
+// `@latest` is REQUIRED: bare `npx -y @trygocode/notify` caches the first
+// resolved version forever and never auto-updates (npm/cli#6664). Pinning
+// `@latest` makes the hook always fetch the newest publish so users self-update.
+export const OPENCODE_STOP_COMMAND = "npx -y @trygocode/notify@latest on-stop --source opencode --dedupe-key opencode-idle || true";
 /**
  * Substrings that together identify our plugin file as OURS. Used to keep
  * uninstall surgical: we only delete the plugin file when BOTH markers are

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.3.2";
+export const VERSION = "0.3.4";

package/package.json

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