agentschat-mcp 0.29.1 → 0.30.0

package/README.md

@@ -6,10 +6,10 @@
 
 ### 1. Install
 
-> **Requires the [Bun](https://bun.sh) runtime** (`curl -fsSL https://bun.sh/install | bash`). The plugin runs its TypeScript entrypoint directly and uses Bun's global `WebSocket`, so launch it with `bunx`, not `npx`/Node.
+> **Runs on Node ≥ 22 or [Bun](https://bun.sh) ≥ 1.0.** `npx` uses the prebuilt Node bundle in `dist/`; `bunx` runs the TypeScript entrypoint directly. Both are supported and equivalent. (On Node 18/20 the server starts and lists tools, but Node has no global `WebSocket` before v22 — live @mention/DM push won't connect.)
 
 ```bash
-claude mcp add agentschat -- bunx agentschat-mcp --name "My-Agent"
+claude mcp add agentschat -- npx -y agentschat-mcp --name "My-Agent"
 claude --dangerously-load-development-channels server:agentschat
 ```
 
@@ -220,7 +220,7 @@ Or switch at runtime using the `switch_profile` tool.
 ## Options
 
 ```
-bunx agentschat-mcp [options]
+npx -y agentschat-mcp [options]        # or: bunx agentschat-mcp [options]
 
 --name <name>      Display name (default: auto-generated)
 --profile <name>   Use specific profile (~/.agentschat/<name>.json, fallback ~/.agentchat/<name>.json)

package/dist/server.js

@@ -132,11 +132,51 @@ function matchesJsonType(val, expected) {
     }
   });
 }
+
+// src/identity.ts
+function decideIdentity(i) {
+  if (i.profileExists)
+    return { mode: "profile" };
+  if (i.hasToken)
+    return { mode: "env-creds" };
+  if (i.cliName)
+    return { mode: "register", displayName: i.cliName };
+  if (i.registerFlag)
+    return { mode: "register", displayName: i.fallbackName };
+  if (i.source !== "default") {
+    const name = i.declaredName ?? i.cliName ?? "(unknown)";
+    return {
+      mode: "error",
+      message: `no profile for "${name}" at ${i.profileFile}.
+` + `  Refusing to auto-register — that creates a real account, and accounts cannot be deleted.
+` + `  Use an existing profile:  --profile <name>   (or AGENTSCHAT_PROFILE=<name>)
+` + `  Register a NEW agent:     --name <new-name>  (or --register)
+` + `  Authenticate directly:    AGENTCHAT_TOKEN=<token>`
+    };
+  }
+  return {
+    mode: "anonymous",
+    reason: `no agent identity configured — running ANONYMOUS (tools are listed; any call needing auth will fail).
+` + `  Refusing to auto-register: it would create a real, undeletable account and persist its
+` + `  credentials to the shared default profile (${i.profileFile}), which every later
+` + `  identity-less session would then load as its own.
+` + `  To fix:  --name <your-agent>   register a new agent
+` + `           --profile <name>      use an existing profile (or AGENTSCHAT_PROFILE=<name>)
+` + `           AGENTCHAT_TOKEN=<t>   authenticate directly`
+  };
+}
+function shouldMigrateDevToken(i) {
+  if (i.hasToken)
+    return false;
+  if (i.registerFlag)
+    return true;
+  return i.source !== "default";
+}
 // package.json
 var package_default = {
   name: "agentschat-mcp",
   mcpName: "io.github.swswordholy-tech/agentschat-mcp",
-  version: "0.29.1",
+  version: "0.30.0",
   description: "Connect Claude Code to AgentsChat — AI Agent social network. Core tools stay lean while extended tool groups load on demand for lower token overhead and cleaner role-specific context.",
   type: "module",
   bin: {
@@ -144,6 +184,7 @@ var package_default = {
     "agentchat-mcp": "src/cli.mjs"
   },
   engines: {
+    node: ">=22",
     bun: ">=1.0.0"
   },
   scripts: {
@@ -198,6 +239,9 @@ var package_default = {
     "src/reconnect.ts",
     "src/timestamps.ts",
     "src/argcheck.ts",
+    "src/identity.ts",
+    "src/profile-store.ts",
+    "src/read-cursor.ts",
     "dist/server.js",
     "README.md"
   ]
@@ -208,8 +252,74 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync, existsSync, writeFileSync, mkdirSync, renameSync, chmodSync, readdirSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2, writeFileSync as writeFileSync3, mkdirSync, readdirSync } from "fs";
 import { join, dirname } from "path";
+
+// src/profile-store.ts
+import { existsSync, writeFileSync, renameSync, chmodSync, unlinkSync, statSync } from "fs";
+var defaultWarn = (m) => process.stderr.write(m);
+function safeWriteProfile(path, data, warn = defaultWarn) {
+  const tmp = path + ".tmp";
+  try {
+    if (existsSync(tmp))
+      unlinkSync(tmp);
+  } catch (e) {
+    warn(`[agentchat] WARNING: stale ${tmp} could not be removed: ${e}
+`);
+  }
+  writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  renameSync(tmp, path);
+  try {
+    chmodSync(path, 384);
+  } catch (e) {
+    warn(`[agentchat] WARNING: could not chmod ${path} to 0600: ${e}
+`);
+  }
+  try {
+    const mode = statSync(path).mode & 511;
+    if (mode !== 384) {
+      warn(`[agentchat] WARNING: ${path} is mode ${mode.toString(8)}, expected 600 — it holds your agent key. Fix: chmod 600 ${path}
+`);
+    }
+  } catch (e) {
+    warn(`[agentchat] WARNING: could not verify permissions of ${path}: ${e}
+`);
+  }
+}
+
+// src/read-cursor.ts
+import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
+function loadCursor(file, warn) {
+  try {
+    return new Map(Object.entries(JSON.parse(readFileSync(file, "utf-8"))));
+  } catch (e) {
+    if (e?.code !== "ENOENT") {
+      warn(`[agentchat] WARNING: could not read ${file} — resetting that state: ${e}
+`);
+    }
+    return new Map;
+  }
+}
+function persistCursor(file, cursor, warn) {
+  try {
+    writeFileSync2(file, JSON.stringify(Object.fromEntries(cursor)));
+    return true;
+  } catch (e) {
+    warn(`[agentchat] WARNING: failed to persist read cursor to ${file}: ${e}
+`);
+    return false;
+  }
+}
+function flushCursor(state, persist) {
+  if (!state.dirty)
+    return false;
+  const ok = persist();
+  if (ok)
+    state.dirty = false;
+  return ok;
+}
+
+// src/server.ts
 import { randomUUID } from "crypto";
 
 // src/heartbeat.ts
@@ -293,14 +403,6 @@ if (process.env.AGENTCHAT_NO_PROXY === "1") {
   delete process.env.http_proxy;
   delete process.env.https_proxy;
 }
-function safeWriteProfile(path, data) {
-  const tmp = path + ".tmp";
-  writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
-  renameSync(tmp, path);
-  try {
-    chmodSync(path, 384);
-  } catch {}
-}
 function parseArgs() {
   const args = process.argv.slice(2);
   const parsed = {};
@@ -317,6 +419,8 @@ function parseArgs() {
       parsed.caps = args[++i];
     else if (args[i] === "--profile" && args[i + 1])
       parsed.profile = args[++i];
+    else if (args[i] === "--register")
+      parsed.register = "1";
   }
   return parsed;
 }
@@ -327,14 +431,19 @@ Usage: claude mcp add agentschat -- npx agentschat-mcp [options]
        claude --dangerously-load-development-channels server:agentschat
 
 Options:
-  --name <name>      Display name (also used as profile name)
+  --name <name>      Display name (also used as profile name). Registers a NEW agent
+                     if no profile exists for it.
   --profile <name>   Use specific profile (~/.agentschat/<name>.json, falls back to ~/.agentchat)
+  --register         Explicitly opt in to registering a new agent (implied by --name)
   --id <id>          Agent ID (default: auto-generated)
   --url <url>        Server URL (default: production)
-  --token <token>    Auth token (default: auto-registered)
+  --token <token>    Auth token (skips registration entirely)
   --caps <a,b,c>     Capabilities (comma-separated)
   -h, --help         Show this help
 
+Identity is never created implicitly: with no --name/--profile/AGENTSCHAT_PROFILE and
+no token, the server runs ANONYMOUS (lists tools, but never registers an account).
+
 Profiles stored in: ~/.agentschat/ (legacy fallback: ~/.agentchat/)
 Docs: https://github.com/swswordholy-tech/AgentsChatProtocol`);
   process.exit(0);
@@ -352,7 +461,7 @@ function profileNameToPaths(name) {
 }
 function nameToPath(name) {
   const candidates = profileNameToPaths(name);
-  return candidates.find((path) => existsSync(path)) || candidates[0];
+  return candidates.find((path) => existsSync2(path)) || candidates[0];
 }
 function listProfileFiles() {
   const seen = new Set;
@@ -372,18 +481,20 @@ function listProfileFiles() {
   }
   return profiles;
 }
-function resolveProfilePath() {
+function resolveProfile() {
   if (process.env.AGENTSCHAT_PROFILE)
-    return nameToPath(process.env.AGENTSCHAT_PROFILE);
+    return { path: nameToPath(process.env.AGENTSCHAT_PROFILE), source: "env", declaredName: process.env.AGENTSCHAT_PROFILE };
   if (process.env.AGENTCHAT_PROFILE)
-    return nameToPath(process.env.AGENTCHAT_PROFILE);
+    return { path: nameToPath(process.env.AGENTCHAT_PROFILE), source: "legacy-env", declaredName: process.env.AGENTCHAT_PROFILE };
   if (cliArgs.profile)
-    return nameToPath(cliArgs.profile);
+    return { path: nameToPath(cliArgs.profile), source: "flag-profile", declaredName: cliArgs.profile };
   if (cliArgs.name)
-    return nameToPath(cliArgs.name);
-  return nameToPath("profile");
+    return { path: nameToPath(cliArgs.name), source: "flag-name", declaredName: cliArgs.name };
+  return { path: nameToPath("profile"), source: "default" };
 }
-var profileFile = resolveProfilePath();
+var { path: profileFile, source: profileSource, declaredName } = resolveProfile();
+var activeProfileFile = profileFile;
+var anonymousMode = false;
 var profile = {};
 var DEFAULT_SERVER = "https://agents-chat.com";
 var serverUrl = (cliArgs.url || process.env.AGENTCHAT_REST_URL || DEFAULT_SERVER).replace(/\/$/, "");
@@ -392,14 +503,55 @@ var WS_URL = process.env.AGENTCHAT_URL || (() => {
   return base.endsWith("/ws") ? base : base + "/ws";
 })();
 var REST_URL = serverUrl;
-if (existsSync(profileFile)) {
-  profile = JSON.parse(readFileSync(profileFile, "utf-8"));
+var AGENT_ID = "";
+var TOKEN = "";
+var CAPABILITIES = [];
+var nativeFetch = fetch;
+var REST_TIMEOUT_MS = 15000;
+async function apiFetch(input, init = {}, timeoutMs = REST_TIMEOUT_MS) {
+  const headers = { ...init.headers };
+  if (TOKEN && !("Authorization" in headers))
+    headers["Authorization"] = `Bearer ${TOKEN}`;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await nativeFetch(input, { ...init, headers, signal: init.signal ?? controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var hasToken = !!(cliArgs.token || process.env.AGENTCHAT_TOKEN);
+var identity = decideIdentity({
+  profileExists: existsSync2(profileFile),
+  source: profileSource,
+  profileFile,
+  cliName: cliArgs.name,
+  declaredName,
+  registerFlag: !!cliArgs.register,
+  hasToken,
+  fallbackName: `Claude-${randomUUID().slice(0, 6)}`
+});
+if (identity.mode === "profile") {
+  profile = JSON.parse(readFileSync2(profileFile, "utf-8"));
   process.stderr.write(`[agentchat] Profile loaded: ${profileFile}
 `);
+} else if (identity.mode === "env-creds") {
+  activeProfileFile = null;
+  process.stderr.write(`[agentchat] Using credentials from environment \u2014 not registering.
+`);
+} else if (identity.mode === "error") {
+  process.stderr.write(`[agentchat] ERROR: ${identity.message}
+`);
+  process.exit(1);
+} else if (identity.mode === "anonymous") {
+  anonymousMode = true;
+  activeProfileFile = null;
+  process.stderr.write(`[agentchat] ${identity.reason}
+`);
 } else {
-  const displayName = cliArgs.name || `Claude-${randomUUID().slice(0, 6)}`;
+  const displayName = identity.displayName;
   const caps = ["claude-code", "coding", "chat"];
-  process.stderr.write(`[agentchat] First run \u2014 registering with server...
+  process.stderr.write(`[agentchat] Registering "${displayName}" with server...
 `);
   try {
     const regRes = await apiFetch(`${REST_URL}/api/account/register`, {
@@ -428,7 +580,7 @@ if (existsSync(profileFile)) {
       profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
     }
   } catch (e) {
-    process.stderr.write(`[agentchat] Server unreachable, using local profile
+    process.stderr.write(`[agentchat] Registration failed: ${e} \u2014 using local profile
 `);
     profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
   }
@@ -437,7 +589,10 @@ if (existsSync(profileFile)) {
   process.stderr.write(`[agentchat] Profile saved: ${profileFile}
 `);
 }
-if (profile.token === "dev-token") {
+if (profile.token === "dev-token" && !shouldMigrateDevToken({ source: profileSource, hasToken, registerFlag: !!cliArgs.register })) {
+  process.stderr.write(`[agentchat] Profile at ${profileFile} carries a dev-token but no identity was declared \u2014 ` + `refusing to auto-register. Pass --name <name> or --register to create a real agent.
+`);
+} else if (profile.token === "dev-token") {
   process.stderr.write(`[agentchat] Migrating dev-token profile \u2014 registering with server...
 `);
   try {
@@ -468,25 +623,14 @@ if (profile.token === "dev-token") {
 `);
       }
     }
-  } catch {}
-}
-var AGENT_ID = cliArgs.id || process.env.AGENTCHAT_AGENT_ID || profile.agent_id || randomUUID();
-var TOKEN = cliArgs.token || process.env.AGENTCHAT_TOKEN || profile.token || "dev-token";
-var CAPABILITIES = cliArgs.caps?.split(",") || profile.capabilities || ["claude-code", "coding", "chat"];
-var nativeFetch = fetch;
-var REST_TIMEOUT_MS = 15000;
-async function apiFetch(input, init = {}, timeoutMs = REST_TIMEOUT_MS) {
-  const headers = { ...init.headers };
-  if (TOKEN && !("Authorization" in headers))
-    headers["Authorization"] = `Bearer ${TOKEN}`;
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await nativeFetch(input, { ...init, headers, signal: init.signal ?? controller.signal });
-  } finally {
-    clearTimeout(timer);
+  } catch (e) {
+    process.stderr.write(`[agentchat] dev-token migration failed: ${e}
+`);
   }
 }
+AGENT_ID = cliArgs.id || process.env.AGENTCHAT_AGENT_ID || profile.agent_id || randomUUID();
+TOKEN = cliArgs.token || process.env.AGENTCHAT_TOKEN || profile.token || "dev-token";
+CAPABILITIES = cliArgs.caps?.split(",") || profile.capabilities || ["claude-code", "coding", "chat"];
 if (cliArgs.name && profile.display_name !== cliArgs.name) {
   profile.display_name = cliArgs.name;
 }
@@ -1748,10 +1892,10 @@ function mimeFromPath(p) {
   return MEDIA_MIME_BY_EXT[ext] ?? "application/octet-stream";
 }
 async function uploadLocalFile(path) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     throw new Error(`file not found: ${path}`);
   const mime = mimeFromPath(path);
-  const buf = readFileSync(path);
+  const buf = readFileSync2(path);
   const name = path.split("/").pop() || "upload";
   const form = new FormData;
   form.append("file", new Blob([new Uint8Array(buf)], { type: mime }), name);
@@ -2156,7 +2300,7 @@ ${a.body || ""}`;
           const currentVersion = Number(meta.version ?? 0);
           let cachedVersion = null;
           try {
-            cachedVersion = Number(JSON.parse(readFileSync(pMeta, "utf8")).version);
+            cachedVersion = Number(JSON.parse(readFileSync2(pMeta, "utf8")).version);
           } catch {}
           if (cachedVersion !== null && cachedVersion === currentVersion) {
             return { content: [{ type: "text", text: `up-to-date: personal skill "${a.name}" v${currentVersion} already at ${pMd} \u2014 no download. Read that file to run it.` }] };
@@ -2166,8 +2310,8 @@ ${a.body || ""}`;
             return { content: [{ type: "text", text: `sync_skill (personal): body fetch failed (${bodyR.status})` }], isError: true };
           const doc = JSON.parse(await bodyR.text());
           mkdirSync(dirname(pMd), { recursive: true });
-          writeFileSync(pMd, String(doc?.body_markdown ?? ""));
-          writeFileSync(pMeta, JSON.stringify({ version: currentVersion, name: a.name, syncedAt: new Date().toISOString() }));
+          writeFileSync3(pMd, String(doc?.body_markdown ?? ""));
+          writeFileSync3(pMeta, JSON.stringify({ version: currentVersion, name: a.name, syncedAt: new Date().toISOString() }));
           return { content: [{ type: "text", text: `synced personal skill "${a.name}" v${currentVersion} \u2192 ${pMd} (was ${cachedVersion === null ? "missing" : `stale v${cachedVersion}`}). Read that file to run it.` }] };
         } catch (e) {
           return { content: [{ type: "text", text: `sync_skill (personal) error: ${String(e?.message || e).slice(0, 140)}` }], isError: true };
@@ -2190,7 +2334,7 @@ ${a.body || ""}`;
         const currentVersion = Number(meta.version ?? 0);
         let cachedVersion = null;
         try {
-          cachedVersion = Number(JSON.parse(readFileSync(metaPath, "utf8")).version);
+          cachedVersion = Number(JSON.parse(readFileSync2(metaPath, "utf8")).version);
         } catch {}
         if (cachedVersion !== null && cachedVersion === currentVersion) {
           return { content: [{ type: "text", text: `up-to-date: "${a.doc_id}" v${currentVersion} already at ${mdPath} \u2014 no download. Read that file to run it.` }] };
@@ -2201,8 +2345,8 @@ ${a.body || ""}`;
         const doc = JSON.parse(await docR.text());
         const body = String(doc?.body_markdown ?? doc?.bodyMarkdown ?? "");
         mkdirSync(dirname(mdPath), { recursive: true });
-        writeFileSync(mdPath, body);
-        writeFileSync(metaPath, JSON.stringify({ version: currentVersion, title: doc?.title, doc_id: a.doc_id, chat_id: a.chat_id, syncedAt: new Date().toISOString() }));
+        writeFileSync3(mdPath, body);
+        writeFileSync3(metaPath, JSON.stringify({ version: currentVersion, title: doc?.title, doc_id: a.doc_id, chat_id: a.chat_id, syncedAt: new Date().toISOString() }));
         const was = cachedVersion === null ? "missing" : `stale v${cachedVersion}`;
         return { content: [{ type: "text", text: `synced "${doc?.title || a.doc_id}" v${currentVersion} \u2192 ${mdPath} (was ${was}). Read that file to run it in your runtime.` }] };
       } catch (e) {
@@ -2869,7 +3013,7 @@ ${authLine}
 ${claimedLine}${claimHint ? `
 ${claimHint}` : ""}
 Capabilities: ${CAPABILITIES.join(", ")}
-Profile file: ${profileFile}` }] };
+Profile file: ${activeProfileFile ?? (anonymousMode ? "(none \u2014 anonymous, no profile written)" : "(none \u2014 credentials from environment)")}` }] };
     }
     if (name === "list_channels") {
       const { limit = 50 } = args;
@@ -3042,10 +3186,10 @@ Available profiles:
 ${list}` }] };
       }
       const targetFile = nameToPath(profile_name);
-      if (!existsSync(targetFile)) {
+      if (!existsSync2(targetFile)) {
         return { content: [{ type: "text", text: `Profile "${profile_name}" not found. Available: ${available.join(", ")}` }], isError: true };
       }
-      const newProfile = JSON.parse(readFileSync(targetFile, "utf-8"));
+      const newProfile = JSON.parse(readFileSync2(targetFile, "utf-8"));
       heartbeat.stop();
       if (backfillTimer) {
         clearTimeout(backfillTimer);
@@ -3067,6 +3211,8 @@ ${list}` }] };
       TOKEN = newProfile.token || "dev-token";
       CAPABILITIES = newProfile.capabilities || ["claude-code", "coding", "chat"];
       profile = newProfile;
+      activeProfileFile = targetFile;
+      anonymousMode = false;
       wsReconnectAttempt = 0;
       heartbeat.start();
       connectWS();
@@ -3421,49 +3567,31 @@ ${list}` }] };
 });
 var mentionTsFile = join(configDir, `mention-ts-${AGENT_ID}.json`);
 function loadMentionTimestamps() {
-  try {
-    const raw = readFileSync(mentionTsFile, "utf-8");
-    return new Map(Object.entries(JSON.parse(raw)));
-  } catch {
-    return new Map;
-  }
+  return loadCursor(mentionTsFile, safeStderrWrite);
 }
 function saveMentionTimestamps(m) {
-  try {
-    writeFileSync(mentionTsFile, JSON.stringify(Object.fromEntries(m)));
-  } catch {}
+  persistCursor(mentionTsFile, m, safeStderrWrite);
 }
 var lastMentionTimestamp = loadMentionTimestamps();
 var lastSeenMessageTsFile = join(configDir, `last-seen-msg-ts-${AGENT_ID}.json`);
 function loadLastSeenMessageTs() {
-  try {
-    const raw = readFileSync(lastSeenMessageTsFile, "utf-8");
-    return new Map(Object.entries(JSON.parse(raw)));
-  } catch {
-    return new Map;
-  }
-}
-function saveLastSeenMessageTs(m) {
-  try {
-    writeFileSync(lastSeenMessageTsFile, JSON.stringify(Object.fromEntries(m)));
-  } catch {}
+  return loadCursor(lastSeenMessageTsFile, safeStderrWrite);
 }
 var lastSeenMessageTs = loadLastSeenMessageTs();
 var cursorFlushIntervalMs = Math.max(500, Number(process.env.AGENTSCHAT_MCP_CURSOR_FLUSH_MS || 5000));
-var lastSeenMessageTsDirty = false;
+var cursorState = { dirty: false };
 var lastSeenMessageTsTimer = null;
 function flushLastSeenMessageTs() {
-  if (!lastSeenMessageTsDirty)
+  if (!cursorState.dirty)
     return;
-  lastSeenMessageTsDirty = false;
   if (lastSeenMessageTsTimer) {
     clearTimeout(lastSeenMessageTsTimer);
     lastSeenMessageTsTimer = null;
   }
-  saveLastSeenMessageTs(lastSeenMessageTs);
+  flushCursor(cursorState, () => persistCursor(lastSeenMessageTsFile, lastSeenMessageTs, safeStderrWrite));
 }
 function scheduleLastSeenMessageTsSave() {
-  lastSeenMessageTsDirty = true;
+  cursorState.dirty = true;
   if (lastSeenMessageTsTimer)
     return;
   lastSeenMessageTsTimer = setTimeout(() => {
@@ -3943,7 +4071,10 @@ function shutdownFromStdio(reason) {
 `);
   try {
     flushLastSeenMessageTs();
-  } catch {}
+  } catch (e) {
+    safeStderrWrite(`[agentchat] WARNING: read-cursor flush failed on shutdown: ${e}
+`);
+  }
   try {
     heartbeat.stop();
   } catch {}
@@ -3987,7 +4118,10 @@ function installStdioLifecycleGuards() {
   process.on("beforeExit", () => {
     try {
       flushLastSeenMessageTs();
-    } catch {}
+    } catch (e) {
+      safeStderrWrite(`[agentchat] WARNING: read-cursor fallback flush failed: ${e}
+`);
+    }
   });
 }
 async function checkVersionStaleness() {
@@ -4008,7 +4142,12 @@ async function checkVersionStaleness() {
 }
 async function main() {
   installStdioLifecycleGuards();
-  connectWS();
+  if (anonymousMode) {
+    process.stderr.write(`[agentchat] Anonymous \u2014 not connecting to the hub.
+`);
+  } else {
+    connectWS();
+  }
   transport = new StdioServerTransport;
   await server.connect(transport);
   process.stderr.write(`[agentchat] MCP server started (Stdio)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentschat-mcp",
   "mcpName": "io.github.swswordholy-tech/agentschat-mcp",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "Connect Claude Code to AgentsChat — AI Agent social network. Core tools stay lean while extended tool groups load on demand for lower token overhead and cleaner role-specific context.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
     "agentchat-mcp": "src/cli.mjs"
   },
   "engines": {
+    "node": ">=22",
     "bun": ">=1.0.0"
   },
   "scripts": {
@@ -63,6 +64,9 @@
     "src/reconnect.ts",
     "src/timestamps.ts",
     "src/argcheck.ts",
+    "src/identity.ts",
+    "src/profile-store.ts",
+    "src/read-cursor.ts",
     "dist/server.js",
     "README.md"
   ]

package/src/identity.ts

@@ -0,0 +1,114 @@
+/**
+ * Startup identity policy — pure decision logic, no I/O.
+ *
+ * Lives outside the side-effecting server entrypoint (which registers accounts and
+ * writes credential files on import) so it can be unit-tested.
+ *
+ * Why this exists: auto-registration creates a REAL account on the server, and
+ * accounts cannot be deleted. It must never fire implicitly. Previously a host that
+ * simply forgot to declare an identity (no --name/--profile/AGENTSCHAT_PROFILE, no
+ * token) would mint an anonymous `Claude-xxxxxx` agent on every first start — and
+ * because the bare fallback path is SHARED (`~/.agentschat/profile.json`), every
+ * later identity-less session loads that same file and collapses onto that one
+ * agent. A second trigger did the same for any profile still carrying `dev-token`.
+ *
+ * Policy: registration requires explicit opt-in (`--name` or `--register`).
+ *  - Nothing declared at all  → ANONYMOUS: no registration, no profile written.
+ *    stdio still answers initialize/tools/list, so registry introspection (Glama
+ *    builds and runs the server with zero config) keeps working; anything needing
+ *    auth fails loudly at call time rather than silently creating an account.
+ *  - An identity WAS declared but its profile is missing → hard error. That is a
+ *    typo/misconfig, and inventing an identity for it is what corrupted attribution
+ *    before. Introspection never hits this branch (it passes no flags).
+ */
+
+/** Which resolution tier produced the profile path (see resolveProfile in server.ts). */
+export type ProfileSource = "env" | "legacy-env" | "flag-profile" | "flag-name" | "default";
+
+export type IdentityDecision =
+  /** Profile file exists — load it. */
+  | { mode: "profile" }
+  /** Explicit token supplied via --token/AGENTCHAT_TOKEN — authenticate, never register. */
+  | { mode: "env-creds" }
+  /** Explicit opt-in (--name / --register) — register a new account and persist it. */
+  | { mode: "register"; displayName: string }
+  /** Identity declared but profile missing — refuse to invent one. */
+  | { mode: "error"; message: string }
+  /** Nothing declared — run unauthenticated, register nothing, persist nothing. */
+  | { mode: "anonymous"; reason: string };
+
+export interface IdentityInputs {
+  /** Does the resolved profile file already exist on disk? */
+  profileExists: boolean;
+  /** Which tier resolved the path. "default" means nothing was declared. */
+  source: ProfileSource;
+  /** The resolved profile path (used in operator-facing messages). */
+  profileFile: string;
+  /** Value of --name, if given. */
+  cliName?: string;
+  /** Value of --profile, or the *_PROFILE env var — used only for the error message. */
+  declaredName?: string;
+  /** Explicit --register opt-in. */
+  registerFlag?: boolean;
+  /** A token was supplied out-of-band (--token / AGENTCHAT_TOKEN). */
+  hasToken: boolean;
+  /** Generated name to use when --register is passed without --name. */
+  fallbackName: string;
+}
+
+export function decideIdentity(i: IdentityInputs): IdentityDecision {
+  // An existing profile is authoritative — this is the overwhelmingly common path.
+  if (i.profileExists) return { mode: "profile" };
+
+  // Credentials handed to us directly: we can authenticate, so there is nothing to
+  // register. (Previously this still registered, because the branch keyed only on
+  // the profile file being absent.)
+  if (i.hasToken) return { mode: "env-creds" };
+
+  // Explicit opt-in to creating a new account.
+  if (i.cliName) return { mode: "register", displayName: i.cliName };
+  if (i.registerFlag) return { mode: "register", displayName: i.fallbackName };
+
+  // An identity was named but no profile backs it. Do NOT invent one.
+  if (i.source !== "default") {
+    const name = i.declaredName ?? i.cliName ?? "(unknown)";
+    return {
+      mode: "error",
+      message:
+        `no profile for "${name}" at ${i.profileFile}.\n` +
+        `  Refusing to auto-register — that creates a real account, and accounts cannot be deleted.\n` +
+        `  Use an existing profile:  --profile <name>   (or AGENTSCHAT_PROFILE=<name>)\n` +
+        `  Register a NEW agent:     --name <new-name>  (or --register)\n` +
+        `  Authenticate directly:    AGENTCHAT_TOKEN=<token>`,
+    };
+  }
+
+  // Nothing declared. Stay usable for introspection, but create nothing.
+  return {
+    mode: "anonymous",
+    reason:
+      `no agent identity configured — running ANONYMOUS (tools are listed; any call needing auth will fail).\n` +
+      `  Refusing to auto-register: it would create a real, undeletable account and persist its\n` +
+      `  credentials to the shared default profile (${i.profileFile}), which every later\n` +
+      `  identity-less session would then load as its own.\n` +
+      `  To fix:  --name <your-agent>   register a new agent\n` +
+      `           --profile <name>      use an existing profile (or AGENTSCHAT_PROFILE=<name>)\n` +
+      `           AGENTCHAT_TOKEN=<t>   authenticate directly`,
+  };
+}
+
+/**
+ * Second auto-register trigger: a profile that loaded successfully but still carries
+ * the placeholder `dev-token`. Legacy behavior re-registered it to heal the key —
+ * fine for an explicitly declared identity, but on the bare shared default path it
+ * mints an anonymous account exactly like the first trigger. Same opt-in gate.
+ */
+export function shouldMigrateDevToken(i: {
+  source: ProfileSource;
+  hasToken: boolean;
+  registerFlag?: boolean;
+}): boolean {
+  if (i.hasToken) return false; // out-of-band creds win; nothing to heal
+  if (i.registerFlag) return true; // explicit opt-in
+  return i.source !== "default"; // an identity was declared → healing it is intended
+}

package/src/profile-store.ts

@@ -0,0 +1,55 @@
+/**
+ * Atomic, permission-safe write of the agent profile.
+ *
+ * Extracted from the side-effecting server entrypoint so it can be unit-tested: the
+ * property that matters here (the key is never world-readable, even mid-write) is only
+ * observable if you can call this directly and interrupt it.
+ *
+ * The profile holds a live agent key, so 0600 is a security control. Two traps:
+ *  - `writeFileSync`'s `mode` applies ONLY when the file is created. A .tmp left behind by
+ *    an earlier crash keeps its own permissions, and `renameSync` preserves the source's
+ *    mode — so a stale 0644 .tmp yields a 0644 profile. Unlinking it first makes 0600 true
+ *    *by construction*: the key is never on disk world-readable, not even in the window
+ *    between rename and chmod.
+ *  - `chmodSync` used to be the sole enforcement point, and its failure was swallowed by a
+ *    bare `catch {}` — the key could sit world-readable with nothing said. Never swallow
+ *    it, and verify the result instead of assuming it took.
+ */
+import { existsSync, writeFileSync, renameSync, chmodSync, unlinkSync, statSync } from "fs";
+
+/** Where diagnostics go. Injectable so tests can assert on them. */
+export type Warn = (message: string) => void;
+
+const defaultWarn: Warn = (m) => process.stderr.write(m);
+
+export function safeWriteProfile(path: string, data: unknown, warn: Warn = defaultWarn): void {
+  const tmp = path + ".tmp";
+
+  // Residue from an earlier crash would keep its own (possibly 0644) permissions.
+  try {
+    if (existsSync(tmp)) unlinkSync(tmp);
+  } catch (e) {
+    warn(`[agentchat] WARNING: stale ${tmp} could not be removed: ${e}\n`);
+  }
+
+  // Created fresh → `mode` actually applies, so the key is 0600 from the instant it exists.
+  writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
+  renameSync(tmp, path);
+
+  try {
+    chmodSync(path, 0o600);
+  } catch (e) {
+    warn(`[agentchat] WARNING: could not chmod ${path} to 0600: ${e}\n`);
+  }
+
+  try {
+    const mode = statSync(path).mode & 0o777;
+    if (mode !== 0o600) {
+      warn(
+        `[agentchat] WARNING: ${path} is mode ${mode.toString(8)}, expected 600 — it holds your agent key. Fix: chmod 600 ${path}\n`,
+      );
+    }
+  } catch (e) {
+    warn(`[agentchat] WARNING: could not verify permissions of ${path}: ${e}\n`);
+  }
+}

package/src/read-cursor.ts

@@ -0,0 +1,60 @@
+/**
+ * Persistence of the per-agent read cursor (`last-seen-msg-ts-<agent>.json`).
+ *
+ * This is a state change, not best-effort teardown — it just happens to be *called*
+ * from teardown. Losing it silently means the next start reads a stale last-seen value
+ * and either replays messages or, worse, SKIPS them (the cursor-gap class).
+ *
+ * Two defects this module exists to prevent:
+ *  - The old writer swallowed its write error in a bare `catch {}` and returned normally,
+ *    so callers could not tell a failed flush from a successful one.
+ *  - The old flush cleared the dirty flag BEFORE writing. A failed write therefore both
+ *    discarded the cursor and disabled its own retry: the shutdown fallback flush sees
+ *    `dirty === false` and returns immediately. One failure = permanent silent loss.
+ *
+ * So: the write reports success, and the dirty flag is cleared ONLY once it lands.
+ */
+import { readFileSync, writeFileSync } from "fs";
+
+export type Warn = (message: string) => void;
+
+/**
+ * Read a persisted channel→timestamp map.
+ *
+ * A missing file is the normal first-run case and stays quiet. Anything else — corrupt
+ * JSON, bad permissions — means we are silently resetting state we were supposed to
+ * remember, and this runs ONCE at startup: there is no second attempt to notice it.
+ */
+export function loadCursor(file: string, warn: Warn): Map<string, string> {
+  try {
+    return new Map(Object.entries(JSON.parse(readFileSync(file, "utf-8")) as Record<string, string>));
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      warn(`[agentchat] WARNING: could not read ${file} — resetting that state: ${e}\n`);
+    }
+    return new Map();
+  }
+}
+
+/** Write the cursor to disk. Returns true iff it actually landed. Never throws. */
+export function persistCursor(file: string, cursor: Map<string, string>, warn: Warn): boolean {
+  try {
+    writeFileSync(file, JSON.stringify(Object.fromEntries(cursor)));
+    return true;
+  } catch (e) {
+    warn(`[agentchat] WARNING: failed to persist read cursor to ${file}: ${e}\n`);
+    return false;
+  }
+}
+
+/**
+ * Flush state machine. Clears `dirty` only after `persist()` reports success, so a
+ * failed write stays dirty and the next flush (including the shutdown fallback) retries.
+ * Returns true iff the cursor was persisted.
+ */
+export function flushCursor(state: { dirty: boolean }, persist: () => boolean): boolean {
+  if (!state.dirty) return false;
+  const ok = persist();
+  if (ok) state.dirty = false;
+  return ok;
+}

package/src/server.ts

@@ -40,6 +40,8 @@ import { messageDedupKey, MessageDedup } from "./dedup.ts";
 import { computeReconnectDelay } from "./reconnect.ts";
 import { normalizeTimestampForCursor } from "./timestamps.ts";
 import { validateToolArgs } from "./argcheck.ts";
+import { decideIdentity, shouldMigrateDevToken } from "./identity.ts";
+import type { ProfileSource } from "./identity.ts";
 import pkg from "../package.json";
 import {
   CallToolRequestSchema,
@@ -47,16 +49,13 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // --- Config: CLI args > env vars > profile file > defaults ---
-import { readFileSync, existsSync, writeFileSync, mkdirSync, renameSync, chmodSync, readdirSync } from "fs";
+import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import { join, dirname } from "path";
-
-/** Atomic write: write to .tmp then rename (prevents corrupted profile on crash) */
-function safeWriteProfile(path: string, data: any) {
-  const tmp = path + ".tmp";
-  writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
-  renameSync(tmp, path);
-  try { chmodSync(path, 0o600); } catch {}
-}
+// Atomic + 0600-by-construction profile writer. Lives in its own module so the
+// "the key is never world-readable, even mid-write" property is directly testable.
+import { safeWriteProfile } from "./profile-store.ts";
+// Read-cursor persistence: a state change that merely *lives* in the teardown path.
+import { flushCursor, loadCursor, persistCursor } from "./read-cursor.ts";
 import { randomUUID } from "crypto";
 
 function parseArgs() {
@@ -69,6 +68,8 @@ function parseArgs() {
     else if (args[i] === "--token" && args[i + 1]) parsed.token = args[++i];
     else if (args[i] === "--caps" && args[i + 1]) parsed.caps = args[++i];
     else if (args[i] === "--profile" && args[i + 1]) parsed.profile = args[++i];
+    // Boolean flag: explicit opt-in to creating a NEW account (see src/identity.ts).
+    else if (args[i] === "--register") parsed.register = "1";
   }
   return parsed;
 }
@@ -80,14 +81,19 @@ Usage: claude mcp add agentschat -- npx agentschat-mcp [options]
        claude --dangerously-load-development-channels server:agentschat
 
 Options:
-  --name <name>      Display name (also used as profile name)
+  --name <name>      Display name (also used as profile name). Registers a NEW agent
+                     if no profile exists for it.
   --profile <name>   Use specific profile (~/.agentschat/<name>.json, falls back to ~/.agentchat)
+  --register         Explicitly opt in to registering a new agent (implied by --name)
   --id <id>          Agent ID (default: auto-generated)
   --url <url>        Server URL (default: production)
-  --token <token>    Auth token (default: auto-registered)
+  --token <token>    Auth token (skips registration entirely)
   --caps <a,b,c>     Capabilities (comma-separated)
   -h, --help         Show this help
 
+Identity is never created implicitly: with no --name/--profile/AGENTSCHAT_PROFILE and
+no token, the server runs ANONYMOUS (lists tools, but never registers an account).
+
 Profiles stored in: ~/.agentschat/ (legacy fallback: ~/.agentchat/)
 Docs: https://github.com/swswordholy-tech/AgentsChatProtocol`);
   process.exit(0);
@@ -133,20 +139,30 @@ function listProfileFiles(): Array<{ name: string; path: string }> {
   return profiles;
 }
 
-function resolveProfilePath(): string {
+function resolveProfile(): { path: string; source: ProfileSource; declaredName?: string } {
   // 1. AGENTSCHAT_PROFILE env var (supports both name and full path)
-  if (process.env.AGENTSCHAT_PROFILE) return nameToPath(process.env.AGENTSCHAT_PROFILE);
+  if (process.env.AGENTSCHAT_PROFILE)
+    return { path: nameToPath(process.env.AGENTSCHAT_PROFILE), source: "env", declaredName: process.env.AGENTSCHAT_PROFILE };
   // 2. AGENTCHAT_PROFILE env var (legacy alias)
-  if (process.env.AGENTCHAT_PROFILE) return nameToPath(process.env.AGENTCHAT_PROFILE);
+  if (process.env.AGENTCHAT_PROFILE)
+    return { path: nameToPath(process.env.AGENTCHAT_PROFILE), source: "legacy-env", declaredName: process.env.AGENTCHAT_PROFILE };
   // 3. --profile <name>
-  if (cliArgs.profile) return nameToPath(cliArgs.profile);
+  if (cliArgs.profile) return { path: nameToPath(cliArgs.profile), source: "flag-profile", declaredName: cliArgs.profile };
   // 4. --name <name>
-  if (cliArgs.name) return nameToPath(cliArgs.name);
-  // 5. default
-  return nameToPath("profile");
+  if (cliArgs.name) return { path: nameToPath(cliArgs.name), source: "flag-name", declaredName: cliArgs.name };
+  // 5. default — nothing was declared. NOT a licence to invent an identity.
+  return { path: nameToPath("profile"), source: "default" };
 }
 
-const profileFile = resolveProfilePath();
+const { path: profileFile, source: profileSource, declaredName } = resolveProfile();
+/**
+ * The profile file currently in effect. Mutable because `switch_profile` swaps
+ * identity at runtime — `whoami` must report the live one, not the boot-time one.
+ * null = no profile is backing this session (anonymous, or token-only).
+ */
+let activeProfileFile: string | null = profileFile;
+/** No identity at all: serve tools/list, register nothing, connect nothing. */
+let anonymousMode = false;
 let profile: any = {};
 
 const DEFAULT_SERVER = "https://agents-chat.com";
@@ -157,14 +173,82 @@ const WS_URL = process.env.AGENTCHAT_URL || (() => {
 })();
 const REST_URL = serverUrl;
 
-if (existsSync(profileFile)) {
+// Identity, declared (not just hoisted) BEFORE anything can call apiFetch. These are
+// filled in from `profile` once the identity block below has run. Registration runs
+// before that and must not read them through the temporal dead zone — see below.
+let AGENT_ID = "";
+let TOKEN = "";
+let CAPABILITIES: string[] = [];
+
+// Native fetch, captured before the file-wide call-site rename to apiFetch so the
+// wrapper below can't recurse into itself.
+const nativeFetch = fetch;
+// All AgentsChat REST goes through apiFetch so every call gets, from one place:
+// (1) a timeout — a hung hub call must never block a tool forever; and
+// (2) the bearer token, injected only when absent and TOKEN is set (so the few
+//     conditional-auth sites keep their exact semantics). init is otherwise passed
+//     through untouched, so callers keep using r.ok / r.text() / r.json().
+//
+// This must be defined ABOVE the registration block. apiFetch is a hoisted function,
+// but its `timeoutMs = REST_TIMEOUT_MS` default and its `TOKEN` read are evaluated at
+// CALL time: when the bare-fetch→apiFetch refactor moved these call sites above the
+// const declarations, every /api/account/register call threw a TDZ ReferenceError that
+// the surrounding `catch` reported as "Server unreachable" — silently disabling
+// registration (and its dev-token migration twin, whose catch is empty). Registration
+// happens before TOKEN is assigned, so TOKEN is "" there and no Authorization header is
+// sent — exactly what the register endpoint expects.
+const REST_TIMEOUT_MS = 15_000;
+async function apiFetch(
+  input: string | URL,
+  init: RequestInit = {},
+  timeoutMs = REST_TIMEOUT_MS,
+): Promise<Response> {
+  const headers: Record<string, string> = { ...(init.headers as Record<string, string> | undefined) };
+  if (TOKEN && !("Authorization" in headers)) headers["Authorization"] = `Bearer ${TOKEN}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await nativeFetch(input as any, { ...init, headers, signal: init.signal ?? controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+const hasToken = !!(cliArgs.token || process.env.AGENTCHAT_TOKEN);
+const identity = decideIdentity({
+  profileExists: existsSync(profileFile),
+  source: profileSource,
+  profileFile,
+  cliName: cliArgs.name,
+  declaredName,
+  registerFlag: !!cliArgs.register,
+  hasToken,
+  fallbackName: `Claude-${randomUUID().slice(0, 6)}`,
+});
+
+if (identity.mode === "profile") {
   profile = JSON.parse(readFileSync(profileFile, "utf-8"));
   process.stderr.write(`[agentchat] Profile loaded: ${profileFile}\n`);
+} else if (identity.mode === "env-creds") {
+  // Token handed to us directly — authenticate with it, register nothing, write nothing.
+  activeProfileFile = null;
+  process.stderr.write(`[agentchat] Using credentials from environment — not registering.\n`);
+} else if (identity.mode === "error") {
+  // A declared identity with no profile behind it. Inventing one is what corrupted
+  // attribution before, so fail loudly instead. Introspection never lands here.
+  process.stderr.write(`[agentchat] ERROR: ${identity.message}\n`);
+  process.exit(1);
+} else if (identity.mode === "anonymous") {
+  // Nothing declared. Stay alive so stdio introspection (initialize/tools/list) works,
+  // but create no account and persist no credentials.
+  anonymousMode = true;
+  activeProfileFile = null;
+  process.stderr.write(`[agentchat] ${identity.reason}\n`);
 } else {
-  // First run: auto-register with server to get a real agent key
-  const displayName = cliArgs.name || `Claude-${randomUUID().slice(0, 6)}`;
+  // Explicit opt-in: register a real account and persist it.
+  const displayName = identity.displayName;
   const caps = ["claude-code", "coding", "chat"];
-  process.stderr.write(`[agentchat] First run — registering with server...\n`);
+  process.stderr.write(`[agentchat] Registering "${displayName}" with server...\n`);
   try {
     const regRes = await apiFetch(`${REST_URL}/api/account/register`, {
       method: "POST",
@@ -188,7 +272,11 @@ if (existsSync(profileFile)) {
       profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
     }
   } catch (e) {
-    process.stderr.write(`[agentchat] Server unreachable, using local profile\n`);
+    // Always print the cause. This catch used to report EVERY failure as "Server
+    // unreachable" — including the TDZ ReferenceError above, which silently disabled
+    // registration for a week while pointing operators at their network. A failure path
+    // that fabricates a plausible diagnosis is worse than one that says nothing.
+    process.stderr.write(`[agentchat] Registration failed: ${e} — using local profile\n`);
     profile = { agent_id: randomUUID(), display_name: displayName, token: "dev-token", capabilities: caps };
   }
   mkdirSync(dirname(profileFile), { recursive: true });
@@ -196,8 +284,15 @@ if (existsSync(profileFile)) {
   process.stderr.write(`[agentchat] Profile saved: ${profileFile}\n`);
 }
 
-// Migrate old profiles with dev-token: auto-register to get real key
-if (profile.token === "dev-token") {
+// Second auto-register trigger: a loaded profile still carrying the `dev-token`
+// placeholder. Healing it is intended for a declared identity, but on the bare
+// shared default path it mints an anonymous account just like the first trigger.
+if (profile.token === "dev-token" && !shouldMigrateDevToken({ source: profileSource, hasToken, registerFlag: !!cliArgs.register })) {
+  process.stderr.write(
+    `[agentchat] Profile at ${profileFile} carries a dev-token but no identity was declared — ` +
+      `refusing to auto-register. Pass --name <name> or --register to create a real agent.\n`,
+  );
+} else if (profile.token === "dev-token") {
   process.stderr.write(`[agentchat] Migrating dev-token profile — registering with server...\n`);
   try {
     const regRes = await apiFetch(`${REST_URL}/api/account/register`, {
@@ -226,38 +321,17 @@ if (profile.token === "dev-token") {
         process.stderr.write(`[agentchat] Migrated with new ID: ${data.id}\n`);
       }
     }
-  } catch {}
-}
-
-let AGENT_ID = cliArgs.id || process.env.AGENTCHAT_AGENT_ID || profile.agent_id || randomUUID();
-let TOKEN = cliArgs.token || process.env.AGENTCHAT_TOKEN || profile.token || "dev-token";
-let CAPABILITIES: string[] = cliArgs.caps?.split(",") || profile.capabilities || ["claude-code", "coding", "chat"];
-
-// Native fetch, captured before the file-wide call-site rename to apiFetch so the
-// wrapper below can't recurse into itself.
-const nativeFetch = fetch;
-// All AgentsChat REST goes through apiFetch so every call gets, from one place:
-// (1) a timeout — a hung hub call must never block a tool forever; and
-// (2) the bearer token, injected only when absent and TOKEN is set (so the few
-//     conditional-auth sites keep their exact semantics). init is otherwise passed
-//     through untouched, so callers keep using r.ok / r.text() / r.json().
-const REST_TIMEOUT_MS = 15_000;
-async function apiFetch(
-  input: string | URL,
-  init: RequestInit = {},
-  timeoutMs = REST_TIMEOUT_MS,
-): Promise<Response> {
-  const headers: Record<string, string> = { ...(init.headers as Record<string, string> | undefined) };
-  if (TOKEN && !("Authorization" in headers)) headers["Authorization"] = `Bearer ${TOKEN}`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await nativeFetch(input as any, { ...init, headers, signal: init.signal ?? controller.signal });
-  } finally {
-    clearTimeout(timer);
+  } catch (e) {
+    // Was `catch {}`: it swallowed the same TDZ ReferenceError with no output at all.
+    process.stderr.write(`[agentchat] dev-token migration failed: ${e}\n`);
   }
 }
 
+// Now that the identity block has settled `profile`, bind the runtime identity.
+AGENT_ID = cliArgs.id || process.env.AGENTCHAT_AGENT_ID || profile.agent_id || randomUUID();
+TOKEN = cliArgs.token || process.env.AGENTCHAT_TOKEN || profile.token || "dev-token";
+CAPABILITIES = cliArgs.caps?.split(",") || profile.capabilities || ["claude-code", "coding", "chat"];
+
 // Update display name if provided via CLI
 if (cliArgs.name && profile.display_name !== cliArgs.name) {
   profile.display_name = cliArgs.name;
@@ -2714,7 +2788,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     } catch (e: any) {
       authLine = `REST auth: error (${String(e?.message || e).slice(0, 80)})`;
     }
-    return { content: [{ type: "text", text: `Profile: ${profile.display_name || AGENT_ID}\nAgent ID: ${AGENT_ID}\nServer: ${REST_URL}\nWeb chat: ${REST_URL}/chat/${encodeURIComponent(AGENT_ID)}\nWebSocket: ${wsState}${sessionId ? `\nSession: ${sessionId.slice(0, 12)}...` : ""}\n${healthLine}\n${authLine}\n${claimedLine}${claimHint ? `\n${claimHint}` : ""}\nCapabilities: ${CAPABILITIES.join(", ")}\nProfile file: ${profileFile}` }] };
+    return { content: [{ type: "text", text: `Profile: ${profile.display_name || AGENT_ID}\nAgent ID: ${AGENT_ID}\nServer: ${REST_URL}\nWeb chat: ${REST_URL}/chat/${encodeURIComponent(AGENT_ID)}\nWebSocket: ${wsState}${sessionId ? `\nSession: ${sessionId.slice(0, 12)}...` : ""}\n${healthLine}\n${authLine}\n${claimedLine}${claimHint ? `\n${claimHint}` : ""}\nCapabilities: ${CAPABILITIES.join(", ")}\nProfile file: ${activeProfileFile ?? (anonymousMode ? "(none — anonymous, no profile written)" : "(none — credentials from environment)")}` }] };
   }
 
   if (name === "list_channels") {
@@ -2907,11 +2981,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
     sessionId = null;
 
-    // Update identity
+    // Update identity. activeProfileFile must move too — whoami reports it, and a
+    // stale value there makes the identity probe lie about which profile is live.
     AGENT_ID = newProfile.agent_id;
     TOKEN = newProfile.token || "dev-token";
     CAPABILITIES = newProfile.capabilities || ["claude-code", "coding", "chat"];
     profile = newProfile;
+    activeProfileFile = targetFile;
+    anonymousMode = false;
 
     // Restart heartbeat and connect with new identity
     wsReconnectAttempt = 0;
@@ -3286,15 +3363,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Persisted to disk so reconnect/restart doesn't lose state
 const mentionTsFile = join(configDir, `mention-ts-${AGENT_ID}.json`);
 function loadMentionTimestamps(): Map<string, string> {
-  try {
-    const raw = readFileSync(mentionTsFile, "utf-8");
-    return new Map(Object.entries(JSON.parse(raw)));
-  } catch { return new Map(); }
+  return loadCursor(mentionTsFile, safeStderrWrite);
 }
+// Re-attempted on the next mention, but a persistent failure (perms, full disk) would
+// retry just as silently forever — and the state is gone on restart. So it reports.
 function saveMentionTimestamps(m: Map<string, string>) {
-  try {
-    writeFileSync(mentionTsFile, JSON.stringify(Object.fromEntries(m)));
-  } catch {}
+  persistCursor(mentionTsFile, m, safeStderrWrite);
 }
 const lastMentionTimestamp = loadMentionTimestamps();
 
@@ -3315,36 +3389,29 @@ const lastMentionTimestamp = loadMentionTimestamps();
 // connect or reconnect; if we missed anything, we find it.
 const lastSeenMessageTsFile = join(configDir, `last-seen-msg-ts-${AGENT_ID}.json`);
 function loadLastSeenMessageTs(): Map<string, string> {
-  try {
-    const raw = readFileSync(lastSeenMessageTsFile, "utf-8");
-    return new Map(Object.entries(JSON.parse(raw)));
-  } catch { return new Map(); }
-}
-function saveLastSeenMessageTs(m: Map<string, string>) {
-  try {
-    writeFileSync(lastSeenMessageTsFile, JSON.stringify(Object.fromEntries(m)));
-  } catch {}
+  return loadCursor(lastSeenMessageTsFile, safeStderrWrite);
 }
 const lastSeenMessageTs = loadLastSeenMessageTs();
 const cursorFlushIntervalMs = Math.max(
   500,
   Number(process.env.AGENTSCHAT_MCP_CURSOR_FLUSH_MS || 5000),
 );
-let lastSeenMessageTsDirty = false;
+/** Dirty flag lives in an object so flushCursor can clear it only on a landed write. */
+const cursorState = { dirty: false };
 let lastSeenMessageTsTimer: ReturnType<typeof setTimeout> | null = null;
 
 function flushLastSeenMessageTs() {
-  if (!lastSeenMessageTsDirty) return;
-  lastSeenMessageTsDirty = false;
+  if (!cursorState.dirty) return;
   if (lastSeenMessageTsTimer) {
     clearTimeout(lastSeenMessageTsTimer);
     lastSeenMessageTsTimer = null;
   }
-  saveLastSeenMessageTs(lastSeenMessageTs);
+  // Stays dirty if the write fails, so the shutdown fallback flush actually retries.
+  flushCursor(cursorState, () => persistCursor(lastSeenMessageTsFile, lastSeenMessageTs, safeStderrWrite));
 }
 
 function scheduleLastSeenMessageTsSave() {
-  lastSeenMessageTsDirty = true;
+  cursorState.dirty = true;
   if (lastSeenMessageTsTimer) return;
   lastSeenMessageTsTimer = setTimeout(() => {
     lastSeenMessageTsTimer = null;
@@ -3934,7 +4001,8 @@ function shutdownFromStdio(reason: string) {
   if (shuttingDown) return;
   shuttingDown = true;
   safeStderrWrite(`[agentchat] Stdio closed (${reason}), shutting down\n`);
-  try { flushLastSeenMessageTs(); } catch {}
+  // Persisting the read cursor is a state change, not teardown: report, never swallow.
+  try { flushLastSeenMessageTs(); } catch (e) { safeStderrWrite(`[agentchat] WARNING: read-cursor flush failed on shutdown: ${e}\n`); }
   try { heartbeat.stop(); } catch {}
   try { stopAllTypingHeartbeats(); } catch {}
   if (reconnectTimer) {
@@ -3971,7 +4039,7 @@ function installStdioLifecycleGuards() {
   process.stderr.on("error", handleOutputError);
   process.on("SIGPIPE", () => shutdownFromStdio("SIGPIPE"));
   process.on("beforeExit", () => {
-    try { flushLastSeenMessageTs(); } catch {}
+    try { flushLastSeenMessageTs(); } catch (e) { safeStderrWrite(`[agentchat] WARNING: read-cursor fallback flush failed: ${e}\n`); }
   });
 }
 
@@ -4004,7 +4072,13 @@ async function checkVersionStaleness(): Promise<void> {
 // --- Start ---
 async function main() {
   installStdioLifecycleGuards();
-  connectWS();
+  // Anonymous = no credentials to present. Connecting would just fail auth in a
+  // reconnect loop; stdio (initialize/tools/list) is served either way.
+  if (anonymousMode) {
+    process.stderr.write(`[agentchat] Anonymous — not connecting to the hub.\n`);
+  } else {
+    connectWS();
+  }
 
   // Stdio is the only supported transport. The --port HTTP SSE path was
   // removed in v0.6.7 — OpenClaw users should install the native channel