cdx-manager 0.15.0 → 0.16.0

package/src/cli.py

@@ -5,6 +5,7 @@ import os
 import sys
 from datetime import datetime, timezone
 
+from .agent_notify import handle_notify
 from .cli_commands import (
     API_SCHEMA_VERSION,
     STATUS_USAGE,
@@ -34,7 +35,7 @@ from .cli_commands import (
     handle_logout,
     handle_memory,
     handle_next,
-    handle_notify,
+    handle_ready,
     handle_remove,
     handle_rename,
     handle_repair,
@@ -258,8 +259,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx view [--json]', '36', use_color)}",
         f"  {_style('cdx update [all] [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
         f"  {_style('cdx ready [--refresh] [--json]', '36', use_color)}",
-        f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
-        f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",
+        f"  {_style('cdx notify', '36', use_color)}  # hook target, called by the provider",
         f"  {_style('cdx <name> [--json]', '36', use_color)}",
         f"  {_style('cdx --help', '36', use_color)}",
         f"  {_style('cdx --version', '36', use_color)}",
@@ -576,9 +576,7 @@ def main(argv, options=None):
     }
 
     if resolved_command == "ready":
-        if any(arg not in ("--refresh", "--json") for arg in rest):
-            raise CdxError("Usage: cdx ready [--refresh] [--json]")
-        return handle_notify(["--next-ready", "--schedule", *rest], ctx)
+        return handle_ready(rest, ctx)
 
     if resolved_command in ("power", "perm", "fast", "model"):
         return handle_launch_setting_alias(resolved_command, rest, ctx)

package/src/cli_args.py

@@ -248,6 +248,7 @@ def _parse_set_args(args):
         "--fast": {"key": "fast", "type": "str", "default": None, "transform": _parse_fast_value},
         "--rtk": {"key": "rtk", "type": "str", "default": None, "transform": _parse_fast_value},
         "--logics": {"key": "logics", "type": "str", "default": None, "transform": _parse_fast_value},
+        "--notify": {"key": "notify", "type": "str", "default": None, "transform": _parse_fast_value},
         "--model": {"key": "model", "type": "str", "default": None},
         "--fallback-model": {"key": "fallback_model", "type": "str", "default": None},
         "--budget": {"key": "budget", "type": "str", "default": None, "transform": _parse_budget_value},
@@ -269,7 +270,7 @@ def _parse_set_args(args):
         raise CdxError(SET_USAGE)
     settings = {
         key: parsed[key]
-        for key in ("power", "permission", "fast", "rtk", "logics", "model", "fallback_model", "budget", "extra_args", "priority")
+        for key in ("power", "permission", "fast", "rtk", "logics", "notify", "model", "fallback_model", "budget", "extra_args", "priority")
         if parsed[key] is not None
     }
     if not settings:
@@ -291,6 +292,7 @@ def _parse_unset_args(args):
         "--fast": {"key": "fast", "type": "bool", "default": False},
         "--rtk": {"key": "rtk", "type": "bool", "default": False},
         "--logics": {"key": "logics", "type": "bool", "default": False},
+        "--notify": {"key": "notify", "type": "bool", "default": False},
         "--model": {"key": "model", "type": "bool", "default": False},
         "--fallback-model": {"key": "fallback_model", "type": "bool", "default": False},
         "--budget": {"key": "budget", "type": "bool", "default": False},
@@ -312,7 +314,7 @@ def _parse_unset_args(args):
     if not parsed["names"] and not parsed["sessions"] and not parsed["provider"]:
         raise CdxError(UNSET_USAGE)
     _UNSET_KEYS = (
-        "power", "reasoning_effort", "permission", "fast", "rtk", "logics",
+        "power", "reasoning_effort", "permission", "fast", "rtk", "logics", "notify",
         "model", "fallback_model", "budget", "extra_args", "priority",
     )
     keys = list(_UNSET_KEYS) if parsed["all"] else [key for key in _UNSET_KEYS if parsed[key]]

package/src/cli_commands.py

@@ -48,7 +48,7 @@ from .commands.auth import (
     handle_logout as handle_logout,
 )
 from .commands.auth import (
-    handle_notify as handle_notify,
+    handle_ready as handle_ready,
 )
 from .commands.auth import (
     handle_reset as handle_reset,

package/src/cli_helpers.py

@@ -486,6 +486,7 @@ def _format_launch_config(session, use_color=False):
         ("fast", "Fast"),
         ("rtk", "RTK"),
         ("logics", "Logics"),
+        ("notify", "Notify"),
         ("model", "Model"),
         ("fallback_model", "Fallback"),
         ("budget", "Budget"),
@@ -508,17 +509,19 @@ def _format_launch_config(session, use_color=False):
 def _format_launch_settings_hint(name="<name>"):
     return (
         f"Set a value: cdx set {name} --power medium --permission auto "
-        "--fast on --rtk on --logics on --model MODEL --priority 80"
+        "--fast on --rtk on --logics on --notify on --model MODEL --priority 80"
     )
 
 def _format_launch_setting_value(launch, key, use_color=False):
-    if key in ("fast", "rtk", "logics"):
+    if key in ("fast", "rtk", "logics", "notify"):
         if launch.get(key) is True:
             return _style("on", "32", use_color)
         if launch.get(key) is False:
             return _style("off", "2", use_color)
         if key == "logics":
             return _dim("auto", use_color)
+        if key == "notify":
+            return _style("off", "2", use_color)
         return _dim("default", use_color)
     value = launch.get(key)
     if value is None or value == "":

package/src/commands/auth.py

@@ -1,4 +1,4 @@
-"""Authentication domain commands: login, logout, reset, notify.
+"""Authentication domain commands: login, logout, reset, ready.
 
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
@@ -20,13 +20,11 @@ from ..codex_usage import consume_codex_rate_limit_reset_credit
 from ..config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from ..errors import CdxError
 from ..notify import (
-    format_notify_event,
     format_scheduled_notification,
-    parse_notify_args,
+    parse_ready_args,
     resolve_notify_event,
     schedule_notification_event,
     send_desktop_notification,
-    wait_for_notification_event,
 )
 from ..provider_runtime import _ensure_session_authentication, _run_interactive_provider_command
 
@@ -35,61 +33,46 @@ def _confirm_reset(name):
     answer = input(f"Consume one banked Codex reset for {name}? [y/N] ")
     return answer.strip().lower() in ("y", "yes")
 
-def handle_notify(rest, ctx):
-    parsed = parse_notify_args(rest)
+def handle_ready(rest, ctx):
+    """`cdx ready`: schedule an OS notification for the next session to come back.
 
-    def notifier(title, message):
+    This is all that remains of the quota-reset flow: `cdx notify` now means
+    agent notifications, and the wait-and-poll surface that used to sit here was
+    unreachable once `cdx ready` became the only entry point.
+    """
+    parsed = parse_ready_args(rest)
+    event = resolve_notify_event(
+        ctx["service"]["get_status_rows"](
+            progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
+            force_refresh=parsed["refresh"],
+        ),
+        parsed,
+        (ctx["options"].get("now") or time.time)(),
+    )
+    if event["ready"]:
         send_desktop_notification(
-            title,
-            message,
-            spawn_sync=ctx.get("spawn_sync"),
-            env=ctx.get("env"),
+            event["title"], event["message"],
+            spawn_sync=ctx.get("spawn_sync"), env=ctx.get("env"),
         )
-
-    if parsed["schedule"]:
-        event = resolve_notify_event(
-            ctx["service"]["get_status_rows"](
-                progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
-                force_refresh=parsed.get("refresh", False),
-            ),
+        schedule = {
+            "scheduled": False,
+            "backend": "immediate",
+            "message": event["message"],
+            "target_timestamp": event.get("target_timestamp"),
+        }
+    else:
+        schedule = schedule_notification_event(
+            ctx["service"]["base_dir"],
             parsed,
-            (ctx["options"].get("now") or time.time)(),
+            event,
+            spawn_sync=ctx.get("spawn_sync"),
+            env=ctx.get("env"),
+            now_fn=ctx["options"].get("now"),
         )
-        if event["ready"]:
-            notifier(event["title"], event["message"])
-            schedule = {
-                "scheduled": False,
-                "backend": "immediate",
-                "message": event["message"],
-                "target_timestamp": event.get("target_timestamp"),
-            }
-        else:
-            schedule = schedule_notification_event(
-                ctx["service"]["base_dir"],
-                parsed,
-                event,
-                spawn_sync=ctx.get("spawn_sync"),
-                env=ctx.get("env"),
-                now_fn=ctx["options"].get("now"),
-            )
-        if parsed["json"]:
-            _write_json(ctx, _json_success("notify", "Scheduled notification event", event=event, schedule=schedule))
-        else:
-            ctx["out"](f"{format_scheduled_notification(schedule)}\n")
-        return 0
-
-    event = wait_for_notification_event(
-        ctx["service"],
-        parsed,
-        notifier=notifier,
-        sleep_fn=ctx["options"].get("sleep"),
-        now_fn=ctx["options"].get("now"),
-        progress_callback=None if parsed["json"] else _make_notify_progress(ctx),
-    )
     if parsed["json"]:
-        _write_json(ctx, _json_success("notify", "Resolved notification event", event=event))
+        _write_json(ctx, _json_success("notify", "Scheduled notification event", event=event, schedule=schedule))
     else:
-        ctx["out"](f"{format_notify_event(event)}\n")
+        ctx["out"](f"{format_scheduled_notification(schedule)}\n")
     return 0
 
 def handle_reset(rest, ctx):

package/src/commands/launch.py

@@ -6,6 +6,7 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 import os
 import shlex
 
+from ..agent_notify import notifications_enabled, provision
 from ..cli_args import CAN_RESUME_USAGE, HANDOFF_USAGE, RESUME_USAGE, _parse_json_flag
 from ..cli_helpers import (
     API_SCHEMA_VERSION,
@@ -21,9 +22,10 @@ from ..cli_helpers import (
     _write_update_notice,
 )
 from ..cli_render import _dim, _info, _success, _warn
+from ..config import PROVIDER_CODEX
 from ..context_store import install_context_for_session, write_context
 from ..errors import CdxError
-from ..provider_runtime import _ensure_session_authentication, _run_interactive_provider_command
+from ..provider_runtime import _ensure_session_authentication, _get_auth_home, _run_interactive_provider_command
 
 
 def _format_resume_capability(capability, use_color=False):
@@ -108,6 +110,23 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
         _write_update_notice(ctx)
+    installed = provision(
+        _get_auth_home(session),
+        session["provider"],
+        notifications_enabled(session),
+        ctx.get("env"),
+        spawn_sync=ctx.get("spawn_sync"),
+        base_dir=ctx["service"]["base_dir"],
+    )
+    if installed and not json_flag:
+        notice = f"Notification hooks installed for {session['name']}"
+        if session["provider"] == PROVIDER_CODEX:
+            # Codex refuses to run a hook it has not been told to trust, so
+            # silence here would leave the user with a feature that quietly does
+            # nothing. Claude Code honours them straight away — verified against
+            # a real turn — so it gets no instruction it does not need.
+            notice += " — approve them once in Codex to enable"
+        ctx["out"](f"{_info(notice, ctx['use_color'])}\n")
     cwd = ctx.get("cwd") or os.getcwd()
     runtime_run_id = None
 

package/src/notify.py

@@ -10,126 +10,51 @@ from .errors import CdxError
 from .session_ranking import rank_sessions
 from .status_view import (
     PRIORITY_EMPTY_AVAILABLE_THRESHOLD,
-    _parse_reset_timestamp,
     _priority_reset_timestamp,
 )
 
-NOTIFY_USAGE = "Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]"
-
-
-def parse_notify_args(args):
-    json_flag = "--json" in args
-    once = "--once" in args
-    at_reset = "--at-reset" in args
-    next_ready = "--next-ready" in args
-    refresh = "--refresh" in args
-    schedule = "--schedule" in args
-    poll = 60
-    cleaned = []
-    i = 0
-    while i < len(args):
-        arg = args[i]
-        if arg in ("--json", "--once", "--at-reset", "--next-ready", "--refresh", "--schedule"):
-            i += 1
-            continue
-        if arg == "--poll":
-            if i + 1 >= len(args):
-                raise CdxError(NOTIFY_USAGE)
-            try:
-                poll = max(1, int(args[i + 1]))
-            except ValueError as error:
-                raise CdxError("--poll must be a number of seconds") from error
-            i += 2
-            continue
-        if arg.startswith("--poll="):
-            try:
-                poll = max(1, int(arg.split("=", 1)[1]))
-            except ValueError as error:
-                raise CdxError("--poll must be a number of seconds") from error
-            i += 1
-            continue
-        if arg.startswith("-"):
-            raise CdxError(NOTIFY_USAGE)
-        cleaned.append(arg)
-        i += 1
-    if at_reset == next_ready:
-        raise CdxError(NOTIFY_USAGE)
-    if at_reset and len(cleaned) != 1:
-        raise CdxError("Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh]")
-    if next_ready and cleaned:
-        raise CdxError("Usage: cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]")
-    return {
-        "name": cleaned[0] if cleaned else None,
-        "mode": "at-reset" if at_reset else "next-ready",
-        "poll": poll,
-        "once": once,
-        "json": json_flag,
-        "refresh": refresh,
-        "schedule": schedule,
-    }
+READY_USAGE = "Usage: cdx ready [--refresh] [--json]"
 
 
-def wait_for_notification_event(service, parsed, notifier=None, sleep_fn=None, now_fn=None, progress_callback=None):
-    notifier = notifier or send_desktop_notification
-    sleep_fn = sleep_fn or time.sleep
-    now_fn = now_fn or time.time
-    while True:
-        if progress_callback:
-            progress_callback({"event": "notify_check_started", "mode": parsed["mode"], "session_name": parsed["name"]})
-        event = resolve_notify_event(
-            service["get_status_rows"](
-                progress_callback=progress_callback,
-                force_refresh=parsed.get("refresh", False),
-            ),
-            parsed,
-            now_fn(),
-        )
-        if event["ready"] or parsed["once"]:
-            if event["ready"]:
-                notifier(event["title"], event["message"])
-            return event
-        if progress_callback:
-            progress_callback({
-                "event": "notify_waiting",
-                "message": event["message"],
-                "poll": parsed["poll"],
-                "session_name": event.get("session"),
-                "target_timestamp": event.get("target_timestamp"),
-            })
-        sleep_fn(parsed["poll"])
+def parse_ready_args(args):
+    """`cdx ready [--refresh] [--json]`.
+
+    This used to parse a much wider surface — --at-reset, --once, --poll and a
+    blocking wait loop — reachable through a `cdx notify` that no longer exists.
+    `cdx ready` always schedules the next-ready event, so none of it could run.
+    """
+    unknown = [arg for arg in args if arg not in ("--refresh", "--json")]
+    if unknown:
+        raise CdxError(READY_USAGE)
+    return {
+        "name": None,
+        "mode": "next-ready",
+        "json": "--json" in args,
+        "refresh": "--refresh" in args,
+        "schedule": True,
+    }
 
 
 def resolve_notify_event(rows, parsed, now_ts=None):
     now_ts = time.time() if now_ts is None else now_ts
-    if parsed["mode"] == "next-ready":
-        active_rows = [row for row in rows if row.get("enabled", True) is not False]
-        # Same ranking every other selector uses; the pre-filter is what makes
-        # this "next to come back" rather than "best right now".
-        priority, _decision = rank_sessions(
-            [
-                row for row in active_rows
-                if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
-            ],
-            now_ts,
-            _priority_reset_timestamp,
-        )
-        if not priority:
-            return _event(False, "cdx", "No upcoming session reset available", None)
-        first = priority[0]
-        timestamp = _priority_reset_timestamp(first)
-        if _needs_refresh(first, timestamp, now_ts):
-            return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
-        return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
-
-    row = next((item for item in rows if item["session_name"] == parsed["name"]), None)
-    if not row:
-        raise CdxError(f"Unknown session: {parsed['name']}")
-    timestamp = _next_reset_timestamp(row)
-    if timestamp is None:
-        return _event(False, "cdx", f"No reset time known for {row['session_name']}", row["session_name"])
-    if timestamp <= now_ts:
-        return _event(True, "cdx", f"{row['session_name']} reset is due", row["session_name"], timestamp)
-    return _event(False, "cdx", f"Waiting for {row['session_name']} reset", row["session_name"], timestamp)
+    active_rows = [row for row in rows if row.get("enabled", True) is not False]
+    # Same ranking every other selector uses; the pre-filter is what makes
+    # this "next to come back" rather than "best right now".
+    priority, _decision = rank_sessions(
+        [
+            row for row in active_rows
+            if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
+        ],
+        now_ts,
+        _priority_reset_timestamp,
+    )
+    if not priority:
+        return _event(False, "cdx", "No upcoming session reset available", None)
+    first = priority[0]
+    timestamp = _priority_reset_timestamp(first)
+    if _needs_refresh(first, timestamp, now_ts):
+        return _event(True, "cdx", f"{first['session_name']} reset is due; refresh status", first["session_name"])
+    return _event(False, "cdx", f"Waiting for {first['session_name']}", first["session_name"], timestamp)
 
 
 def _is_usable_now(row):
@@ -144,18 +69,6 @@ def _needs_refresh(row, reset_timestamp, now_ts):
     return reset_timestamp is not None and reset_timestamp < now_ts
 
 
-def _next_reset_timestamp(row):
-    values = [row.get("reset_5h_at"), row.get("reset_week_at"), row.get("reset_at")]
-    timestamps = [
-        timestamp
-        for timestamp in (_parse_reset_timestamp(value) for value in values)
-        if timestamp is not None
-    ]
-    if not timestamps:
-        return None
-    return min(timestamps)
-
-
 def _event(ready, title, message, session_name, target_timestamp=None):
     return {
         "ready": ready,
@@ -166,22 +79,70 @@ def _event(ready, title, message, session_name, target_timestamp=None):
     }
 
 
-def send_desktop_notification(title, message, spawn_sync=None, env=None):
+def notification_channel(env=None):
+    """Name the delivery mechanism usable on this host, or None if there is none.
+
+    Two callers depend on this answer: `cdx notify` decides whether to bother
+    delivering, and launch provisioning decides whether to install hooks at all.
+    A host with no channel gets no hooks, so the user is never asked to approve
+    a hook that could not have shown them anything.
+    """
     import sys
-    spawn_sync = spawn_sync or subprocess.run
     env = env or os.environ
+    path = env.get("PATH")
     if sys.platform == "win32":
-        _send_windows_notification(title, message, spawn_sync, env)
-    elif shutil.which("osascript", path=env.get("PATH")):
+        return "powershell" if shutil.which("powershell", path=path) else None
+    if _is_wsl(env):
+        # WSL has no notification daemon of its own; delivery crosses to Windows
+        # through interop, which /etc/wsl.conf can disable.
+        return "wsl" if shutil.which("powershell.exe", path=path) else None
+    if shutil.which("osascript", path=path):
+        return "osascript" if _has_desktop_session(env) else None
+    if shutil.which("notify-send", path=path):
+        return "notify-send" if _has_desktop_session(env) else None
+    return None
+
+
+def _is_wsl(env):
+    if env.get("WSL_DISTRO_NAME") or env.get("WSL_INTEROP"):
+        return True
+    try:
+        with open("/proc/version", encoding="utf-8") as handle:
+            return "microsoft" in handle.read().lower()
+    except OSError:
+        return False
+
+
+def _has_desktop_session(env):
+    """Whether anything is around to render a notification.
+
+    Over SSH or in a container there is no session bus and no display, so
+    notify-send is delivered nowhere and osascript has no session to talk to.
+    """
+    import sys
+    if sys.platform == "darwin":
+        return not env.get("SSH_CONNECTION")
+    return bool(env.get("DISPLAY") or env.get("WAYLAND_DISPLAY") or env.get("DBUS_SESSION_BUS_ADDRESS"))
+
+
+def send_desktop_notification(title, message, spawn_sync=None, env=None):
+    spawn_sync = spawn_sync or subprocess.run
+    env = env or os.environ
+    channel = notification_channel(env)
+    if channel == "powershell":
+        _send_windows_notification(title, message, spawn_sync, env, ["powershell"])
+    elif channel == "wsl":
+        _send_windows_notification(title, message, spawn_sync, env, ["powershell.exe"])
+    elif channel == "osascript":
         script = f'display notification "{_escape_applescript(message)}" with title "{_escape_applescript(title)}"'
         _run_notification_command(
             ["osascript", "-e", script],
             spawn_sync,
             env,
         )
-    elif shutil.which("notify-send", path=env.get("PATH")):
+    elif channel == "notify-send":
         _run_notification_command(
-            ["notify-send", str(title), str(message)],
+            ["notify-send", "-a", "cdx", str(title), str(message)],
             spawn_sync,
             env,
         )
@@ -190,26 +151,45 @@ def send_desktop_notification(title, message, spawn_sync=None, env=None):
 def _run_notification_command(argv, spawn_sync, env):
     try:
         spawn_sync(argv, env=env, capture_output=True, text=True, timeout=5)
-    except (FileNotFoundError, OSError):
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
         pass
 
 
-def _send_windows_notification(title, message, spawn_sync, env):
-    title_escaped = _escape_powershell(title)
-    message_escaped = _escape_powershell(message)
-    script = (
-        "Add-Type -AssemblyName System.Windows.Forms; "
-        f"[System.Windows.Forms.MessageBox]::Show('{message_escaped}', '{title_escaped}')"
+# Windows only shows a toast on behalf of an application it knows. Registering our
+# own identifier would mean installing a Start Menu shortcut, so we borrow the one
+# PowerShell already ships with; an unknown identifier is dropped in silence.
+_POWERSHELL_AUMID = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe"
+
+_TOAST_SCRIPT = """
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null
+[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType=WindowsRuntime] > $null
+$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+$nodes = $template.GetElementsByTagName('text')
+$nodes.Item(0).AppendChild($template.CreateTextNode('{title}')) > $null
+$nodes.Item(1).AppendChild($template.CreateTextNode('{message}')) > $null
+$toast = [Windows.UI.Notifications.ToastNotification]::new($template)
+[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('{aumid}').Show($toast)
+"""
+
+
+def _send_windows_notification(title, message, spawn_sync, env, launcher):
+    """Raise a toast rather than a dialog.
+
+    The dialog this replaced blocked with no timeout, which was survivable for a
+    once-a-day quota alert and not for a hook that fires on every agent turn: an
+    undismissed window holds the turn open, and one that steals focus every turn
+    is worse than no notification at all.
+    """
+    script = _TOAST_SCRIPT.format(
+        title=_escape_powershell(title),
+        message=_escape_powershell(message),
+        aumid=_POWERSHELL_AUMID,
+    )
+    _run_notification_command(
+        [*launcher, "-NoProfile", "-NonInteractive", "-Command", script],
+        spawn_sync,
+        env,
     )
-    try:
-        spawn_sync(
-            ["powershell", "-NoProfile", "-NonInteractive", "-Command", script],
-            env=env,
-            capture_output=True,
-            text=True,
-        )
-    except (FileNotFoundError, OSError):
-        pass
 
 
 def _escape_powershell(value):
@@ -437,10 +417,6 @@ def _escape_xml(value):
     return str(value).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
 
 
-def format_notify_event(event):
-    return event["message"]
-
-
 def format_scheduled_notification(schedule):
     if schedule.get("scheduled"):
         return f"Scheduled notification via {schedule['backend']} for {schedule['target_iso']}"

package/src/provider_runtime.py

@@ -10,6 +10,7 @@ import sys
 import uuid
 from datetime import datetime, timezone
 
+from .agent_notify import launch_notify_env, notifications_enabled
 from .claude_usage import _clean_oauth_token, _decode_jwt_claims
 from .codex_usage import codex_auth_lock
 from .config import (
@@ -517,6 +518,7 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
     cwd = cwd or os.getcwd()
     env_override = env_override or {}
     env = {**os.environ, **env_override}
+    env.update(launch_notify_env(session, notifications_enabled(session)))
     initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
     _validate_initial_prompt(initial_prompt)
     if session["provider"] == PROVIDER_CLAUDE:
@@ -724,6 +726,9 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
     _validate_initial_prompt(initial_prompt)
     cwd = cwd or os.getcwd()
     env = {**os.environ, **(env_override or {})}
+    # Headless runs read the same home, and so the same hooks, as an interactive
+    # launch. Their caller already learns of completion from the return value.
+    env.update(launch_notify_env(session, enabled=False))
     initial_prompt = _with_launch_preferences(session, initial_prompt, env=env)
     _validate_initial_prompt(initial_prompt)
     launch = session.get("launch") or {}