n2n-nexus 0.9.2 → 0.9.4

package/build/cli/install.js

@@ -9,12 +9,15 @@
  * Dock do not read the shell PATH. The `node` found on PATH is preferred when it
  * is the running binary, because process.execPath is the resolved, versioned
  * location (nvm, Homebrew Cellar, ...) that disappears when Node is upgraded.
+ * The hooks run this installation's entry script; the MCP server runs
+ * `n2n-nexus@latest` through npm's npx with that Node, so every new
+ * conversation starts the latest published client.
  */
 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, HOOK_STOP_TIMEOUT_SEC, HOOK_TIMEOUT_SEC, MCP_SERVER_NAME, WAIT_HOOK_TIMEOUT_SEC, isHookClient } from "../contract.js";
+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 { entryScript } from "./entry.js";
@@ -27,6 +30,8 @@ export 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[/\\]/;
+/** The package the MCP server command starts through npx. */
+export const MCP_PACKAGE = `${pkg.name}@latest`;
 /** fnm puts a per-shell symlink directory first on PATH; it is gone when the shell ends. */
 const PER_SHELL_NODE_DIR = /[/\\]fnm_multishells[/\\]/;
 function sameFile(a, b) {
@@ -52,6 +57,49 @@ export function stableNodePath(env = process.env) {
     }
     return process.execPath;
 }
+/**
+ * What the MCP server command needs from `node`: npm's npx script, run as `"<node>" "<npx>"`, and `bin`, a folder
+ * whose `node` (`node.exe`) is that Node, put first on the server's PATH. npx is the `npx` link next to the Node
+ * (Unix; kept unresolved, like the Node path, when it leads to npx-cli.js) or `node_modules/npm/bin/npx-cli.js` next
+ * to it (Windows), else the same next to the resolved Node, else next to the binary the Node runs (a version
+ * manager's shim reports it as process.execPath).
+ */
+export function npxFor(node) {
+    const nearby = (file) => {
+        const dir = path.dirname(file);
+        const candidate = process.platform === "win32" ? path.join(dir, "node_modules", "npm", "bin", "npx-cli.js") : path.join(dir, "npx");
+        try {
+            return fs.realpathSync(candidate).endsWith(".js") ? candidate : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const named = (file) => /^node(\.exe)?$/i.test(path.basename(file));
+    let resolved = node;
+    try {
+        resolved = fs.realpathSync(node);
+    }
+    catch {
+        // checkNodePath / stableNodePath already made sure the Node exists
+    }
+    let npx = nearby(node) ?? nearby(resolved);
+    let bin = [node, resolved].find(named);
+    if (!npx || !bin) {
+        const probe = spawnSync(node, ["-p", "process.execPath"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const runs = probe.status === 0 ? probe.stdout.trim() : "";
+        if (runs) {
+            npx ??= nearby(runs);
+            if (named(runs))
+                bin ??= runs;
+        }
+    }
+    if (!npx)
+        throw new InstallError(`npm's npx was not found next to ${node}; install with --node <path> pointing at a Node.js that includes npm.`);
+    if (!bin)
+        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) {
     const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(text.trim());
     return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
@@ -162,7 +210,11 @@ function removeOurEntries(config, client, file) {
 function addOurEntries(config, client, command, commandWindows) {
     const hooks = (config.hooks ??= {});
     for (const event of EVENTS[client]) {
-        const entry = { type: "command", command, timeout: event === "Stop" ? HOOK_STOP_TIMEOUT_SEC : HOOK_TIMEOUT_SEC };
+        // Codex clamps a SessionEnd hook timeout above 3 s (and warns in its settings), so ask for 3 s there.
+        const timeout = event === "Stop" ? HOOK_STOP_TIMEOUT_SEC
+            : client === "codex" && event === "SessionEnd" ? CODEX_SESSION_END_TIMEOUT_SEC
+                : HOOK_TIMEOUT_SEC;
+        const entry = { type: "command", command, timeout };
         if (commandWindows)
             entry.commandWindows = commandWindows;
         const group = client === "claude" && event === "PreToolUse"
@@ -213,10 +265,18 @@ function mcpRemoveArgs(client) {
         ? ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]
         : ["mcp", "remove", MCP_SERVER_NAME];
 }
-function mcpAddArgs(client, node, entry, endpoint) {
-    const env = endpoint ? [client === "claude" ? "-e" : "--env", `NEXUS_ENDPOINT=${endpoint}`] : [];
+/**
+ * `<client> mcp add` for `"<node>" "<npx>" -y n2n-nexus@latest mcp`. PATH starts with `bin` (see npxFor): npx starts
+ * the package's bin, `#!/usr/bin/env node` (Unix) or a .cmd shim running `node` (Windows), which looks Node up on
+ * PATH, and a GUI client started from the Dock has none there. The rest is the system folders.
+ */
+function mcpAddArgs(client, node, { npx, bin }, endpoint) {
+    const flag = client === "claude" ? "-e" : "--env";
+    const systemRoot = process.env.SystemRoot || "C:\\Windows";
+    const dirs = process.platform === "win32" ? [bin, path.join(systemRoot, "System32"), systemRoot] : [bin, "/usr/bin", "/bin"];
+    const vars = [...(endpoint ? [`NEXUS_ENDPOINT=${endpoint}`] : []), `PATH=${dirs.join(process.platform === "win32" ? ";" : ":")}`];
     const scope = client === "claude" ? ["--scope", "user"] : [];
-    return ["mcp", "add", ...scope, MCP_SERVER_NAME, ...env, "--", node, entry, "mcp"];
+    return ["mcp", "add", ...scope, MCP_SERVER_NAME, ...vars.flatMap((v) => [flag, v]), "--", node, npx, "-y", MCP_PACKAGE, "mcp"];
 }
 /**
  * Run `<client> <args>` and throw like execFileSync when it fails. On Windows
@@ -233,7 +293,9 @@ function runClient(client, args, stdio) {
 /**
  * Run `<client> mcp remove`. A failure is ignored only when `<client> mcp get`
  * shows the server is not registered (never installed, or already removed);
- * otherwise the removal really failed and we stop before `mcp add`.
+ * otherwise the removal really failed and we stop before `mcp add`. On
+ * uninstall, a client that cannot be run skips the step with a note on how to
+ * remove the registration that is still there.
  */
 function removeMcpServer(client, action, hooksRemoved) {
     const removeArgs = mcpRemoveArgs(client);
@@ -255,6 +317,13 @@ function removeMcpServer(client, action, hooksRemoved) {
         }
         if (!registered)
             return;
+        if (action === "uninstall" && error.code === "ENOENT") {
+            const file = mcpConfigFile(client);
+            const what = client === "claude" ? `the "${MCP_SERVER_NAME}" entry under "mcpServers"` : `the [mcp_servers.${MCP_SERVER_NAME}] table`;
+            process.stdout.write(`Skipped "${client} ${removeArgs.join(" ")}": the "${client}" command could not be run (not on PATH, or not runnable without a shell). `
+                + `The MCP server is still registered in ${file}; run that command once ${client} can be run, or delete ${what} from ${file}.\n`);
+            return;
+        }
         const failure = error;
         const stderr = typeof failure.stderr === "string" ? failure.stderr.trim() : "";
         const detail = stderr || (typeof failure.status === "number" ? `exit code ${failure.status}` : failure.message);
@@ -270,13 +339,17 @@ export function runInstall(options) {
     const entry = options.entry ?? entryScript();
     try {
         if (action === "install" && /[/\\]_npx[/\\]/.test(entry)) {
-            throw new InstallError(`n2n-nexus is running from an npx cache (${entry}), which can be cleared at any time. Install it first: npm i -g n2n-nexus`);
+            throw new InstallError(`n2n-nexus is running from an npx cache (${entry}), which can be cleared at any time. Install it first: npm i -g ${MCP_PACKAGE}`);
         }
-        const probe = spawnClientSync(client, ["--version"], { stdio: "ignore" });
-        if (probe.error || probe.status !== 0) {
-            throw new InstallError(`The "${client}" command was not found on PATH; install ${client === "claude" ? "Claude Code" : "Codex"} first.`);
+        // Uninstall does not need the client: our hooks are removed from its config file either way.
+        if (action === "install") {
+            const probe = spawnClientSync(client, ["--version"], { stdio: "ignore" });
+            if (probe.error || probe.status !== 0) {
+                throw new InstallError(`The "${client}" command was not found on PATH; install ${client === "claude" ? "Claude Code" : "Codex"} first.`);
+            }
         }
         const node = action === "install" ? (options.node ? checkNodePath(options.node) : stableNodePath()) : undefined;
+        const npm = node ? npxFor(node) : undefined;
         const file = configFile(client);
         const config = readConfig(file);
         const removed = removeOurEntries(config, client, file);
@@ -292,13 +365,13 @@ export function runInstall(options) {
             process.stdout.write(`${action === "install" ? "Wrote hooks to" : "Removed hooks from"} ${file}\n`);
         }
         removeMcpServer(client, action, removed);
-        if (action === "install" && node) {
-            const addArgs = mcpAddArgs(client, node, entry, endpoint);
+        if (action === "install" && node && npm) {
+            const addArgs = mcpAddArgs(client, node, npm, endpoint);
             runClient(client, addArgs, ["ignore", "ignore", "inherit"]);
             process.stdout.write(`Ran: ${client} ${addArgs.join(" ")}\n`);
             process.stdout.write(`Node: ${node}\n`);
-            if (VERSIONED_NODE_DIR.test(node)) {
-                process.stdout.write(`Note: this Node path contains a version directory that an upgrade may remove. After upgrading Node, run "n2n-nexus install ${client}" again, or install with --node <path> pointing at a stable entry such as /usr/local/bin/node.\n`);
+            if (VERSIONED_NODE_DIR.test(node) || VERSIONED_NODE_DIR.test(npm.npx)) {
+                process.stdout.write(`Note: this Node or npx path contains a version directory that an upgrade may remove. After upgrading Node, run "n2n-nexus install ${client}" again, or install with --node <path> pointing at a stable entry such as /usr/local/bin/node.\n`);
             }
             if (client === "codex") {
                 process.stdout.write("Next: open Codex and run /hooks to trust the n2n-nexus hooks; until then they do not run.\n");

package/build/cli/title.js

@@ -0,0 +1,126 @@
+/**
+ * The conversation's title as its client shows it, which the hook command adds
+ * to the input it forwards as `title`. Neither source is documented, so every
+ * failure (missing file, unexpected format, locked database, time budget
+ * spent) yields undefined and the hook goes on without a title.
+ *
+ * Claude Code: the transcript (`transcript_path`, JSONL, can be very large)
+ * gets `{"type":"custom-title","customTitle":…}` records when the user renames
+ * the conversation and `{"type":"ai-title","aiTitle":…}` records for the
+ * automatic title, appended again and again; only its last and, failing that,
+ * first TRANSCRIPT_CHUNK_BYTES are read. Codex: `threads.name` (set by the
+ * 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";
+/** 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) {
+    if (typeof value !== "string")
+        return undefined;
+    const line = value.trim().split(/\r\n|\r|\n/)[0].trim();
+    const chars = Array.from(line);
+    const title = chars.length > MAX_TITLE_CHARS ? chars.slice(0, MAX_TITLE_CHARS).join("").trimEnd() : line;
+    return title || undefined;
+}
+/** The last custom title in `text`, or else the last automatic one. */
+function titleInJsonl(text) {
+    let custom;
+    let ai;
+    for (const line of text.split("\n")) {
+        if (!line.includes("-title"))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue; // the chunk's cut-off first or last line
+        }
+        if (typeof record !== "object" || record === null)
+            continue;
+        const { type, customTitle, aiTitle } = record;
+        if (type === "custom-title")
+            custom = cleanTitle(customTitle) ?? custom;
+        else if (type === "ai-title")
+            ai = cleanTitle(aiTitle) ?? ai;
+    }
+    return custom ?? ai;
+}
+async function claudeTitle(transcriptPath) {
+    if (typeof transcriptPath !== "string" || !transcriptPath)
+        return undefined;
+    const file = await open(transcriptPath, "r");
+    try {
+        const { size } = await file.stat();
+        const read = async (position, length) => {
+            const buffer = Buffer.alloc(length);
+            const { bytesRead } = await file.read(buffer, 0, length, position);
+            return buffer.toString("utf8", 0, bytesRead);
+        };
+        const tailStart = Math.max(0, size - TRANSCRIPT_CHUNK_BYTES);
+        const title = titleInJsonl(await read(tailStart, size - tailStart));
+        if (title !== undefined || tailStart === 0)
+            return title;
+        return titleInJsonl(await read(0, TRANSCRIPT_CHUNK_BYTES));
+    }
+    finally {
+        await file.close();
+    }
+}
+/** node:sqlite without the ExperimentalWarning older Node versions print on stderr when it loads. */
+async function loadSqlite() {
+    const emitWarning = process.emitWarning;
+    process.emitWarning = function (warning, ...args) {
+        const type = typeof args[0] === "string" ? args[0] : args[0]?.type ?? (warning instanceof Error ? warning.name : undefined);
+        const message = warning instanceof Error ? warning.message : String(warning);
+        if (type === "ExperimentalWarning" && message.includes("SQLite"))
+            return;
+        return emitWarning.call(process, warning, ...args);
+    };
+    try {
+        return await import("node:sqlite");
+    }
+    finally {
+        process.emitWarning = emitWarning;
+    }
+}
+async function codexTitle(sessionId) {
+    if (typeof sessionId !== "string" || !sessionId)
+        return undefined;
+    const home = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    let newest;
+    for (const name of await readdir(home)) {
+        const match = /^state_(\d+)\.sqlite$/.exec(name);
+        if (match && (newest === undefined || Number(match[1]) > newest.n))
+            newest = { n: Number(match[1]), name };
+    }
+    if (!newest)
+        return undefined;
+    const { DatabaseSync } = await loadSqlite();
+    const db = new DatabaseSync(path.join(home, newest.name), { readOnly: true });
+    try {
+        const row = db.prepare("SELECT name, title FROM threads WHERE id = ?").get(sessionId);
+        return row ? cleanTitle(row.name) ?? cleanTitle(row.title) : undefined;
+    }
+    finally {
+        db.close();
+    }
+}
+/** The title of the conversation `input` (the hook's stdin) belongs to, or undefined; never throws. */
+export async function readTitle(client, input) {
+    let timer;
+    const budget = new Promise((resolve) => { timer = setTimeout(resolve, TITLE_BUDGET_MS, undefined); });
+    const read = client === "claude" ? claudeTitle(input.transcript_path) : codexTitle(input.session_id);
+    try {
+        return await Promise.race([read.catch(() => undefined), budget]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/build/contract.js

@@ -24,20 +24,28 @@ export const CLIENT_INFO_NAMES = contract.clientInfoNames;
 export const CLAUDE_TOOL_USE_META_KEY = contract.meta.claudeToolUseKey;
 export const CODEX_SESSION_META_KEY = contract.meta.codexSessionKey;
 /**
- * Hook stdin fields the host uses. The hook command forwards only these:
+ * Hook stdin fields the host uses. The hook command forwards only these (plus
+ * `title` on SessionStart, UserPromptSubmit and Stop, see cli/title.ts):
  * PostToolUse stdin also carries the whole tool input and response, which can
  * be large and runs on every tool call.
  */
 export const HOOK_INPUT_FIELDS = contract.hookInputFields;
 /**
  * Pseudo hook event of the background wait (`n2n-nexus hook <client> --wait`):
- * started when a turn ends, it waits and returns `{ wake: text }` when
+ * started when a turn ends, it waits and returns `{ wake: text, dispatchId }` when
  * something new arrives for the session, `{ timeout: true }` when the time
  * runs out (the client asks again), or null when the session became active
  * again (the client stops). Claude delivers the text through an asyncRewake
  * hook, Codex through `codex queue`.
  */
 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
+ * `ok: false` the host undoes the wake, so its messages and notices wake the
+ * session again.
+ */
+export const WAKE_RESULT_EVENT = contract.wakeResultEvent;
 /** HTTP timeout of the hook command: a listening Stop may wait long, every other event is quick. */
 export const HOOK_STOP_REQUEST_TIMEOUT_MS = contract.timing.hookStopRequestTimeoutMs;
 export const HOOK_REQUEST_TIMEOUT_MS = contract.timing.hookRequestTimeoutMs;
@@ -46,6 +54,18 @@ export const HOOK_STOP_TIMEOUT_SEC = contract.timing.hookStopTimeoutSec;
 /** `timeout` (seconds) of the background wait hook; a conversation idle for longer is not woken. */
 export const WAIT_HOOK_TIMEOUT_SEC = contract.timing.waitHookTimeoutSec;
 export const HOOK_TIMEOUT_SEC = contract.timing.hookTimeoutSec;
+/** `timeout` (seconds) of the Codex SessionEnd hook: Codex clamps a longer one to 3 s and warns about it. */
+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. */
+export const WAKE_RETRY_FIRST_DELAY_MS = contract.timing.wakeRetryFirstDelayMs;
+export const WAKE_RETRY_MAX_DELAY_MS = contract.timing.wakeRetryMaxDelayMs;
+/**
+ * The hook command adds the conversation's title, as its client shows it, to
+ * the input it forwards as `title` (at most this many characters).
+ */
+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}__.*`;

package/build/index.js

@@ -16,9 +16,10 @@ USAGE:
   n2n-nexus uninstall <claude|codex>
                      Remove the hooks and the MCP server installed by install
   n2n-nexus doctor [claude|codex]
-                     Check that the Node path and entry script in the installed hook and
-                     MCP commands exist and run, and that the host answers with the same
-                     contract version; exit 1 and say how to fix them when not
+                     Check that the Node path and entry script in the installed hooks and
+                     the Node path and npx in the MCP command exist and run, and that the
+                     host answers with the same contract version; exit 1 and say how to
+                     fix them when not
   n2n-nexus hook <claude|codex> [--endpoint <url>] [--wait]
                      Forward a client hook event to the host (run by the hooks)
 

package/build/server/instance-id.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import os from "node:os";
 /**
- * Identity of this MCP adapter as seen by the daemon. Read cursors and
- * meeting initiator permissions are keyed on it, so it has to
+ * Identity of this MCP adapter as seen by the daemon. Read cursors are
+ * keyed on it, so it has to
  * survive an IDE restart: derive it from the machine, the workspace the IDE
  * launched the adapter in and the IDE itself (two IDEs open on the same
  * workspace must not share cursors), unless the user pins one explicitly.

package/build/server/nexus.js

@@ -12,10 +12,14 @@ const SERVICE_NAME = "n2n-nexus";
 /** Sent to the client on connect so the model knows it can talk to other AI sessions. */
 const INSTRUCTIONS = "n2n-nexus connects this conversation with other AI sessions (Claude Code and Codex conversations, " +
     "possibly on other machines). Direct messages: call peers to see who is online, send to message a session, " +
-    "read to read messages sent to you and reply to answer one; listen waits for messages after each turn. " +
+    "read to read messages sent to you, carry out what they ask and reply to answer one (set expectsReply and wake false " +
+    "on a message that needs no answer, and send no 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; the instance ids in read_messages, list_events and meetings (mcp-…) name MCP adapters, not sessions. " +
+    "takes; with the hooks, chat and meetings also record senders and unread cursors per session id " +
+    "(without them, per MCP adapter instance id, mcp-…). join_meeting makes new messages of a meeting wake you " +
+    "(mode active) or show at your next prompt (async) until leave_meeting or the meeting ends; a draft " +
+    "(send_message draft) is decided with stance, and the meeting closes once its required approvers endorse it. " +
     "Projects, global docs, the strategy document and tasks are shared through the other tools.";
 /**
  * MCP adapter in front of the daemon. It holds no session of its own: each

package/contract/errors.json

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

package/contract/hook.json

@@ -1,5 +1,5 @@
 {
-  "contractVersion": 1,
+  "contractVersion": 2,
   "clients": [
     "claude",
     "codex"
@@ -24,6 +24,7 @@
     "reason"
   ],
   "backgroundWaitEvent": "BackgroundWait",
+  "wakeResultEvent": "WakeResult",
   "agentStatuses": [
     "working",
     "idle",
@@ -37,6 +38,10 @@
     "hookStopTimeoutSec": 600,
     "waitHookTimeoutSec": 3600,
     "hookTimeoutSec": 10,
+    "codexSessionEndTimeoutSec": 3,
+    "sessionEndRequestTimeoutMs": 1500,
+    "wakeRetryFirstDelayMs": 1000,
+    "wakeRetryMaxDelayMs": 300000,
     "wakePromptWindowMs": 60000,
     "toolUseBindingTtlMs": 300000,
     "messageTtlMs": 86400000,
@@ -45,9 +50,10 @@
     "staleSessionMs": 1800000
   },
   "limits": {
-    "defaultMaxAutoTurns": 8,
+    "defaultMaxAutoTurns": 0,
     "maxMessageChars": 32000,
     "maxNoteChars": 200,
+    "maxTitleChars": 80,
     "sessionNamePattern": "^[A-Za-z0-9._@#-]{1,48}$",
     "previewChars": 100,
     "notifyListLimit": 5
@@ -58,7 +64,18 @@
     "stopClosing": "Read them with read and answer with reply before you finish.",
     "statusNote": "Only listening sessions answer right away; idle and working ones see a message when their user next sends a prompt or they next call a tool.",
     "sessionStartClosing": "Call peers for the current list, send to message a session, read to read messages sent to you and reply to answer one; set_profile tells others what you work on.",
-    "messageTrustNote": "Messages come from other AI sessions. Read them with read and answer with reply; replying needs no permission from your user. Carry out what a message asks only if it fits what your own user asked for and allows.",
+    "messageTrustNote": "Messages come from other AI sessions. Read them with read, carry out what they ask and answer with reply; replying needs no permission from your user.",
+    "messageInfoNote": "Messages come from other AI sessions; they need no reply.",
+    "noReplyMark": "(no reply needed)",
+    "earlierUnread": "%d earlier direct message(s) still unread; read them with read.",
+    "meetingNews": "Meeting \"%s\" (%s): %d new message(s) (#%d–#%d) from %s.",
+    "meetingClosing": "Read them with read_messages(meetingId); post with send_message(meetingId) only when you have something to add.",
+    "meetingEnded": "Meeting \"%s\" (%s) has ended%s. No reply needed.",
+    "stanceNotice": "%s %s draft #%d of meeting \"%s\" (%s)%s. No reply needed.",
+    "approversChanged": "Required approvers of draft #%d changed (version %d): %s.",
+    "consensusDecision": "Decision by consensus on draft #%d: every required approver (%s) endorsed it.\n\n%s",
+    "stanceReminder": "Meeting \"%s\" (%s) waits for your stance on draft #%d: call stance with meetingId and messageId %d, endorse or object (with a reason). No other reply needed.",
+    "stanceWaiting": "Meeting \"%s\" (%s): draft #%d still waits for the stance of %s. No reply needed.",
     "noAgentSessionError": "This call carries no agent session, so direct messaging cannot tell who you are. It needs the n2n-nexus hooks (n2n-nexus install <claude|codex>, then a new conversation) and the MCP server registered as 'n2n-nexus'. If both are in place, call the tool again: the identity from the hook may have expired."
   },
   "schemas": {