@cfio/cohort-sync 0.2.0 → 0.2.2

package/dist/index.js

@@ -11568,23 +11568,35 @@ var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSess
 var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
 var HOT_KEY = "__cohort_sync__";
 function getHotState() {
-  return globalThis[HOT_KEY] ?? null;
-}
-function setHotState(state) {
-  globalThis[HOT_KEY] = state;
+  let state = globalThis[HOT_KEY];
+  if (!state) {
+    state = {
+      tracker: null,
+      client: null,
+      convexUrl: null,
+      unsubscribers: [],
+      lastKnownRoster: [],
+      intervals: { heartbeat: null, activityFlush: null },
+      activityBuffer: [],
+      channelAgentBridge: {}
+    };
+    globalThis[HOT_KEY] = state;
+  }
+  if (!state.activityBuffer) state.activityBuffer = [];
+  if (!state.intervals) state.intervals = { heartbeat: null, activityFlush: null };
+  if (!state.channelAgentBridge) state.channelAgentBridge = {};
+  if (!state.unsubscribers) state.unsubscribers = [];
+  if (!state.lastKnownRoster) state.lastKnownRoster = [];
+  return state;
 }
 function clearHotState() {
   delete globalThis[HOT_KEY];
 }
 function setRosterHotState(roster) {
-  const hot = getHotState();
-  if (hot) {
-    hot.lastKnownRoster = roster;
-  }
+  getHotState().lastKnownRoster = roster;
 }
 function getRosterHotState() {
-  const hot = getHotState();
-  return hot?.lastKnownRoster ?? null;
+  return getHotState().lastKnownRoster;
 }
 var savedLogger = null;
 function setLogger(logger) {
@@ -11601,51 +11613,54 @@ var client = null;
 var savedConvexUrl = null;
 var unsubscribers = [];
 function setConvexUrl(cfg) {
-  savedConvexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
+  const url = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
+  savedConvexUrl = url;
+  getHotState().convexUrl = url;
 }
 function restoreFromHotReload(logger) {
-  const hot = getHotState();
-  if (!hot) return;
-  if (!client && hot.client) {
-    client = hot.client;
-    savedConvexUrl = hot.convexUrl;
+  const state = getHotState();
+  if (!client && state.client) {
+    client = state.client;
+    savedConvexUrl = state.convexUrl;
     logger.info("cohort-sync: recovered ConvexClient after hot-reload");
   }
-  if (unsubscribers.length === 0 && hot.unsubscribers.length > 0) {
-    unsubscribers.push(...hot.unsubscribers);
-    logger.info(`cohort-sync: recovered ${hot.unsubscribers.length} notification subscriptions after hot-reload`);
+  if (unsubscribers.length === 0 && state.unsubscribers.length > 0) {
+    unsubscribers.push(...state.unsubscribers);
+    logger.info(`cohort-sync: recovered ${state.unsubscribers.length} notification subscriptions after hot-reload`);
   }
 }
 function getOrCreateClient() {
   if (client) return client;
-  const hot = getHotState();
-  if (hot?.client) {
-    client = hot.client;
+  const state = getHotState();
+  if (state.client) {
+    client = state.client;
     getLogger().info("cohort-sync: recovered ConvexClient from globalThis");
     return client;
   }
   if (!savedConvexUrl) return null;
   client = new ConvexClient(savedConvexUrl);
   getLogger().info(`cohort-sync: created fresh ConvexClient (${savedConvexUrl})`);
-  setHotState({ client, convexUrl: savedConvexUrl, unsubscribers: [], lastKnownRoster: [] });
+  state.client = client;
+  state.convexUrl = savedConvexUrl;
   return client;
 }
 async function initSubscription(port, cfg, hooksToken, logger) {
   const convexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
   savedConvexUrl = convexUrl;
-  const hot = getHotState();
-  if (hot?.client) {
-    client = hot.client;
+  const state = getHotState();
+  if (state.client) {
+    client = state.client;
     logger.info("cohort-sync: reusing hot-reload ConvexClient for subscription");
   } else {
     client = new ConvexClient(convexUrl);
     logger.info(`cohort-sync: created new ConvexClient for subscription (${convexUrl})`);
   }
+  state.client = client;
+  state.convexUrl = convexUrl;
   if (!hooksToken) {
     logger.warn(
       `cohort-sync: hooks.token not configured \u2014 real-time notifications disabled (telemetry will still be pushed).`
     );
-    setHotState({ client, convexUrl, unsubscribers: [], lastKnownRoster: [] });
     return;
   }
   const agentNames = cfg.agentNameMap ? Object.values(cfg.agentNameMap) : ["main"];
@@ -11688,7 +11703,7 @@ async function initSubscription(port, cfg, hooksToken, logger) {
     );
     unsubscribers.push(unsubscribe);
   }
-  setHotState({ client, convexUrl, unsubscribers: [...unsubscribers], lastKnownRoster: [] });
+  state.unsubscribers = [...unsubscribers];
 }
 function closeSubscription() {
   for (const unsub of unsubscribers) {
@@ -11698,13 +11713,11 @@ function closeSubscription() {
     }
   }
   unsubscribers.length = 0;
-  const hot = getHotState();
-  if (hot?.unsubscribers) {
-    for (const unsub of hot.unsubscribers) {
-      try {
-        unsub();
-      } catch {
-      }
+  const state = getHotState();
+  for (const unsub of state.unsubscribers) {
+    try {
+      unsub();
+    } catch {
     }
   }
   client?.close();
@@ -11739,14 +11752,35 @@ async function pushActivity(apiKey, entries) {
     getLogger().error(`cohort-sync: pushActivity failed: ${err}`);
   }
 }
-function saveAgentStatesToHot(states) {
-  const hot = getHotState();
-  if (hot) {
-    hot.agentStates = states;
+function saveIntervalsToHot(heartbeat, activityFlush) {
+  const state = getHotState();
+  state.intervals = { heartbeat, activityFlush };
+}
+function clearIntervalsFromHot() {
+  const state = getHotState();
+  if (state.intervals.heartbeat) clearInterval(state.intervals.heartbeat);
+  if (state.intervals.activityFlush) clearInterval(state.intervals.activityFlush);
+  state.intervals = { heartbeat: null, activityFlush: null };
+}
+function addActivityToHot(entry) {
+  const state = getHotState();
+  state.activityBuffer.push(entry);
+  const logger = savedLogger;
+  if (logger) {
+    logger.info(`cohort-sync: +activity [${entry.category}] "${entry.text}"`);
   }
 }
-function getAgentStatesFromHot() {
-  return getHotState()?.agentStates ?? null;
+function drainActivityFromHot() {
+  const state = getHotState();
+  const buf = state.activityBuffer;
+  state.activityBuffer = [];
+  return buf;
+}
+function setChannelAgent(channelId, agentName) {
+  getHotState().channelAgentBridge[channelId] = agentName;
+}
+function getChannelAgent(channelId) {
+  return getHotState().channelAgentBridge[channelId] ?? null;
 }
 
 // src/sync.ts
@@ -11977,6 +12011,9 @@ async function fullSync(agentName, model, cfg, logger, openClawAgents) {
   logger.info("cohort-sync: full sync complete");
 }
 
+// src/agent-state.ts
+import { basename } from "node:path";
+
 // src/session-key.ts
 function parseSessionKey(key) {
   if (!key || !key.includes(":")) {
@@ -12014,6 +12051,7 @@ function shouldPushTelemetry(current, lastPushed) {
   if (!lastPushed) return true;
   if (current.status !== lastPushed.status) return true;
   if (current.compactions !== lastPushed.compactions) return true;
+  if (current.activeSessions !== lastPushed.activeSessions) return true;
   if (current.contextLimit > 0 && lastPushed.contextLimit > 0) {
     const currentPct = current.contextTokens / current.contextLimit;
     const lastPct = lastPushed.contextTokens / lastPushed.contextLimit;
@@ -12042,57 +12080,180 @@ function shouldPushSessions(current, lastPushed) {
   }
   return false;
 }
-function basename(filePath) {
-  const parts = filePath.split("/");
-  return parts[parts.length - 1] ?? filePath;
+function summarizeError(error) {
+  const str = String(error ?? "");
+  const firstLine = str.split("\n")[0] ?? str;
+  return firstLine.slice(0, 120);
 }
-function buildActivitySentence(agentName, event, context) {
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  return `${minutes}m`;
+}
+function buildActivityEntry(agentName, hook, context) {
   const ts = Date.now();
   const name = agentName.charAt(0).toUpperCase() + agentName.slice(1);
-  switch (event) {
-    case "before_tool_call": {
+  const sessionKey = context.sessionKey;
+  const model = context.model;
+  const channel = context.channel;
+  switch (hook) {
+    case "after_tool_call": {
       const toolName = String(context.toolName ?? "a tool");
       const params = context.params;
-      if (toolName === "Edit" || toolName === "Write") {
-        const file = params?.file_path ? basename(String(params.file_path)) : "a file";
-        return { agentName, text: `${name} is editing ${file}`, category: "tool", timestamp: ts };
-      }
+      const error = context.error;
+      const durationMs = context.durationMs;
+      const hasError = error != null && error !== "";
+      let text;
       if (toolName === "Read") {
         const file = params?.file_path ? basename(String(params.file_path)) : "a file";
-        return { agentName, text: `${name} is reading ${file}`, category: "tool", timestamp: ts };
-      }
-      if (toolName === "Bash") {
-        return { agentName, text: `${name} is running a command`, category: "tool", timestamp: ts };
-      }
-      if (toolName === "cohort_comment") {
+        text = hasError ? `${name} failed to read ${file}: ${summarizeError(error)}` : `${name} read ${file}`;
+      } else if (toolName === "Edit" || toolName === "Write") {
+        const file = params?.file_path ? basename(String(params.file_path)) : "a file";
+        text = hasError ? `${name} failed to edit ${file}: ${summarizeError(error)}` : `${name} edited ${file}`;
+      } else if (toolName === "Bash") {
+        text = hasError ? `${name} ran a command (failed: ${summarizeError(error)})` : `${name} ran a command`;
+      } else if (toolName === "cohort_comment") {
         const taskNum = params?.task_number ?? "?";
-        return { agentName, text: `${name} is commenting on task #${taskNum}`, category: "tool", timestamp: ts };
+        text = hasError ? `${name} failed to comment on task #${taskNum}: ${summarizeError(error)}` : `${name} commented on task #${taskNum}`;
+      } else {
+        text = hasError ? `${name} used ${toolName} (failed: ${summarizeError(error)})` : `${name} used ${toolName}`;
       }
-      return { agentName, text: `${name} used ${toolName}`, category: "tool", timestamp: ts };
+      return {
+        agentName,
+        text,
+        category: "tool",
+        timestamp: ts,
+        hook,
+        toolName,
+        sessionKey,
+        model,
+        durationMs,
+        error: hasError ? true : void 0,
+        errorSummary: hasError ? summarizeError(error) : void 0
+      };
     }
     case "message_received": {
-      const ch = String(context.channel ?? context.messageProvider ?? "unknown");
-      return { agentName, text: `${name} received a message on ${ch}`, category: "message", timestamp: ts };
+      const ch = String(channel ?? "unknown");
+      return {
+        agentName,
+        text: `${name} received a message on ${ch}`,
+        category: "message",
+        timestamp: ts,
+        hook,
+        channel: ch,
+        sessionKey,
+        model
+      };
     }
     case "message_sent": {
-      const ch = String(context.channel ?? context.messageProvider ?? "unknown");
-      return { agentName, text: `${name} sent a reply on ${ch}`, category: "message", timestamp: ts };
-    }
-    case "after_compaction": {
-      const before = context.beforePercent != null ? `${context.beforePercent}%` : "?";
-      const after = context.afterPercent != null ? `${context.afterPercent}%` : "?";
-      return { agentName, text: `${name} context compacted \u2014 ${before} \u2192 ${after}`, category: "system", timestamp: ts };
+      const ch = String(channel ?? "unknown");
+      const success = context.success !== false;
+      const error = context.error;
+      const text = success ? `${name} sent a reply on ${ch}` : `${name} failed to send on ${ch}: ${summarizeError(error)}`;
+      return {
+        agentName,
+        text,
+        category: "message",
+        timestamp: ts,
+        hook,
+        channel: ch,
+        sessionKey,
+        model,
+        error: !success ? true : void 0,
+        errorSummary: !success ? summarizeError(error) : void 0
+      };
     }
     case "session_start": {
-      const ch = String(context.channel ?? "unknown");
-      return { agentName, text: `${name} started a session on ${ch}`, category: "session", timestamp: ts };
+      const ch = String(channel ?? "unknown");
+      const resumed = context.resumedFrom != null;
+      const text = resumed ? `${name} resumed a session` : `${name} started a session on ${ch}`;
+      return {
+        agentName,
+        text,
+        category: "session",
+        timestamp: ts,
+        hook,
+        channel: ch,
+        sessionKey,
+        model
+      };
     }
     case "session_end": {
-      return { agentName, text: `${name} ended a session`, category: "session", timestamp: ts };
+      const msgCount = context.messageCount;
+      const durationMs = context.durationMs;
+      const parts = [];
+      if (msgCount != null) parts.push(`${msgCount} messages`);
+      if (durationMs != null) parts.push(formatDuration(durationMs));
+      const stats = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+      return {
+        agentName,
+        text: `${name} ended a session${stats}`,
+        category: "session",
+        timestamp: ts,
+        hook,
+        sessionKey,
+        model,
+        durationMs
+      };
+    }
+    case "before_compaction": {
+      return {
+        agentName,
+        text: `${name} context compaction starting`,
+        category: "system",
+        timestamp: ts,
+        hook,
+        sessionKey,
+        model
+      };
     }
-    case "before_agent_start": {
-      const ch = String(context.channel ?? "unknown");
-      return { agentName, text: `${name} is working on ${ch}`, category: "session", timestamp: ts };
+    case "after_compaction": {
+      const compactedCount = context.compactedCount;
+      const messageCount = context.messageCount;
+      const parts = [];
+      if (compactedCount != null) parts.push(`${compactedCount} messages removed`);
+      if (messageCount != null) parts.push(`${messageCount} remaining`);
+      const stats = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+      return {
+        agentName,
+        text: `${name} context compacted${stats}`,
+        category: "system",
+        timestamp: ts,
+        hook,
+        sessionKey,
+        model
+      };
+    }
+    case "agent_end": {
+      if (context.success !== false) return null;
+      const error = context.error;
+      const durationMs = context.durationMs;
+      return {
+        agentName,
+        text: `${name} processing failed: ${summarizeError(error)}`,
+        category: "system",
+        timestamp: ts,
+        hook,
+        sessionKey,
+        model,
+        durationMs,
+        error: true,
+        errorSummary: summarizeError(error)
+      };
+    }
+    case "before_reset": {
+      const reason = context.reason;
+      const text = reason ? `${name} session was reset (${reason})` : `${name} session was reset`;
+      return {
+        agentName,
+        text,
+        category: "system",
+        timestamp: ts,
+        hook,
+        sessionKey,
+        model
+      };
     }
     default:
       return null;
@@ -12101,6 +12262,13 @@ function buildActivitySentence(agentName, event, context) {
 var AgentStateTracker = class {
   agents = /* @__PURE__ */ new Map();
   activityBuffer = [];
+  sessionKeyToAgent = /* @__PURE__ */ new Map();
+  setSessionAgent(sessionKey, agentName) {
+    this.sessionKeyToAgent.set(sessionKey, agentName);
+  }
+  getSessionAgent(sessionKey) {
+    return this.sessionKeyToAgent.get(sessionKey) ?? null;
+  }
   getOrCreate(agentName) {
     let state = this.agents.get(agentName);
     if (!state) {
@@ -12142,7 +12310,29 @@ var AgentStateTracker = class {
       state.sessions.delete(sessionKey);
     }
   }
+  hasSession(agentName, sessionKey) {
+    const state = this.agents.get(agentName);
+    if (!state) return false;
+    return state.sessions.has(sessionKey);
+  }
+  pruneStaleSessions(agentName, maxAgeMs) {
+    const state = this.agents.get(agentName);
+    if (!state) return [];
+    const now = Date.now();
+    const pruned = [];
+    for (const [key, session] of state.sessions) {
+      const lastMs = new Date(session.lastActivity).getTime();
+      if (now - lastMs > maxAgeMs) {
+        state.sessions.delete(key);
+        pruned.push(key);
+      }
+    }
+    return pruned;
+  }
   // --- Telemetry updates ---
+  getStatus(agentName) {
+    return this.agents.get(agentName)?.status ?? null;
+  }
   updateStatus(agentName, status) {
     this.getOrCreate(agentName).status = status;
   }
@@ -12243,21 +12433,72 @@ var AgentStateTracker = class {
   clear() {
     this.agents.clear();
     this.activityBuffer = [];
+    this.sessionKeyToAgent.clear();
   }
   exportState() {
-    return new Map(this.agents);
+    return {
+      agents: new Map(this.agents),
+      sessionKeyToAgent: new Map(this.sessionKeyToAgent),
+      activityBuffer: [...this.activityBuffer]
+    };
   }
   importState(states) {
-    for (const [name, state] of states) {
+    const agentMap = states instanceof Map ? states : states.agents;
+    for (const [name, state] of agentMap) {
       if (!(state.sessions instanceof Map)) {
         state.sessions = new Map(Object.entries(state.sessions));
       }
       this.agents.set(name, state);
     }
+    if (!(states instanceof Map) && states.activityBuffer) {
+      this.activityBuffer.push(...states.activityBuffer);
+    }
+    if (!(states instanceof Map) && states.sessionKeyToAgent) {
+      for (const [key, agent] of states.sessionKeyToAgent) {
+        this.sessionKeyToAgent.set(key, agent);
+      }
+    }
   }
 };
 
 // src/hooks.ts
+var BUILD_ID = "B9-ACCOUNTID-20260311";
+var DIAG_LOG_PATH = "/tmp/cohort-sync-diag.log";
+function diag(label, data) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const payload = data ? " " + JSON.stringify(data, (_k, v2) => {
+    if (typeof v2 === "string" && v2.length > 200) return v2.slice(0, 200) + "\u2026";
+    return v2;
+  }) : "";
+  const line = `[${ts}] ${label}${payload}
+`;
+  try {
+    fs.appendFileSync(DIAG_LOG_PATH, line);
+  } catch {
+  }
+}
+function dumpCtx(ctx) {
+  if (!ctx || typeof ctx !== "object") return { _raw: String(ctx) };
+  const out = {};
+  for (const key of Object.keys(ctx)) {
+    const val = ctx[key];
+    if (typeof val === "function") {
+      out[key] = "[Function]";
+    } else if (typeof val === "object" && val !== null) {
+      try {
+        out[key] = JSON.parse(JSON.stringify(val));
+      } catch {
+        out[key] = "[Object]";
+      }
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function dumpEvent(event) {
+  return dumpCtx(event);
+}
 var PLUGIN_VERSION = "unknown";
 try {
   const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "package.json");
@@ -12265,6 +12506,7 @@ try {
   PLUGIN_VERSION = pkgJson.version ?? "unknown";
 } catch {
 }
+diag("MODULE_LOADED", { BUILD_ID, PLUGIN_VERSION });
 function parseIdentityFile(workspaceDir) {
   try {
     const filePath = path.join(workspaceDir, "IDENTITY.md");
@@ -12297,24 +12539,189 @@ function resolveIdentity(configIdentity, workspaceDir) {
     avatar: configIdentity?.avatar ?? fileIdentity?.avatar
   };
 }
+function getOrCreateTracker() {
+  const state = getHotState();
+  if (state.tracker instanceof AgentStateTracker) {
+    return state.tracker;
+  }
+  const fresh = new AgentStateTracker();
+  state.tracker = fresh;
+  return fresh;
+}
+var STATE_FILE_PATH = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  ".session-state.json"
+);
+function saveSessionsToDisk(tracker) {
+  try {
+    const state = tracker.exportState();
+    const data = {
+      sessions: [],
+      sessionKeyToAgent: Object.fromEntries(state.sessionKeyToAgent),
+      channelAgents: { ...globalThis["__cohort_sync_channel_agent__"] ?? {} },
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    for (const [name, agent] of state.agents) {
+      for (const key of agent.sessions.keys()) {
+        data.sessions.push({ agentName: name, key });
+      }
+    }
+    fs.writeFileSync(STATE_FILE_PATH, JSON.stringify(data));
+  } catch {
+  }
+}
+function loadSessionsFromDisk(tracker, logger) {
+  try {
+    if (!fs.existsSync(STATE_FILE_PATH)) return;
+    const data = JSON.parse(fs.readFileSync(STATE_FILE_PATH, "utf8"));
+    if (Date.now() - new Date(data.savedAt).getTime() > 864e5) {
+      logger.info("cohort-sync: disk session state too old (>24h), skipping");
+      return;
+    }
+    let count = 0;
+    for (const { agentName, key } of data.sessions) {
+      if (!tracker.hasSession(agentName, key)) {
+        tracker.addSession(agentName, key);
+        count++;
+      }
+    }
+    for (const [key, agent] of Object.entries(data.sessionKeyToAgent)) {
+      tracker.setSessionAgent(key, agent);
+    }
+    for (const [channelId, agent] of Object.entries(data.channelAgents ?? {})) {
+      setChannelAgent(channelId, agent);
+    }
+    if (count > 0) {
+      logger.info(`cohort-sync: restored ${count} sessions from disk`);
+    }
+  } catch {
+  }
+}
 function registerHooks(api, cfg) {
   const { logger, config } = api;
   const nameMap = cfg.agentNameMap;
-  const tracker = new AgentStateTracker();
+  const tracker = getOrCreateTracker();
   let heartbeatInterval = null;
   let activityFlushInterval = null;
+  logger.info(`cohort-sync: registerHooks [${BUILD_ID}]`);
+  diag("REGISTER_HOOKS", {
+    BUILD_ID,
+    PLUGIN_VERSION,
+    hasNameMap: !!nameMap,
+    nameMapKeys: nameMap ? Object.keys(nameMap) : [],
+    nameMapValues: nameMap ? Object.values(nameMap) : [],
+    agentCount: config?.agents?.list?.length ?? 0,
+    agentIds: (config?.agents?.list ?? []).map((a) => a.id),
+    agentMessageProviders: (config?.agents?.list ?? []).map((a) => ({ id: a.id, mp: a.messageProvider }))
+  });
   setConvexUrl(cfg);
   setLogger(logger);
   restoreFromHotReload(logger);
   restoreRosterFromHotReload(getRosterHotState(), logger);
-  const savedStates = getAgentStatesFromHot();
-  if (savedStates) {
-    tracker.importState(savedStates);
-    logger.info("cohort-sync: recovered AgentStateTracker state after hot-reload");
+  if (tracker.getAgentNames().length === 0) {
+    loadSessionsFromDisk(tracker, logger);
+    const restoredAgents = tracker.getAgentNames();
+    for (const agentName of restoredAgents) {
+      const sessSnapshot = tracker.getSessionsSnapshot(agentName);
+      if (sessSnapshot.length > 0) {
+        pushSessions(cfg.apiKey, agentName, sessSnapshot).then(() => {
+          tracker.markSessionsPushed(agentName);
+          logger.info(`cohort-sync: pushed ${sessSnapshot.length} restored sessions for ${agentName}`);
+        }).catch((err) => {
+          logger.warn(`cohort-sync: failed to push restored sessions for ${agentName}: ${String(err)}`);
+        });
+      }
+    }
   }
   function resolveAgentName(agentId) {
     return (nameMap?.[agentId] ?? agentId).toLowerCase();
   }
+  function resolveAgentFromContext(ctx) {
+    const allCtxKeys = Object.keys(ctx);
+    diag("RESOLVE_AGENT_FROM_CTX_START", {
+      ctxKeys: allCtxKeys,
+      agentId: ctx.agentId,
+      sessionKey: ctx.sessionKey,
+      sessionId: ctx.sessionId,
+      channelId: ctx.channelId,
+      accountId: ctx.accountId,
+      conversationId: ctx.conversationId,
+      messageProvider: ctx.messageProvider,
+      workspaceDir: ctx.workspaceDir
+    });
+    if (ctx.agentId && typeof ctx.agentId === "string") {
+      const resolved2 = resolveAgentName(ctx.agentId);
+      diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "agentId", raw: ctx.agentId, resolved: resolved2 });
+      return resolved2;
+    }
+    const sessionKey = ctx.sessionKey ?? ctx.sessionId;
+    if (sessionKey && typeof sessionKey === "string") {
+      const mapped = tracker.getSessionAgent(sessionKey);
+      if (mapped) {
+        diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "sessionKey_mapped", sessionKey, mapped });
+        return mapped;
+      }
+      const parts = sessionKey.split(":");
+      if (parts[0] === "agent" && parts.length >= 2) {
+        const resolved2 = resolveAgentName(parts[1]);
+        diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "sessionKey_parsed", sessionKey, agentPart: parts[1], resolved: resolved2 });
+        return resolved2;
+      }
+    }
+    const accountId = ctx.accountId;
+    if (accountId && typeof accountId === "string") {
+      const resolved2 = resolveAgentName(accountId);
+      diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "accountId", accountId, resolved: resolved2 });
+      return resolved2;
+    }
+    const channelId = ctx.channelId;
+    if (channelId && typeof channelId === "string") {
+      const channelAgent = getChannelAgent(channelId);
+      if (channelAgent) {
+        diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "channelId_bridge", channelId, channelAgent, bridgeState: { ...getHotState().channelAgentBridge } });
+        return channelAgent;
+      }
+      diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "channelId_raw", channelId, bridgeState: { ...getHotState().channelAgentBridge } });
+      return String(channelId);
+    }
+    const resolved = resolveAgentName("main");
+    diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "fallback_main", resolved });
+    return resolved;
+  }
+  function resolveChannelFromContext(ctx) {
+    if (ctx.messageProvider && typeof ctx.messageProvider === "string") {
+      return ctx.messageProvider;
+    }
+    if (ctx.channelId && typeof ctx.channelId === "string") {
+      return ctx.channelId;
+    }
+    const sessionKey = ctx.sessionKey ?? ctx.sessionId;
+    if (sessionKey && typeof sessionKey === "string") {
+      const parsed = parseSessionKey(sessionKey);
+      return parsed.channel;
+    }
+    return "unknown";
+  }
+  const pendingActivity = drainActivityFromHot();
+  if (pendingActivity.length > 0) {
+    pushActivity(cfg.apiKey, pendingActivity).catch((err) => {
+      logger.warn(`cohort-sync: pre-reload activity flush failed: ${String(err)}`);
+    });
+    logger.info(`cohort-sync: flushed ${pendingActivity.length} pending activity entries before hot-reload`);
+  }
+  clearIntervalsFromHot();
+  heartbeatInterval = setInterval(() => {
+    pushHeartbeat().catch((err) => {
+      logger.warn(`cohort-sync: heartbeat tick failed: ${String(err)}`);
+    });
+  }, 12e4);
+  activityFlushInterval = setInterval(() => {
+    flushActivityBuffer().catch((err) => {
+      logger.warn(`cohort-sync: activity flush tick failed: ${String(err)}`);
+    });
+  }, 3e3);
+  saveIntervalsToHot(heartbeatInterval, activityFlushInterval);
+  logger.info("cohort-sync: intervals created (heartbeat=2m, activityFlush=3s)");
   api.registerTool((toolCtx) => {
     const agentId = toolCtx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
@@ -12361,6 +12768,13 @@ function registerHooks(api, cfg) {
   }
   async function pushHeartbeat() {
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
+    for (const agentId of allAgentIds) {
+      const agentName = resolveAgentName(agentId);
+      const pruned = tracker.pruneStaleSessions(agentName, 864e5);
+      if (pruned.length > 0) {
+        logger.info(`cohort-sync: pruned ${pruned.length} stale sessions for ${agentName}`);
+      }
+    }
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);
       try {
@@ -12374,10 +12788,23 @@ function registerHooks(api, cfg) {
         logger.warn(`cohort-sync: heartbeat push failed for ${agentName}: ${String(err)}`);
       }
     }
+    for (const agentId of allAgentIds) {
+      const agentName = resolveAgentName(agentId);
+      try {
+        if (tracker.shouldPushSessions(agentName)) {
+          const sessSnapshot = tracker.getSessionsSnapshot(agentName);
+          await pushSessions(cfg.apiKey, agentName, sessSnapshot);
+          tracker.markSessionsPushed(agentName);
+        }
+      } catch (err) {
+        logger.warn(`cohort-sync: heartbeat session push failed for ${agentName}: ${String(err)}`);
+      }
+    }
+    saveSessionsToDisk(tracker);
     logger.info(`cohort-sync: heartbeat pushed for ${allAgentIds.length} agents`);
   }
   async function flushActivityBuffer() {
-    const entries = tracker.flushActivity();
+    const entries = drainActivityFromHot();
     if (entries.length === 0) return;
     try {
       await pushActivity(cfg.apiKey, entries);
@@ -12386,6 +12813,7 @@ function registerHooks(api, cfg) {
     }
   }
   api.on("gateway_start", async (event) => {
+    diag("HOOK_gateway_start", { port: event.port, eventKeys: Object.keys(event) });
     try {
       checkForUpdate(PLUGIN_VERSION, logger).catch(() => {
       });
@@ -12401,6 +12829,15 @@ function registerHooks(api, cfg) {
     } catch (err) {
       logger.error(`cohort-sync: gateway_start sync failed: ${String(err)}`);
     }
+    for (const a of config?.agents?.list ?? []) {
+      const agentName = resolveAgentName(a.id);
+      const mp = a.messageProvider;
+      diag("GATEWAY_START_SEED_BRIDGE", { agentId: a.id, agentName, messageProvider: mp, accountId: a.accountId });
+      if (mp && typeof mp === "string") {
+        setChannelAgent(mp, agentName);
+      }
+    }
+    diag("GATEWAY_START_BRIDGE_AFTER_SEED", { bridge: { ...getHotState().channelAgentBridge } });
     await initSubscription(
       event.port,
       cfg,
@@ -12425,20 +12862,9 @@ function registerHooks(api, cfg) {
       }
     }
     logger.info(`cohort-sync: seeded telemetry for ${allAgentIds.length} agents`);
-    heartbeatInterval = setInterval(() => {
-      pushHeartbeat().catch((err) => {
-        logger.warn(`cohort-sync: heartbeat tick failed: ${String(err)}`);
-      });
-    }, 12e4);
-    logger.info("cohort-sync: heartbeat started (2m interval)");
-    activityFlushInterval = setInterval(() => {
-      flushActivityBuffer().catch((err) => {
-        logger.warn(`cohort-sync: activity flush tick failed: ${String(err)}`);
-      });
-    }, 1500);
-    logger.info("cohort-sync: activity flush started (1.5s interval)");
   });
-  api.on("agent_end", async (_event, ctx) => {
+  api.on("agent_end", async (event, ctx) => {
+    diag("HOOK_agent_end", { ctx: dumpCtx(ctx), success: event.success, error: event.error, durationMs: event.durationMs });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
@@ -12451,11 +12877,21 @@ function registerHooks(api, cfg) {
           tracker.markTelemetryPushed(agentName);
         }
       }
+      if (event.success === false) {
+        const entry = buildActivityEntry(agentName, "agent_end", {
+          success: false,
+          error: event.error,
+          durationMs: event.durationMs,
+          sessionKey: ctx.sessionKey
+        });
+        if (entry) addActivityToHot(entry);
+      }
     } catch (err) {
       logger.warn(`cohort-sync: agent_end sync failed: ${String(err)}`);
     }
   });
   api.on("llm_output", async (event, ctx) => {
+    diag("HOOK_llm_output", { ctx: dumpCtx(ctx), model: event.model, tokensIn: event.usage?.input, tokensOut: event.usage?.output });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
@@ -12469,6 +12905,13 @@ function registerHooks(api, cfg) {
         contextTokens: ext.contextTokens ?? usage.total ?? 0,
         contextLimit: ext.contextLimit ?? 0
       });
+      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
+        tracker.addSession(agentName, sessionKey);
+        logger.info(`cohort-sync: inferred session for ${agentName} from llm_output (${sessionKey})`);
+      }
+      if (sessionKey) {
+        tracker.setSessionAgent(sessionKey, agentName);
+      }
       if (tracker.shouldPushTelemetry(agentName)) {
         const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
@@ -12486,6 +12929,7 @@ function registerHooks(api, cfg) {
     }
   });
   api.on("after_compaction", async (event, ctx) => {
+    diag("HOOK_after_compaction", { ctx: dumpCtx(ctx), messageCount: event.messageCount, tokenCount: event.tokenCount });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
@@ -12501,18 +12945,21 @@ function registerHooks(api, cfg) {
           tracker.markTelemetryPushed(agentName);
         }
       }
-      const entry = buildActivitySentence(agentName, "after_compaction", {
-        beforePercent: ext.beforePercent,
-        afterPercent: ext.afterPercent
+      const entry = buildActivityEntry(agentName, "after_compaction", {
+        messageCount: event.messageCount,
+        compactedCount: ext.compactedCount ?? event.compactedCount,
+        sessionKey: ctx.sessionKey
       });
-      if (entry) tracker.addActivity(entry);
+      if (entry) addActivityToHot(entry);
     } catch (err) {
       logger.warn(`cohort-sync: after_compaction telemetry failed: ${String(err)}`);
     }
   });
   api.on("before_agent_start", async (_event, ctx) => {
+    diag("HOOK_before_agent_start", { ctx: dumpCtx(ctx), event: dumpEvent(_event) });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
+    diag("HOOK_before_agent_start_RESOLVED", { agentId, agentName, ctxChannelId: ctx.channelId, ctxMessageProvider: ctx.messageProvider, ctxSessionKey: ctx.sessionKey, ctxAccountId: ctx.accountId });
     try {
       tracker.updateStatus(agentName, "working");
       if (tracker.shouldPushTelemetry(agentName)) {
@@ -12522,19 +12969,37 @@ function registerHooks(api, cfg) {
           tracker.markTelemetryPushed(agentName);
         }
       }
-      const entry = buildActivitySentence(agentName, "before_agent_start", {
-        channel: ctx.messageProvider ?? "unknown"
-      });
-      if (entry) tracker.addActivity(entry);
+      const sessionKey = ctx.sessionKey;
+      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
+        tracker.addSession(agentName, sessionKey);
+        tracker.setSessionAgent(sessionKey, agentName);
+        logger.info(`cohort-sync: inferred session for ${agentName} (${sessionKey})`);
+        if (tracker.shouldPushSessions(agentName)) {
+          const sessSnapshot = tracker.getSessionsSnapshot(agentName);
+          await pushSessions(cfg.apiKey, agentName, sessSnapshot);
+          tracker.markSessionsPushed(agentName);
+        }
+      } else if (sessionKey) {
+        tracker.setSessionAgent(sessionKey, agentName);
+      }
+      const ctxChannelId = ctx.channelId;
+      if (ctxChannelId) {
+        setChannelAgent(ctxChannelId, agentName);
+      }
+      const mp = ctx.messageProvider;
+      if (mp) {
+        setChannelAgent(mp, agentName);
+      }
     } catch (err) {
       logger.warn(`cohort-sync: before_agent_start telemetry failed: ${String(err)}`);
     }
   });
   api.on("session_start", async (event, ctx) => {
+    diag("HOOK_session_start", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const sessionKey = ctx.sessionKey ?? event.sessionId ?? String(Date.now());
+      const sessionKey = ctx.sessionId ?? String(Date.now());
       tracker.addSession(agentName, sessionKey);
       if (tracker.shouldPushSessions(agentName)) {
         const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
@@ -12542,77 +13007,139 @@ function registerHooks(api, cfg) {
         tracker.markSessionsPushed(agentName);
       }
       const parsed = parseSessionKey(sessionKey);
-      const entry = buildActivitySentence(agentName, "session_start", {
-        channel: parsed.channel
+      const entry = buildActivityEntry(agentName, "session_start", {
+        channel: parsed.channel,
+        sessionKey,
+        resumedFrom: event.resumedFrom
       });
-      if (entry) tracker.addActivity(entry);
+      if (entry) addActivityToHot(entry);
     } catch (err) {
       logger.warn(`cohort-sync: session_start tracking failed: ${String(err)}`);
     }
   });
   api.on("session_end", async (event, ctx) => {
+    diag("HOOK_session_end", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const sessionKey = ctx.sessionKey ?? event.sessionId ?? "";
+      const sessionKey = ctx.sessionId ?? "";
       tracker.removeSession(agentName, sessionKey);
       if (tracker.shouldPushSessions(agentName)) {
         const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
         tracker.markSessionsPushed(agentName);
       }
-      const entry = buildActivitySentence(agentName, "session_end", {});
-      if (entry) tracker.addActivity(entry);
+      const entry = buildActivityEntry(agentName, "session_end", {
+        sessionKey,
+        messageCount: event.messageCount,
+        durationMs: event.durationMs
+      });
+      if (entry) addActivityToHot(entry);
     } catch (err) {
       logger.warn(`cohort-sync: session_end tracking failed: ${String(err)}`);
     }
   });
-  api.on("before_tool_call", async (event, ctx) => {
-    const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+  api.on("after_tool_call", async (event, ctx) => {
+    diag("HOOK_after_tool_call", { ctx: dumpCtx(ctx), toolName: event.toolName, error: event.error });
+    const agentName = resolveAgentFromContext(ctx);
     try {
-      const entry = buildActivitySentence(agentName, "before_tool_call", {
-        toolName: event.toolName ?? event.name,
-        params: event.params ?? event.input
+      const entry = buildActivityEntry(agentName, "after_tool_call", {
+        toolName: event.toolName,
+        params: event.params,
+        error: event.error,
+        durationMs: event.durationMs,
+        sessionKey: ctx.sessionKey,
+        model: resolveModel(ctx.agentId ?? "main")
       });
-      if (entry) tracker.addActivity(entry);
+      if (entry) addActivityToHot(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: before_tool_call activity failed: ${String(err)}`);
+      logger.warn(`cohort-sync: after_tool_call activity failed: ${String(err)}`);
     }
   });
   api.on("message_received", async (_event, ctx) => {
+    diag("HOOK_message_received_RAW", {
+      ctx: dumpCtx(ctx),
+      event: dumpEvent(_event),
+      bridgeStateBefore: { ...getHotState().channelAgentBridge }
+    });
+    const agentName = resolveAgentFromContext(ctx);
+    const channel = ctx.channelId;
+    diag("HOOK_message_received_RESOLVED", {
+      agentName,
+      channel,
+      accountId: ctx.accountId,
+      conversationId: ctx.conversationId,
+      from: _event.from
+    });
+    try {
+      const entry = buildActivityEntry(agentName, "message_received", {
+        channel: channel ?? "unknown"
+      });
+      if (entry) addActivityToHot(entry);
+    } catch (err) {
+      logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
+    }
+  });
+  api.on("message_sent", async (event, ctx) => {
+    diag("HOOK_message_sent_RAW", {
+      ctx: dumpCtx(ctx),
+      event: dumpEvent(event),
+      bridgeStateBefore: { ...getHotState().channelAgentBridge }
+    });
+    const agentName = resolveAgentFromContext(ctx);
+    const channel = ctx.channelId;
+    diag("HOOK_message_sent_RESOLVED", {
+      agentName,
+      channel,
+      accountId: ctx.accountId,
+      conversationId: ctx.conversationId,
+      to: event.to,
+      success: event.success,
+      error: event.error
+    });
+    try {
+      const entry = buildActivityEntry(agentName, "message_sent", {
+        channel: channel ?? "unknown",
+        success: event.success,
+        error: event.error
+      });
+      if (entry) addActivityToHot(entry);
+    } catch (err) {
+      logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
+    }
+  });
+  api.on("before_compaction", async (_event, ctx) => {
+    diag("HOOK_before_compaction", { ctx: dumpCtx(ctx) });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const entry = buildActivitySentence(agentName, "message_received", {
-        channel: ctx.messageProvider ?? "unknown"
+      const entry = buildActivityEntry(agentName, "before_compaction", {
+        sessionKey: ctx.sessionKey
       });
-      if (entry) tracker.addActivity(entry);
+      if (entry) addActivityToHot(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
+      logger.warn(`cohort-sync: before_compaction activity failed: ${String(err)}`);
     }
   });
-  api.on("message_sent", async (_event, ctx) => {
+  api.on("before_reset", async (event, ctx) => {
+    diag("HOOK_before_reset", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const entry = buildActivitySentence(agentName, "message_sent", {
-        channel: ctx.messageProvider ?? "unknown"
+      const entry = buildActivityEntry(agentName, "before_reset", {
+        reason: event.reason,
+        sessionKey: ctx.sessionKey
       });
-      if (entry) tracker.addActivity(entry);
+      if (entry) addActivityToHot(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
+      logger.warn(`cohort-sync: before_reset activity failed: ${String(err)}`);
     }
   });
   api.on("gateway_stop", async () => {
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = null;
-    }
-    if (activityFlushInterval) {
-      clearInterval(activityFlushInterval);
-      activityFlushInterval = null;
-    }
+    diag("HOOK_gateway_stop", { bridgeState: { ...getHotState().channelAgentBridge } });
+    clearIntervalsFromHot();
+    heartbeatInterval = null;
+    activityFlushInterval = null;
     await flushActivityBuffer().catch((err) => {
       logger.warn(`cohort-sync: final activity flush failed: ${String(err)}`);
     });
@@ -12629,7 +13156,7 @@ function registerHooks(api, cfg) {
         logger.warn(`cohort-sync: final unreachable push failed for ${agentName}: ${String(err)}`);
       }
     }
-    saveAgentStatesToHot(tracker.exportState());
+    saveSessionsToDisk(tracker);
     try {
       await markAllUnreachable(cfg, logger);
     } catch (err) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",