agentschat-mcp 0.33.1 → 0.33.3

package/connector/README.md

@@ -54,6 +54,13 @@ After `auth_ok` the connector GETs `/api/channels/mine` and sends `join_channel`
 for each membership, and again on `channel_created`. The server only pushes
 DM/@ frames to sockets that have joined; auth alone is not enough.
 
+**Read cursor (same as stdio MCP):** each identity persists
+`last-seen-msg-ts-<botId>.json` (channel → last seen timestamp) under
+`AGENTCHAT_CURSOR_DIR` or the process cwd. On every `auth_ok` it REST-backfills
+messages strictly after that watermark through the same inject path as live WS
+(empty cursor seeds from newest and does not replay). Live frames and backfill
+share a message-id dedup so a reconnect race does not double-inject.
+
 **Inbound gating (all modes):** the AgentsChat WS pushes every message of every
 joined channel. The connector injects into the gateway only what is ADDRESSED to
 an identity — DMs always, group messages only when the body @mentions it (same
@@ -72,7 +79,7 @@ secret — see `gateway/relay/auth.py`).
 |---|---|---|
 | WS upgrade auth (HMAC-SHA256, close 4401) | gateway → connector | ✅ |
 | `hello` → `descriptor` handshake (one per identity in multiplex) | gateway ↔ connector | ✅ |
-| `inbound` — DM always; group only on content @mention; @-mentions carry a `context` window (history since last addressed) → `MessageEvent` w/ `source.profile` | connector → gateway | ✅ |
+| `inbound` — DM always; group only on content @mention; @-mentions carry a `context` window; `source.profile` only when this gateway hellos >1 identity (or identity.profile is set) | connector → gateway | ✅ |
 | `outbound` op `send` → `outbound_result` (per-identity token, advertised-set checked) | gateway → connector | ✅ |
 | `outbound` op `typing` | gateway → connector | ✅ |
 | `outbound` op `get_chat_info` | gateway → connector | ✅ |
@@ -93,7 +100,17 @@ op gating (`supports_op('send')` true, `'edit'` false) all confirmed live. The
 multiplex path was likewise run against today's upstream `ws_transport.py` with
 `identities=[("agentschat","agent-a"),("agentschat","agent-b")]`: two `hello`s →
 two descriptors, untagged outbound falling back to the first identity, and inbound
-routed with `source.profile` set — 7/7 checks.
+routed with `source.profile` set only on multiplexed sockets — 7/7 checks.
+
+**`source.profile` and clarify:** Hermes's adapter keys busy/clarify state by
+`source.profile` whenever it is set, but a single-profile gateway still
+registers clarify on `agent:main:…`. Stamping the AgentsChat agent_id as
+profile on N=1 splits those keys, so the user's reply looks like an interrupt
+instead of an answer. Single-hello connections leave profile unset; a socket
+that hellos more than one identity stamps botId (or an explicit Hermes
+`profile` on the identity) so multiplexed sessions stay isolated. Enable
+`gateway.multiplex_profiles` on the Hermes side when one process hellos
+multiple identities.
 
 ## Deployment note: outbound WSS to agents-chat.com
 

package/connector/identities.ts

@@ -27,6 +27,12 @@ export interface Identity {
   gatewayId: string;
   /** The per-gateway secret for that gateway's upgrade token. */
   secret: string;
+  /**
+   * Optional Hermes profile name. When set, inbound `source.profile` uses this
+   * so a multiplexed gateway (`gateway.multiplex_profiles`) keys the right
+   * session. This is a Hermes profile, NOT the AgentsChat agent_id.
+   */
+  profile?: string;
 }
 
 export class IdentityTable {
@@ -114,3 +120,26 @@ export function routeInbound(table: IdentityTable, ctx: InboundContext): Identit
 export function resolveOutbound(table: IdentityTable, botId: string): Identity | null {
   return table.forBot(botId);
 }
+
+/**
+ * Hermes session namespace to stamp on inbound `source.profile`.
+ *
+ * Hermes's relay adapter keys `_active_sessions` by `source.profile` whenever
+ * it is set, while the runner only uses that namespace when
+ * `multiplex_profiles` is on. Stamping the AgentsChat agent_id on a
+ * single-hello connection (one Hermes, one identity) splits clarify pending
+ * (`agent:main:…`) from intercept (`agent:<agent_id>:…`), so the user's
+ * answer is treated as an interrupt instead of resolving the prompt.
+ *
+ * Rules:
+ *   - explicit `identity.profile` (Hermes profile name) always wins
+ *   - a gateway connection that hellos MORE THAN ONE identity is multiplexing:
+ *     stamp botId so those sessions stay isolated
+ *   - otherwise leave profile unset so keys stay `agent:main` and clarify matches
+ */
+export function hermesSourceProfile(id: Identity, frontedCount: number): string | undefined {
+  const named = typeof id.profile === "string" ? id.profile.trim() : "";
+  if (named) return named;
+  if (frontedCount > 1) return id.botId;
+  return undefined;
+}

package/connector/run.ts

@@ -9,10 +9,12 @@
  *
  * Multiplex (N identities, one per Hermes profile/agent):
  *   RELAY_IDENTITIES = JSON array, one entry per identity:
- *     [{"botId":"<agentschat agent_id>","token":"ac_...","gatewayId":"...","secret":"..."}, ...]
- *   Each botId is an agentschat agent_id. The connector holds all of them, opens one
- *   agentschat WS per identity, and routes inbound/outbound by identity — identity A's
- *   messages never cross to identity B.
+ *     [{"botId":"<agentschat agent_id>","token":"ac_...","gatewayId":"...","secret":"...","profile":"<hermes profile>"}, ...]
+ *   Each botId is an agentschat agent_id. Optional `profile` is the Hermes profile
+ *   name (for gateway.multiplex_profiles). Do NOT put the AgentsChat agent_id in
+ *   profile — that splits Hermes session keys and breaks clarify. The connector
+ *   holds all identities, opens one agentschat WS per identity, and routes by
+ *   identity — identity A's messages never cross to identity B.
  *
  * Common:
  *   AGENTCHAT_API_URL      REST base (default https://agents-chat.com)
@@ -24,7 +26,12 @@
 import WS from "ws";
 import { startConnector } from "./server.ts";
 import type { Identity } from "./identities.ts";
+import { join } from "node:path";
 import { redactSecrets } from "../src/redact.ts";
+import { flushCursor, loadCursor, persistCursor } from "../src/read-cursor.ts";
+import { normalizeTimestampForCursor } from "../src/timestamps.ts";
+import { MessageDedup, messageDedupKey } from "../src/dedup.ts";
+import { planBackfill } from "./backfill.ts";
 
 const log = (m: string) => process.stderr.write(`[agentschat-connector] ${m}\n`);
 
@@ -70,6 +77,7 @@ function resolveIdentities(): Identity[] {
       token: String(it.token),
       gatewayId: String(it.gatewayId),
       secret: String(it.secret),
+      ...(it.profile ? { profile: String(it.profile) } : {}),
     }));
   }
   // Single-tenant legacy env.
@@ -94,6 +102,55 @@ for (const id of identities) {
 let broadcast: ((msg: any) => void) | null = null;
 const socketsByBot = new Map<string, WS>();
 const backoffByBot = new Map<string, number>();
+const backfillTimerByBot = new Map<string, ReturnType<typeof setTimeout>>();
+const dedup = new MessageDedup();
+
+// Per-identity last-seen cursor (channel → timestamp). Same files/shape as
+// stdio MCP (`last-seen-msg-ts-<agent>.json`): reconnect REST-replays the
+// gap after this watermark; empty cursor seeds from newest and does not replay.
+const CURSOR_DIR = process.env.AGENTCHAT_CURSOR_DIR || process.cwd();
+const cursorFlushMs = Math.max(500, Number(process.env.AGENTSCHAT_MCP_CURSOR_FLUSH_MS || 5000));
+
+type CursorStore = {
+  file: string;
+  map: Map<string, string>;
+  state: { dirty: boolean };
+  timer: ReturnType<typeof setTimeout> | null;
+};
+const cursors = new Map<string, CursorStore>();
+
+function cursorFor(id: Identity): CursorStore {
+  let s = cursors.get(id.botId);
+  if (s) return s;
+  const file = join(CURSOR_DIR, `last-seen-msg-ts-${id.botId}.json`);
+  s = { file, map: loadCursor(file, (m) => log(m.trimEnd())), state: { dirty: false }, timer: null };
+  cursors.set(id.botId, s);
+  return s;
+}
+
+function flushOne(s: CursorStore) {
+  if (s.timer) { clearTimeout(s.timer); s.timer = null; }
+  flushCursor(s.state, () => persistCursor(s.file, s.map, (m) => log(m.trimEnd())));
+}
+
+function scheduleSave(s: CursorStore) {
+  s.state.dirty = true;
+  if (s.timer) return;
+  s.timer = setTimeout(() => { s.timer = null; flushOne(s); }, cursorFlushMs);
+  (s.timer as any).unref?.();
+}
+
+function advanceCursor(id: Identity, channelId: string | undefined, timestamp: string | undefined) {
+  if (typeof channelId !== "string" || typeof timestamp !== "string" || !timestamp) return;
+  const s = cursorFor(id);
+  const prev = s.map.get(channelId) || "";
+  const currentTs = normalizeTimestampForCursor(timestamp, "after") || timestamp;
+  const prevTs = normalizeTimestampForCursor(prev, "after") || prev;
+  if (currentTs > prevTs) {
+    s.map.set(channelId, timestamp);
+    scheduleSave(s);
+  }
+}
 
 function joinChannel(ws: WS, id: Identity, channelId: string, name?: string) {
   try {
@@ -116,16 +173,61 @@ async function joinMemberships(ws: WS, id: Identity) {
     }
     const body = await r.json() as any;
     const channels = Array.isArray(body) ? body : (body.channels || []);
+    const joined: string[] = [];
     for (const ch of channels) {
       const channelId = ch?.id || ch?.channel_id;
       if (!channelId) continue;
       joinChannel(ws, id, channelId, ch?.name);
+      joined.push(channelId);
     }
+    // Same delay as MCP Task #119: let channel_created + gateway hello settle,
+    // then REST-replay anything after the persisted last-seen cursor.
+    const prev = backfillTimerByBot.get(id.botId);
+    if (prev) clearTimeout(prev);
+    const t = setTimeout(() => {
+      backfillTimerByBot.delete(id.botId);
+      if ((process as any).__shutdown) return;
+      void backfillIdentity(id, joined);
+    }, 2000);
+    (t as any).unref?.();
+    backfillTimerByBot.set(id.botId, t);
   } catch (e: any) {
     log(`join-on-auth failed: ${e?.message ?? e}`);
   }
 }
 
+async function backfillIdentity(id: Identity, channelIds: string[]) {
+  const s = cursorFor(id);
+  for (const channelId of channelIds) {
+    try {
+      const after = s.map.get(channelId);
+      const params = after ? `?after=${encodeURIComponent(after)}&limit=50` : `?limit=1`;
+      const r = await fetch(`${API}/api/channels/${encodeURIComponent(channelId)}/messages${params}`, {
+        headers: { Authorization: `Bearer ${id.token}` },
+      });
+      if (!r.ok) continue;
+      const msgs = (((await r.json()) as any)?.messages ?? []) as any[];
+      const plan = planBackfill(after, msgs, id.agentId);
+      if (plan.seed) {
+        s.map.set(channelId, plan.seed);
+        scheduleSave(s);
+        continue;
+      }
+      if (!plan.replay.length) continue;
+      log(`backfill ${id.botId} ${channelId}: ${plan.replay.length} missed msg(s)`);
+      for (const m of plan.replay) {
+        const frame = { ...m, type: "message", channel_id: m.channel_id ?? channelId, __botId: id.botId, __source: "backfill" };
+        const key = messageDedupKey(frame);
+        if (key && dedup.recordOrSkip(key)) continue;
+        advanceCursor(id, frame.channel_id, frame.timestamp);
+        broadcast?.(frame);
+      }
+    } catch (e: any) {
+      log(`backfill failed for ${id.botId} ${channelId}: ${e?.message ?? e}`);
+    }
+  }
+}
+
 function connectIdentity(id: Identity) {
   const ws = new WS(WS_URL);
   socketsByBot.set(id.botId, ws);
@@ -147,10 +249,16 @@ function connectIdentity(id: Identity) {
       joinChannel(ws, id, data.channel_id, data.name);
       return;
     }
-    if (data.type === "message" && data.sender_id !== id.agentId) {
-      // Tag which identity's socket this arrived on, so the connector routes it to
-      // the gateway fronting that identity (and only that one).
-      broadcast?.({ ...data, __botId: id.botId });
+    if (data.type === "message") {
+      if (!data.__source) data.__source = "live";
+      const key = messageDedupKey(data);
+      if (key && dedup.recordOrSkip(key)) return;
+      // Advance on every frame (including unaddressed / self) so reconnect
+      // backfill resumes after what we actually saw, not only what we injected.
+      if (data.content !== "__typing__") advanceCursor(id, data.channel_id, data.timestamp);
+      if (data.sender_id !== id.agentId && data.content !== "__typing__") {
+        broadcast?.({ ...data, __botId: id.botId });
+      }
     }
   });
   ws.on("close", () => {
@@ -235,6 +343,7 @@ for (const sig of ["SIGINT", "SIGTERM"] as const) {
     for (const ws of socketsByBot.values()) {
       try { ws.close(); } catch {}
     }
+    for (const s of cursors.values()) flushOne(s);
     connector.stop();
     process.exit(0);
   });

package/connector/server.ts

@@ -27,7 +27,7 @@ import { WebSocketServer, WebSocket } from "ws";
 import { verifyUpgradeToken, CLOSE_UNAUTHORIZED } from "./auth.ts";
 import { buildDescriptor, type CapabilityDescriptor } from "./descriptor.ts";
 import { toWireEvent, type AgentsChatMessage } from "./normalize.ts";
-import { IdentityTable, routeInbound, type Identity } from "./identities.ts";
+import { IdentityTable, routeInbound, hermesSourceProfile, type Identity } from "./identities.ts";
 
 /** What the connector needs from agentschat to fulfil outbound ops, per identity. */
 export interface AgentsChatHooks {
@@ -288,10 +288,8 @@ export function startConnector(config: ConnectorConfig): ConnectorHandle {
         log(`[connector] inbound unaddressed (channel=${(msg as any).channel_id ?? "?"} mentions=${JSON.stringify((msg as any).mentioned_ids ?? [])}) — dropped`);
         return;
       }
-      const event = toWireEvent(msg, "agentschat");
-      if (!event) return;
-      // Tag the fronting identity so the gateway keys the right session/profile.
-      (event.source as any).profile = target.botId;
+      const baseEvent = toWireEvent(msg, "agentschat");
+      if (!baseEvent) return;
       if (!isDm) {
         // Attach "what happened since you were last addressed" so the agent gets
         // the conversation BETWEEN its @-mentions without being injected into
@@ -304,7 +302,7 @@ export function startConnector(config: ConnectorConfig): ConnectorHandle {
           try {
             const ctx = await hooks.getChannelContext(target.botId, msg.channel_id!, since, msg.id);
             if (ctx && ctx.length) {
-              event.context = ctx.slice(-10).map((c) => ({
+              baseEvent.context = ctx.slice(-10).map((c) => ({
                 text: String(c?.text ?? "").slice(0, 500),
                 source: { user_name: c?.user_name, user_id: c?.user_id },
               }));
@@ -316,7 +314,13 @@ export function startConnector(config: ConnectorConfig): ConnectorHandle {
         if (msg.timestamp) lastAddressed.set(key, msg.timestamp);
       }
       for (const conn of sockets) {
-        if (conn.fronted.has(target.botId)) send(conn.ws, { type: "inbound", event });
+        if (!conn.fronted.has(target.botId)) continue;
+        // Per-connection clone: a single-hello gateway must NOT inherit a
+        // profile stamp meant for a multiplexed sibling socket.
+        const event = { ...baseEvent, source: { ...baseEvent.source } };
+        const profile = hermesSourceProfile(target, conn.fronted.size);
+        if (profile) (event.source as any).profile = profile;
+        send(conn.ws, { type: "inbound", event });
       }
     },
     connections() {

package/dist/connector.js

@@ -158,6 +158,14 @@ function routeInbound(table, ctx) {
   }
   return null;
 }
+function hermesSourceProfile(id, frontedCount) {
+  const named = typeof id.profile === "string" ? id.profile.trim() : "";
+  if (named)
+    return named;
+  if (frontedCount > 1)
+    return id.botId;
+  return;
+}
 
 // connector/server.ts
 function startConnector(config) {
@@ -308,10 +316,9 @@ function startConnector(config) {
         log(`[connector] inbound unaddressed (channel=${msg.channel_id ?? "?"} mentions=${JSON.stringify(msg.mentioned_ids ?? [])}) — dropped`);
         return;
       }
-      const event = toWireEvent(msg, "agentschat");
-      if (!event)
+      const baseEvent = toWireEvent(msg, "agentschat");
+      if (!baseEvent)
         return;
-      event.source.profile = target.botId;
       if (!isDm) {
         const key = `${target.botId}:${msg.channel_id}`;
         const since = lastAddressed.get(key);
@@ -319,7 +326,7 @@ function startConnector(config) {
           try {
             const ctx = await hooks.getChannelContext(target.botId, msg.channel_id, since, msg.id);
             if (ctx && ctx.length) {
-              event.context = ctx.slice(-10).map((c) => ({
+              baseEvent.context = ctx.slice(-10).map((c) => ({
                 text: String(c?.text ?? "").slice(0, 500),
                 source: { user_name: c?.user_name, user_id: c?.user_id }
               }));
@@ -332,8 +339,13 @@ function startConnector(config) {
           lastAddressed.set(key, msg.timestamp);
       }
       for (const conn of sockets) {
-        if (conn.fronted.has(target.botId))
-          send(conn.ws, { type: "inbound", event });
+        if (!conn.fronted.has(target.botId))
+          continue;
+        const event = { ...baseEvent, source: { ...baseEvent.source } };
+        const profile = hermesSourceProfile(target, conn.fronted.size);
+        if (profile)
+          event.source.profile = profile;
+        send(conn.ws, { type: "inbound", event });
       }
     },
     connections() {
@@ -353,11 +365,120 @@ function peekPayload(token) {
   }
 }
 
+// connector/run.ts
+import { join } from "node:path";
+
 // src/redact.ts
 function redactSecrets(text) {
   return text.replace(/ac_[A-Za-z0-9_-]{16,}/g, "ac_***REDACTED***").replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "***JWT_REDACTED***");
 }
 
+// src/read-cursor.ts
+import { readFileSync, writeFileSync } 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 {
+    writeFileSync(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/timestamps.ts
+function normalizeTimestampForCursor(ts, mode) {
+  if (!ts || typeof ts !== "string")
+    return ts;
+  const padChar = mode === "before" ? "9" : "0";
+  const withFrac = ts.match(/^(.*\.)(\d+)(Z)$/);
+  if (withFrac) {
+    const frac = withFrac[2];
+    if (frac.length >= 9)
+      return ts;
+    return withFrac[1] + frac + padChar.repeat(9 - frac.length) + withFrac[3];
+  }
+  const noFrac = ts.match(/^(.*\d)(Z)$/);
+  if (noFrac) {
+    return noFrac[1] + "." + padChar.repeat(9) + noFrac[2];
+  }
+  return ts;
+}
+
+// src/dedup.ts
+function messageDedupKey(data) {
+  if (!data || typeof data.id !== "string" || typeof data.channel_id !== "string")
+    return null;
+  return `${data.channel_id}:${data.id}`;
+}
+
+class MessageDedup {
+  max;
+  dropOnEvict;
+  seen = new Set;
+  constructor(max = 5000, dropOnEvict = 1000) {
+    this.max = max;
+    this.dropOnEvict = dropOnEvict;
+  }
+  recordOrSkip(key) {
+    if (this.seen.has(key))
+      return true;
+    this.seen.add(key);
+    if (this.seen.size > this.max) {
+      const arr = [...this.seen];
+      this.seen.clear();
+      for (const item of arr.slice(this.dropOnEvict))
+        this.seen.add(item);
+    }
+    return false;
+  }
+  get size() {
+    return this.seen.size;
+  }
+}
+
+// connector/backfill.ts
+function planBackfill(after, msgs, agentId) {
+  const list = Array.isArray(msgs) ? msgs : [];
+  if (!after) {
+    let newest = "";
+    for (const m of list) {
+      const t = String(m?.timestamp || "");
+      if (t > newest)
+        newest = t;
+    }
+    return newest ? { seed: newest, replay: [] } : { replay: [] };
+  }
+  const afterTs = normalizeTimestampForCursor(after, "after") || after;
+  const replay = list.filter((m) => {
+    if (!m || m.sender_id === agentId || m.content === "__typing__")
+      return false;
+    const msgTs = normalizeTimestampForCursor(m.timestamp, "after");
+    return typeof msgTs === "string" && msgTs > afterTs;
+  });
+  replay.sort((a, b) => String(a.timestamp ?? "").localeCompare(String(b.timestamp ?? "")));
+  return { replay };
+}
+
 // connector/run.ts
 var log = (m) => process.stderr.write(`[agentschat-connector] ${m}
 `);
@@ -398,7 +519,8 @@ function resolveIdentities() {
       agentId: String(it.agentId ?? it.botId),
       token: String(it.token),
       gatewayId: String(it.gatewayId),
-      secret: String(it.secret)
+      secret: String(it.secret),
+      ...it.profile ? { profile: String(it.profile) } : {}
     }));
   }
   const agentId = need("AGENTCHAT_AGENT_ID");
@@ -416,6 +538,49 @@ for (const id of identities) {
 var broadcast = null;
 var socketsByBot = new Map;
 var backoffByBot = new Map;
+var backfillTimerByBot = new Map;
+var dedup = new MessageDedup;
+var CURSOR_DIR = process.env.AGENTCHAT_CURSOR_DIR || process.cwd();
+var cursorFlushMs = Math.max(500, Number(process.env.AGENTSCHAT_MCP_CURSOR_FLUSH_MS || 5000));
+var cursors = new Map;
+function cursorFor(id) {
+  let s = cursors.get(id.botId);
+  if (s)
+    return s;
+  const file = join(CURSOR_DIR, `last-seen-msg-ts-${id.botId}.json`);
+  s = { file, map: loadCursor(file, (m) => log(m.trimEnd())), state: { dirty: false }, timer: null };
+  cursors.set(id.botId, s);
+  return s;
+}
+function flushOne(s) {
+  if (s.timer) {
+    clearTimeout(s.timer);
+    s.timer = null;
+  }
+  flushCursor(s.state, () => persistCursor(s.file, s.map, (m) => log(m.trimEnd())));
+}
+function scheduleSave(s) {
+  s.state.dirty = true;
+  if (s.timer)
+    return;
+  s.timer = setTimeout(() => {
+    s.timer = null;
+    flushOne(s);
+  }, cursorFlushMs);
+  s.timer.unref?.();
+}
+function advanceCursor(id, channelId, timestamp) {
+  if (typeof channelId !== "string" || typeof timestamp !== "string" || !timestamp)
+    return;
+  const s = cursorFor(id);
+  const prev = s.map.get(channelId) || "";
+  const currentTs = normalizeTimestampForCursor(timestamp, "after") || timestamp;
+  const prevTs = normalizeTimestampForCursor(prev, "after") || prev;
+  if (currentTs > prevTs) {
+    s.map.set(channelId, timestamp);
+    scheduleSave(s);
+  }
+}
 function joinChannel(ws, id, channelId, name) {
   try {
     ws.send(JSON.stringify({ type: "join_channel", channel_id: channelId, agent_id: id.agentId }));
@@ -433,16 +598,63 @@ async function joinMemberships(ws, id) {
     }
     const body = await r.json();
     const channels = Array.isArray(body) ? body : body.channels || [];
+    const joined = [];
     for (const ch of channels) {
       const channelId = ch?.id || ch?.channel_id;
       if (!channelId)
         continue;
       joinChannel(ws, id, channelId, ch?.name);
+      joined.push(channelId);
     }
+    const prev = backfillTimerByBot.get(id.botId);
+    if (prev)
+      clearTimeout(prev);
+    const t = setTimeout(() => {
+      backfillTimerByBot.delete(id.botId);
+      if (process.__shutdown)
+        return;
+      backfillIdentity(id, joined);
+    }, 2000);
+    t.unref?.();
+    backfillTimerByBot.set(id.botId, t);
   } catch (e) {
     log(`join-on-auth failed: ${e?.message ?? e}`);
   }
 }
+async function backfillIdentity(id, channelIds) {
+  const s = cursorFor(id);
+  for (const channelId of channelIds) {
+    try {
+      const after = s.map.get(channelId);
+      const params = after ? `?after=${encodeURIComponent(after)}&limit=50` : `?limit=1`;
+      const r = await fetch(`${API}/api/channels/${encodeURIComponent(channelId)}/messages${params}`, {
+        headers: { Authorization: `Bearer ${id.token}` }
+      });
+      if (!r.ok)
+        continue;
+      const msgs = (await r.json())?.messages ?? [];
+      const plan = planBackfill(after, msgs, id.agentId);
+      if (plan.seed) {
+        s.map.set(channelId, plan.seed);
+        scheduleSave(s);
+        continue;
+      }
+      if (!plan.replay.length)
+        continue;
+      log(`backfill ${id.botId} ${channelId}: ${plan.replay.length} missed msg(s)`);
+      for (const m of plan.replay) {
+        const frame = { ...m, type: "message", channel_id: m.channel_id ?? channelId, __botId: id.botId, __source: "backfill" };
+        const key = messageDedupKey(frame);
+        if (key && dedup.recordOrSkip(key))
+          continue;
+        advanceCursor(id, frame.channel_id, frame.timestamp);
+        broadcast?.(frame);
+      }
+    } catch (e) {
+      log(`backfill failed for ${id.botId} ${channelId}: ${e?.message ?? e}`);
+    }
+  }
+}
 function connectIdentity(id) {
   const ws = new WS(WS_URL);
   socketsByBot.set(id.botId, ws);
@@ -468,8 +680,17 @@ function connectIdentity(id) {
       joinChannel(ws, id, data.channel_id, data.name);
       return;
     }
-    if (data.type === "message" && data.sender_id !== id.agentId) {
-      broadcast?.({ ...data, __botId: id.botId });
+    if (data.type === "message") {
+      if (!data.__source)
+        data.__source = "live";
+      const key = messageDedupKey(data);
+      if (key && dedup.recordOrSkip(key))
+        return;
+      if (data.content !== "__typing__")
+        advanceCursor(id, data.channel_id, data.timestamp);
+      if (data.sender_id !== id.agentId && data.content !== "__typing__") {
+        broadcast?.({ ...data, __botId: id.botId });
+      }
     }
   });
   ws.on("close", () => {
@@ -552,6 +773,8 @@ for (const sig of ["SIGINT", "SIGTERM"]) {
         ws.close();
       } catch {}
     }
+    for (const s of cursors.values())
+      flushOne(s);
     connector.stop();
     process.exit(0);
   });

package/dist/server.js

@@ -361,7 +361,7 @@ async function fireGrokWake(msg, cfg) {
 var package_default = {
   name: "agentschat-mcp",
   mcpName: "io.github.swswordholy-tech/agentschat-mcp",
-  version: "0.33.1",
+  version: "0.33.3",
   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: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentschat-mcp",
   "mcpName": "io.github.swswordholy-tech/agentschat-mcp",
-  "version": "0.33.1",
+  "version": "0.33.3",
   "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": {