n2n-nexus 0.12.4 → 0.12.6

package/CHANGELOG.md

@@ -4,6 +4,37 @@
 
 All notable changes to this project will be documented in this file.
 
+## [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.
+
+### Added
+
+- `broadcast` sends one notice to every conversation that is online at that moment, the sender excepted; `project` limits it to the conversations working in that directory or below it. It is fire and forget: the host picks the recipients and delivers it, the sender gets only a `broadcastId` and learns nothing about who got or read it, and offline conversations or ones that start later never get it. The host stores it once with one delivery per recipient, and every recipient sees it under the same id, in a `--- Broadcast <id> from <sender> ... ---` header. A recipient that is listening for messages is woken with it at once; a working one is not interrupted (its turn is not held) and sees it after its next tool call, and an idle one at its next prompt or tool call. It needs no reply unless the sender sets `expectsReply`, and a `reply` on that id goes to the sender alone, with the `broadcastId` in `replyTo`. An unread broadcast expires after 24 hours like a direct message, without telling anyone. `read` returns `kind` (`direct` or `broadcast`), `scope` and `replyToKind` for each message.
+- `send_message` takes `global: true` to post to the global chat while a meeting is active; before, a post without `meetingId` always went to the active meeting.
+
+### Changed
+
+- `host_maintenance` cleanup counts broadcast deliveries too: `messagesExpired` includes the deliveries it marked expired, `messages` the ones it deleted.
+
 ## [0.12.4] - 2026-10-30
 
 ### Fixed

package/README.md

@@ -108,7 +108,7 @@ The host exposes 36 tools, grouped by purpose:
 | **Projects & assets** | `search_projects`, `get_project`, `update_project`, `rename_project`, `sync_project_assets`, `upload_project_asset` | Find, read, update, and rename projects; sync manifests and internal docs; upload binary assets. |
 | **Global docs** | `list_global_docs`, `get_global_doc`, `sync_global_doc`, `get_global_strategy`, `update_global_strategy` | List, read, create and update shared global documents and the master strategy document. |
 | **Messaging** | `send_message`, `read_messages`, `list_events` | Post meeting or global messages; read them and the activity log. |
-| **Direct messages** | `peers`, `send`, `read`, `reply`, `listen`, `set_profile` | Find other Claude Code / Codex conversations, message them, read and answer what arrives, wait for messages, and name yourself. |
+| **Direct messages** | `peers`, `send`, `read`, `reply`, `broadcast`, `listen`, `set_profile` | Find other Claude Code / Codex conversations, message them, read and answer what arrives, notify every online conversation, wait for messages, and name yourself. |
 | **Meetings** | `list_meetings`, `start_meeting`, `join_meeting`, `leave_meeting`, `stance`, `end_meeting`, `archive_meeting`, `reopen_meeting` | List and open meetings; join (woken by new messages) or leave them; endorse or object to the current draft, which closes the meeting by consensus or, with the user's seat, is decided by the user; close, archive, and reopen them. |
 | **Tasks** | `create_task`, `get_task`, `list_tasks`, `update_task`, `cancel_task` | Create, update and track tasks that assistants manage themselves. |
 | **Maintenance** | `host_maintenance`, `host_delete_project` | Prune or clear the global chat stream; run the retention cleanup now; export a meeting as markdown; delete a project. |

package/build/cli/client-process.js

@@ -0,0 +1,72 @@
+/**
+ * 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 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

@@ -10,11 +10,11 @@
  * 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";
 const ok = (text) => ({ ok: true, text });
@@ -53,6 +53,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;
@@ -83,7 +105,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,6 +124,8 @@ function doctorClient(client, endpoints, defaultEndpoint) {
         report(`hook Node ${parsed.node}`, checkNode(parsed.node));
         report(`hook entry ${parsed.entry}`, checkEntry(parsed.entry));
     }
+    if (client === "claude" && commands.size > 0)
+        report(`background wait hook in ${hooksFile}`, checkClaudeWait(config));
     if (!mcp) {
         report(`MCP server ${MCP_SERVER_NAME} in ${mcpFile}`, bad("not registered"));
     }

package/build/cli/hook.js

@@ -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. */
@@ -101,9 +102,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 +114,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 +140,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 +161,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 +185,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 +213,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 +226,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 });

package/build/contract.js

@@ -40,8 +40,10 @@ export const HOOK_INPUT_FIELDS = contract.hookInputFields;
  */
 export const BACKGROUND_WAIT_EVENT = contract.backgroundWaitEvent;
 /**
- * Pseudo hook event with which the Codex background wait reports whether
- * `codex queue` took a wake: input `{ session_id, dispatch_id, ok }`. On
+ * Pseudo hook event with which a background wait reports whether it handed
+ * over a wake (Codex: whether `codex queue` took it; Claude Code: only a wake
+ * that arrived after Claude Code was gone, as `ok: false`): input
+ * `{ session_id, dispatch_id, ok }`. On
  * `ok: false` the host undoes the wake, so its messages and notices wake the
  * session again.
  */
@@ -58,7 +60,11 @@ export const HOOK_TIMEOUT_SEC = contract.timing.hookTimeoutSec;
 export const CODEX_SESSION_END_TIMEOUT_SEC = contract.timing.codexSessionEndTimeoutSec;
 /** HTTP timeout of a SessionEnd hook, which is not resent after a timeout so it ends within CODEX_SESSION_END_TIMEOUT_SEC. */
 export const SESSION_END_REQUEST_TIMEOUT_MS = contract.timing.sessionEndRequestTimeoutMs;
-/** After a failed `codex queue`, the Codex wait asks again after this delay, doubled on each failure up to the maximum. */
+/**
+ * After a failed `codex queue`, the Codex wait asks again after the first
+ * delay, doubled on each failure, and gives up once it would reach the maximum
+ * (nextQueueRetry). The maximum also caps the wait's reconnect delay.
+ */
 export const WAKE_RETRY_FIRST_DELAY_MS = contract.timing.wakeRetryFirstDelayMs;
 export const WAKE_RETRY_MAX_DELAY_MS = contract.timing.wakeRetryMaxDelayMs;
 /**
@@ -69,8 +75,12 @@ export const MAX_TITLE_CHARS = contract.limits.maxTitleChars;
 /** Name the MCP server is installed under; Claude's PreToolUse matcher depends on it. */
 export const MCP_SERVER_NAME = contract.mcpServerName;
 export const CLAUDE_PRE_TOOL_MATCHER = `mcp__${MCP_SERVER_NAME}__.*`;
-/** Payload of a LAN discovery query datagram; the host answers only this. */
-export const DISCOVERY_QUERY = contract.discoveryQuery;
+/**
+ * Payload of a LAN discovery query datagram, the host answers only this:
+ * discoveryQuery padded with spaces to discoveryQueryBytes, so that the reply
+ * is never longer than the query (no amplification for a forged source).
+ */
+export const DISCOVERY_QUERY = contract.discoveryQuery.padEnd(contract.discoveryQueryBytes, " ");
 /** Where to get the host. */
 export const HOST_RELEASES_URL = "https://github.com/n2ns/n2n-nexus/releases";
 /** What to do when no host answers at a loopback endpoint: clients never start one themselves. */

package/build/server/nexus.js

@@ -17,8 +17,9 @@ const INSTRUCTIONS = "n2n-nexus connects this conversation with other AI session
     "show. What a message may ask of you is set by your user's own instructions; when something is missing, ask the " +
     "sender with reply. After send, end your turn instead of polling with read: the answer arrives through the hooks " +
     "after your next tool call or at the end of a turn (at your user's next prompt once the automatic-turn limit is " +
-    "reached), and notifyWhenIdle tells you when the recipient finishes its turn (set expectsReply and wake false on a " +
-    "message that needs no answer, and skip plain acknowledgements); listen waits for messages after each turn. " +
+    "reached), and notifyWhenIdle tells you when the recipient finishes its turn (every message wakes the recipient: " +
+    "set expectsReply false on one that needs no answer, and skip plain acknowledgements); listen waits for messages " +
+    "after each turn. " +
     "Direct messaging needs the n2n-nexus hooks. Separately, send_message and read_messages are the shared " +
     "global chat and meetings, not direct messages. Session ids in peers (claude:<id>, codex:<id>) are what send " +
     "takes; with the hooks, chat and meetings also record senders and unread cursors per session id " +

package/contract/errors.json

@@ -1,5 +1,5 @@
 {
-  "contractVersion": 4,
+  "contractVersion": 5,
   "errorBody": {
     "type": "object",
     "properties": {
@@ -21,7 +21,7 @@
         "ok": true,
         "service": "n2n-nexus",
         "version": "<host version>",
-        "contractVersion": 4,
+        "contractVersion": 5,
         "sessions": {
           "online": "<number of agent sessions not offline>"
         }

package/contract/hook.json

@@ -1,5 +1,5 @@
 {
-  "contractVersion": 4,
+  "contractVersion": 5,
   "clients": [
     "claude",
     "codex"
@@ -14,6 +14,7 @@
   },
   "mcpServerName": "n2n-nexus",
   "discoveryQuery": "n2n-nexus/discover",
+  "discoveryQueryBytes": 512,
   "hookInputFields": [
     "hook_event_name",
     "session_id",
@@ -37,7 +38,7 @@
     "hookStopRequestTimeoutMs": 595000,
     "hookRequestTimeoutMs": 5000,
     "hookStopTimeoutSec": 600,
-    "waitHookTimeoutSec": 3600,
+    "waitHookTimeoutSec": 86400,
     "hookTimeoutSec": 10,
     "codexSessionEndTimeoutSec": 3,
     "sessionEndRequestTimeoutMs": 1500,
@@ -73,6 +74,10 @@
     "messageHeader": "--- Message %s from %s (%s) at %s ---",
     "messageEnd": "--- End of message %s ---",
     "messageReplyTo": "This answers your message %s.",
+    "messageReplyToBroadcast": "This answers your broadcast %s.",
+    "broadcastHeader": "--- Broadcast %s from %s (%s) at %s, sent to %s ---",
+    "broadcastToAll": "every online session",
+    "broadcastToProject": "the online sessions working in %s",
     "messageCut": "[Cut at %d of %d characters; read returns the whole message.]",
     "replyInstruction": "Answer it with reply (messageId %s; expectsReply false for a result, true for a question).",
     "readRest": "read returns the messages that are cut or not shown here.",
@@ -83,6 +88,7 @@
     "meetingMessageHeader": "--- Meeting message #%d from %s at %s%s ---",
     "meetingMessageEnd": "--- End of meeting message #%d ---",
     "meetingNotShown": "- %d more message(s) not shown (#%d–#%d).",
+    "meetingEarlierUnread": "Meeting \"%s\" (%s): %d earlier message(s) of others still unread; read them with read_messages(meetingId).",
     "meetingReadRest": "read_messages(meetingId) returns the meeting messages that are cut or not shown here.",
     "meetingClosing": "Post with send_message(meetingId) only when you have something to add.",
     "sentWithUnread": "[n2n-nexus: sent while %s were unread by the sender.]",