n2n-nexus 0.12.5 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.13.0] - 2026-11-15
+
+Upgrade the host and the client together for pi (the contract version stays 5: an older host answers a pi hook with 400, which the hook ignores, and Claude Code and Codex are not affected). The database is upgraded in place: keep `nexus.db`. An older host refuses the upgraded database.
+
+### Added
+
+- pi as a client: `n2n-nexus install pi` writes a pi extension (`~/.pi/agent/extensions/n2n-nexus.ts`, or under `$PI_CODING_AGENT_DIR`) that runs `n2n-nexus hook pi` on pi's session start, prompt, tool result, end of run and shutdown, continues a run when messages arrive during it and wakes an idle pi session through the background wait, and registers the MCP server with `pi mcp add`; `uninstall pi` removes both and `doctor pi` checks them. pi's MCP tool calls carry no session, so the MCP server started by pi names the processes above it (pi starts it through npx and a shell) and its machine, and the host attributes the call to the session the nearest pi process among them on that machine reported last.
+
+## [0.12.6] - 2026-11-10
+
+Upgrade the host and the client together (contract version 5), then run `n2n-nexus install <client>` again so the background wait hook gets its new timeout. The database is upgraded in place: keep `nexus.db`. An older host refuses the upgraded database.
+
+### Changed
+
+- Every direct message wakes its recipient: `send` and `reply` no longer take `wake`, so a sender cannot keep a message from waking an idle conversation or holding a working one's turn at its end. `expectsReply: false` only says that no reply is needed. Plain acknowledgements are still not to be sent. Broadcasts are unchanged.
+- The background wait that wakes an idle conversation lasts up to a day after its last turn instead of an hour (`waitHookTimeoutSec` 86400): the timeout of the Claude Code `--wait` hook and the deadline of the Codex wait.
+
+### Fixed
+
+- A background wait whose client was killed or crashed (no `SessionEnd`) no longer keeps the conversation `listening`, nor takes a wake for it: before each request (at most 590 s apart) the wait checks that Claude Code (`CLAUDE_PID`) or the Codex process that ran the Stop hook still runs and ends when it does not, and a wake that arrives after that is reported as not delivered, so the host announces its messages again instead of marking them read. Before, a Claude Code conversation killed with its wait still running lost the message that woke it.
+- The Codex wait stops trying `codex queue` after ten failures in a row (about 8.5 minutes) instead of until its deadline: Codex does not have the conversation loaded, and with a day's deadline a closed terminal (its app-server still running) would otherwise retry every 5 minutes all day. The messages stay unread for the user's next prompt.
+- `n2n-nexus doctor claude` reports a background wait hook whose timeout is not this client's (left by an older install) or that is missing.
+- A tool call that names neither a conversation nor an instance (no `instanceId` in `POST /api/tools/call`, no hooks) is refused by every tool that acts as someone: `send_message`, `start_meeting`, `end_meeting`, `archive_meeting`, `reopen_meeting`, `join_meeting`, `leave_meeting` and `stance`, as `read_messages` already was. Before, all such callers acted as one shared identity `unknown`, with one membership and one read cursor. The MCP adapter always sends `instanceId`.
+- Meeting messages that a tool call's notification announced (its context may be a sub-agent's) are no longer lost to the conversation: the member is told at its next prompt how many earlier messages of others are still unread, and an active member's turn continues once for them at its end, as for an earlier direct message still unread.
+- LAN discovery amplifies nothing: the query is padded to 512 bytes (`discoveryQueryBytes`), and the host answers only that datagram and never with more bytes than it got. Before, an 18-byte query got a reply of about 70 bytes sent to an unverified source address. An older client's query gets no answer, hence contract version 5.
+
 ## [0.12.5] - 2026-11-04
 
 Upgrade the host; the client needs no update for these tools (contract version 4). The database is upgraded in place: keep `nexus.db`. An older host refuses the upgraded database.

package/README.md

@@ -53,7 +53,7 @@ n2n-nexus gives AI assistants a shared coordination workspace. A long-running lo
 
 **Quick summary**
 
-- **Install**: the host `n2n-nexus-host` with Scoop / Homebrew / a Releases archive; the client with `npm i -g n2n-nexus@latest`, then `n2n-nexus install <claude|codex>`
+- **Install**: the host `n2n-nexus-host` with Scoop / Homebrew / a Releases archive; the client with `npm i -g n2n-nexus@latest`, then `n2n-nexus install <claude|codex|pi>`
 - **Protocol**: Model Context Protocol (MCP); the adapters reach the host over HTTP
 - **Storage**: one SQLite database in the host's data directory
 - **Good for**: multi-assistant coding sessions, project handoffs, shared decisions, meeting records, task tracking, project manifests
@@ -62,7 +62,7 @@ n2n-nexus gives AI assistants a shared coordination workspace. A long-running lo
 ## 🎯 Why use it?
 
 - Coordinate multiple AI assistants working on the same project.
-- Let Claude Code and Codex conversations message each other directly: a message arrives whole through the client's hooks, wakes a waiting conversation, and is answered with `reply`; each session shows the machine and environment it runs on.
+- Let Claude Code, Codex and pi conversations message each other directly: a message arrives whole through the client's hooks, wakes a waiting conversation, and is answered with `reply`; each session shows the machine and environment it runs on.
 - Hold meetings among assistants and keep their decisions. When you take part, your conversation holds the user's seat: you decide each draft and end the meeting, and the assistants' consensus is only reported.
 - Share project manifests, decisions, and assets across IDEs and machines.
 - Keep decisions, proposals, and updates in a local meeting and message log; old data is cleaned up after the retention you set.
@@ -87,13 +87,13 @@ n2n-nexus gives AI assistants a shared coordination workspace. A long-running lo
 
 - **The host is the source of truth**: install it once and keep it running, as a tray app or as a background service.
 - **MCP adapters are stateless**: each IDE starts an adapter (`n2n-nexus mcp`), which forwards tool calls to the host.
-- **Every Claude Code and Codex conversation has its own identity**: client hooks register the conversation with the host and deliver new direct messages and meeting messages to it; each tool call names its conversation through the request metadata the client attaches, never through model-supplied arguments.
+- **Every Claude Code, Codex and pi conversation has its own identity**: client hooks (for pi, an extension) register the conversation with the host and deliver new direct messages and meeting messages to it; each tool call names its conversation through the request metadata the client attaches (for pi, the pi process above the MCP server), never through model-supplied arguments.
 - **Cross-environment by design**: point `NEXUS_ENDPOINT` at the same host from different machines or shells. The host listens on `127.0.0.1` by default; turn on LAN access only on a trusted network.
 
 ## 🚀 Quick start
 
 1. Install and start the host, `n2n-nexus-host`, with Scoop, Homebrew or an archive from [Releases](https://github.com/n2ns/n2n-nexus/releases): [Installation guide, steps 1–2](docs/INSTALL.md#1-install-the-host).
-2. Install the client and connect Claude Code or Codex (`npm i -g n2n-nexus@latest`, then `n2n-nexus install claude` or `n2n-nexus install codex`): [step 3](docs/INSTALL.md#3-install-the-client-for-claude-code-and-codex).
+2. Install the client and connect Claude Code, Codex or pi (`npm i -g n2n-nexus@latest`, then `n2n-nexus install claude`, `n2n-nexus install codex` or `n2n-nexus install pi`): [step 3](docs/INSTALL.md#3-install-the-client-for-claude-code-codex-and-pi).
 3. Codex only: `install codex` trusts the n2n-nexus hooks in Codex; if it says it could not, trust them by hand: [step 4](docs/INSTALL.md#4-turn-on-the-codex-hooks-one-time-required).
 
 Other MCP clients and several machines: see the [Installation guide](docs/INSTALL.md). Using it, troubleshooting and configuration: see the [User guide](docs/USER_GUIDE.md).

package/build/cli/client-dirs.js

@@ -1,5 +1,5 @@
 /**
- * Where Claude Code and Codex keep their configuration. Node built-ins only:
+ * Where Claude Code, Codex and pi keep their configuration. Node built-ins only:
  * the hook command uses this to read a Codex conversation's title.
  */
 import os from "node:os";
@@ -10,3 +10,5 @@ export const claudeConfigDir = () => process.env.CLAUDE_CONFIG_DIR || path.join(
 export const claudeJsonDir = () => process.env.CLAUDE_CONFIG_DIR || os.homedir();
 /** Codex's hooks.json, config.toml and state databases: CODEX_HOME, else ~/.codex. */
 export const codexHome = () => process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+/** pi's agent directory (extensions, mcp.json, settings.json): PI_CODING_AGENT_DIR, else ~/.pi/agent. */
+export const piAgentDir = () => process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");

package/build/cli/client-process.js

@@ -0,0 +1,97 @@
+/**
+ * The client process a background wait would wake, so that the wait ends when
+ * it is gone instead of keeping the session listening: Claude Code names its
+ * own process in CLAUDE_PID; for Codex the Stop hook looks it up among its
+ * ancestors and hands it to the detached wait (`--client-pid`).
+ */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/** Shells a client may run a hook command through (Codex on Windows: PowerShell for commandWindows). */
+export const SHELL_NAMES = ["sh", "bash", "dash", "zsh", "fish", "powershell", "pwsh", "cmd"];
+/** Whether process `pid` runs (EPERM: it runs, as another user). */
+export function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** A positive integer process id, else undefined. */
+export function parsePid(value) {
+    const pid = Number(value);
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
+}
+/** The name (lower case) and parent of process `pid` on Linux or macOS; throws when it cannot be read. */
+function describe(pid) {
+    let name;
+    let ppid;
+    if (process.platform === "linux") {
+        // "<pid> (<comm>) <state> <ppid> ...": comm may hold spaces and parentheses.
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const close = stat.lastIndexOf(")");
+        name = stat.slice(stat.indexOf("(") + 1, close);
+        ppid = Number(stat.slice(close + 2).split(" ")[1]);
+    }
+    else {
+        const out = execFileSync("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { encoding: "utf8", timeout: 5000 }).trim();
+        const m = /^(\d+)\s+(.*)$/.exec(out);
+        if (!m)
+            throw new Error(`no process ${pid}`);
+        ppid = Number(m[1]);
+        name = path.basename(m[2]);
+    }
+    if (!Number.isSafeInteger(ppid) || ppid <= 0 || !name)
+        throw new Error(`no process ${pid}`);
+    return { name: name.toLowerCase(), ppid };
+}
+/** The most processes ancestorPids lists (contract/hook.json caller.clientPids maxItems). */
+const MAX_ANCESTORS = 16;
+/**
+ * This process's parent, its parent and so on up to (not including) init,
+ * nearest first; on Windows, or where a parent cannot be read, the list ends
+ * there. pi starts the MCP adapter through npx and a shell, so the pi process
+ * is one of them (the host finds it among them).
+ */
+export function ancestorPids() {
+    const pids = [process.ppid];
+    if (process.platform === "win32")
+        return pids;
+    try {
+        while (pids.length < MAX_ANCESTORS) {
+            const { ppid } = describe(pids[pids.length - 1]);
+            if (ppid <= 1 || pids.includes(ppid))
+                break;
+            pids.push(ppid);
+        }
+    }
+    catch {
+        // Not readable: the processes found so far.
+    }
+    return pids;
+}
+/**
+ * The process that ran this hook, past the shells it went through: the
+ * nearest ancestor that is not a shell; undefined when it cannot be told.
+ * Linux and macOS only: on Windows the PowerShell that starts the detached wait
+ * looks it up itself (hook.ts startDetached), saving a PowerShell of its own.
+ */
+export function hookClientPid() {
+    if (process.platform === "win32")
+        return undefined;
+    try {
+        let pid = process.ppid;
+        for (let hops = 0; hops < 4; hops++) {
+            const { name, ppid } = describe(pid);
+            if (!SHELL_NAMES.includes(name))
+                return pid;
+            pid = ppid;
+        }
+    }
+    catch {
+        // Not readable: the wait runs without the check.
+    }
+    return undefined;
+}

package/build/cli/doctor.js

@@ -1,6 +1,6 @@
 /**
- * `n2n-nexus doctor [claude|codex]`: check that the Node path and the entry
- * script in the hook commands, and the Node path and npm's npx script in the
+ * `n2n-nexus doctor [claude|codex|pi]`: check that the Node path and the entry
+ * script in the hook commands (for pi, in its extension file), and the Node path and npm's npx script in the
  * MCP server command (`"<node>" "<npx>" -y n2n-nexus@latest mcp`), that
  * `install` wrote still exist and run, that the host those commands talk to answers
  * GET /health as n2n-nexus-host with this client's contract version, that
@@ -10,13 +10,14 @@
  * check failed.
  */
 import fs from "node:fs";
-import { CONTRACT_VERSION, HOOK_CLIENTS, MCP_SERVER_NAME, isHookClient, noDaemonHint } from "../contract.js";
+import { CONTRACT_VERSION, HOOK_CLIENTS, MCP_SERVER_NAME, WAIT_HOOK_TIMEOUT_SEC, isHookClient, noDaemonHint } from "../contract.js";
 import { NexusClient, NexusToolError } from "../client/nexus-client.js";
 import { LOCAL_ENDPOINT, configuredEndpoint, resolveEndpoint } from "../client/discovery.js";
 import { pkg } from "../config/index.js";
-import { hookEndpoint, ourCommands, parseHookCommand } from "./hook-command.js";
+import { hookEndpoint, isOurs, ourCommands, parseHookCommand } from "./hook-command.js";
 import { MCP_PACKAGE, VERSIONED_NODE_DIR, configFile, probeNode, readConfig } from "./install.js";
 import { mcpConfigFile, readMcpCommand } from "./mcp-config.js";
+import { PI_EXTENSION_MARK, piExtensionFile, readPiExtension, readPiExtensionFile } from "./pi.js";
 const ok = (text) => ({ ok: true, text });
 const bad = (text) => ({ ok: false, text });
 const VERSIONED_NOTE = "in a version directory that an upgrade may remove";
@@ -53,6 +54,28 @@ export async function checkHost(endpoint) {
     }
     return ok(`n2n-nexus-host ${version}, contract version ${CONTRACT_VERSION}`);
 }
+/**
+ * Claude's background wait hook (the Stop hook running `hook claude --wait`)
+ * must be an asyncRewake hook with this client's timeout: the wait ends just
+ * before WAIT_HOOK_TIMEOUT_SEC, and a shorter timeout written by an older
+ * install kills it earlier, possibly while it hands over a wake.
+ */
+function checkClaudeWait(config) {
+    const groups = config.hooks?.Stop;
+    for (const group of Array.isArray(groups) ? groups : []) {
+        for (const entry of Array.isArray(group?.hooks) ? group.hooks : []) {
+            if (!isOurs(entry, "claude") || !entry.command.endsWith(" --wait"))
+                continue;
+            const { asyncRewake, timeout } = entry;
+            if (asyncRewake !== true)
+                return bad("not an asyncRewake hook");
+            if (timeout !== WAIT_HOOK_TIMEOUT_SEC)
+                return bad(`timeout ${String(timeout)} s, this client needs ${WAIT_HOOK_TIMEOUT_SEC} s`);
+            return ok(`timeout ${WAIT_HOOK_TIMEOUT_SEC} s`);
+        }
+    }
+    return bad("missing");
+}
 /** Check the host at each endpoint; prints the report and returns whether all passed. */
 async function doctorHosts(endpoints) {
     let passed = true;
@@ -70,7 +93,72 @@ async function doctorHosts(endpoints) {
  * Check one client; prints the report and returns whether everything passed, or undefined when nothing is installed.
  * Adds the endpoints its hook and MCP commands use to `endpoints`, falling back to defaultEndpoint.
  */
+/** The MCP server registration of `client`: whether there is one (reported), and the endpoints it names. */
+function doctorMcp(client, endpoints, defaultEndpoint, report, mcp) {
+    const mcpFile = mcpConfigFile(client);
+    if (!mcp) {
+        report(`MCP server ${MCP_SERVER_NAME} in ${mcpFile}`, bad("not registered"));
+        return;
+    }
+    endpoints.add(mcp.endpoint === undefined ? defaultEndpoint : mcp.endpoint || LOCAL_ENDPOINT);
+    report(`MCP Node ${mcp.command}`, checkNode(mcp.command));
+    const [npx, ...rest] = mcp.args;
+    if (npx && rest.join(" ") === `-y ${MCP_PACKAGE} mcp`)
+        report(`MCP npx ${npx}`, checkEntry(npx));
+    else
+        report(`MCP command in ${mcpFile}`, bad(`not in the form "<node>" "<npx>" -y ${MCP_PACKAGE} mcp`));
+}
+/** pi: the extension file that carries the hooks, and the MCP server. */
+function doctorPi(endpoints, defaultEndpoint) {
+    const file = piExtensionFile();
+    const mcp = readMcpCommand("pi", mcpConfigFile("pi"));
+    const text = readPiExtensionFile(file);
+    if (text === undefined && !mcp)
+        return undefined;
+    const lines = [];
+    let failed = false;
+    let versioned = false;
+    const report = (label, check) => {
+        lines.push(`  ${check.ok ? "ok  " : "FAIL"} ${label}: ${check.text}`);
+        if (!check.ok)
+            failed = true;
+        if (check.text.includes(VERSIONED_NOTE))
+            versioned = true;
+    };
+    lines.push("pi");
+    if (text === undefined) {
+        report(`extension in ${file}`, bad("not installed"));
+    }
+    else if (!text.startsWith(PI_EXTENSION_MARK)) {
+        report(`extension in ${file}`, bad("not written by n2n-nexus"));
+    }
+    else {
+        const command = readPiExtension(text);
+        if (!command) {
+            report(`extension in ${file}`, bad("its Node path and entry script cannot be read"));
+        }
+        else {
+            if (command.endpoint)
+                endpoints.add(command.endpoint);
+            else
+                endpoints.add(defaultEndpoint);
+            report(`extension Node ${command.node}`, checkNode(command.node));
+            report(`extension entry ${command.entry}`, checkEntry(command.entry));
+        }
+    }
+    doctorMcp("pi", endpoints, defaultEndpoint, report, mcp);
+    if (failed) {
+        lines.push(`  fix: run "n2n-nexus install pi" again (add --node <path> to use a stable Node path such as /usr/local/bin/node).`);
+    }
+    else if (versioned) {
+        lines.push(`  note: after upgrading Node, run "n2n-nexus install pi" again, or install with --node <path> pointing at a stable entry such as /usr/local/bin/node.`);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+    return !failed;
+}
 function doctorClient(client, endpoints, defaultEndpoint) {
+    if (client === "pi")
+        return doctorPi(endpoints, defaultEndpoint);
     const hooksFile = configFile(client);
     const mcpFile = mcpConfigFile(client);
     const lines = [];
@@ -83,7 +171,8 @@ function doctorClient(client, endpoints, defaultEndpoint) {
         if (check.text.includes(VERSIONED_NOTE))
             versioned = true;
     };
-    const commands = ourCommands(readConfig(hooksFile), client);
+    const config = readConfig(hooksFile);
+    const commands = ourCommands(config, client);
     const mcp = readMcpCommand(client, mcpFile);
     if (commands.size === 0 && !mcp)
         return undefined;
@@ -101,18 +190,9 @@ function doctorClient(client, endpoints, defaultEndpoint) {
         report(`hook Node ${parsed.node}`, checkNode(parsed.node));
         report(`hook entry ${parsed.entry}`, checkEntry(parsed.entry));
     }
-    if (!mcp) {
-        report(`MCP server ${MCP_SERVER_NAME} in ${mcpFile}`, bad("not registered"));
-    }
-    else {
-        endpoints.add(mcp.endpoint === undefined ? defaultEndpoint : mcp.endpoint || LOCAL_ENDPOINT);
-        report(`MCP Node ${mcp.command}`, checkNode(mcp.command));
-        const [npx, ...rest] = mcp.args;
-        if (npx && rest.join(" ") === `-y ${MCP_PACKAGE} mcp`)
-            report(`MCP npx ${npx}`, checkEntry(npx));
-        else
-            report(`MCP command in ${mcpFile}`, bad(`not in the form "<node>" "<npx>" -y ${MCP_PACKAGE} mcp`));
-    }
+    if (client === "claude" && commands.size > 0)
+        report(`background wait hook in ${hooksFile}`, checkClaudeWait(config));
+    doctorMcp(client, endpoints, defaultEndpoint, report, mcp);
     if (failed) {
         lines.push(`  fix: run "n2n-nexus install ${client}" again (add --node <path> to use a stable Node path such as /usr/local/bin/node).`);
     }
@@ -153,11 +233,11 @@ async function doctorCodexTrust() {
         + `  fix: run "n2n-nexus install codex" again, or ${MANUAL_TRUST}.\n`);
     return false;
 }
-/** Parse `[claude|codex]`, run the checks and return the exit code. */
+/** Parse `[claude|codex|pi]`, run the checks and return the exit code. */
 export async function runDoctor(argv) {
     const client = argv[0];
     if (client !== undefined && !isHookClient(client)) {
-        process.stderr.write("Usage: n2n-nexus doctor [claude|codex]\n");
+        process.stderr.write("Usage: n2n-nexus doctor [claude|codex|pi]\n");
         return 1;
     }
     try {

package/build/cli/hook.js

@@ -1,5 +1,5 @@
 /**
- * `n2n-nexus hook <claude|codex> [--endpoint <url>] [--wait]`: forward one client
+ * `n2n-nexus hook <claude|codex|pi> [--endpoint <url>] [--wait]`: forward one client
  * hook event to the daemon and print its output, or with `--wait` run the
  * background wait that wakes an idle conversation. Runs on every tool call, so
  * it loads only node built-ins (no MCP SDK or zod; node:sqlite only to read a
@@ -11,6 +11,7 @@ import path from "node:path";
 import { BACKGROUND_WAIT_EVENT, WAKE_RESULT_EVENT, HOOK_INPUT_FIELDS, HOOK_REQUEST_TIMEOUT_MS, HOOK_STOP_REQUEST_TIMEOUT_MS, SESSION_END_REQUEST_TIMEOUT_MS, WAIT_HOOK_TIMEOUT_SEC, WAKE_RETRY_FIRST_DELAY_MS, WAKE_RETRY_MAX_DELAY_MS, noDaemonHint, isHookClient } from "../contract.js";
 import { NexusClient, NexusTransportError, REQUEST_TIMEOUT_CODE } from "../client/nexus-client.js";
 import { DISCOVER_ENDPOINT, configuredEndpoint, resolveEndpoint } from "../client/discovery.js";
+import { SHELL_NAMES, hookClientPid, parsePid, processAlive } from "./client-process.js";
 import { machineInfo } from "./machine.js";
 import { readTitle } from "./title.js";
 /** Errors after which a discovered daemon is looked up again: it was never reached, so resending is safe. */
@@ -34,7 +35,7 @@ function argValue(argv, name) {
 function clientAndEndpoint(argv) {
     const client = argv[0];
     if (!isHookClient(client))
-        throw new Error(`unknown client "${client ?? ""}" (expected claude or codex)`);
+        throw new Error(`unknown client "${client ?? ""}" (expected claude, codex or pi)`);
     return { client, configured: configuredEndpoint(argValue(argv, "--endpoint")) };
 }
 /** Returns the text to print on stdout ("" for nothing); throws on any failure. */
@@ -56,6 +57,12 @@ async function forward(argv) {
     }
     // Every event says where the conversation runs; the host refuses one without it.
     input.machine = machineInfo();
+    // A pi process names itself (--client-pid, its extension passes it): tool calls from it find the session.
+    if (client === "pi") {
+        const pid = parsePid(argValue(argv, "--client-pid"));
+        if (pid !== undefined)
+            input.client_pid = pid;
+    }
     // SessionEnd must finish within Codex's 3 s hook limit (discovery included): a short budget and a single attempt.
     const sessionEnd = stdin.hook_event_name === "SessionEnd";
     const timeoutMs = stdin.hook_event_name === "Stop" ? HOOK_STOP_REQUEST_TIMEOUT_MS : sessionEnd ? SESSION_END_REQUEST_TIMEOUT_MS : HOOK_REQUEST_TIMEOUT_MS;
@@ -101,9 +108,10 @@ const WAIT_DEADLINE_MS = (WAIT_HOOK_TIMEOUT_SEC - 10) * 1000;
 const WAIT_RETRY_CODES = new Set([...UNREACHABLE_CODES, "ECONNRESET", "EPIPE", "ENOTFOUND", "EAI_AGAIN", REQUEST_TIMEOUT_CODE]);
 /**
  * Ask the daemon until something arrives for the session (the wake), the
- * session becomes active again or the deadline passes (null).
+ * session becomes active again, the deadline passes or, checked before each
+ * request, `stop` says the client is gone (null).
  */
-export async function waitForWake(client, sessionId, configured, deadlineMs = WAIT_DEADLINE_MS) {
+export async function waitForWake(client, sessionId, configured, deadlineMs = WAIT_DEADLINE_MS, stop = () => false) {
     const deadline = Date.now() + deadlineMs;
     let endpoint = await resolveEndpoint(configured);
     let delay = WAKE_RETRY_FIRST_DELAY_MS;
@@ -112,7 +120,7 @@ export async function waitForWake(client, sessionId, configured, deadlineMs = WA
         if (fresh)
             endpoint = await resolveEndpoint(configured, { fresh: true });
         const remaining = deadline - Date.now();
-        if (remaining <= 0)
+        if (remaining <= 0 || stop())
             return null;
         let response;
         try {
@@ -138,6 +146,18 @@ export async function waitForWake(client, sessionId, configured, deadlineMs = WA
     }
     return null;
 }
+/**
+ * The delay before the Codex wait tries again after the failed `codex queue`
+ * it waited `delay` before (the first failure waits WAKE_RETRY_FIRST_DELAY_MS),
+ * doubled each time, or null once it would reach WAKE_RETRY_MAX_DELAY_MS
+ * (about 8.5 minutes of failures): Codex does not have the conversation loaded
+ * (its terminal was closed, the app restarted), so the wait ends, and the
+ * messages, undone by the failure report, wait for the user's next prompt there.
+ */
+export function nextQueueRetry(delay) {
+    const next = delay * 2;
+    return next >= WAKE_RETRY_MAX_DELAY_MS ? null : next;
+}
 /**
  * `--wait`, started by a Stop hook when a turn ends. Claude runs it as an
  * asyncRewake hook: exit code 2 with the notification on stderr wakes the
@@ -147,7 +167,15 @@ export async function waitForWake(client, sessionId, configured, deadlineMs = WA
  * and reports to the host whether it did (WAKE_RESULT_EVENT): after a failed
  * queue the host undoes the wake and the copy waits again after a delay that
  * doubles on each failure, so the same messages wake the session on a later
- * try without retrying a broken `codex` in a loop.
+ * try without retrying a broken `codex` in a loop; once the delay reaches its
+ * maximum the copy ends, and the messages wait for the user's next prompt.
+ *
+ * The wait ends when the client it would wake is gone (Claude Code's
+ * CLAUDE_PID, or the Codex process the Stop hook passes as `--client-pid`),
+ * checked before each request, so a client that was killed is not kept
+ * listening; a wake that arrives after it is gone is reported as not delivered.
+ * A request is never cut short for it: the host may already have handed over a
+ * wake on it, which only a report can undo.
  */
 async function runWait(argv) {
     const { client, configured } = clientAndEndpoint(argv);
@@ -163,18 +191,27 @@ async function runWait(argv) {
         if (client === "codex") {
             const { entryScript } = await import("./entry.js");
             const args = [entryScript(), "hook", "codex", "--wait", "--session", sessionId, ...(argValue(argv, "--endpoint") ? ["--endpoint", configured] : [])];
-            await startDetached(process.execPath, args);
+            await startDetached(process.execPath, args, hookClientPid);
             return 0;
         }
     }
-    // Load what a wake needs before waiting: the wait lasts up to an hour, and an
+    const clientPid = parsePid(client === "claude" ? process.env.CLAUDE_PID : argValue(argv, "--client-pid"));
+    const clientGone = () => clientPid !== undefined && !processAlive(clientPid);
+    // Load what a wake needs before waiting: the wait lasts up to a day, and an
     // upgrade or a cleared npx cache may remove the package's files meanwhile.
     const { spawnClientSync } = client === "codex" ? await import("./client-command.js") : { spawnClientSync: undefined };
+    const report = (wake, ok) => new NexusClient({ endpoint: wake.endpoint })
+        .hook({ client, input: { hook_event_name: WAKE_RESULT_EVENT, session_id: sessionId, dispatch_id: wake.dispatchId, ok } }, HOOK_REQUEST_TIMEOUT_MS)
+        .then(() => true, () => false);
     const deadline = Date.now() + WAIT_DEADLINE_MS;
-    for (let delay = WAKE_RETRY_FIRST_DELAY_MS;; delay = Math.min(delay * 2, WAKE_RETRY_MAX_DELAY_MS)) {
-        const wake = await waitForWake(client, sessionId, configured, deadline - Date.now());
+    for (let delay = WAKE_RETRY_FIRST_DELAY_MS;; delay = nextQueueRetry(delay)) {
+        const wake = await waitForWake(client, sessionId, configured, deadline - Date.now(), clientGone);
         if (wake === null)
             return 0;
+        if (clientGone()) {
+            await report(wake, false);
+            return 0;
+        }
         if (!spawnClientSync) {
             await new Promise((resolve) => process.stderr.write(wake.text + "\n", () => resolve()));
             return 2;
@@ -182,10 +219,9 @@ async function runWait(argv) {
         // Never through cmd.exe: the text comes from another session and spans several lines.
         const queued = spawnClientSync(process.env.NEXUS_CODEX_COMMAND || "codex", ["queue", "--thread", sessionId, "--message", wake.text], { stdio: "ignore", windowsHide: true });
         const ok = !queued.error && queued.status === 0;
-        const input = { hook_event_name: WAKE_RESULT_EVENT, session_id: sessionId, dispatch_id: wake.dispatchId, ok };
-        const reported = await new NexusClient({ endpoint: wake.endpoint }).hook({ client, input }, HOOK_REQUEST_TIMEOUT_MS).then(() => true, () => false);
+        const reported = await report(wake, ok);
         // Unknown result (no report): the host keeps the wake, and waiting again would deliver nothing.
-        if (ok || !reported || Date.now() + delay >= deadline)
+        if (ok || !reported || delay === null || Date.now() + delay >= deadline)
             return 0;
         await new Promise((resolve) => setTimeout(resolve, delay));
     }
@@ -196,17 +232,27 @@ async function runWait(argv) {
  * on: a process Node spawns inherits every inheritable handle of this one, and
  * when Codex runs the hook through PowerShell (`commandWindows`) those include
  * the pipes Codex reads the hook's output from. Codex then waits for the pipes
- * until the hook's timeout and ends the wait copy with the hook.
+ * until the hook's timeout and ends the wait copy with the hook. The copy gets
+ * the client process as `--client-pid`: from `clientPid` on Linux and macOS,
+ * found by the launching PowerShell itself on Windows.
  */
-async function startDetached(file, args) {
+async function startDetached(file, args, clientPid) {
     if (process.platform !== "win32") {
-        spawn(file, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+        const pid = clientPid();
+        spawn(file, [...args, ...(pid !== undefined ? ["--client-pid", String(pid)] : [])], { detached: true, stdio: "ignore", windowsHide: true }).unref();
         return;
     }
     const literal = (s) => `'${s.replace(/'/g, "''")}'`;
     // Start-Process joins -ArgumentList with spaces, so each argument is quoted for the command line itself.
     const quoted = (s) => `"${s.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
-    const command = `Start-Process -WindowStyle Hidden -FilePath ${literal(file)} -ArgumentList ${args.map((a) => literal(quoted(a))).join(",")}`;
+    // The client process (--client-pid) is found here, in the PowerShell that starts the copy anyway, not
+    // in one of its own: the nearest ancestor of this hook that is not a shell (Codex runs commandWindows
+    // through PowerShell). Not found: the copy runs without it.
+    const shells = SHELL_NAMES.map(literal).join(",");
+    const command = `$a = @(${args.map((a) => literal(quoted(a))).join(",")}); `
+        + `try { $c = ${process.ppid}; for ($i = 0; $i -lt 4; $i++) { $p = Get-CimInstance Win32_Process -Filter ('ProcessId=' + $c); if (-not $p) { break }; `
+        + `if (@(${shells}) -notcontains ($p.Name -replace '[.]exe$', '').ToLower()) { $a += ${literal(quoted("--client-pid"))}, ('"' + $c + '"'); break }; $c = $p.ParentProcessId } } catch { }; `
+        + `Start-Process -WindowStyle Hidden -FilePath ${literal(file)} -ArgumentList $a`;
     const powershell = path.join(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
     await new Promise((resolve, reject) => {
         const launcher = spawn(powershell, ["-NoProfile", "-NonInteractive", "-Command", command], { stdio: "ignore", windowsHide: true });