@cfio/cohort-sync 0.10.3 → 0.11.1

package/dist/index.js

@@ -13271,53 +13271,6 @@ var AgentStateTracker = class {
   }
 };
 
-// src/pocket-guide.ts
-var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
-
-> These are the essential rules. For the full guide, see https://docs.cohort.bot/integration/guide
-
-## Getting Started
-- Call the cohort_context tool at the start of every work session for your personalized briefing.
-- If cohort_context is unavailable, call GET /api/v1/context directly.
-- Do not skip the context call \u2014 it contains workspace-specific overrides that supersede these rules.
-
-## Task Lifecycle
-- Create tasks for trackable work items. Always set priority (default p2) and effort when estimable.
-- Use POST /tasks/:id/transition for status changes. Never PATCH status directly \u2014 the server rejects it.
-- If a transition is rejected, read the error response for valid transitions from the current status.
-- You cannot transition tasks to "done" unless your workspace admin has enabled it. Only humans close tasks by default.
-- When moving to "in_progress", you are claiming ownership \u2014 only claim tasks you can actively work on.
-- When moving to "waiting", comment what you are blocked on and who/what can unblock you.
-- When work is complete, comment with evidence: PR link, test output, or summary of changes.
-
-## Comments
-- Comment before every status transition explaining what happened.
-- Post progress updates every 15-30 minutes on long-running work.
-- Keep comments factual \u2014 what you did, what you found, what is next.
-- No conversational filler. Every comment must contain information.
-- Reference specific files, line numbers, error messages, or URLs when relevant.
-
-## Projects & Initiatives
-- Don't create projects or initiatives without explicit instruction.
-- Assign tasks to existing projects when one fits. Don't create a project for a single task.
-- If no project fits, leave the task unassigned to a project.
-
-## Error Recovery
-- If auth fails (401), stop immediately. Do not retry. Report the failure.
-- If rate limited (429), wait per Retry-After header.
-- If 404, verify you are using the correct task number or ID (both accepted).
-- If 500, retry once after a brief pause. If it fails again, stop and report.
-
-## What Not To Do
-- Don't poll /tasks in a loop \u2014 check assignments, then do your work.
-- Don't create duplicate tasks \u2014 search first.
-- Don't delete tasks unless explicitly told to.
-- Don't bulk-create tasks speculatively \u2014 create them as work becomes concrete.
-- Don't modify tasks assigned to other agents unless coordinating through comments.
-- Don't set "done" on tasks you didn't work on.
-- Don't ignore workspace-specific overrides from your context response.
-`;
-
 // src/types.ts
 var DEFAULT_API_URL = "https://api.cohort.bot";
 
@@ -13381,13 +13334,7 @@ function dumpCtx(ctx) {
 function dumpEvent(event) {
   return dumpCtx(event);
 }
-var PLUGIN_VERSION = true ? "0.10.3" : "unknown";
-var _gatewayStartHandler = null;
-async function handleGatewayStart(event) {
-  if (_gatewayStartHandler) {
-    await _gatewayStartHandler(event);
-  }
-}
+var PLUGIN_VERSION = true ? "0.11.1" : "unknown";
 function resolveGatewayToken(api) {
   const token = api.config?.gateway?.auth?.token;
   return typeof token === "string" ? token : null;
@@ -13443,21 +13390,9 @@ function resolveIdentity(configIdentity, workspaceDir) {
     avatar: configIdentity?.avatar ?? fileIdentity?.avatar
   };
 }
-var tracker = null;
-function getOrCreateTracker() {
-  if (!tracker) tracker = new AgentStateTracker();
-  return tracker;
-}
-var gatewayPort = null;
-var gatewayToken = null;
-var persistentGwClient = null;
-var gwClientInitialized = false;
-var keepaliveInterval = null;
-var commandUnsubscriber2 = null;
-var STATE_FILE_PATH = "";
-function saveSessionsToDisk(tracker2) {
+function saveSessionsToDisk(tracker, stateFilePath) {
   try {
-    const state = tracker2.exportState();
+    const state = tracker.exportState();
     const data = {
       sessions: [],
       sessionKeyToAgent: Object.fromEntries(state.sessionKeyToAgent),
@@ -13469,27 +13404,27 @@ function saveSessionsToDisk(tracker2) {
         data.sessions.push({ agentName: name, key });
       }
     }
-    fs2.writeFileSync(STATE_FILE_PATH, JSON.stringify(data), { mode: 384 });
+    fs2.writeFileSync(stateFilePath, JSON.stringify(data), { mode: 384 });
   } catch {
   }
 }
-function loadSessionsFromDisk(tracker2, logger) {
+function loadSessionsFromDisk(tracker, stateFilePath, logger) {
   try {
-    if (!fs2.existsSync(STATE_FILE_PATH)) return;
-    const data = JSON.parse(fs2["read"+"FileSync"](STATE_FILE_PATH, "utf8"));
+    if (!fs2.existsSync(stateFilePath)) return;
+    const data = JSON.parse(fs2["read"+"FileSync"](stateFilePath, "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 (!tracker2.hasSession(agentName, key)) {
-        tracker2.addSession(agentName, key);
+      if (!tracker.hasSession(agentName, key)) {
+        tracker.addSession(agentName, key);
         count++;
       }
     }
     for (const [key, agent] of Object.entries(data.sessionKeyToAgent)) {
-      tracker2.setSessionAgent(key, agent);
+      tracker.setSessionAgent(key, agent);
     }
     for (const [channelId, agent] of Object.entries(data.channelAgents ?? {})) {
       setChannelAgent(channelId, agent);
@@ -13502,8 +13437,6 @@ function loadSessionsFromDisk(tracker2, logger) {
 }
 function initGatewayClient(port, token, cfg, resolveAgentName, logger) {
   const client2 = new GatewayClient(port, token, logger, PLUGIN_VERSION);
-  persistentGwClient = client2;
-  gwClientInitialized = true;
   const onConnected = async () => {
     logger.debug(`cohort-sync: gateway client connected (methods=${client2.availableMethods.size}, events=${client2.availableEvents.size})`);
     logger.info(`cohort-sync: gateway client connected (methods=${client2.availableMethods.size}, events=${client2.availableEvents.size})`);
@@ -13528,75 +13461,109 @@ function initGatewayClient(port, token, cfg, resolveAgentName, logger) {
     logger.debug("cohort-sync: initial connect deferred", { error: String(err) });
     logger.warn(`cohort-sync: GW connect will retry: ${String(err)}`);
   });
+  return client2;
 }
-function registerHooks(api, cfg) {
-  STATE_FILE_PATH = path2.join(cfg.stateDir, "session-state.json");
-  const { logger, config } = api;
-  const nameMap = cfg.agentNameMap;
-  const tracker2 = getOrCreateTracker();
-  const convexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
-  createClient(convexUrl);
-  setLogger(logger);
-  gatewayPort = api.config?.gateway?.port ?? null;
-  gatewayToken = resolveGatewayToken(api);
-  if (gatewayPort && gatewayToken) {
-    initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, logger);
+async function handleGatewayStart(event, state) {
+  if (!state) {
+    console.log("[cohort-sync] handleGatewayStart: state is null, skipping");
+    return;
   }
-  const cronStorePath = api.config?.cron?.store ?? path2.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
-  for (const eventType of ["agent", "session", "command", "gateway", "message"]) {
-    api.registerHook(eventType, async (event) => {
-      logger.info(`cohort-sync: [DIAG] event=${eventType} action=${event?.action} sessionKey=${event?.sessionKey} ctxKeys=${Object.keys(event?.context ?? {}).join(",")}`);
-    }, { name: `cohort-sync.diag-${eventType}`, description: `Diagnostic: catch all ${eventType} events` });
+  const { cfg, tracker, logger, config, api } = state;
+  logger.info("cohort-sync: handleGatewayStart ENTERED", { port: event.port, hasConfig: !!config, hasCfg: !!cfg });
+  try {
+    checkForUpdate(PLUGIN_VERSION, logger).catch(() => {
+    });
+  } catch {
   }
-  logger.info(`cohort-sync: registerHooks v${PLUGIN_VERSION}`);
-  logger.info("cohort-sync: hooks registered", {
-    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 }))
+  try {
+    const agentList = (config?.agents?.list ?? []).map((a) => ({
+      id: a.id,
+      model: state.resolveModel(a.id),
+      identity: resolveIdentity(a.identity, a.workspace)
+    }));
+    await fullSync(state.resolveAgentName("main"), state.resolveModel("main"), cfg, logger, agentList);
+  } catch (err) {
+    logger.error(`cohort-sync: gateway_start sync failed: ${String(err)}`);
+  }
+  for (const a of config?.agents?.list ?? []) {
+    const agentName = state.resolveAgentName(a.id);
+    const mp = a.messageProvider;
+    logger.debug("cohort-sync: gateway start: seed bridge", { agentId: a.id, agentName, messageProvider: mp, accountId: a.accountId });
+    if (mp && typeof mp === "string") {
+      setChannelAgent(mp, agentName);
+    }
+  }
+  logger.debug("cohort-sync: gateway start: bridge after seed", { bridge: Object.fromEntries(getChannelAgentBridge()) });
+  state.gatewayPort = event.port;
+  const token = resolveGatewayToken(api);
+  if (token) {
+    state.gatewayToken = token;
+    logger.debug("cohort-sync: gateway client connecting", { port: event.port, hasToken: true });
+    try {
+      const client2 = initGatewayClient(event.port, token, cfg, state.resolveAgentName, logger);
+      state.persistentGwClient = client2;
+      state.gwClientInitialized = true;
+      if (state.commandUnsubscriber) {
+        state.commandUnsubscriber();
+        state.commandUnsubscriber = null;
+      }
+      const unsub = startCommandSubscription(cfg, logger, state.resolveAgentName, state.persistentGwClient);
+      state.commandUnsubscriber = unsub;
+    } catch (err) {
+      logger.debug("cohort-sync: gateway client connect failed", { error: String(err) });
+      logger.error(`cohort-sync: gateway client connect failed: ${String(err)}`);
+    }
+  } else {
+    logger.debug("cohort-sync: no gateway token");
+    logger.warn("cohort-sync: no gateway auth token \u2014 cron operations disabled");
+  }
+  await startNotificationSubscription(
+    event.port,
+    cfg,
+    api.config.hooks?.token,
+    logger,
+    state.persistentGwClient
+  ).catch((err) => {
+    logger.error(`cohort-sync: subscription init failed: ${String(err)}`);
   });
-  const identityNameMap = {};
-  const mainIdentity = parseIdentityFile(process.cwd());
-  if (mainIdentity?.name) {
-    identityNameMap["main"] = mainIdentity.name.toLowerCase();
-  }
-  for (const agent of config?.agents?.list ?? []) {
-    const identity = resolveIdentity(agent.identity, agent.workspace);
-    if (identity?.name) {
-      identityNameMap[agent.id] = identity.name.toLowerCase();
+  const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
+  for (const agentId of allAgentIds) {
+    const agentName = state.resolveAgentName(agentId);
+    try {
+      tracker.setModel(agentName, state.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.debug("cohort-sync: identity name map", { identityNameMap });
-  if (tracker2.getAgentNames().length === 0) {
-    loadSessionsFromDisk(tracker2, logger);
-    const restoredAgents = tracker2.getAgentNames();
-    for (const agentName of restoredAgents) {
-      const sessSnapshot = tracker2.getSessionsSnapshot(agentName);
-      if (sessSnapshot.length > 0) {
-        pushSessions(cfg.apiKey, agentName, sessSnapshot).then(() => {
-          tracker2.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)}`);
+  logger.info(`cohort-sync: seeded telemetry for ${allAgentIds.length} agents`);
+  if (state.keepaliveInterval) clearInterval(state.keepaliveInterval);
+  state.keepaliveInterval = setInterval(async () => {
+    for (const agentId of allAgentIds) {
+      const agentName = state.resolveAgentName(agentId);
+      const snapshot = tracker.getTelemetrySnapshot(agentName);
+      if (snapshot) {
+        await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION }).catch(() => {
         });
       }
     }
-  }
-  function resolveAgentName(agentId) {
-    return (nameMap?.[agentId] ?? identityNameMap[agentId] ?? agentId).toLowerCase();
-  }
-  setToolRuntime({
-    apiKey: cfg.apiKey,
-    apiUrl: cfg.apiUrl,
-    resolveAgentName,
-    logger
-  });
-  function resolveAgentFromContext(ctx) {
+    for (const agentId of allAgentIds) {
+      const agentName = state.resolveAgentName(agentId);
+      tracker.pruneStaleSessions(agentName, 864e5);
+    }
+    saveSessionsToDisk(tracker, state.stateFilePath);
+  }, 15e4);
+  logger.info("cohort-sync: keepalive interval started (150s)");
+}
+function registerHookHandlers(api, logger, getState) {
+  function resolveAgentFromContext(state, ctx) {
     const allCtxKeys = Object.keys(ctx);
-    logger.debug("cohort-sync: resolve agent: start", {
+    state.logger.debug("cohort-sync: resolve agent: start", {
       ctxKeys: allCtxKeys,
       agentId: ctx.agentId,
       sessionKey: ctx.sessionKey,
@@ -13608,230 +13575,96 @@ function registerHooks(api, cfg) {
       workspaceDir: ctx.workspaceDir
     });
     if (ctx.agentId && typeof ctx.agentId === "string") {
-      const resolved2 = resolveAgentName(ctx.agentId);
-      logger.debug("cohort-sync: resolve agent: result", { method: "agentId", raw: ctx.agentId, resolved: resolved2 });
+      const resolved2 = state.resolveAgentName(ctx.agentId);
+      state.logger.debug("cohort-sync: resolve agent: result", { method: "agentId", raw: ctx.agentId, resolved: resolved2 });
       return resolved2;
     }
     const sessionKey = ctx.sessionKey ?? ctx.sessionId;
     if (sessionKey && typeof sessionKey === "string") {
-      const mapped = tracker2.getSessionAgent(sessionKey);
+      const mapped = state.tracker.getSessionAgent(sessionKey);
       if (mapped) {
-        logger.debug("cohort-sync: resolve agent: result", { method: "sessionKey_mapped", sessionKey, mapped });
+        state.logger.debug("cohort-sync: resolve agent: result", { method: "sessionKey_mapped", sessionKey, mapped });
         return mapped;
       }
       const parts = sessionKey.split(":");
       if (parts[0] === "agent" && parts.length >= 2) {
-        const resolved2 = resolveAgentName(parts[1]);
-        logger.debug("cohort-sync: resolve agent: result", { method: "sessionKey_parsed", sessionKey, agentPart: parts[1], resolved: resolved2 });
+        const resolved2 = state.resolveAgentName(parts[1]);
+        state.logger.debug("cohort-sync: resolve agent: 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);
-      logger.debug("cohort-sync: resolve agent: result", { method: "accountId", accountId, resolved: resolved2 });
+      const resolved2 = state.resolveAgentName(accountId);
+      state.logger.debug("cohort-sync: resolve agent: result", { method: "accountId", accountId, resolved: resolved2 });
       return resolved2;
     }
     const channelId = ctx.channelId;
     if (channelId && typeof channelId === "string") {
       const channelAgent = getChannelAgent(channelId);
       if (channelAgent) {
-        logger.debug("cohort-sync: resolve agent: result", { method: "channelId_bridge", channelId, channelAgent, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
+        state.logger.debug("cohort-sync: resolve agent: result", { method: "channelId_bridge", channelId, channelAgent, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
         return channelAgent;
       }
-      logger.debug("cohort-sync: resolve agent: result", { method: "channelId_raw", channelId, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
+      state.logger.debug("cohort-sync: resolve agent: result", { method: "channelId_raw", channelId, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
       return String(channelId);
     }
-    const resolved = resolveAgentName("main");
-    logger.debug("cohort-sync: resolve agent: result", { method: "fallback_main", resolved });
+    const resolved = state.resolveAgentName("main");
+    state.logger.debug("cohort-sync: resolve agent: 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 activityBatch = new MicroBatch({
-    maxSize: 10,
-    maxDelayMs: 1e3,
-    flush: (entries) => pushActivity(cfg.apiKey, entries),
-    onError: (err) => logger.warn(`cohort-sync: activity batch flush failed: ${String(err)}`)
-  });
-  const KEEPALIVE_INTERVAL_MS = 15e4;
-  {
-    if (commandUnsubscriber2) {
-      commandUnsubscriber2();
-      commandUnsubscriber2 = null;
-    }
-    const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
-    commandUnsubscriber2 = unsub;
-  }
-  function resolveModel(agentId) {
-    const agent = config?.agents?.list?.find((a) => a.id === agentId);
-    const m = agent?.model;
-    if (typeof m === "string") return m;
-    if (m && typeof m === "object" && "primary" in m) return String(m.primary);
-    return "unknown";
-  }
-  function getModelContextLimit(model) {
-    const m = model.toLowerCase();
-    if (m.includes("opus") || m.includes("sonnet") || m.includes("haiku")) return 2e5;
-    if (m.includes("gpt-4o")) return 128e3;
-    if (m.includes("gpt-4-turbo") || m.includes("gpt-4-1")) return 128e3;
-    if (m.includes("gpt-4")) return 8192;
-    if (m.includes("o3") || m.includes("o4-mini")) return 2e5;
-    if (m.includes("gemini-2")) return 1e6;
-    if (m.includes("gemini")) return 128e3;
-    if (m.includes("deepseek")) return 128e3;
-    return 2e5;
-  }
-  _gatewayStartHandler = async (event) => {
-    logger.debug("cohort-sync: hook: gateway_start", { port: event.port, eventKeys: Object.keys(event) });
-    try {
-      checkForUpdate(PLUGIN_VERSION, logger).catch(() => {
-      });
-    } catch {
-    }
-    try {
-      const agentList = (config?.agents?.list ?? []).map((a) => ({
-        id: a.id,
-        model: resolveModel(a.id),
-        identity: resolveIdentity(a.identity, a.workspace)
-      }));
-      await fullSync(resolveAgentName("main"), resolveModel("main"), cfg, logger, agentList);
-    } 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;
-      logger.debug("cohort-sync: gateway start: seed bridge", { agentId: a.id, agentName, messageProvider: mp, accountId: a.accountId });
-      if (mp && typeof mp === "string") {
-        setChannelAgent(mp, agentName);
-      }
-    }
-    logger.debug("cohort-sync: gateway start: bridge after seed", { bridge: Object.fromEntries(getChannelAgentBridge()) });
-    gatewayPort = event.port;
-    const token = resolveGatewayToken(api);
-    if (token) {
-      gatewayToken = token;
-      logger.debug("cohort-sync: gateway client connecting", { port: event.port, hasToken: true });
-      try {
-        await initGatewayClient(event.port, token, cfg, resolveAgentName, logger);
-        if (commandUnsubscriber2) {
-          commandUnsubscriber2();
-          commandUnsubscriber2 = null;
-        }
-        const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
-        commandUnsubscriber2 = unsub;
-      } catch (err) {
-        logger.debug("cohort-sync: gateway client connect failed", { error: String(err) });
-        logger.error(`cohort-sync: gateway client connect failed: ${String(err)}`);
-      }
-    } else {
-      logger.debug("cohort-sync: no gateway token");
-      logger.warn("cohort-sync: no gateway auth token \u2014 cron operations disabled");
-    }
-    await startNotificationSubscription(
-      event.port,
-      cfg,
-      api.config.hooks?.token,
-      logger,
-      persistentGwClient
-    ).catch((err) => {
-      logger.error(`cohort-sync: subscription init failed: ${String(err)}`);
-    });
-    const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
-    for (const agentId of allAgentIds) {
-      const agentName = resolveAgentName(agentId);
-      try {
-        tracker2.setModel(agentName, resolveModel(agentId));
-        tracker2.updateStatus(agentName, "idle");
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
-        if (snapshot) {
-          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker2.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`);
-    if (keepaliveInterval) clearInterval(keepaliveInterval);
-    keepaliveInterval = setInterval(async () => {
-      for (const agentId of allAgentIds) {
-        const agentName = resolveAgentName(agentId);
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
-        if (snapshot) {
-          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION }).catch(() => {
-          });
-        }
-      }
-      for (const agentId of allAgentIds) {
-        const agentName = resolveAgentName(agentId);
-        tracker2.pruneStaleSessions(agentName, 864e5);
-      }
-      saveSessionsToDisk(tracker2);
-    }, KEEPALIVE_INTERVAL_MS);
-    logger.info(`cohort-sync: keepalive interval started (${KEEPALIVE_INTERVAL_MS / 1e3}s)`);
-  };
-  api.registerHook("agent_end", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: agent_end", { ctx: dumpCtx(ctx), success: ctx.success, error: ctx.error, durationMs: ctx.durationMs });
+  api.on("agent_end", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    log.debug("cohort-sync: hook: agent_end", { ctx: dumpCtx(ctx), success: event.success, error: event.error, durationMs: event.durationMs });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
-      tracker2.updateStatus(agentName, "idle");
-      await syncAgentStatus(agentName, "idle", resolveModel(agentId), cfg, logger);
-      if (tracker2.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
+      tracker.updateStatus(agentName, "idle");
+      await syncAgentStatus(agentName, "idle", state.resolveModel(agentId), cfg, log);
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker2.markTelemetryPushed(agentName);
+          tracker.markTelemetryPushed(agentName);
         }
       }
       const sessionKey = ctx.sessionKey;
       if (sessionKey && sessionKey.includes(":cron:")) {
         try {
-          const raw = fs2["read"+"FileSync"](cronStorePath, "utf8");
+          const raw = fs2["read"+"FileSync"](state.cronStorePath, "utf8");
           const store = JSON.parse(raw);
           const jobs = store.jobs ?? [];
-          const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
+          const mapped = jobs.map((j) => mapCronJob(j, state.resolveAgentName));
           await pushCronSnapshot(cfg.apiKey, mapped);
-          logger.debug("cohort-sync: cron agent end push", { count: mapped.length, sessionKey });
+          log.debug("cohort-sync: cron agent end push", { count: mapped.length, sessionKey });
         } catch (err) {
-          logger.debug("cohort-sync: cron agent end push failed", { error: String(err) });
+          log.debug("cohort-sync: cron agent end push failed", { error: String(err) });
         }
       }
-      if (ctx.success === false) {
+      if (event.success === false) {
         const entry = buildActivityEntry(agentName, "agent_end", {
           success: false,
-          error: ctx.error,
-          durationMs: ctx.durationMs,
+          error: event.error,
+          durationMs: event.durationMs,
           sessionKey: ctx.sessionKey
         });
-        if (entry) activityBatch.add(entry);
+        if (entry) state.activityBatch.add(entry);
       }
     } catch (err) {
-      logger.warn(`cohort-sync: agent_end sync failed: ${String(err)}`);
+      log.warn(`cohort-sync: agent_end sync failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.agent_end", description: "Mark idle, push telemetry, emit activity on failure" });
-  api.registerHook("llm_output", async (event) => {
-    const ctx = event.context ?? {};
-    const usage = ctx.usage ?? {};
+  });
+  api.on("llm_output", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    const usage = event.usage ?? {};
     const contextTokens = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-    const model = ctx.model ?? resolveModel(ctx.agentId ?? "main");
-    const contextLimit = getModelContextLimit(model);
-    logger.debug("cohort-sync: hook: llm_output", {
+    const model = event.model ?? state.resolveModel(ctx.agentId ?? "main");
+    const contextLimit = state.getModelContextLimit(model);
+    log.debug("cohort-sync: hook: llm_output", {
       ctx: dumpCtx(ctx),
       model,
       tokensIn: usage.input,
@@ -13842,106 +13675,112 @@ function registerHooks(api, cfg) {
       contextLimit
     });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
       const sessionKey = ctx.sessionKey;
-      tracker2.updateFromLlmOutput(agentName, sessionKey, {
+      tracker.updateFromLlmOutput(agentName, sessionKey, {
         model,
         tokensIn: usage.input ?? 0,
         tokensOut: usage.output ?? 0,
         contextTokens,
         contextLimit
       });
-      if (sessionKey && !tracker2.hasSession(agentName, sessionKey)) {
-        tracker2.addSession(agentName, sessionKey);
-        logger.info(`cohort-sync: inferred session for ${agentName} from llm_output (${sessionKey})`);
+      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
+        tracker.addSession(agentName, sessionKey);
+        log.info(`cohort-sync: inferred session for ${agentName} from llm_output (${sessionKey})`);
       }
       if (sessionKey) {
-        tracker2.setSessionAgent(sessionKey, agentName);
+        tracker.setSessionAgent(sessionKey, agentName);
       }
-      if (tracker2.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker2.markTelemetryPushed(agentName);
+          tracker.markTelemetryPushed(agentName);
         }
       }
-      if (tracker2.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
+      if (tracker.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker2.markSessionsPushed(agentName);
+        tracker.markSessionsPushed(agentName);
       }
     } catch (err) {
-      logger.warn(`cohort-sync: llm_output telemetry failed: ${String(err)}`);
+      log.warn(`cohort-sync: llm_output telemetry failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.llm_output", description: "Accumulate token usage, push telemetry and sessions" });
-  api.registerHook("after_compaction", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: after_compaction", { ctx: dumpCtx(ctx), messageCount: ctx.messageCount, tokenCount: ctx.tokenCount });
+  });
+  api.on("after_compaction", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    log.debug("cohort-sync: hook: after_compaction", { ctx: dumpCtx(ctx), messageCount: event.messageCount, tokenCount: event.tokenCount });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
-      tracker2.updateFromCompaction(agentName, {
-        contextTokens: ctx.tokenCount ?? 0,
-        contextLimit: getModelContextLimit(resolveModel(agentId))
+      tracker.updateFromCompaction(agentName, {
+        contextTokens: event.tokenCount ?? 0,
+        contextLimit: state.getModelContextLimit(state.resolveModel(agentId))
       });
-      if (tracker2.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker2.markTelemetryPushed(agentName);
+          tracker.markTelemetryPushed(agentName);
         }
       }
       const entry = buildActivityEntry(agentName, "after_compaction", {
-        messageCount: ctx.messageCount,
-        compactedCount: ctx.compactedCount,
+        messageCount: event.messageCount,
+        compactedCount: event.compactedCount,
         sessionKey: ctx.sessionKey
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: after_compaction telemetry failed: ${String(err)}`);
+      log.warn(`cohort-sync: after_compaction telemetry failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.after_compaction", description: "Increment compaction count, push telemetry" });
-  api.registerHook("before_agent_start", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: before_agent_start", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
+  });
+  api.on("before_agent_start", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    log.debug("cohort-sync: hook: before_agent_start", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
-    logger.debug("cohort-sync: hook: before_agent_start resolved", { agentId, agentName, ctxChannelId: ctx.channelId, ctxMessageProvider: ctx.messageProvider, ctxSessionKey: ctx.sessionKey, ctxAccountId: ctx.accountId });
+    const agentName = state.resolveAgentName(agentId);
+    log.debug("cohort-sync: hook: before_agent_start resolved", { agentId, agentName, ctxChannelId: ctx.channelId, ctxMessageProvider: ctx.messageProvider, ctxSessionKey: ctx.sessionKey, ctxAccountId: ctx.accountId });
     try {
-      if (!gwClientInitialized && gatewayPort && gatewayToken) {
+      if (!state.gwClientInitialized && state.gatewayPort && state.gatewayToken) {
         try {
-          await initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, logger);
-          if (commandUnsubscriber2) {
-            commandUnsubscriber2();
-            commandUnsubscriber2 = null;
+          const client2 = initGatewayClient(state.gatewayPort, state.gatewayToken, cfg, state.resolveAgentName, log);
+          state.persistentGwClient = client2;
+          state.gwClientInitialized = true;
+          if (state.commandUnsubscriber) {
+            state.commandUnsubscriber();
+            state.commandUnsubscriber = null;
           }
-          const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
-          commandUnsubscriber2 = unsub;
+          const unsub = startCommandSubscription(cfg, log, state.resolveAgentName, state.persistentGwClient);
+          state.commandUnsubscriber = unsub;
         } catch (err) {
-          logger.debug("cohort-sync: gateway client lazy init failed", { error: String(err) });
+          log.debug("cohort-sync: gateway client lazy init failed", { error: String(err) });
         }
       }
-      tracker2.updateStatus(agentName, "working");
-      if (tracker2.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
+      tracker.updateStatus(agentName, "working");
+      if (tracker.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker2.markTelemetryPushed(agentName);
+          tracker.markTelemetryPushed(agentName);
         }
       }
       const sessionKey = ctx.sessionKey;
-      if (sessionKey && !tracker2.hasSession(agentName, sessionKey)) {
-        tracker2.addSession(agentName, sessionKey);
-        tracker2.setSessionAgent(sessionKey, agentName);
-        logger.info(`cohort-sync: inferred session for ${agentName} (${sessionKey})`);
-        if (tracker2.shouldPushSessions(agentName)) {
-          const sessSnapshot = tracker2.getSessionsSnapshot(agentName);
+      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
+        tracker.addSession(agentName, sessionKey);
+        tracker.setSessionAgent(sessionKey, agentName);
+        log.info(`cohort-sync: inferred session for ${agentName} (${sessionKey})`);
+        if (tracker.shouldPushSessions(agentName)) {
+          const sessSnapshot = tracker.getSessionsSnapshot(agentName);
           await pushSessions(cfg.apiKey, agentName, sessSnapshot);
-          tracker2.markSessionsPushed(agentName);
+          tracker.markSessionsPushed(agentName);
         }
       } else if (sessionKey) {
-        tracker2.setSessionAgent(sessionKey, agentName);
+        tracker.setSessionAgent(sessionKey, agentName);
       }
       const ctxChannelId = ctx.channelId;
       if (ctxChannelId) {
@@ -13952,193 +13791,362 @@ function registerHooks(api, cfg) {
         setChannelAgent(mp, agentName);
       }
     } catch (err) {
-      logger.warn(`cohort-sync: before_agent_start telemetry failed: ${String(err)}`);
+      log.warn(`cohort-sync: before_agent_start telemetry failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.before_agent_start", description: "Mark working, infer sessions, populate channel bridge" });
-  api.registerHook("session_start", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: session_start", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
+  });
+  api.on("session_start", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    log.debug("cohort-sync: hook: session_start", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
-      const sessionKey = ctx.sessionId ?? String(Date.now());
-      tracker2.addSession(agentName, sessionKey);
-      if (tracker2.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
+      const sessionKey = event.sessionId ?? ctx.sessionId ?? String(Date.now());
+      tracker.addSession(agentName, sessionKey);
+      if (tracker.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker2.markSessionsPushed(agentName);
+        tracker.markSessionsPushed(agentName);
       }
       const parsed = parseSessionKey(sessionKey);
       const entry = buildActivityEntry(agentName, "session_start", {
         channel: parsed.channel,
         sessionKey,
-        resumedFrom: ctx.resumedFrom
+        resumedFrom: event.resumedFrom
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: session_start tracking failed: ${String(err)}`);
+      log.warn(`cohort-sync: session_start tracking failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.session_start", description: "Track session start, push sessions" });
-  api.registerHook("session_end", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: session_end", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
+  });
+  api.on("session_end", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log } = state;
+    log.debug("cohort-sync: hook: session_end", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
-      const sessionKey = ctx.sessionId ?? "";
-      tracker2.removeSession(agentName, sessionKey);
-      if (tracker2.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
+      const sessionKey = event.sessionId ?? ctx.sessionId ?? "";
+      tracker.removeSession(agentName, sessionKey);
+      if (tracker.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker2.markSessionsPushed(agentName);
+        tracker.markSessionsPushed(agentName);
       }
       const entry = buildActivityEntry(agentName, "session_end", {
         sessionKey,
-        messageCount: ctx.messageCount,
-        durationMs: ctx.durationMs
+        messageCount: event.messageCount,
+        durationMs: event.durationMs
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: session_end tracking failed: ${String(err)}`);
+      log.warn(`cohort-sync: session_end tracking failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.session_end", description: "Remove session, push sessions" });
-  api.registerHook("after_tool_call", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: after_tool_call", { ctx: dumpCtx(ctx), toolName: ctx.toolName, error: ctx.error });
-    const agentName = resolveAgentFromContext(ctx);
+  });
+  api.on("after_tool_call", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    state.logger.debug("cohort-sync: hook: after_tool_call", { ctx: dumpCtx(ctx), toolName: event.toolName, error: event.error });
+    const agentName = resolveAgentFromContext(state, ctx);
     try {
       const entry = buildActivityEntry(agentName, "after_tool_call", {
-        toolName: ctx.toolName,
-        params: ctx.params,
-        error: ctx.error,
-        durationMs: ctx.durationMs,
+        toolName: event.toolName,
+        params: event.params,
+        error: event.error,
+        durationMs: event.durationMs,
         sessionKey: ctx.sessionKey,
-        model: resolveModel(ctx.agentId ?? "main")
+        model: state.resolveModel(ctx.agentId ?? "main")
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: after_tool_call activity failed: ${String(err)}`);
+      state.logger.warn(`cohort-sync: after_tool_call activity failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.after_tool_call", description: "Emit activity entry for tool calls" });
-  api.registerHook("message_received", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: message_received raw", {
+  });
+  api.on("message_received", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    state.logger.debug("cohort-sync: hook: message_received raw", {
       ctx: dumpCtx(ctx),
       event: dumpEvent(event),
       bridgeStateBefore: Object.fromEntries(getChannelAgentBridge())
     });
-    const agentName = resolveAgentFromContext(ctx);
+    const agentName = resolveAgentFromContext(state, ctx);
     const channel = ctx.channelId;
-    logger.debug("cohort-sync: hook: message_received resolved", {
+    state.logger.debug("cohort-sync: hook: message_received resolved", {
       agentName,
       channel,
       accountId: ctx.accountId,
       conversationId: ctx.conversationId,
-      from: ctx.from
+      from: event.from
     });
     try {
       const entry = buildActivityEntry(agentName, "message_received", {
         channel: channel ?? "unknown"
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
+      state.logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.message_received", description: "Emit activity entry for received messages" });
-  api.registerHook("message_sent", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: message_sent raw", {
+  });
+  api.on("message_sent", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    state.logger.debug("cohort-sync: hook: message_sent raw", {
       ctx: dumpCtx(ctx),
       event: dumpEvent(event),
       bridgeStateBefore: Object.fromEntries(getChannelAgentBridge())
     });
-    const agentName = resolveAgentFromContext(ctx);
+    const agentName = resolveAgentFromContext(state, ctx);
     const channel = ctx.channelId;
-    logger.debug("cohort-sync: hook: message_sent resolved", {
+    state.logger.debug("cohort-sync: hook: message_sent resolved", {
       agentName,
       channel,
       accountId: ctx.accountId,
       conversationId: ctx.conversationId,
-      to: ctx.to,
-      success: ctx.success,
-      error: ctx.error
+      to: event.to,
+      success: event.success,
+      error: event.error
     });
     try {
       const entry = buildActivityEntry(agentName, "message_sent", {
         channel: channel ?? "unknown",
-        success: ctx.success,
-        error: ctx.error
+        success: event.success,
+        error: event.error
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
+      state.logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.message_sent", description: "Emit activity entry for sent messages" });
-  api.registerHook("before_compaction", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: before_compaction", { ctx: dumpCtx(ctx) });
+  });
+  api.on("before_compaction", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    state.logger.debug("cohort-sync: hook: before_compaction", { ctx: dumpCtx(ctx) });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
       const entry = buildActivityEntry(agentName, "before_compaction", {
         sessionKey: ctx.sessionKey
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: before_compaction activity failed: ${String(err)}`);
+      state.logger.warn(`cohort-sync: before_compaction activity failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.before_compaction", description: "Emit activity entry before compaction" });
-  api.registerHook("before_reset", async (event) => {
-    const ctx = event.context ?? {};
-    logger.debug("cohort-sync: hook: before_reset", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
+  });
+  api.on("before_reset", async (event, ctx) => {
+    const state = getState();
+    if (!state) return;
+    state.logger.debug("cohort-sync: hook: before_reset", { ctx: dumpCtx(ctx), event: dumpEvent(event) });
     const agentId = ctx.agentId ?? "main";
-    const agentName = resolveAgentName(agentId);
+    const agentName = state.resolveAgentName(agentId);
     try {
       const entry = buildActivityEntry(agentName, "before_reset", {
-        reason: ctx.reason,
+        reason: event.reason,
         sessionKey: ctx.sessionKey
       });
-      if (entry) activityBatch.add(entry);
+      if (entry) state.activityBatch.add(entry);
     } catch (err) {
-      logger.warn(`cohort-sync: before_reset activity failed: ${String(err)}`);
+      state.logger.warn(`cohort-sync: before_reset activity failed: ${String(err)}`);
     }
-  }, { name: "cohort-sync.before_reset", description: "Emit activity entry before reset" });
-  api.registerHook("gateway_stop", async () => {
-    logger.debug("cohort-sync: hook: gateway_stop", { bridgeState: Object.fromEntries(getChannelAgentBridge()) });
-    if (keepaliveInterval) {
-      clearInterval(keepaliveInterval);
-      keepaliveInterval = null;
-    }
-    activityBatch.drain();
+  });
+  api.on("gateway_stop", async (_event, _ctx) => {
+    const state = getState();
+    if (!state) return;
+    const { cfg, tracker, logger: log, config } = state;
+    log.debug("cohort-sync: hook: gateway_stop", { bridgeState: Object.fromEntries(getChannelAgentBridge()) });
+    if (state.keepaliveInterval) {
+      clearInterval(state.keepaliveInterval);
+      state.keepaliveInterval = null;
+    }
+    state.activityBatch.drain();
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
     for (const agentId of allAgentIds) {
-      const agentName = resolveAgentName(agentId);
+      const agentName = state.resolveAgentName(agentId);
       try {
-        tracker2.updateStatus(agentName, "unreachable");
-        const snapshot = tracker2.getTelemetrySnapshot(agentName);
+        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)}`);
+        log.warn(`cohort-sync: final unreachable push failed for ${agentName}: ${String(err)}`);
       }
     }
-    saveSessionsToDisk(tracker2);
-    if (persistentGwClient) {
-      persistentGwClient.close();
-      persistentGwClient = null;
-      gwClientInitialized = false;
+    saveSessionsToDisk(tracker, state.stateFilePath);
+    if (state.persistentGwClient) {
+      state.persistentGwClient.close();
+      state.persistentGwClient = null;
+      state.gwClientInitialized = false;
     }
     try {
-      await markAllUnreachable(cfg, logger);
+      await markAllUnreachable(cfg, log);
     } catch (err) {
-      logger.warn(`cohort-sync: markAllUnreachable failed: ${String(err)}`);
+      log.warn(`cohort-sync: markAllUnreachable failed: ${String(err)}`);
     }
-    tracker2.clear();
+    tracker.clear();
     closeBridge();
-    logger.info("cohort-sync: gateway stopped, all resources cleaned up");
-  }, { name: "cohort-sync.gateway_stop", description: "Cleanup, final telemetry, mark unreachable" });
+    log.info("cohort-sync: gateway stopped, all resources cleaned up");
+  });
 }
+function initializeHookState(api, cfg) {
+  const { logger, config } = api;
+  const stateFilePath = path2.join(cfg.stateDir, "session-state.json");
+  const nameMap = cfg.agentNameMap;
+  const tracker = new AgentStateTracker();
+  const convexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
+  createClient(convexUrl);
+  setLogger(logger);
+  const identityNameMap = {};
+  const mainIdentity = parseIdentityFile(process.cwd());
+  if (mainIdentity?.name) {
+    identityNameMap["main"] = mainIdentity.name.toLowerCase();
+  }
+  for (const agent of config?.agents?.list ?? []) {
+    const identity = resolveIdentity(agent.identity, agent.workspace);
+    if (identity?.name) {
+      identityNameMap[agent.id] = identity.name.toLowerCase();
+    }
+  }
+  logger.debug("cohort-sync: identity name map", { identityNameMap });
+  function resolveAgentName(agentId) {
+    return (nameMap?.[agentId] ?? identityNameMap[agentId] ?? agentId).toLowerCase();
+  }
+  function resolveModel(agentId) {
+    const agent = config?.agents?.list?.find((a) => a.id === agentId);
+    const m = agent?.model;
+    if (typeof m === "string") return m;
+    if (m && typeof m === "object" && "primary" in m) return String(m.primary);
+    return "unknown";
+  }
+  function getModelContextLimit(model) {
+    const m = model.toLowerCase();
+    if (m.includes("opus") || m.includes("sonnet") || m.includes("haiku")) return 2e5;
+    if (m.includes("gpt-4o")) return 128e3;
+    if (m.includes("gpt-4-turbo") || m.includes("gpt-4-1")) return 128e3;
+    if (m.includes("gpt-4")) return 8192;
+    if (m.includes("o3") || m.includes("o4-mini")) return 2e5;
+    if (m.includes("gemini-2")) return 1e6;
+    if (m.includes("gemini")) return 128e3;
+    if (m.includes("deepseek")) return 128e3;
+    return 2e5;
+  }
+  const cronStorePath = api.config?.cron?.store ?? path2.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
+  const activityBatch = new MicroBatch({
+    maxSize: 10,
+    maxDelayMs: 1e3,
+    flush: (entries) => pushActivity(cfg.apiKey, entries),
+    onError: (err) => logger.warn(`cohort-sync: activity batch flush failed: ${String(err)}`)
+  });
+  const gatewayPort = api.config?.gateway?.port ?? null;
+  const gatewayToken = resolveGatewayToken(api);
+  let persistentGwClient = null;
+  let gwClientInitialized = false;
+  if (gatewayPort && gatewayToken) {
+    const client2 = initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, logger);
+    persistentGwClient = client2;
+    gwClientInitialized = true;
+  }
+  const commandUnsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
+  setToolRuntime({
+    apiKey: cfg.apiKey,
+    apiUrl: cfg.apiUrl,
+    resolveAgentName,
+    logger
+  });
+  if (tracker.getAgentNames().length === 0) {
+    loadSessionsFromDisk(tracker, stateFilePath, 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)}`);
+        });
+      }
+    }
+  }
+  logger.info(`cohort-sync: initializeHookState v${PLUGIN_VERSION}`);
+  logger.info("cohort-sync: state initialized", {
+    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 }))
+  });
+  return {
+    cfg,
+    tracker,
+    logger,
+    config,
+    resolveAgentName,
+    resolveModel,
+    getModelContextLimit,
+    activityBatch,
+    cronStorePath,
+    stateFilePath,
+    gatewayPort,
+    gatewayToken,
+    persistentGwClient,
+    gwClientInitialized,
+    keepaliveInterval: null,
+    commandUnsubscriber: commandUnsub,
+    api
+  };
+}
+
+// src/pocket-guide.ts
+var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
+
+> These are the essential rules. For the full guide, see https://docs.cohort.bot/integration/guide
+
+## Getting Started
+- Call the cohort_context tool at the start of every work session for your personalized briefing.
+- If cohort_context is unavailable, call GET /api/v1/context directly.
+- Do not skip the context call \u2014 it contains workspace-specific overrides that supersede these rules.
+
+## Task Lifecycle
+- Create tasks for trackable work items. Always set priority (default p2) and effort when estimable.
+- Use POST /tasks/:id/transition for status changes. Never PATCH status directly \u2014 the server rejects it.
+- If a transition is rejected, read the error response for valid transitions from the current status.
+- You cannot transition tasks to "done" unless your workspace admin has enabled it. Only humans close tasks by default.
+- When moving to "in_progress", you are claiming ownership \u2014 only claim tasks you can actively work on.
+- When moving to "waiting", comment what you are blocked on and who/what can unblock you.
+- When work is complete, comment with evidence: PR link, test output, or summary of changes.
+
+## Comments
+- Comment before every status transition explaining what happened.
+- Post progress updates every 15-30 minutes on long-running work.
+- Keep comments factual \u2014 what you did, what you found, what is next.
+- No conversational filler. Every comment must contain information.
+- Reference specific files, line numbers, error messages, or URLs when relevant.
+
+## Projects & Initiatives
+- Don't create projects or initiatives without explicit instruction.
+- Assign tasks to existing projects when one fits. Don't create a project for a single task.
+- If no project fits, leave the task unassigned to a project.
+
+## Error Recovery
+- If auth fails (401), stop immediately. Do not retry. Report the failure.
+- If rate limited (429), wait per Retry-After header.
+- If 404, verify you are using the correct task number or ID (both accepted).
+- If 500, retry once after a brief pause. If it fails again, stop and report.
+
+## What Not To Do
+- Don't poll /tasks in a loop \u2014 check assignments, then do your work.
+- Don't create duplicate tasks \u2014 search first.
+- Don't delete tasks unless explicitly told to.
+- Don't bulk-create tasks speculatively \u2014 create them as work becomes concrete.
+- Don't modify tasks assigned to other agents unless coordinating through comments.
+- Don't set "done" on tasks you didn't work on.
+- Don't ignore workspace-specific overrides from your context response.
+`;
 
 // index.ts
 function textResult(text, details) {
@@ -14166,14 +14174,21 @@ var plugin = {
       );
       return;
     }
-    const gatewayPort2 = api.config?.gateway?.port ?? 18789;
+    let hookState = null;
+    registerHookHandlers(api, api.logger, () => hookState);
+    const gatewayPort = api.config?.gateway?.port ?? 18789;
     api.registerHook(
       "gateway:startup",
       async (...args) => {
         const event = args[0] ?? {};
-        const port = event?.port ?? gatewayPort2;
-        api.logger.info(`cohort-sync: gateway:startup hook fired (port=${port})`);
-        await handleGatewayStart({ ...event, port });
+        const port = event?.port ?? gatewayPort;
+        api.logger.info(`cohort-sync: gateway:startup hook fired (port=${port}, hookState=${hookState ? "SET" : "NULL"})`);
+        try {
+          await handleGatewayStart({ ...event, port }, hookState);
+          api.logger.info("cohort-sync: handleGatewayStart completed");
+        } catch (err) {
+          api.logger.error(`cohort-sync: handleGatewayStart THREW: ${err instanceof Error ? err.stack : String(err)}`);
+        }
       },
       {
         name: "cohort-sync.gateway-startup",
@@ -14420,7 +14435,7 @@ Do not attempt more comments until tomorrow.`);
           return;
         }
         api.logger.info(`cohort-sync: activated (api: ${apiUrl2})`);
-        registerHooks(api, {
+        hookState = initializeHookState(api, {
           apiUrl: apiUrl2,
           apiKey: apiKey2,
           stateDir: svcCtx.stateDir,
@@ -14428,6 +14443,7 @@ Do not attempt more comments until tomorrow.`);
         });
       },
       async stop() {
+        hookState = null;
         closeBridge();
         api.logger.info("cohort-sync: service stopped");
       }

package/dist/openclaw.plugin.json

@@ -55,5 +55,5 @@
       }
     }
   },
-  "version": "0.10.3"
+  "version": "0.11.1"
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "description": "OpenClaw plugin — syncs agent telemetry, sessions, and activity to the Cohort dashboard",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "description": "OpenClaw plugin — syncs agent telemetry, sessions, and activity to the Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",