@trygocode/notify 0.3.4 → 0.5.0

package/dist/src/notify_copy.js

@@ -0,0 +1,189 @@
+// `notify_copy` — the ONE place the desktop banner's wording is built so it
+// reads WORD-FOR-WORD identical to the phone push (GOCODE_NOTIFY_DESKTOP PRD
+// §3 "same title/body as the phone"). This is a faithful port of the server's
+// decoration (`dispatcher._decorated_title` / `_decorated_body` +
+// `notify_routes._DEFAULT_TITLES` / `_DEFAULT_BODIES`) AND the Flutter client's
+// `decorateNotificationTitle` / `sourceLabelFor` (`push_notification_service.dart`
+// / `firebase_push_notification_service.dart`). All three MUST agree — there is a
+// cross-check test (`notify_copy.test.ts`) that pins these tables against the
+// server/Flutter strings so a future edit on one side can't silently drift.
+//
+// Why mirror server-side copy in the CLI at all? The desktop banner fires
+// LOCALLY (it never round-trips the server — that would add latency + a failure
+// mode to a best-effort banner), so the CLI must reproduce the exact string the
+// server would have rendered for the phone. Keeping it in its own tiny module
+// (rather than inline in `on_stop.ts`) makes the "single source of truth, pinned
+// by a test" contract explicit.
+//
+// Zero runtime deps — pure string logic, no imports.
+/**
+ * Max display length for a project / chat name folded into the title or body.
+ * Mirrors the server's `_NOTIFICATION_NAME_MAX_LEN` and the Flutter client's
+ * `kNotificationNameMaxLen` so a long name truncates to the SAME string the
+ * phone shows.
+ */
+export const NOTIFICATION_NAME_MAX_LEN = 40;
+/**
+ * Per-kind status emoji prefixed onto the decorated title. Mirrors the server's
+ * `_STATUS_EMOJI` and the Flutter client's `_statusEmojiFor`. Unknown kinds get
+ * no emoji (fall through), exactly like the server.
+ */
+const STATUS_EMOJI = {
+    finished: "✅",
+    loop_completed: "✅",
+    error: "❌",
+    awaiting_input: "❓",
+    ralph_waiting: "❓",
+    loop_halted: "⚠️",
+};
+/**
+ * Per-kind DEFAULT title used when the caller supplies no explicit title — the
+ * funnel/stop-hook path always omits a title, so this is what the phone shows.
+ * Mirrors the server's `notify_routes._DEFAULT_TITLES` (chat kinds) +
+ * `dispatcher.LOOP_KIND_COPY` (loop kinds) EXACTLY. Keep these strings in sync
+ * with the server — the cross-check test pins them.
+ */
+export const DEFAULT_TITLES = {
+    finished: "Agent finished",
+    error: "Agent hit an error",
+    awaiting_input: "Agent needs you",
+    loop_completed: "Autopilot finished",
+    loop_halted: "Autopilot halted — needs you",
+};
+/**
+ * Per-kind DEFAULT body used when the caller supplies no explicit body. Mirrors
+ * the server's `notify_routes._DEFAULT_BODIES` + `dispatcher.LOOP_KIND_COPY`.
+ */
+export const DEFAULT_BODIES = {
+    finished: "Your coding run finished — tap to review.",
+    error: "Your coding run hit an error — tap to see what happened.",
+    awaiting_input: "Your coding run is waiting on you — tap to respond.",
+    loop_completed: "Your Autopilot loop finished — tap to review.",
+    loop_halted: "Your Autopilot loop stopped and needs your input — tap to resolve.",
+};
+/** Loop kinds whose decorated title carries the "Autopilot" prefix (no project). */
+const AUTOPILOT_KINDS = new Set(["loop_completed", "loop_halted", "ralph_waiting"]);
+/**
+ * Human-readable source label for the title prefix. `"cursor"` → `"Cursor"`,
+ * `"claude_code"`/`"claude"` → `"Claude"`. Mirrors the Flutter client's
+ * `sourceLabelFor` and the server's `_source_label` EXACTLY: a known token maps
+ * to its brand; `"manual"`/`"app"`/`"cli"` return null (no prefix); any other
+ * token is title-cased defensively. Returns null when there is no label.
+ */
+export function sourceLabelFor(source) {
+    if (source == null)
+        return undefined;
+    const s = source.trim().toLowerCase();
+    if (s === "")
+        return undefined;
+    switch (s) {
+        case "gocode":
+            return "GoCode";
+        case "cursor":
+            return "Cursor";
+        case "claude_code":
+        case "claude":
+            return "Claude";
+        case "opencode":
+            return "OpenCode";
+        case "ralph":
+            return "Ralph";
+        case "homer":
+            return "Homer";
+        // In-app origins carry no brand prefix (mirror Flutter/`_source_label`).
+        case "manual":
+        case "app":
+        case "cli":
+            return undefined;
+        default: {
+            // Title-case an unknown token so a new server source still renders
+            // something sensible (mirrors Flutter's defensive default + the server).
+            const t = source.trim();
+            return t.charAt(0).toUpperCase() + t.slice(1);
+        }
+    }
+}
+/**
+ * Trim + cap a project / chat name at {@link NOTIFICATION_NAME_MAX_LEN},
+ * appending an ellipsis when truncated. Returns undefined when the name is
+ * empty/whitespace so a blank field never folds an empty segment into the
+ * title/body. Mirrors the server's `_truncate_notification_name` and the
+ * client's `truncateNotificationName`.
+ */
+export function truncateNotificationName(name) {
+    if (name == null)
+        return undefined;
+    const n = name.trim();
+    if (n === "")
+        return undefined;
+    if (n.length <= NOTIFICATION_NAME_MAX_LEN)
+        return n;
+    // Reserve one char for the ellipsis so the result length equals the cap.
+    return n.slice(0, NOTIFICATION_NAME_MAX_LEN - 1) + "…";
+}
+/**
+ * Build the OS-rendered banner title — WORD-FOR-WORD identical to the phone push.
+ * Format: `<emoji> <source label> · <project> · Autopilot — <title>`, omitting
+ * any empty segment. A faithful port of the server's `_decorated_title` and the
+ * Flutter client's `decorateNotificationTitle` (the project segment is suppressed
+ * for autopilot/loop kinds, exactly like both). Idempotent on the emoji.
+ */
+export function decorateTitle(input) {
+    const kind = input.kind;
+    const autopilot = AUTOPILOT_KINDS.has(kind);
+    const rawTitle = input.title != null && input.title.trim() !== ""
+        ? input.title
+        : DEFAULT_TITLES[kind] ?? "";
+    const emoji = STATUS_EMOJI[kind];
+    const label = sourceLabelFor(input.source);
+    // Project is folded into the title for IDE/funnel pushes, but NOT for
+    // autopilot pushes (whose title already reads "<tool> · Autopilot — …").
+    const projectLabel = autopilot ? undefined : truncateNotificationName(input.project);
+    const prefixParts = [];
+    if (label)
+        prefixParts.push(label);
+    if (projectLabel)
+        prefixParts.push(projectLabel);
+    if (autopilot)
+        prefixParts.push("Autopilot");
+    const prefix = prefixParts.join(" · ");
+    // Defend against a caller that already prepended the emoji to the raw title.
+    let base = rawTitle.replace(/^\s+/, "");
+    if (emoji && base.startsWith(emoji)) {
+        base = base.slice(emoji.length).replace(/^\s+/, "");
+    }
+    const emojiS = emoji ?? "";
+    if (prefix) {
+        const left = `${emojiS} ${prefix}`.trim();
+        if (base === "")
+            return left;
+        return `${left} — ${base}`;
+    }
+    // No source/autopilot prefix.
+    if (base === "")
+        return emojiS;
+    return emojiS ? `${emojiS} ${base}`.trim() : base;
+}
+/**
+ * Build the OS-rendered banner body — matching the phone push. Folds the project
+ * (+ optional chat title) into the body: `<project> · <body>` or
+ * `<project> › <chat> · <body>`. A faithful port of the server's `_decorated_body`
+ * and the client's `decorateNotificationBody`. When no body is supplied the
+ * per-kind {@link DEFAULT_BODIES} is used so the banner is never body-less (the
+ * phone is never title-only either).
+ */
+export function decorateBody(input) {
+    const raw = input.body != null && input.body.trim() !== ""
+        ? input.body
+        : DEFAULT_BODIES[input.kind] ?? "";
+    const base = raw.trim() !== "" ? raw.trim() : undefined;
+    const proj = truncateNotificationName(input.project);
+    const conv = truncateNotificationName(input.chat);
+    const contextParts = [proj, conv].filter((p) => p != null);
+    if (contextParts.length === 0)
+        return base ?? "";
+    const context = contextParts.join(" › ");
+    if (base == null)
+        return context;
+    return `${context} · ${base}`;
+}

package/dist/src/on_stop.js

@@ -33,6 +33,8 @@ import { deriveRepoIdentity } from "./repo_key.js";
 import { pushOnStop, } from "./push.js";
 import { appendLog, send } from "./send.js";
 import { checkDedupLock } from "./dedup_lock.js";
+import { notifyDesktop, } from "./desktop_notify.js";
+import { decorateTitle, decorateBody } from "./notify_copy.js";
 /**
  * Parse the Cursor `stop` hook stdin JSON and extract the `status` field.
  * Best-effort: returns `undefined` on absent/empty/unparseable input or when the
@@ -118,6 +120,74 @@ export function cursorStopStatusToKind(status) {
 export function shouldSuppressAbortedStop(source, status) {
     return source === "cursor" && status === "aborted";
 }
+/**
+ * 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
+ * the same. Falls back to the raw kind for any future/unknown value.
+ */
+export function kindLabel(kind) {
+    switch (kind) {
+        case "finished":
+            return "Finished";
+        case "error":
+            return "Error";
+        case "awaiting_input":
+            return "Needs your input";
+        case "loop_completed":
+            return "Autopilot finished";
+        case "loop_halted":
+            return "Autopilot halted — needs you";
+        case "ralph_waiting":
+            return "Autopilot waiting";
+        default:
+            return String(kind);
+    }
+}
+/**
+ * Map a notification `source` (the IDE that raised the turn) to the macOS app
+ * name `open -a <app>` should launch, and the Windows process name. Returns
+ * undefined for non-IDE / unknown sources so the banner is display-only rather
+ * than opening the wrong thing. We intentionally cover ONLY the editors that run
+ * a stop hook (Cursor / Claude Code / OpenCode) — Autopilot/Ralph/Homer loops
+ * have no local IDE window to focus, and `manual`/webhook sources aren't IDEs.
+ */
+export function ideAppNameFor(source) {
+    if (!source)
+        return undefined;
+    switch (source.trim().toLowerCase()) {
+        case "cursor":
+            return "Cursor";
+        case "claude":
+        case "claude_code":
+            // Claude Code is a CLI inside a terminal/VS Code; "Visual Studio Code" is
+            // the closest reliable window to focus when it runs inside VS Code. When
+            // it runs in a bare terminal there is no stable app to open, so callers
+            // fall back gracefully (the click just no-ops rather than mis-opening).
+            return "Visual Studio Code";
+        case "opencode":
+            return "Visual Studio Code";
+        default:
+            return undefined;
+    }
+}
+/**
+ * Build the best-effort click target for the desktop banner (PRD §3.6): clicking
+ * the banner opens the IDE window for the project at `cwd`. Returns undefined
+ * when we can't name an IDE for `source` (then the banner is display-only — a
+ * graceful no-click, never a dead/mis-routed click). The `cwd` is the project
+ * directory the agent ran in, so `open -a <ide> <cwd>` focuses (or opens) that
+ * IDE on the right project window. `ideChatId` is carried for future use (deep
+ * link to the exact chat) but not required to open the window.
+ */
+export function clickTarget(source, cwd, _ideChatId) {
+    const app = ideAppNameFor(source);
+    if (!app)
+        return undefined;
+    const projectPath = cwd && cwd.trim() !== "" ? cwd : undefined;
+    if (!projectPath)
+        return undefined;
+    return { app, projectPath };
+}
 /** Slice the merged settings down to what the push flow consumes. */
 function toPushSettings(settings) {
     return {
@@ -493,6 +563,46 @@ export async function onStop(opts = {}) {
             timeoutMs: opts.timeoutMs,
             timestamp: opts.timestamp,
         }));
+    const desktopImpl = opts.notifyDesktopImpl ?? notifyDesktop;
+    /**
+     * Fire a branded local desktop banner for this turn (PRD §3) when
+     * `settings.desktop.enabled` is true. Best-effort + total: never throws, and
+     * the result is purely informational (the phone push is the source of truth).
+     * Gated on the SAME server-synced settings as the phone push so a toggle on
+     * the app or terminal flips the computer banner too. Returns undefined when
+     * desktop is disabled (so the result field is omitted).
+     */
+    const fireDesktop = async (settings, banner, source, ideChatId) => {
+        if (settings.desktop?.enabled === false)
+            return undefined;
+        if (opts.dryRun) {
+            await logLine(`dry-run: would show desktop banner "${banner.title ?? ""}"`);
+            return undefined;
+        }
+        try {
+            const res = await desktopImpl({
+                ...banner,
+                sound: settings.desktop?.sound !== false,
+                // Best-effort click target (PRD §3.6): clicking the banner opens the
+                // IDE window for THIS project (the agent's cwd), the same IDE that
+                // raised the turn. Omitted when we can't name the IDE or the path —
+                // then the banner is display-only (graceful, never a dead click).
+                click: clickTarget(source, cwd, ideChatId),
+            }, {
+                home: opts.home,
+                timeoutMs: opts.timeoutMs,
+                timestamp: opts.timestamp,
+            });
+            await logLine(`desktop banner → ${res.ok ? "shown" : "failed"} (${res.platform})`);
+            return res;
+        }
+        catch (err) {
+            // desktop banner must never block the turn — but leave a breadcrumb so a
+            // throwing (injected/future) impl is diagnosable from the notify log.
+            await logLine(`desktop banner threw — ignored: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    };
     try {
         // ── 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
@@ -564,7 +674,26 @@ export async function onStop(opts = {}) {
                 home: opts.home,
             });
             await logLine(`auto-push path → ${push.outcome} (source: ${source}, settings: ${resolved.source})`);
-            return { mode: "push", settingsSource: resolved.source, push, repo, detail: push.detail };
+            // 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.
+            let desktop;
+            if (push.notified === true) {
+                const project = projectLabel(repo, cwd);
+                const isError = push.outcome === "conflict-aborted" || push.outcome === "push-rejected";
+                const pushKind = isError ? "error" : "finished";
+                // Decorate WORD-FOR-WORD like the phone push (PRD §3): the auto-push
+                // path leaves `title` to the server default per kind, and folds the
+                // project into title + body exactly as `dispatcher._decorated_*` does.
+                const rawBody = push.detail || (isError ? "Auto-push needs you" : `Pushed to ${push.branch ?? "branch"}`);
+                desktop = await fireDesktop(settings, {
+                    title: decorateTitle({ kind: pushKind, source, project }),
+                    body: decorateBody({ kind: pushKind, body: rawBody, project }),
+                    kind: pushKind,
+                }, source);
+            }
+            return { mode: "push", settingsSource: resolved.source, push, desktop, repo, detail: push.detail };
         }
         // ── Step 3b: auto-push off → the plain notification (legacy flow). ──
         // Derive the notification kind from the Cursor stop hook's stdin JSON (T-CUR1
@@ -622,9 +751,27 @@ export async function onStop(opts = {}) {
         const chatTitle = await chatTitleFromHookStdin(opts.hookStdin);
         if (chatTitle)
             payload.chat = chatTitle;
-        const sent = await sendImpl(payload);
+        // Fire the phone push and the branded desktop banner in parallel (PRD §3):
+        // the computer gets told the same instant the phone does, and a slow banner
+        // never delays the phone send. The banner reuses the SAME project label,
+        // kind, and (when present) chat title that the phone notification carries.
+        // Decorate the banner WORD-FOR-WORD like the phone push (PRD §3): same
+        // emoji + source label + project folded into the title, and the per-kind
+        // default body with project (+ chat title) folded in — exactly what the
+        // server's `_decorated_title`/`_decorated_body` produce for this push. The
+        // CLI omits an explicit title (like the phone send) so the per-kind default
+        // ("Agent finished" / …) flows through identically on both surfaces.
+        const desktopBanner = {
+            title: decorateTitle({ kind: sendKind, source, project }),
+            body: decorateBody({ kind: sendKind, project, chat: chatTitle }),
+            kind: sendKind,
+        };
+        const [sent, desktop] = await Promise.all([
+            sendImpl(payload),
+            fireDesktop(settings, desktopBanner, source, ideChatId),
+        ]);
         await logLine(`send path → ${sendKind} ${sent.ok ? "delivered" : "failed"} (source: ${source}, settings: ${resolved.source})`);
-        return { mode: "send", settingsSource: resolved.source, send: sent, repo };
+        return { mode: "send", settingsSource: resolved.source, send: sent, desktop, repo };
     }
     catch (err) {
         // Defence in depth: the dispatcher must never throw. Degrade to a logged

package/dist/src/opencode.js

@@ -8,14 +8,20 @@
 //                           "command": ["npx","-y","@trygocode/notify","mcp"],
 //                           "enabled": true }
 //      `command` is a single ARRAY (binary + args), plus `type` + `enabled`.
-//   2. WRITE a `session.idle` plugin to `<config-dir>/plugin/gocode-notify.js`.
-//      OpenCode has NO stop-hook command array; instead a plugin subscribes to
-//      the `session.idle` event (the OpenCode equivalent of Cursor `stop` /
-//      Claude `Stop`) and fires the SHARED `on-stop` dispatcher:
-//        gocode-notify on-stop --source opencode --dedupe-key opencode-idle || true
-//      The child is detached + unref'd and errors are swallowed (`|| true`), so a
-//      notification/push failure can never block the session — exactly one ping
-//      per idle, in lockstep with Claude/Cursor (same `on-stop` dispatcher).
+//   2. WRITE an event plugin to `<config-dir>/plugin/gocode-notify.js` that
+//      subscribes to TWO event classes:
+//        a) END-OF-TURN — `session.idle` (legacy) + `session.status` (modern),
+//           the OpenCode equivalent of Cursor `stop` / Claude `Stop`. Fires the
+//           SHARED `on-stop` dispatcher → a `finished` ping.
+//        b) QUESTION — `permission.asked` (the "asking now" edge), the OpenCode
+//           equivalent of Claude's `Notification` hook. Fires a plain
+//           `awaiting_input` ping ("Agent needs you") so a real question shows as
+//           a QUESTION, not a misleading `finished`. (Cursor has NO such event;
+//           OpenCode genuinely exposes it via permission events. We do NOT listen
+//           to permission.updated/replied — those also fire after the user
+//           answers and would re-ping a resolved question.)
+//      Each child is detached + unref'd and errors are swallowed (`|| true`), so a
+//      notification/push failure can never block the session.
 //
 // The on-demand rule/skill (Claude SKILL.md / Cursor rule) is SKIPPED for
 // OpenCode: OpenCode has no auto-loaded standalone per-file rule mechanism (the
@@ -72,6 +78,21 @@ export const OPENCODE_MCP_ENTRY = {
 // 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";
+/**
+ * The shell command the plugin fires when OpenCode raises a PERMISSION request —
+ * the OpenCode equivalent of "the agent needs the user" (Claude's `Notification`
+ * hook / the Cursor AskQuestion hook). Unlike Cursor, OpenCode genuinely exposes
+ * this signal: the `permission.asked` event fires the instant the agent pauses to
+ * ask the user to approve/answer something. We map it to a plain `awaiting_input`
+ * ping ("Agent needs you") — the SAME kind Claude Code fires — so a real question
+ * surfaces as a QUESTION notification, not a misleading `finished`. (We listen to
+ * `permission.asked` ONLY, never `permission.updated`/`permission.replied`, which
+ * also fire AFTER the user answers and would re-ping a resolved question.)
+ *
+ * Ends in `|| true` so a failed push can never block the session; carries a
+ * distinct `--dedupe-key` so it coalesces with itself but not with the idle ping.
+ */
+export const OPENCODE_ASK_COMMAND = 'npx -y @trygocode/notify@latest send --kind awaiting_input --source opencode --title "Agent needs you" --dedupe-key opencode-permission || 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
@@ -157,13 +178,15 @@ import { spawn } from "node:child_process";
 // Per-session last-fire timestamps so idle+status for the SAME turn coalesce.
 const lastFiredAt = new Map();
 const DEDUPE_MS = 4000;
+// Separate per-session debounce for permission/question events so a rapid burst
+// of permission.asked events for one prompt coalesces into a single ping, while
+// staying INDEPENDENT of the end-of-turn debounce (a question must not be
+// suppressed by a recent finished ping — different event class).
+const lastAskedAt = new Map();
 
-function fire() {
+function fire(command) {
   try {
-    const child = spawn(
-      ${JSON.stringify(OPENCODE_STOP_COMMAND)},
-      { shell: true, detached: true, stdio: "ignore" },
-    );
+    const child = spawn(command, { shell: true, detached: true, stdio: "ignore" });
     child.unref();
   } catch {
     // never block the session on a notification failure
@@ -195,13 +218,39 @@ function maybeFire(sessionID) {
   const prev = lastFiredAt.get(key) ?? 0;
   if (now - prev < DEDUPE_MS) return; // coalesce idle+status for one turn
   lastFiredAt.set(key, now);
-  fire();
+  fire(${JSON.stringify(OPENCODE_STOP_COMMAND)});
+}
+
+// The agent paused to ask the user (permission.asked). Fire an "Agent needs
+// you" question ping. Debounced separately from the end-of-turn ping so a burst
+// of asks for one prompt coalesces into one.
+function maybeAsk(sessionID) {
+  const key = sessionID || "_";
+  const now = Date.now();
+  const prev = lastAskedAt.get(key) ?? 0;
+  if (now - prev < DEDUPE_MS) return;
+  lastAskedAt.set(key, now);
+  fire(${JSON.stringify(OPENCODE_ASK_COMMAND)});
 }
 
 export const GocodeNotify = async () => ({
   event: async ({ event }) => {
     if (!event) return;
     const props = event.properties ?? {};
+    // QUESTION signal — the agent is waiting on the user (OpenCode's real
+    // "needs you" event; Cursor has no equivalent). Fired BEFORE the idle/status
+    // checks so a permission request is never misread as a plain end-of-turn.
+    //
+    // We listen ONLY to \`permission.asked\` — the moment the agent RAISES a
+    // request. We deliberately do NOT listen to \`permission.updated\` /
+    // \`permission.replied\`: those are state transitions that ALSO fire AFTER the
+    // user answers, which would re-emit "Agent needs you" once the question is
+    // already resolved — exactly the false-notification class this fix exists to
+    // avoid. \`permission.asked\` is the unambiguous "asking now" edge.
+    if (event.type === "permission.asked") {
+      maybeAsk(props.sessionID);
+      return;
+    }
     if (event.type === "session.idle") {
       maybeFire(props.sessionID);
       return;
@@ -332,7 +381,7 @@ export async function writeOpenCodeConfig(runtime, opts) {
             runtime: name,
             written,
             skipped: false,
-            detail: "merged mcp.gocode-notify entry; wrote session.idle plugin (rule skipped — OpenCode has no standalone rule file)",
+            detail: "merged mcp.gocode-notify entry; wrote end-of-turn + permission(question) plugin (rule skipped — OpenCode has no standalone rule file)",
         };
     }
     catch (err) {

package/dist/src/settings.js

@@ -47,6 +47,12 @@ export const DEFAULT_NOTIFY_SETTINGS = {
         command: null,
         max_diff_bytes: 61440,
     },
+    // Branded desktop banners ON by default (PRD §3): installing the package opts
+    // you into computer notifications; flip `desktop.enabled false` to silence.
+    desktop: {
+        enabled: true,
+        sound: true,
+    },
 };
 /**
  * Every dotted setting key the CLI accepts in `config set <key> <value>`, with
@@ -74,6 +80,9 @@ export const KEY_SPECS = {
     "commit_message.mode": { kind: "enum", enumValues: ["auto", "ai", "deterministic"] },
     "commit_message.command": { kind: "string_or_null" },
     "commit_message.max_diff_bytes": { kind: "int_pos" },
+    // Branded desktop banners (GOCODE_NOTIFY_DESKTOP PRD §3) — ON by default.
+    "desktop.enabled": { kind: "boolean" },
+    "desktop.sound": { kind: "boolean" },
 };
 /** Sorted list of every valid `config set` key — for help text + error messages. */
 export function validKeys() {

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trygocode/notify",
-  "version": "0.3.4",
-  "description": "Free phone notifications for any coding agent (Cursor, Claude Code, OpenCode, Ralph/Homer) via the GoCode app.",
+  "version": "0.5.0",
+  "description": "Free phone + branded desktop notifications for any coding agent (Cursor, Claude Code, OpenCode, Ralph/Homer) via the GoCode app.",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/src",
+    "assets",
     "snippets",
     "README.md"
   ],
@@ -26,6 +27,8 @@
     "notifications",
     "push",
     "fcm",
+    "desktop-notifications",
+    "toast",
     "mcp",
     "cli",
     "claude-code",