@trygocode/notify 0.3.3 → 0.3.4

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 {
@@ -468,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 {
@@ -509,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/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.3";
+export const VERSION = "0.3.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trygocode/notify",
-  "version": "0.3.3",
+  "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",