@cfio/cohort-sync 0.1.7 → 0.2.1

package/dist/index.js

@@ -11565,6 +11565,7 @@ var getUndeliveredForPlugin = makeFunctionReference("notifications:getUndelivere
 var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredByPlugin");
 var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTelemetryFromPlugin");
 var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
+var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
 var HOT_KEY = "__cohort_sync__";
 function getHotState() {
   return globalThis[HOT_KEY] ?? null;
@@ -11728,6 +11729,38 @@ async function pushSessions(apiKey, agentName, sessions) {
     getLogger().error(`cohort-sync: pushSessions failed: ${err}`);
   }
 }
+async function pushActivity(apiKey, entries) {
+  if (entries.length === 0) return;
+  const c = getOrCreateClient();
+  if (!c) return;
+  try {
+    await c.mutation(pushActivityFromPluginRef, { apiKey, entries });
+  } catch (err) {
+    getLogger().error(`cohort-sync: pushActivity failed: ${err}`);
+  }
+}
+function saveAgentStatesToHot(states) {
+  const hot = getHotState();
+  if (hot) {
+    hot.agentStates = states;
+  }
+}
+function getAgentStatesFromHot() {
+  return getHotState()?.agentStates ?? null;
+}
+function saveIntervalsToHot(heartbeat, activityFlush) {
+  const hot = getHotState();
+  if (hot) {
+    hot.intervals = { heartbeat, activityFlush };
+  }
+}
+function clearIntervalsFromHot() {
+  const hot = getHotState();
+  if (!hot?.intervals) return;
+  if (hot.intervals.heartbeat) clearInterval(hot.intervals.heartbeat);
+  if (hot.intervals.activityFlush) clearInterval(hot.intervals.activityFlush);
+  hot.intervals = { heartbeat: null, activityFlush: null };
+}
 
 // src/sync.ts
 function extractJson(raw) {
@@ -11957,78 +11990,331 @@ async function fullSync(agentName, model, cfg, logger, openClawAgents) {
   logger.info("cohort-sync: full sync complete");
 }
 
-// src/telemetry.ts
-var TelemetryTracker = class {
-  state = /* @__PURE__ */ new Map();
-  /** Update accumulated state for an agent and return the full snapshot. */
-  update(agentName, delta) {
-    const current = this.state.get(agentName) ?? {
-      agentName,
-      status: "idle",
+// src/session-key.ts
+function parseSessionKey(key) {
+  if (!key || !key.includes(":")) {
+    return { kind: "cli", channel: "cli" };
+  }
+  const parts = key.split(":");
+  if (parts[0] === "hook" && parts[1] === "cohort") {
+    return { kind: "hook", channel: "cohort", identifier: parts.slice(2).join(":") };
+  }
+  if (parts[0] === "agent" && parts.length >= 3) {
+    const rest = parts.slice(2);
+    if (rest[0] === "main") {
+      return { kind: "direct", channel: "signal" };
+    }
+    if (rest[0] === "signal") {
+      if (rest[1] === "group") {
+        return { kind: "group", channel: "signal", identifier: rest.slice(2).join(":") };
+      }
+      if (rest.length >= 3 && rest.some((p) => p === "dm")) {
+        const dmIndex = rest.indexOf("dm");
+        return { kind: "direct", channel: "signal", identifier: rest.slice(dmIndex + 1).join(":") };
+      }
+      return { kind: "direct", channel: "signal" };
+    }
+    if (rest[0] === "slack" && rest[1] === "channel") {
+      return { kind: "group", channel: "slack", identifier: rest[2] };
+    }
+  }
+  return { kind: "cli", channel: "cli" };
+}
+
+// src/agent-state.ts
+var DELTA_THRESHOLD = 0.1;
+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;
+    if (Math.abs(currentPct - lastPct) >= DELTA_THRESHOLD) return true;
+  } else if (current.contextLimit > 0 && lastPushed.contextLimit === 0) {
+    return true;
+  }
+  const maxIn = Math.max(lastPushed.tokensIn, 1);
+  if (Math.abs(current.tokensIn - lastPushed.tokensIn) / maxIn >= DELTA_THRESHOLD) return true;
+  const maxOut = Math.max(lastPushed.tokensOut, 1);
+  if (Math.abs(current.tokensOut - lastPushed.tokensOut) / maxOut >= DELTA_THRESHOLD) return true;
+  return false;
+}
+function shouldPushSessions(current, lastPushed) {
+  if (!lastPushed) return true;
+  if (current.length !== lastPushed.length) return true;
+  for (const sess of current) {
+    const prev = lastPushed.find((s) => s.key === sess.key);
+    if (!prev) return true;
+    if (sess.model && sess.model !== "unknown" && prev.model !== sess.model) return true;
+    if (sess.contextLimit && sess.contextLimit > 0 && prev.contextLimit && prev.contextLimit > 0) {
+      const curPct = (sess.contextTokens ?? 0) / sess.contextLimit;
+      const prevPct = (prev.contextTokens ?? 0) / prev.contextLimit;
+      if (Math.abs(curPct - prevPct) >= DELTA_THRESHOLD) return true;
+    }
+  }
+  return false;
+}
+function basename(filePath) {
+  const parts = filePath.split("/");
+  return parts[parts.length - 1] ?? filePath;
+}
+function buildActivitySentence(agentName, event, context) {
+  const ts = Date.now();
+  const name = agentName.charAt(0).toUpperCase() + agentName.slice(1);
+  switch (event) {
+    case "before_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 };
+      }
+      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") {
+        const taskNum = params?.task_number ?? "?";
+        return { agentName, text: `${name} is commenting on task #${taskNum}`, category: "tool", timestamp: ts };
+      }
+      return { agentName, text: `${name} used ${toolName}`, category: "tool", timestamp: ts };
+    }
+    case "message_received": {
+      const ch = String(context.channel ?? context.messageProvider ?? "unknown");
+      return { agentName, text: `${name} received a message on ${ch}`, category: "message", timestamp: ts };
+    }
+    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 };
+    }
+    case "session_start": {
+      const ch = String(context.channel ?? "unknown");
+      return { agentName, text: `${name} started a session on ${ch}`, category: "session", timestamp: ts };
+    }
+    case "session_end": {
+      return { agentName, text: `${name} ended a session`, category: "session", timestamp: ts };
+    }
+    case "before_agent_start": {
+      const ch = String(context.channel ?? "unknown");
+      return { agentName, text: `${name} is working on ${ch}`, category: "session", timestamp: ts };
+    }
+    default:
+      return null;
+  }
+}
+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) {
+      state = {
+        agentName,
+        status: "idle",
+        model: "unknown",
+        tokensIn: 0,
+        tokensOut: 0,
+        contextTokens: 0,
+        contextLimit: 0,
+        compactions: 0,
+        sessions: /* @__PURE__ */ new Map(),
+        lastPushedTelemetry: null,
+        lastPushedSessions: null
+      };
+      this.agents.set(agentName, state);
+    }
+    return state;
+  }
+  // --- Session lifecycle ---
+  addSession(agentName, sessionKey) {
+    const state = this.getOrCreate(agentName);
+    const parsed = parseSessionKey(sessionKey);
+    state.sessions.set(sessionKey, {
+      key: sessionKey,
+      kind: parsed.kind,
+      channel: parsed.channel,
       model: "unknown",
       contextTokens: 0,
       contextLimit: 0,
-      tokensIn: 0,
-      tokensOut: 0,
-      compactions: 0,
-      activeSessions: 0
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      startedAt: Date.now()
+    });
+  }
+  removeSession(agentName, sessionKey) {
+    const state = this.agents.get(agentName);
+    if (state) {
+      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 ---
+  updateStatus(agentName, status) {
+    this.getOrCreate(agentName).status = status;
+  }
+  updateFromLlmOutput(agentName, sessionKey, data) {
+    const state = this.getOrCreate(agentName);
+    if (data.model) state.model = data.model;
+    if (data.tokensIn !== void 0) state.tokensIn += data.tokensIn;
+    if (data.tokensOut !== void 0) state.tokensOut += data.tokensOut;
+    if (data.contextTokens !== void 0) state.contextTokens = data.contextTokens;
+    if (data.contextLimit !== void 0) state.contextLimit = data.contextLimit;
+    state.status = "working";
+    if (sessionKey) {
+      const session = state.sessions.get(sessionKey);
+      if (session) {
+        if (data.model) session.model = data.model;
+        if (data.contextTokens !== void 0) session.contextTokens = data.contextTokens;
+        if (data.contextLimit !== void 0) session.contextLimit = data.contextLimit;
+        session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+  }
+  updateFromCompaction(agentName, data) {
+    const state = this.getOrCreate(agentName);
+    state.compactions += 1;
+    if (data.contextTokens !== void 0) state.contextTokens = data.contextTokens;
+    if (data.contextLimit !== void 0) state.contextLimit = data.contextLimit;
+  }
+  setModel(agentName, model) {
+    this.getOrCreate(agentName).model = model;
+  }
+  // --- Snapshot extraction ---
+  getTelemetrySnapshot(agentName) {
+    const state = this.agents.get(agentName);
+    if (!state) return null;
+    return {
+      agentName: state.agentName,
+      status: state.status,
+      model: state.model,
+      contextTokens: state.contextTokens,
+      contextLimit: state.contextLimit,
+      tokensIn: state.tokensIn,
+      tokensOut: state.tokensOut,
+      compactions: state.compactions,
+      activeSessions: state.sessions.size
     };
-    if (delta.model) current.model = delta.model;
-    if (delta.status) current.status = delta.status;
-    if (delta.tokensIn !== void 0) current.tokensIn += delta.tokensIn;
-    if (delta.tokensOut !== void 0) current.tokensOut += delta.tokensOut;
-    if (delta.contextTokens !== void 0) current.contextTokens = delta.contextTokens;
-    if (delta.contextLimit !== void 0) current.contextLimit = delta.contextLimit;
-    if (delta.activeSessions !== void 0) current.activeSessions = delta.activeSessions;
-    if (delta.compacted) {
-      current.compactions += 1;
-    }
-    this.state.set(agentName, current);
-    return { ...current };
-  }
-  /** Get current state for an agent. */
-  get(agentName) {
-    const s = this.state.get(agentName);
-    return s ? { ...s } : void 0;
-  }
-  /** Return the last known snapshot for an agent (null if unknown). */
-  getSnapshot(agentName) {
-    return this.state.has(agentName) ? { ...this.state.get(agentName) } : null;
-  }
-  /** Clear all tracked state (e.g., on gateway_stop). */
-  clear() {
-    this.state.clear();
   }
-};
-
-// src/sessions.ts
-var SessionTracker = class {
-  sessions = /* @__PURE__ */ new Map();
-  /** Add a session and return the current snapshot. */
-  addSession(sessionId, info) {
-    this.sessions.set(sessionId, info);
-    return this.getSessions();
+  getSessionsSnapshot(agentName) {
+    const state = this.agents.get(agentName);
+    if (!state) return [];
+    return Array.from(state.sessions.values()).map((s) => ({
+      key: s.key,
+      kind: s.kind,
+      channel: s.channel,
+      model: s.model !== "unknown" ? s.model : void 0,
+      contextTokens: s.contextTokens > 0 ? s.contextTokens : void 0,
+      contextLimit: s.contextLimit > 0 ? s.contextLimit : void 0,
+      lastActivity: s.lastActivity
+    }));
+  }
+  // --- Delta detection ---
+  shouldPushTelemetry(agentName) {
+    const snapshot = this.getTelemetrySnapshot(agentName);
+    if (!snapshot) return false;
+    const state = this.agents.get(agentName);
+    return shouldPushTelemetry(snapshot, state.lastPushedTelemetry);
   }
-  /** Remove a session and return the current snapshot. */
-  removeSession(sessionId) {
-    this.sessions.delete(sessionId);
-    return this.getSessions();
+  shouldPushSessions(agentName) {
+    const snapshot = this.getSessionsSnapshot(agentName);
+    const state = this.agents.get(agentName);
+    if (!state) return false;
+    return shouldPushSessions(snapshot, state.lastPushedSessions);
   }
-  /** Get current sessions as an array. */
-  getSessions() {
-    return Array.from(this.sessions.values());
+  markTelemetryPushed(agentName) {
+    const state = this.agents.get(agentName);
+    if (state) {
+      state.lastPushedTelemetry = this.getTelemetrySnapshot(agentName);
+    }
   }
-  /** Get the count of active sessions. */
-  get count() {
-    return this.sessions.size;
+  markSessionsPushed(agentName) {
+    const state = this.agents.get(agentName);
+    if (state) {
+      state.lastPushedSessions = this.getSessionsSnapshot(agentName);
+    }
+  }
+  // --- Activity buffer ---
+  addActivity(entry) {
+    this.activityBuffer.push(entry);
+  }
+  flushActivity() {
+    const entries = [...this.activityBuffer];
+    this.activityBuffer = [];
+    return entries;
+  }
+  // --- Lifecycle ---
+  getAgentNames() {
+    return Array.from(this.agents.keys());
   }
-  /** Clear all sessions (e.g., on gateway_stop). */
   clear() {
-    this.sessions.clear();
+    this.agents.clear();
+    this.activityBuffer = [];
+    this.sessionKeyToAgent.clear();
+  }
+  exportState() {
+    return {
+      agents: new Map(this.agents),
+      sessionKeyToAgent: new Map(this.sessionKeyToAgent)
+    };
+  }
+  importState(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.sessionKeyToAgent) {
+      for (const [key, agent] of states.sessionKeyToAgent) {
+        this.sessionKeyToAgent.set(key, agent);
+      }
+    }
   }
 };
 
 // src/hooks.ts
+var PLUGIN_VERSION = "unknown";
+try {
+  const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "package.json");
+  const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  PLUGIN_VERSION = pkgJson.version ?? "unknown";
+} catch {
+}
 function parseIdentityFile(workspaceDir) {
   try {
     const filePath = path.join(workspaceDir, "IDENTITY.md");
@@ -12064,16 +12350,45 @@ function resolveIdentity(configIdentity, workspaceDir) {
 function registerHooks(api, cfg) {
   const { logger, config } = api;
   const nameMap = cfg.agentNameMap;
-  const telemetry = new TelemetryTracker();
-  const sessions = new SessionTracker();
+  const tracker = new AgentStateTracker();
   let heartbeatInterval = null;
+  let activityFlushInterval = null;
   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");
+  }
   function resolveAgentName(agentId) {
     return (nameMap?.[agentId] ?? agentId).toLowerCase();
   }
+  function resolveAgentFromContext(ctx) {
+    if (ctx.agentId && typeof ctx.agentId === "string") {
+      return resolveAgentName(ctx.agentId);
+    }
+    const sessionKey = ctx.sessionKey ?? ctx.sessionId;
+    if (sessionKey && typeof sessionKey === "string") {
+      const mapped = tracker.getSessionAgent(sessionKey);
+      if (mapped) return mapped;
+    }
+    return resolveAgentName("main");
+  }
+  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)}`);
+    });
+  }, 1500);
+  saveIntervalsToHot(heartbeatInterval, activityFlushInterval);
+  logger.info("cohort-sync: intervals created (heartbeat=2m, activityFlush=1.5s)");
   api.registerTool((toolCtx) => {
     const agentId = toolCtx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
@@ -12120,12 +12435,19 @@ 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, 6e5);
+      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 {
-        const snapshot = telemetry.getSnapshot(agentName);
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
-          await pushTelemetry(cfg.apiKey, snapshot);
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
         } else {
           logger.info(`cohort-sync: heartbeat skipped ${agentName} \u2014 no snapshot in tracker`);
         }
@@ -12133,13 +12455,32 @@ 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)}`);
+      }
+    }
     logger.info(`cohort-sync: heartbeat pushed for ${allAgentIds.length} agents`);
   }
+  async function flushActivityBuffer() {
+    const entries = tracker.flushActivity();
+    if (entries.length === 0) return;
+    try {
+      await pushActivity(cfg.apiKey, entries);
+    } catch (err) {
+      logger.warn(`cohort-sync: activity flush failed: ${String(err)}`);
+    }
+  }
   api.on("gateway_start", async (event) => {
     try {
-      const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "package.json");
-      const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-      checkForUpdate(pkgJson.version, logger).catch(() => {
+      checkForUpdate(PLUGIN_VERSION, logger).catch(() => {
       });
     } catch {
     }
@@ -12165,30 +12506,32 @@ function registerHooks(api, cfg) {
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);
       try {
-        const snapshot = telemetry.update(agentName, {
-          model: resolveModel(agentId),
-          status: "idle"
-        });
-        await pushTelemetry(cfg.apiKey, snapshot);
+        tracker.setModel(agentName, resolveModel(agentId));
+        tracker.updateStatus(agentName, "idle");
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        if (snapshot) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+          tracker.markTelemetryPushed(agentName);
+        }
       } catch (err) {
         logger.warn(`cohort-sync: initial telemetry seed failed for ${agentName}: ${String(err)}`);
       }
     }
     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)");
   });
   api.on("agent_end", async (_event, ctx) => {
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
+      tracker.updateStatus(agentName, "idle");
       await syncAgentStatus(agentName, "idle", resolveModel(agentId), cfg, logger);
-      const snapshot = telemetry.update(agentName, { status: "idle" });
-      await pushTelemetry(cfg.apiKey, snapshot);
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        if (snapshot) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+          tracker.markTelemetryPushed(agentName);
+        }
+      }
     } catch (err) {
       logger.warn(`cohort-sync: agent_end sync failed: ${String(err)}`);
     }
@@ -12199,14 +12542,33 @@ function registerHooks(api, cfg) {
     try {
       const usage = event.usage ?? {};
       const ext = event;
-      const snapshot = telemetry.update(agentName, {
+      const sessionKey = ctx.sessionKey;
+      tracker.updateFromLlmOutput(agentName, sessionKey, {
         model: event.model ?? resolveModel(agentId),
         tokensIn: usage.input ?? 0,
         tokensOut: usage.output ?? 0,
         contextTokens: ext.contextTokens ?? usage.total ?? 0,
         contextLimit: ext.contextLimit ?? 0
       });
-      await pushTelemetry(cfg.apiKey, snapshot);
+      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) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+          tracker.markTelemetryPushed(agentName);
+        }
+      }
+      if (tracker.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
+        await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
+        tracker.markSessionsPushed(agentName);
+      }
     } catch (err) {
       logger.warn(`cohort-sync: llm_output telemetry failed: ${String(err)}`);
     }
@@ -12216,12 +12578,22 @@ function registerHooks(api, cfg) {
     const agentName = resolveAgentName(agentId);
     try {
       const ext = event;
-      const snapshot = telemetry.update(agentName, {
-        compacted: true,
+      tracker.updateFromCompaction(agentName, {
         contextTokens: ext.contextTokens ?? event.tokenCount ?? 0,
         contextLimit: ext.contextLimit ?? 0
       });
-      await pushTelemetry(cfg.apiKey, snapshot);
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        if (snapshot) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+          tracker.markTelemetryPushed(agentName);
+        }
+      }
+      const entry = buildActivitySentence(agentName, "after_compaction", {
+        beforePercent: ext.beforePercent,
+        afterPercent: ext.afterPercent
+      });
+      if (entry) tracker.addActivity(entry);
     } catch (err) {
       logger.warn(`cohort-sync: after_compaction telemetry failed: ${String(err)}`);
     }
@@ -12230,8 +12602,29 @@ function registerHooks(api, cfg) {
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const snapshot = telemetry.update(agentName, { status: "working" });
-      await pushTelemetry(cfg.apiKey, snapshot);
+      tracker.updateStatus(agentName, "working");
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        if (snapshot) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+          tracker.markTelemetryPushed(agentName);
+        }
+      }
+      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);
+        }
+      }
+      const entry = buildActivitySentence(agentName, "before_agent_start", {
+        channel: ctx.messageProvider ?? "unknown"
+      });
+      if (entry) tracker.addActivity(entry);
     } catch (err) {
       logger.warn(`cohort-sync: before_agent_start telemetry failed: ${String(err)}`);
     }
@@ -12240,15 +12633,18 @@ function registerHooks(api, cfg) {
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const ext = event;
-      const sessionId = event.sessionId ?? String(Date.now());
-      const snapshot = sessions.addSession(sessionId, {
-        key: sessionId,
-        kind: ext.kind ?? "cli",
-        channel: ext.channel,
-        model: ext.model
+      const sessionKey = ctx.sessionKey ?? event.sessionId ?? String(Date.now());
+      tracker.addSession(agentName, sessionKey);
+      if (tracker.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
+        await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
+        tracker.markSessionsPushed(agentName);
+      }
+      const parsed = parseSessionKey(sessionKey);
+      const entry = buildActivitySentence(agentName, "session_start", {
+        channel: parsed.channel
       });
-      await pushSessions(cfg.apiKey, agentName, snapshot);
+      if (entry) tracker.addActivity(entry);
     } catch (err) {
       logger.warn(`cohort-sync: session_start tracking failed: ${String(err)}`);
     }
@@ -12257,35 +12653,80 @@ function registerHooks(api, cfg) {
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      const sessionId = event.sessionId ?? "";
-      const snapshot = sessions.removeSession(sessionId);
-      await pushSessions(cfg.apiKey, agentName, snapshot);
+      const sessionKey = ctx.sessionKey ?? event.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);
     } catch (err) {
       logger.warn(`cohort-sync: session_end tracking failed: ${String(err)}`);
     }
   });
-  api.on("gateway_stop", async () => {
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = null;
+  api.on("before_tool_call", async (event, ctx) => {
+    const agentName = resolveAgentFromContext(ctx);
+    try {
+      const entry = buildActivitySentence(agentName, "before_tool_call", {
+        toolName: event.toolName ?? event.name,
+        params: event.params ?? event.input
+      });
+      if (entry) tracker.addActivity(entry);
+    } catch (err) {
+      logger.warn(`cohort-sync: before_tool_call activity failed: ${String(err)}`);
     }
+  });
+  api.on("message_received", async (_event, ctx) => {
+    const agentName = resolveAgentFromContext(ctx);
+    try {
+      const entry = buildActivitySentence(agentName, "message_received", {
+        channel: ctx.messageProvider ?? "unknown"
+      });
+      if (entry) tracker.addActivity(entry);
+    } catch (err) {
+      logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
+    }
+  });
+  api.on("message_sent", async (_event, ctx) => {
+    const agentName = resolveAgentFromContext(ctx);
+    try {
+      const entry = buildActivitySentence(agentName, "message_sent", {
+        channel: ctx.messageProvider ?? "unknown"
+      });
+      if (entry) tracker.addActivity(entry);
+    } catch (err) {
+      logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
+    }
+  });
+  api.on("gateway_stop", async () => {
+    clearIntervalsFromHot();
+    heartbeatInterval = null;
+    activityFlushInterval = null;
+    await flushActivityBuffer().catch((err) => {
+      logger.warn(`cohort-sync: final activity flush failed: ${String(err)}`);
+    });
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);
       try {
-        const snapshot = telemetry.update(agentName, { status: "unreachable" });
-        await pushTelemetry(cfg.apiKey, snapshot);
+        tracker.updateStatus(agentName, "unreachable");
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        if (snapshot) {
+          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
+        }
       } catch (err) {
         logger.warn(`cohort-sync: final unreachable push failed for ${agentName}: ${String(err)}`);
       }
     }
+    saveAgentStatesToHot(tracker.exportState());
     try {
       await markAllUnreachable(cfg, logger);
     } catch (err) {
       logger.warn(`cohort-sync: markAllUnreachable failed: ${String(err)}`);
     }
-    telemetry.clear();
-    sessions.clear();
+    tracker.clear();
     closeSubscription();
     logger.info("cohort-sync: subscription closed");
   });

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "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.1.7",
+  "version": "0.2.1",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",