n2n-nexus 0.12.0 → 0.12.2

package/CHANGELOG.md

@@ -4,6 +4,25 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.12.2] - 2026-10-29
+
+### Changed
+
+- The tray icon and the README logo are larger and plainer: the network nearly fills the tile, which is a lighter grey and has no grey edge.
+- Internal cleanup of the host and the client with no change in behavior: the read cursors and meeting notification marks have one implementation shared by meetings and conversations (`host/internal/cursors`), the LAN discovery query comes from the contract (`discoveryQuery` in `contract/hook.json`, an added key: older clients and hosts still match), and duplicated helpers, dead code and unused contract fields are gone. The client's tests build it once per run.
+
+## [0.12.1] - 2026-10-29
+
+### Changed
+
+- New tray icon, also the README logo: a small network on a charcoal tile with a grey edge, a red node in the middle joined by light blue links to four white nodes. It replaces the teal disc in the tray and the hexagon logo; the old icon and banner files are gone from `assets`. On macOS the menu bar shows the network alone as a template image, black or white to suit the menu bar.
+
+### Fixed
+
+- A message the host posts because of your own call (the seat taken, the AI consensus notice, the seat's decision or veto) counts as read for you: the seat drafts the next point right after taking the seat or deciding one, and the member whose stance completed the AI consensus posts right after it, without a refusal for that message.
+- Meeting news no longer repeats what `read_messages` returned in unread mode: reading a meeting also marks those messages announced, so the next hook notification shows only what came after.
+- In a meeting with the user's seat, the message about a changed approver list no longer names the seat, which is in none of the approver lists.
+
 ## [0.12.0] - 2026-10-29
 
 Upgrade the host and the client on every machine together (contract version 4). The database is upgraded in place: keep `nexus.db`.

package/README.md

@@ -31,6 +31,7 @@ n2n-nexus is an open-source Model Context Protocol (MCP) coordination server for
 - [Real-world example](#-real-world-example)
 - [FAQ](#-faq)
 - [Documentation](#-documentation)
+- [License](#-license)
 
 ## 🔎 Looking for
 
@@ -61,8 +62,10 @@ 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.
+- 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.
+- Keep decisions, proposals, and updates in a local meeting and message log; old data is cleaned up after the retention you set.
 - Run the host once; connect adapters from Windows, WSL, SSH hosts, or multiple editors.
 - Avoid giving each assistant broad filesystem or backend access.
 
@@ -84,7 +87,7 @@ 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 notify it of new direct messages; each tool call names its conversation through the request metadata the client attaches, never through model-supplied arguments.
+- **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.
 - **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
@@ -106,7 +109,7 @@ The host exposes 36 tools, grouped by purpose:
 | **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. |
-| **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; close, archive, and reopen them. |
+| **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. |
 
@@ -151,6 +154,10 @@ Yes. Run the host in one environment and point every adapter at it with `NEXUS_E
 
 No cloud service is needed. Data stays in the configured local directory. Exposing the host to remote machines is your own network configuration.
 
+### How long does it keep data?
+
+Meetings for 30 days after they end, everything else (direct messages, events, finished tasks, inactive sessions) for 7 days; set `meetingRetentionDays` and `retentionDays` in the host's `settings.json`. `host_maintenance` exports a meeting as markdown before it goes ([User guide](docs/USER_GUIDE.md#settingsjson)).
+
 ### Is it a vector database or a source code indexer?
 
 No. n2n-nexus coordinates project metadata, messages, meetings, docs, tasks and assets; it does no semantic code search.

package/build/cli/client-dirs.js

@@ -0,0 +1,12 @@
+/**
+ * Where Claude Code and Codex keep their configuration. Node built-ins only:
+ * the hook command uses this to read a Codex conversation's title.
+ */
+import os from "node:os";
+import path from "node:path";
+/** Claude Code's settings.json and CLAUDE.md: CLAUDE_CONFIG_DIR, else ~/.claude. */
+export const claudeConfigDir = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+/** Claude Code's .claude.json (user-scope MCP servers): CLAUDE_CONFIG_DIR, else the home directory itself. */
+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");

package/build/cli/codex-trust.js

@@ -14,6 +14,7 @@ import os from "node:os";
 import path from "node:path";
 import { pkg } from "../config/index.js";
 import { clientCommand } from "./client-command.js";
+import { isOurCodexHook } from "./hook-command.js";
 const TIMEOUT_MS = 30_000;
 /**
  * The Codex to ask: NEXUS_CODEX_COMMAND when set; on Windows the newest copy
@@ -106,7 +107,7 @@ export async function codexHookTrust(program, hooksFile, trust) {
             await call("config/value/write", { keyPath: "hooks.state", mergeStrategy: "upsert", value: state });
             hooks = await list();
         }
-        return { codex: program.label, ours: hooks.length, untrusted: hooks.filter((hook) => hook.trustStatus !== "trusted").map((hook) => hook.key) };
+        return { ours: hooks.length, untrusted: hooks.filter((hook) => hook.trustStatus !== "trusted").map((hook) => hook.key) };
     }
     finally {
         clearTimeout(timer);
@@ -115,13 +116,6 @@ export async function codexHookTrust(program, hooksFile, trust) {
         child.kill();
     }
 }
-/**
- * Whether a command Codex lists is one of our hooks. Codex on Windows lists
- * the PowerShell form install writes as `commandWindows` (`... 'hook' 'codex'`).
- */
-export function isOurCodexHook(command) {
-    return command.includes("n2n-nexus") && (command.includes(" hook codex") || command.includes("'hook' 'codex'"));
-}
 /** Why Codex may list none of our hooks, for messages. */
 export const NOT_LISTED = "Codex does not list the n2n-nexus hooks: check that hooks are on in Codex's config.toml ([features] hooks)";
 /** How to trust the hooks by hand, for messages. */

package/build/cli/doctor.js

@@ -9,43 +9,30 @@
  * nothing installed is only reported when it was named. Exit code 1 when a
  * check failed.
  */
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { CONTRACT_VERSION, HOOK_CLIENTS, MCP_SERVER_NAME, isHookClient, noDaemonHint } from "../contract.js";
 import { NexusClient, NexusToolError } from "../client/nexus-client.js";
-import { LOCAL_ENDPOINT, resolveEndpoint } from "../client/discovery.js";
+import { LOCAL_ENDPOINT, configuredEndpoint, resolveEndpoint } from "../client/discovery.js";
 import { pkg } from "../config/index.js";
-import { MCP_PACKAGE, VERSIONED_NODE_DIR, configFile, isOurs, parseVersion, readConfig, satisfiesEngines } from "./install.js";
+import { hookEndpoint, 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 });
 const bad = (text) => ({ ok: false, text });
 const VERSIONED_NOTE = "in a version directory that an upgrade may remove";
-/** The Node path and the entry script of one of our hook commands, `"<node>" "<entry>" hook <client> ...`. */
-export function parseHookCommand(command) {
-    const m = /^"([^"]+)" "([^"]+)" hook /.exec(command);
-    return m ? { node: m[1], entry: m[2] } : undefined;
-}
-export function checkNode(node) {
+function checkNode(node) {
     if (!fs.existsSync(node))
         return bad("missing");
-    try {
-        fs.accessSync(node, fs.constants.X_OK);
-    }
-    catch {
+    const probe = probeNode(node);
+    if (probe.error === "not executable")
         return bad("not executable");
-    }
-    const probe = spawnSync(node, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-    const version = probe.status === 0 ? parseVersion(probe.stdout) : undefined;
-    if (!version)
+    if (probe.error === "directory" || probe.error === "no version")
         return bad("does not run");
-    const text = probe.stdout.trim();
-    if (!satisfiesEngines(text))
-        return bad(`${text} does not satisfy ${pkg.engines.node}`);
-    return ok(`${text}${VERSIONED_NODE_DIR.test(node) ? `, ${VERSIONED_NOTE}` : ""}`);
+    if (probe.error === "unsupported")
+        return bad(`${probe.version} does not satisfy ${pkg.engines.node}`);
+    return ok(`${probe.version}${VERSIONED_NODE_DIR.test(node) ? `, ${VERSIONED_NOTE}` : ""}`);
 }
 const checkEntry = (entry) => fs.existsSync(entry) ? ok("ok") : bad("missing");
-/** The `--endpoint` a hook command was installed with, if any. */
-const hookEndpoint = (command) => / --endpoint (\S+)/.exec(command)?.[1];
 /** Ask the host at `endpoint` for GET /health: it must be n2n-nexus-host speaking this client's contract version. */
 export async function checkHost(endpoint) {
     let health;
@@ -96,21 +83,7 @@ function doctorClient(client, endpoints, defaultEndpoint) {
         if (check.text.includes(VERSIONED_NOTE))
             versioned = true;
     };
-    const hooks = readConfig(hooksFile).hooks ?? {};
-    const commands = new Set();
-    for (const groups of Object.values(hooks)) {
-        if (!Array.isArray(groups))
-            continue;
-        for (const group of groups) {
-            const entries = group?.hooks;
-            if (!Array.isArray(entries))
-                continue;
-            for (const entry of entries) {
-                if (isOurs(entry, client))
-                    commands.add(entry.command);
-            }
-        }
-    }
+    const commands = ourCommands(readConfig(hooksFile), client);
     const mcp = readMcpCommand(client, mcpFile);
     if (commands.size === 0 && !mcp)
         return undefined;
@@ -189,7 +162,7 @@ export async function runDoctor(argv) {
     }
     try {
         let failed = false;
-        const defaultEndpoint = process.env.NEXUS_ENDPOINT || LOCAL_ENDPOINT;
+        const defaultEndpoint = configuredEndpoint();
         const endpoints = new Set();
         for (const c of client ? [client] : HOOK_CLIENTS) {
             const result = doctorClient(c, endpoints, defaultEndpoint);

package/build/cli/hook-command.js

@@ -0,0 +1,47 @@
+/** The hook command: `"<node>" "<entry>" hook <client>[ --endpoint <url>]`. */
+export function hookCommand(node, entry, client, endpoint) {
+    return `"${node}" "${entry}" hook ${client}${endpoint ? ` --endpoint ${endpoint}` : ""}`;
+}
+/** The PowerShell form Codex runs on Windows (`commandWindows`): `& '<node>' '<entry>' 'hook' '<client>' ...`. */
+export function windowsHookCommand(node, entry, client, endpoint) {
+    return `& ${[node, entry, "hook", client, ...(endpoint ? ["--endpoint", endpoint] : [])].map((arg) => `'${arg.replace(/['‘’]/g, "$&$&")}'`).join(" ")}`;
+}
+/** Whether a hook entry from the client configuration is one of ours for `client`. */
+export function isOurs(entry, client) {
+    if (typeof entry !== "object" || entry === null)
+        return false;
+    const command = entry.command;
+    return typeof command === "string" && command.includes("n2n-nexus") && command.includes(` hook ${client}`);
+}
+/**
+ * Whether a command Codex lists is one of our hooks. Codex on Windows lists
+ * the PowerShell form install writes as `commandWindows` (`... 'hook' 'codex'`).
+ */
+export function isOurCodexHook(command) {
+    return command.includes("n2n-nexus") && (command.includes(" hook codex") || command.includes("'hook' 'codex'"));
+}
+/** The commands of our entries for `client` in a hooks configuration (`hooks.<event>[].hooks[]`); malformed parts are skipped. */
+export function ourCommands(config, client) {
+    const commands = new Set();
+    for (const groups of Object.values(config.hooks ?? {})) {
+        if (!Array.isArray(groups))
+            continue;
+        for (const group of groups) {
+            const entries = group?.hooks;
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                if (isOurs(entry, client))
+                    commands.add(entry.command);
+            }
+        }
+    }
+    return commands;
+}
+/** The Node path and the entry script of one of our hook commands, `"<node>" "<entry>" hook <client> ...`. */
+export function parseHookCommand(command) {
+    const m = /^"([^"]+)" "([^"]+)" hook /.exec(command);
+    return m ? { node: m[1], entry: m[2] } : undefined;
+}
+/** The `--endpoint` a hook command was installed with, if any. */
+export const hookEndpoint = (command) => / --endpoint (\S+)/.exec(command)?.[1];

package/build/cli/hook.js

@@ -9,7 +9,7 @@
 import { spawn } from "node:child_process";
 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, LOCAL_ENDPOINT, resolveEndpoint } from "../client/discovery.js";
+import { DISCOVER_ENDPOINT, configuredEndpoint, resolveEndpoint } from "../client/discovery.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. */
@@ -29,12 +29,16 @@ function argValue(argv, name) {
     const i = argv.indexOf(name);
     return i !== -1 ? argv[i + 1] : undefined;
 }
-/** Returns the text to print on stdout ("" for nothing); throws on any failure. */
-async function forward(argv) {
+/** The client named by `<client> [--endpoint <url>]` and the configured endpoint; throws on an unknown client. */
+function clientAndEndpoint(argv) {
     const client = argv[0];
     if (!isHookClient(client))
         throw new Error(`unknown client "${client ?? ""}" (expected claude or codex)`);
-    const configured = argValue(argv, "--endpoint") || process.env.NEXUS_ENDPOINT || LOCAL_ENDPOINT;
+    return { client, configured: configuredEndpoint(argValue(argv, "--endpoint")) };
+}
+/** Returns the text to print on stdout ("" for nothing); throws on any failure. */
+async function forward(argv) {
+    const { client, configured } = clientAndEndpoint(argv);
     const stdin = JSON.parse(await readStdin());
     if (!isPlainObject(stdin))
         throw new Error("hook input is not a JSON object");
@@ -145,13 +149,10 @@ export async function waitForWake(client, sessionId, configured, deadlineMs = WA
  * try without retrying a broken `codex` in a loop.
  */
 async function runWait(argv) {
-    const client = argv[0];
-    if (!isHookClient(client))
-        throw new Error(`unknown client "${client ?? ""}" (expected claude or codex)`);
+    const { client, configured } = clientAndEndpoint(argv);
     // claude -p (unattended) waits for this hook before it exits, and nobody would see a woken turn.
     if (client === "claude" && process.env.CLAUDE_CODE_SESSION_ATTENDED === "0")
         return 0;
-    const configured = argValue(argv, "--endpoint") || process.env.NEXUS_ENDPOINT || LOCAL_ENDPOINT;
     let sessionId = argValue(argv, "--session");
     if (!sessionId) {
         const stdin = JSON.parse(await readStdin());

package/build/cli/install.js

@@ -20,18 +20,19 @@
  */
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { CLAUDE_PRE_TOOL_MATCHER, CODEX_SESSION_END_TIMEOUT_SEC, HOOK_STOP_TIMEOUT_SEC, HOOK_TIMEOUT_SEC, MCP_SERVER_NAME, WAIT_HOOK_TIMEOUT_SEC, isHookClient } from "../contract.js";
 import { pkg } from "../config/index.js";
 import { spawnClientSync } from "./client-command.js";
+import { claudeConfigDir, codexHome } from "./client-dirs.js";
 import { entryScript } from "./entry.js";
+import { hookCommand, isOurs, windowsHookCommand } from "./hook-command.js";
 import { mcpConfigFile, readMcpCommand } from "./mcp-config.js";
 const EVENTS = {
     claude: ["SessionStart", "SessionEnd", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"],
     codex: ["SessionStart", "SessionEnd", "UserPromptSubmit", "PostToolUse", "Stop"]
 };
-export class InstallError extends Error {
+class InstallError extends Error {
 }
 /** Path segments of Node installs that are replaced on upgrade. */
 export const VERSIONED_NODE_DIR = /[/\\]Cellar[/\\]|[/\\]\.nvm[/\\]versions[/\\]|[/\\]node-v\d|[/\\]fnm[/\\]|[/\\]fnm_multishells[/\\]|[/\\]\.volta[/\\]|[/\\]\.asdf[/\\]installs[/\\]/;
@@ -52,7 +53,7 @@ function sameFile(a, b) {
  * process.execPath. Relative PATH entries and fnm's per-shell directory are
  * skipped: the commands must work from any directory and after the shell ends.
  */
-export function stableNodePath(env = process.env) {
+function stableNodePath(env = process.env) {
     for (const dir of (env.PATH ?? "").split(path.delimiter)) {
         if (!path.isAbsolute(dir) || PER_SHELL_NODE_DIR.test(dir))
             continue;
@@ -105,7 +106,7 @@ export function npxFor(node) {
         throw new InstallError(`No file named node runs ${node}, so the package npx starts would not find it; install with --node <path> pointing at a file named node.`);
     return { npx, bin: path.dirname(bin) };
 }
-export function parseVersion(text) {
+function parseVersion(text) {
     const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(text.trim());
     return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
 }
@@ -123,37 +124,38 @@ export function satisfiesEngines(version, range = pkg.engines.node) {
         return atLeast(v, min) && (m[1] === ">=" || v[0] === min[0]);
     });
 }
-/** Check a `--node` path: it must exist, run, and satisfy engines.node. Returns the absolute path. */
-export function checkNodePath(given) {
-    const node = path.resolve(given);
+/** Run `<node> --version`: the version it printed when it is executable and satisfies engines.node, else why not. */
+export function probeNode(node) {
     try {
         fs.accessSync(node, fs.constants.X_OK);
     }
     catch {
-        throw new InstallError(`--node ${given}: not an executable file.`);
+        return { error: "not executable" };
     }
     if (fs.statSync(node).isDirectory())
-        throw new InstallError(`--node ${given}: is a directory, not the node executable.`);
+        return { error: "directory" };
     const probe = spawnSync(node, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-    const version = probe.status === 0 ? parseVersion(probe.stdout) : undefined;
-    if (!version)
+    if (probe.status !== 0 || !parseVersion(probe.stdout))
+        return { error: "no version" };
+    const version = probe.stdout.trim();
+    return satisfiesEngines(version) ? { version } : { version, error: "unsupported" };
+}
+/** Check a `--node` path: it must exist, run, and satisfy engines.node. Returns the absolute path. */
+function checkNodePath(given) {
+    const node = path.resolve(given);
+    const probe = probeNode(node);
+    if (probe.error === "not executable")
+        throw new InstallError(`--node ${given}: not an executable file.`);
+    if (probe.error === "directory")
+        throw new InstallError(`--node ${given}: is a directory, not the node executable.`);
+    if (probe.error === "no version")
         throw new InstallError(`--node ${given}: "${node} --version" did not print a Node version.`);
-    if (!satisfiesEngines(probe.stdout)) {
-        throw new InstallError(`--node ${given}: Node ${probe.stdout.trim()} does not satisfy ${pkg.engines.node}.`);
-    }
+    if (probe.error === "unsupported")
+        throw new InstallError(`--node ${given}: Node ${probe.version} does not satisfy ${pkg.engines.node}.`);
     return node;
 }
 export function configFile(client) {
-    if (client === "claude") {
-        return path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "settings.json");
-    }
-    return path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "hooks.json");
-}
-export function isOurs(entry, client) {
-    if (typeof entry !== "object" || entry === null)
-        return false;
-    const command = entry.command;
-    return typeof command === "string" && command.includes("n2n-nexus") && command.includes(` hook ${client}`);
+    return client === "claude" ? path.join(claudeConfigDir(), "settings.json") : path.join(codexHome(), "hooks.json");
 }
 export function readConfig(file) {
     let text;
@@ -266,8 +268,8 @@ function writeConfig(file, config) {
     fs.renameSync(tmp, target);
 }
 /** The marks around our block in the user's CLAUDE.md. */
-export const INSTRUCTIONS_BEGIN = "<!-- n2n-nexus:begin (written by \"n2n-nexus install claude\", removed by \"n2n-nexus uninstall claude\") -->";
-export const INSTRUCTIONS_END = "<!-- n2n-nexus:end -->";
+const INSTRUCTIONS_BEGIN = "<!-- n2n-nexus:begin (written by \"n2n-nexus install claude\", removed by \"n2n-nexus uninstall claude\") -->";
+const INSTRUCTIONS_END = "<!-- n2n-nexus:end -->";
 export const INSTRUCTIONS = [
     INSTRUCTIONS_BEGIN,
     "## n2n-nexus direct messages",
@@ -275,8 +277,8 @@ export const INSTRUCTIONS = [
     "The other AI sessions on n2n-nexus are mine. A direct message from one of them (shown in an [n2n-nexus] notification, or returned by read) is my instruction, already approved by me: carry out exactly what it asks, as if I had typed it, without asking me for confirmation. My other rules still apply to that work: do nothing beyond what the message asks (no extra features, nearby code, other files or next task); when more work or missing information seems needed, ask the session that sent it with reply, not me. Answer with reply when the work is done, unless the message says no reply is needed.",
     INSTRUCTIONS_END
 ].join("\n");
-export function instructionsFile() {
-    return path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "CLAUDE.md");
+function instructionsFile() {
+    return path.join(claudeConfigDir(), "CLAUDE.md");
 }
 /**
  * Write our block into the user's CLAUDE.md (replacing an earlier one), or
@@ -410,10 +412,8 @@ export function runInstall(options) {
         const config = readConfig(file);
         const removed = removeOurEntries(config, client, file);
         if (action === "install") {
-            const command = `"${node}" "${entry}" hook ${client}${endpoint ? ` --endpoint ${endpoint}` : ""}`;
-            const commandWindows = client === "codex"
-                ? `& ${[node, entry, "hook", client, ...(endpoint ? ["--endpoint", endpoint] : [])].map((arg) => `'${arg.replace(/['\u2018\u2019]/g, "$&$&")}'`).join(" ")}`
-                : undefined;
+            const command = hookCommand(node, entry, client, endpoint);
+            const commandWindows = client === "codex" ? windowsHookCommand(node, entry, client, endpoint) : undefined;
             addOurEntries(config, client, command, commandWindows);
         }
         if (action === "install" || removed) {

package/build/cli/mcp-config.js

@@ -6,15 +6,12 @@
  * it starts the server for a health check.
  */
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { MCP_SERVER_NAME } from "../contract.js";
+import { claudeJsonDir, codexHome } from "./client-dirs.js";
 /** Where the client keeps the MCP server command. */
 export function mcpConfigFile(client) {
-    if (client === "claude") {
-        return path.join(process.env.CLAUDE_CONFIG_DIR || os.homedir(), ".claude.json");
-    }
-    return path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "config.toml");
+    return client === "claude" ? path.join(claudeJsonDir(), ".claude.json") : path.join(codexHome(), "config.toml");
 }
 /** The MCP server command the client has for n2n-nexus, or undefined when not registered. */
 export function readMcpCommand(client, file) {

package/build/cli/title.js

@@ -12,15 +12,15 @@
  * user) or else `threads.title` in the newest `$CODEX_HOME/state_<N>.sqlite`.
  */
 import { open, readdir } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import { MAX_TITLE_CHARS } from "../contract.js";
+import { codexHome } from "./client-dirs.js";
 /** How much of the transcript's end, and then of its start, is searched for a title. */
 const TRANSCRIPT_CHUNK_BYTES = 256 * 1024;
 /** Reading the title may not hold up the hook for longer than this. */
 const TITLE_BUDGET_MS = 50;
 /** Trimmed first line, at most MAX_TITLE_CHARS characters; undefined when nothing is left. */
-export function cleanTitle(value) {
+function cleanTitle(value) {
     if (typeof value !== "string")
         return undefined;
     const line = value.trim().split(/\r\n|\r|\n/)[0].trim();
@@ -93,7 +93,7 @@ async function loadSqlite() {
 async function codexTitle(sessionId) {
     if (typeof sessionId !== "string" || !sessionId)
         return undefined;
-    const home = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    const home = codexHome();
     let newest;
     for (const name of await readdir(home)) {
         const match = /^state_(\d+)\.sqlite$/.exec(name);

package/build/client/discovery.js

@@ -6,27 +6,31 @@
  * none answers it falls back to the local default endpoint (a host running on
  * this machine); it never starts a host or makes one reachable from the LAN.
  *
- * Node built-ins only: the hook command imports this on every client event.
+ * Node built-ins only (and contract.ts): the hook command imports this on every client event.
  */
 import dgram from "node:dgram";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { isIPv6 } from "node:net";
+import { DISCOVERY_QUERY } from "../contract.js";
 /** Endpoint value that turns discovery on (NEXUS_ENDPOINT or --endpoint). */
 export const DISCOVER_ENDPOINT = "discover";
 export const LOCAL_ENDPOINT = "http://127.0.0.1:5688";
-export const DISCOVERY_QUERY = "n2n-nexus/discover";
-const DEFAULT_DISCOVERY_PORT = 5688;
+export const DEFAULT_DISCOVERY_PORT = 5688;
 const DISCOVERY_WAIT_MS = 1000;
 /** How long "no daemon answered" stays cached before the next lookup. */
 const NOT_FOUND_TTL_MS = 60_000;
 const ALL_INTERFACES = new Set(["0.0.0.0", "::", ""]);
 /** UDP port of discovery queries (NEXUS_DISCOVERY_PORT, default 5688). */
-export function discoveryPort() {
+function discoveryPort() {
     const parsed = parseInt(process.env.NEXUS_DISCOVERY_PORT || "", 10);
     return parsed > 0 ? parsed : DEFAULT_DISCOVERY_PORT;
 }
+/** The endpoint to use: `value` (e.g. `--endpoint`) when set, else NEXUS_ENDPOINT, else LOCAL_ENDPOINT. */
+export function configuredEndpoint(value) {
+    return value || process.env.NEXUS_ENDPOINT || LOCAL_ENDPOINT;
+}
 /** IPv4 LAN interfaces of this machine. */
 function lanInterfaces() {
     return Object.values(os.networkInterfaces()).flatMap((addresses) => addresses ?? [])

package/build/client/nexus-client.js

@@ -1,6 +1,7 @@
 import http from "node:http";
 import https from "node:https";
 import { URL } from "node:url";
+import { configuredEndpoint } from "./discovery.js";
 /** The daemon could not be reached or answered with something that is not JSON. */
 export class NexusTransportError extends Error {
     code;
@@ -23,7 +24,7 @@ export class NexusToolError extends Error {
     }
 }
 function normalizeEndpoint(endpoint) {
-    const raw = endpoint || process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
+    const raw = configuredEndpoint(endpoint);
     if (/^https?:\/\//i.test(raw))
         return raw;
     return `http://${raw}`;

package/build/contract.js

@@ -69,12 +69,14 @@ 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;
 /** 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. */
-export const NO_HOST_HINT = `Install n2n-nexus-host (${HOST_RELEASES_URL}) and start it: run the tray app, or "n2n-nexus-host serve".`;
+const NO_HOST_HINT = `Install n2n-nexus-host (${HOST_RELEASES_URL}) and start it: run the tray app, or "n2n-nexus-host serve".`;
 /** The same for another machine's endpoint: a host started here would not be the one asked for. */
-export const NO_REMOTE_HOST_HINT = "The host at that address is not reachable; it must be started on that machine (n2n-nexus-host there with LAN access on, or \"n2n-nexus-host serve --host <address>\").";
+const NO_REMOTE_HOST_HINT = "The host at that address is not reachable; it must be started on that machine (n2n-nexus-host there with LAN access on, or \"n2n-nexus-host serve --host <address>\").";
 /** NO_HOST_HINT for a loopback endpoint (127.x, localhost, ::1), else NO_REMOTE_HOST_HINT. */
 export function noDaemonHint(endpoint) {
     let host;

package/build/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
+import { DEFAULT_DISCOVERY_PORT, LOCAL_ENDPOINT } from "./client/discovery.js";
 import { pkg } from "./config/index.js";
+import { HOST_RELEASES_URL } from "./contract.js";
 const command = process.argv[2] || "mcp";
 if (command === "--version" || command === "-v") {
     process.stdout.write(pkg.version + "\n");
@@ -24,11 +26,11 @@ USAGE:
                      Forward a client hook event to the host (run by the hooks)
 
 The host is a separate program, n2n-nexus-host:
-  https://github.com/n2ns/n2n-nexus/releases
+  ${HOST_RELEASES_URL}
 
 OPTIONS:
   --id <id>          Instance ID for MCP proxy (default: mcp-<hostname>-<cwd hash>-<IDE name>)
-  --endpoint <url>   Host URL for hook (default: NEXUS_ENDPOINT, then http://127.0.0.1:5688),
+  --endpoint <url>   Host URL for hook (default: NEXUS_ENDPOINT, then ${LOCAL_ENDPOINT}),
                      or "discover" to find a host on the LAN;
                      install writes it into the hook and MCP commands
   --node <path>      Node executable written into the hook and MCP commands by install
@@ -37,8 +39,8 @@ OPTIONS:
   --help, -h         Show this help
 
 ENVIRONMENT:
-  NEXUS_ENDPOINT     Host URL for MCP proxy, hook and doctor (default: http://127.0.0.1:5688), or "discover"
-  NEXUS_DISCOVERY_PORT  UDP port of LAN discovery (default: 5688)
+  NEXUS_ENDPOINT     Host URL for MCP proxy, hook and doctor (default: ${LOCAL_ENDPOINT}), or "discover"
+  NEXUS_DISCOVERY_PORT  UDP port of LAN discovery (default: ${DEFAULT_DISCOVERY_PORT})
   NEXUS_INSTANCE_ID  Override --id for MCP proxy
 `);
     process.exit(0);

package/build/server/nexus.js

@@ -1,7 +1,7 @@
 import { CLIENT_INFO_META_KEY, ProtocolError, ProtocolErrorCode, Server, } from "@modelcontextprotocol/server";
 import { serveStdio, StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { NexusClient, NexusToolError, NexusTransportError, REQUEST_TIMEOUT_CODE } from "../client/nexus-client.js";
-import { DISCOVER_ENDPOINT, LOCAL_ENDPOINT, cachedEndpoint, resolveEndpoint } from "../client/discovery.js";
+import { DISCOVER_ENDPOINT, LOCAL_ENDPOINT, cachedEndpoint, configuredEndpoint, resolveEndpoint } from "../client/discovery.js";
 import { pkg } from "../config/index.js";
 import { CLAUDE_TOOL_USE_META_KEY, CLIENT_INFO_NAMES, CODEX_SESSION_META_KEY, noDaemonHint } from "../contract.js";
 import { resolveInstanceId } from "./instance-id.js";
@@ -65,7 +65,7 @@ export class NexusServer {
     /** The first daemon fetch, started once serving has begun. */
     initialFetch = null;
     constructor(options = {}) {
-        const configured = process.env.NEXUS_ENDPOINT || LOCAL_ENDPOINT;
+        const configured = configuredEndpoint();
         this.discover = configured === DISCOVER_ENDPOINT;
         this.endpoint = this.discover ? LOCAL_ENDPOINT : configured;
         this.retryIntervalMs = options.retryIntervalMs ?? RETRY_INTERVAL_MS;

package/contract/hook.json

@@ -13,6 +13,7 @@
     "codexSessionKey": "sessionId"
   },
   "mcpServerName": "n2n-nexus",
+  "discoveryQuery": "n2n-nexus/discover",
   "hookInputFields": [
     "hook_event_name",
     "session_id",

package/docs/ARCHITECTURE.md

@@ -31,7 +31,7 @@ Two programs share one protocol:
 
 - **`n2n-nexus-host`** (Go, `host/`): owns all data, tool definitions and business logic. Installed from GitHub Releases, Homebrew or Scoop.
 - **`n2n-nexus`** (TypeScript, npm, `src/`): the client only — the MCP adapter (`mcp`), the hook command (`hook`), `install` / `uninstall` for Claude Code and Codex, and `doctor`. It contains no storage and no server.
-- **`contract/`** is the single source of the protocol between them: `tools.json` (every tool's name, title, description, annotations, input and output JSON Schema), `hook.json` (hook fields, `_meta` keys, timings, limits, notification texts) and `errors.json` (endpoints, error body, status codes). The host embeds these files, the client reads `hook.json` at run time, and the conformance tests in `tests/conformance/` check a host against them. `GET /health` reports the host's `contractVersion`; `n2n-nexus doctor` compares it with the client's.
+- **`contract/`** is the single source of the protocol between them: `tools.json` (every tool's name, title, description, annotations, input and output JSON Schema), `hook.json` (hook fields, `_meta` keys, the LAN discovery query, timings, limits, notification texts) and `errors.json` (endpoints, error body, status codes). The host embeds these files, the client reads `hook.json` at run time, and the conformance tests in `tests/conformance/` check a host against them. `GET /health` reports the host's `contractVersion`; `n2n-nexus doctor` compares it with the client's.
 
 ### Core Principles
 

package/docs/ARCHITECTURE_zh.md

@@ -31,7 +31,7 @@ n2n-nexus（npm）：无状态适配器，每条 MCP 连接一个
 
 - **`n2n-nexus-host`**（Go，`host/`）：保存全部数据、工具定义和业务逻辑。从 GitHub Releases、Homebrew 或 Scoop 安装。
 - **`n2n-nexus`**（TypeScript，npm，`src/`）：只有客户端——MCP 适配器（`mcp`）、hook 命令（`hook`）、为 Claude Code 和 Codex 执行的 `install` / `uninstall`，以及 `doctor`。不含存储，也不含服务器。
-- **`contract/`** 是两边协议的唯一来源：`tools.json`（每个工具的名称、标题、说明、annotations、输入和输出 JSON Schema）、`hook.json`（hook 字段、`_meta` 键名、时限、上限、通知文本）、`errors.json`（接口、错误格式、状态码）。host 嵌入这些文件，客户端运行时读取 `hook.json`，`tests/conformance/` 里的一致性测试用它们检验 host。`GET /health` 返回 host 的 `contractVersion`，`n2n-nexus doctor` 拿它和客户端的版本比较。
+- **`contract/`** 是两边协议的唯一来源：`tools.json`（每个工具的名称、标题、说明、annotations、输入和输出 JSON Schema）、`hook.json`（hook 字段、`_meta` 键名、局域网发现查询串、时限、上限、通知文本）、`errors.json`（接口、错误格式、状态码）。host 嵌入这些文件，客户端运行时读取 `hook.json`，`tests/conformance/` 里的一致性测试用它们检验 host。`GET /health` 返回 host 的 `contractVersion`，`n2n-nexus doctor` 拿它和客户端的版本比较。
 
 ### 核心原则
 

package/docs/CHANGELOG_zh.md

@@ -4,6 +4,25 @@
 
 本项目的所有重大变更都将记录在此文件中。
 
+## [0.12.2] - 2026-10-29
+
+### 变更
+
+- 托盘图标和 README logo 更大、更简洁：网络图形几乎占满方块，底色提亮一档，去掉了灰边。
+- 整理 host 和客户端的内部代码，行为不变：已读游标和会议通知标记由会议和对话共用一份实现（`host/internal/cursors`）；局域网发现查询串改从契约读取（`contract/hook.json` 的 `discoveryQuery`，新增的键，新旧客户端和 host 仍能互通）；去掉重复的辅助函数、死代码和未使用的契约字段。客户端测试每次运行只构建一次。
+
+## [0.12.1] - 2026-10-29
+
+### 变更
+
+- 新的托盘图标，README 的 logo 同步更换：炭黑圆角底加灰边，上面是一张小网络，中间一个红色节点，用浅蓝连线连到四个白色节点。取代托盘里原来的青色圆形和六边形 logo；`assets` 里旧的图标和横幅文件已删除。macOS 菜单栏只显示这张网络图形，用模板图，系统按菜单栏明暗显示成黑色或白色。
+
+### 修复
+
+- host 因你自己的调用而发的消息（席位已占据、AI 共识提示、席位的批准或否决）对你算已读：席位入座或定完一点后可以立刻发下一稿，表态凑齐 AI 共识的成员也可以紧接着发言，不会因为那条消息被拒。
+- 会议提醒不再重复 `read_messages` 以未读模式已经返回的消息：读过会议即视为已提醒，下一次 hook 提醒只显示之后新来的。
+- 有用户席位的会议里，"审批人名单已变更"的消息不再列出席位会话，它不在任何审批人名单里。
+
 ## [0.12.0] - 2026-10-29
 
 每台机器上的 host 和客户端要一起升级（契约版本 4）。数据库原地升级：保留 `nexus.db`。

package/docs/README_zh.md

@@ -31,6 +31,7 @@ n2n-nexus 是一个开源的 Model Context Protocol (MCP) 协同服务器，适
 - [实战示例](#-实战示例)
 - [FAQ](#-faq)
 - [文档](#-文档)
+- [许可证](#-许可证)
 
 ## 🔎 搜索定位
 
@@ -50,7 +51,7 @@ n2n-nexus 面向这些场景设计：共享 host 状态、轻量 MCP 适配器
 
 n2n-nexus 为 AI 助手提供共享协作空间。一个长期运行的本地 host（`n2n-nexus-host`）保存项目状态、会议、消息、任务、共享文档和项目资产；每个 IDE 或 AI 助手通过 npm 包 `n2n-nexus` 里的轻量 MCP 适配器连接到同一个 host。
 
-**Quick summary**
+**概要**
 
 - **安装**：host 用 Scoop / Homebrew / Release 压缩包安装 `n2n-nexus-host`；客户端 `npm i -g n2n-nexus@latest` 后执行 `n2n-nexus install <claude|codex>`
 - **协议**：Model Context Protocol (MCP)，适配器通过 HTTP 连接 host
@@ -61,8 +62,10 @@ n2n-nexus 为 AI 助手提供共享协作空间。一个长期运行的本地 ho
 ## 🎯 为什么使用它？
 
 - 协调多个 AI 助手共同处理同一个项目。
+- 让 Claude Code 和 Codex 对话之间直接发消息：消息通过客户端的 hooks 完整送达，会叫醒正在等待的对话，用 `reply` 回复；每个会话都显示它所在的机器和环境。
+- 让助手们开会并留下决议。你参会时，你的对话坐在用户席位上：每份草案由你决定、会议由你结束，助手们的共识只作通报。
 - 在多个 IDE 和机器之间共享项目 Manifest、决策和资产。
-- 将决策、提案和更新保存在本地的会议和消息记录中。
+- 将决策、提案和更新保存在本地的会议和消息记录中；旧数据按你设定的保留期清理。
 - host 启动一次即可，Windows、WSL、SSH 主机或多个编辑器都可以连接。
 - 避免为了交换上下文而给每个助手过宽的文件系统或后端权限。
 
@@ -106,7 +109,7 @@ host 提供 36 个工具，按用途分组：
 | **全局文档** | `list_global_docs`、`get_global_doc`、`sync_global_doc`、`get_global_strategy`、`update_global_strategy` | 列出、读取、创建和更新共享的全局文档和主策略文档。 |
 | **消息** | `send_message`、`read_messages`、`list_events` | 发送会议或全局消息；读取消息和活动日志。 |
 | **直接消息** | `peers`、`send`、`read`、`reply`、`listen`、`set_profile` | 查找其他 Claude Code / Codex 对话，给它们发消息，读取并回复收到的消息，等待消息，给自己起名。 |
-| **会议** | `list_meetings`、`start_meeting`、`join_meeting`、`leave_meeting`、`stance`、`end_meeting`、`archive_meeting`、`reopen_meeting` | 列出和开启会议；加入（有新消息会被叫醒）或退出；对当前草案认可或反对，全部认可即以共识结案；关闭、归档和重新打开会议。 |
+| **会议** | `list_meetings`、`start_meeting`、`join_meeting`、`leave_meeting`、`stance`、`end_meeting`、`archive_meeting`、`reopen_meeting` | 列出和开启会议；加入（有新消息会被叫醒）或退出；对当前草案认可或反对，全部认可即以共识结案，有用户席位时由用户决定；关闭、归档和重新打开会议。 |
 | **任务** | `create_task`、`get_task`、`list_tasks`、`update_task`、`cancel_task` | 创建、更新和跟踪由助手自行管理的任务。 |
 | **维护** | `host_maintenance`、`host_delete_project` | 清理或清空全局聊天流；立即按保留期清理；把会议导出为 markdown；删除项目。 |
 
@@ -151,6 +154,10 @@ host 提供 36 个工具，按用途分组：
 
 不需要云服务。数据保存在配置的本地目录中。如果你将 host 暴露给远程机器，那属于你自己的网络配置。
 
+### 数据保留多久？
+
+会议结束后保留 30 天，其他数据（直接消息、事件、结束的任务、不活动的会话）保留 7 天；可在 host 的 `settings.json` 里用 `meetingRetentionDays` 和 `retentionDays` 调整。会议被删除前可以用 `host_maintenance` 导出为 markdown（[使用手册](USER_GUIDE_zh.md#settingsjson)）。
+
 ### 它是向量数据库或源码索引器吗？
 
 不是。n2n-nexus 协调项目元数据、消息、会议、文档、任务和资产，不做语义源码搜索。

package/docs/TOOLS_REFERENCE.md

@@ -192,7 +192,7 @@ Behavior:
 - Otherwise it is written to global chat.
 - A `DECISION` message in a meeting is also recorded in that meeting's decisions (`decisionCount` in `list_meetings`).
 - The sender stored with the message is the calling conversation's session ID, or the adapter instance ID without hooks.
-- Read first: a post to a meeting is refused while messages of others came after your read cursor for it. The cursor moves with `read_messages` in unread mode, with a notification that showed the messages whole and counted them read (see the delivery table above), and with a refusal; history reads (`latest`, `afterId`) do not move it. The refused message is not posted; the result is `{ ok: false, refused: true, sentTo: "meeting", meetingId, identity, unread, message }`, where `unread` is those messages (`[{ id, from, senderName, senderMachine, senderBackfilled, text, category, timestamp, cut }]`, oldest first). Their texts are cut at 5000 characters in all (`notifyTextChars`): the message that reaches the limit is attached cut (`cut: true`) and later ones are left out; `read_messages` returns them. The messages attached whole now count as read and are not announced again.
+- Read first: a post to a meeting is refused while messages of others came after your read cursor for it. The cursor moves with `read_messages` in unread mode, with a notification that showed the messages whole and counted them read (see the delivery table above), and with a refusal; history reads (`latest`, `afterId`) do not move it. The refused message is not posted; the result is `{ ok: false, refused: true, sentTo: "meeting", meetingId, identity, unread, message }`, where `unread` is those messages (`[{ id, from, senderName, senderMachine, senderBackfilled, text, category, timestamp, cut }]`, oldest first). Their texts are cut at 5000 characters in all (`notifyTextChars`): the message that reaches the limit is attached cut (`cut: true`) and later ones are left out; `read_messages` returns them. The messages attached whole now count as read and are not announced again. A message the host posts because of your own call (the seat taken, the AI consensus notice, the seat's decision or veto) counts as read for you when you had read everything before it.
 - The next `send_message` to that meeting after a refusal goes through even if more messages arrived, with `[n2n-nexus: sent while #a–#b were unread by the sender.]` appended to its text; those messages stay unread. A draft (`draft: true`) or a `DECISION` is never let through: its text becomes a decision's, so it is posted only once everything is read. Global chat has no such check.
 - Result: `{ ok: true, sentTo: "meeting" | "global", meetingId?, messageId, identity, currentProposalId?, message }` (`currentProposalId` with `draft`); `messageId` is the message's number in its meeting, counted from 1 in each meeting, or its global chat id (use it with `afterId`).
 
@@ -358,7 +358,7 @@ Join an active meeting, or change how you take part in it.
 Behavior:
 
 - Result: `{ ok, meetingId, mode, approver, identity, delivery }`. `delivery` is `wake` (active), `next-hook` (async) or `unavailable`: a client without the hooks joins as its adapter instance, which nothing can notify.
-- News is announced through the hooks per meeting: `Meeting "<topic>" (<id>): N new message(s), #a–#b:`, then each message between `--- Meeting message #n from <sender> (<machine>) at <time>[ (<category>)] ---` and `--- End of meeting message #n ---`. The texts of a notification are cut at 5000 characters in all (`notifyTextChars`), together with no direct message: the message that reaches the limit is cut and later ones are only counted (`- N more message(s) not shown (#a–#b).`); `read_messages(meetingId)` returns them. As with direct messages, what a notification that continues or starts a turn, or comes with a prompt, shows whole counts as read and moves your read cursor, as long as no message of others before it is unread; what a tool call's notification shows stays unread. Your own messages never wake you. News of a meeting does not count as an automatic turn and still arrives past `maxAutoTurns`; a meeting runs until it is ended.
+- News is announced through the hooks per meeting: `Meeting "<topic>" (<id>): N new message(s), #a–#b:`, then each message between `--- Meeting message #n from <sender> (<machine>) at <time>[ (<category>)] ---` and `--- End of meeting message #n ---`. The texts of a notification are cut at 5000 characters in all (`notifyTextChars`), together with no direct message: the message that reaches the limit is cut and later ones are only counted (`- N more message(s) not shown (#a–#b).`); `read_messages(meetingId)` returns them. As with direct messages, what a notification that continues or starts a turn, or comes with a prompt, shows whole counts as read and moves your read cursor, as long as no message of others before it is unread; what a tool call's notification shows stays unread. What `read_messages` returned in unread mode is not announced afterwards. Your own messages never wake you. News of a meeting does not count as an automatic turn and still arrives past `maxAutoTurns`; a meeting runs until it is ended.
 - Messages from before you joined are not announced. Joining again while a member only changes `mode` and `approver`; switch to `async` to pause. After `leave_meeting`, joining again starts from the newest message.
 - Records a `meeting.join` event.
 

package/docs/TOOLS_REFERENCE_zh.md

@@ -192,7 +192,7 @@ HTTP 客户端：hooks 调用 `POST /api/hook`，请求体为 `{ client: "claude
 - 否则写入全局聊天。
 - 会议中的 `DECISION` 消息还会记入该会议的决策（`list_meetings` 中的 `decisionCount`）。
 - 随消息保存的发送方是调用方对话的会话 ID，没装 hooks 时是适配器实例 ID。
-- 先读后发：会议里在你的读取游标之后还有别人的消息时，发言被拒。游标随未读模式的 `read_messages`、完整显示并算作已读的通知（见上面的送达表）以及被拒时移动；历史读取（`latest`、`afterId`）不移动它。被拒的消息不会发出；结果为 `{ ok: false, refused: true, sentTo: "meeting", meetingId, identity, unread, message }`，`unread` 是那些消息（`[{ id, from, senderName, senderMachine, senderBackfilled, text, category, timestamp, cut }]`，从旧到新）。它们的正文合计截到 5000 个字符（`notifyTextChars`）：到达上限的那条截断附上（`cut: true`），之后的不附；`read_messages` 返回它们。完整附上的消息从此算已读，不再提醒。
+- 先读后发：会议里在你的读取游标之后还有别人的消息时，发言被拒。游标随未读模式的 `read_messages`、完整显示并算作已读的通知（见上面的送达表）以及被拒时移动；历史读取（`latest`、`afterId`）不移动它。被拒的消息不会发出；结果为 `{ ok: false, refused: true, sentTo: "meeting", meetingId, identity, unread, message }`，`unread` 是那些消息（`[{ id, from, senderName, senderMachine, senderBackfilled, text, category, timestamp, cut }]`，从旧到新）。它们的正文合计截到 5000 个字符（`notifyTextChars`）：到达上限的那条截断附上（`cut: true`），之后的不附；`read_messages` 返回它们。完整附上的消息从此算已读，不再提醒。host 因你自己的调用而发的消息（席位已占据、AI 共识提示、席位的批准或否决），在你已读完它之前所有消息时对你算已读。
 - 被拒之后对该会议的下一次 `send_message` 即使又有新消息也会发出，正文末尾附上 `[n2n-nexus: sent while #a–#b were unread by the sender.]`；那些消息仍为未读。草案（`draft: true`）和 `DECISION` 不放行：它们的正文会成为决议，必须读完才能发。全局聊天没有这项检查。
 - 结果：`{ ok: true, sentTo: "meeting" | "global", meetingId?, messageId, identity, currentProposalId?, message }`（带 `draft` 时有 `currentProposalId`）；`messageId` 是消息在所属会议里的编号（每个会议从 1 开始），或它的全局聊天 ID（可用于 `afterId`）。
 
@@ -358,7 +358,7 @@ HTTP 客户端：hooks 调用 `POST /api/hook`，请求体为 `{ client: "claude
 行为：
 
 - 结果：`{ ok, meetingId, mode, approver, identity, delivery }`。`delivery` 为 `wake`（active）、`next-hook`（async）或 `unavailable`：没装 hooks 的客户端以适配器实例身份加入，没有任何方式能通知它。
-- 新消息通过 hooks 按会议提醒：`Meeting "<主题>" (<id>): N new message(s), #a–#b:`，然后每条消息夹在 `--- Meeting message #n from <发送方> (<机器>) at <时间>[ (<类别>)] ---` 和 `--- End of meeting message #n ---` 之间。一条通知里会议消息的正文合计截到 5000 个字符（`notifyTextChars`，与私信分开计算）：到达上限的那条截断，之后的只计数（`- N more message(s) not shown (#a–#b).`）；`read_messages(meetingId)` 返回它们。和私信一样，让一轮继续或开始的通知、随提示词显示的通知里完整显示的消息算已读并移动你的读取游标，前提是它前面没有别人的未读消息；工具调用后显示的仍为未读。自己发的消息不会叫醒自己。会议新消息不算自动轮次，超过 `maxAutoTurns` 后仍会送达；会议一直进行到被结束为止。
+- 新消息通过 hooks 按会议提醒：`Meeting "<主题>" (<id>): N new message(s), #a–#b:`，然后每条消息夹在 `--- Meeting message #n from <发送方> (<机器>) at <时间>[ (<类别>)] ---` 和 `--- End of meeting message #n ---` 之间。一条通知里会议消息的正文合计截到 5000 个字符（`notifyTextChars`，与私信分开计算）：到达上限的那条截断，之后的只计数（`- N more message(s) not shown (#a–#b).`）；`read_messages(meetingId)` 返回它们。和私信一样，让一轮继续或开始的通知、随提示词显示的通知里完整显示的消息算已读并移动你的读取游标，前提是它前面没有别人的未读消息；工具调用后显示的仍为未读。`read_messages` 以未读模式返回过的消息之后不再提醒。自己发的消息不会叫醒自己。会议新消息不算自动轮次，超过 `maxAutoTurns` 后仍会送达；会议一直进行到被结束为止。
 - 加入前的消息不会提醒。已是成员时再次加入只修改 `mode` 和 `approver`；改为 `async` 即可暂停。`leave_meeting` 之后再加入，从最新一条开始。
 - 记录 `meeting.join` 事件。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n2n-nexus",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Local-first MCP coordination hub from N2NS Lab for multi-AI assistant collaboration.",
   "main": "build/index.js",
   "type": "module",