@cfio/cohort-sync 0.6.0 → 0.8.0

package/dist/index.js

@@ -16,6 +16,14 @@ __export(keychain_exports, {
   setCredential: () => setCredential
 });
 import { execFile } from "node:child_process";
+import os3 from "node:os";
+function assertMacOS(operation) {
+  if (os3.platform() !== "darwin") {
+    throw new Error(
+      `cohort-sync: ${operation} requires macOS Keychain. On Linux/Windows, set your API key in OpenClaw config: plugins.entries.cohort-sync.config.apiKey`
+    );
+  }
+}
 function securityCmd(args) {
   return new Promise((resolve, reject) => {
     execFile("security", args, { timeout: 5e3 }, (err, stdout, stderr) => {
@@ -37,6 +45,7 @@ function isNotFoundError(err) {
   return false;
 }
 async function setCredential(apiUrl, apiKey) {
+  assertMacOS("storing credentials");
   await securityCmd([
     "add-generic-password",
     "-s",
@@ -49,6 +58,7 @@ async function setCredential(apiUrl, apiKey) {
   ]);
 }
 async function getCredential(apiUrl) {
+  assertMacOS("reading credentials");
   try {
     const { stdout } = await securityCmd([
       "find-generic-password",
@@ -65,6 +75,7 @@ async function getCredential(apiUrl) {
   }
 }
 async function deleteCredential(apiUrl) {
+  assertMacOS("deleting credentials");
   try {
     await securityCmd([
       "delete-generic-password",
@@ -2699,6 +2710,225 @@ var Type = type_exports2;
 
 // src/sync.ts
 import { execSync } from "node:child_process";
+function extractJson(raw) {
+  const jsonStart = raw.search(/[\[{]/);
+  const jsonEndBracket = raw.lastIndexOf("]");
+  const jsonEndBrace = raw.lastIndexOf("}");
+  const jsonEnd = Math.max(jsonEndBracket, jsonEndBrace);
+  if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart) {
+    throw new Error("No JSON found in output");
+  }
+  return raw.slice(jsonStart, jsonEnd + 1);
+}
+function fetchSkills(logger) {
+  try {
+    const raw = execSync("openclaw skills list --json", {
+      encoding: "utf8",
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, NO_COLOR: "1" }
+    });
+    const parsed = JSON.parse(extractJson(raw));
+    const list = Array.isArray(parsed) ? parsed : parsed?.skills ?? [];
+    return list.map((s) => ({
+      name: String(s.name ?? s.id ?? "unknown"),
+      description: String(s.description ?? ""),
+      source: String(s.source ?? s.origin ?? "unknown"),
+      ...s.emoji ? { emoji: String(s.emoji) } : {}
+    }));
+  } catch (err) {
+    logger.warn(`cohort-sync: failed to fetch skills: ${String(err)}`);
+    return [];
+  }
+}
+var VALID_STATUSES = /* @__PURE__ */ new Set(["idle", "working", "waiting"]);
+function normalizeStatus(status) {
+  return VALID_STATUSES.has(status) ? status : "idle";
+}
+async function v1Get(apiUrl, apiKey, path4) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`GET ${path4} \u2192 ${res.status}`);
+  return res.json();
+}
+async function v1Patch(apiUrl, apiKey, path4, body) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
+    method: "PATCH",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`PATCH ${path4} \u2192 ${res.status}`);
+}
+async function v1Post(apiUrl, apiKey, path4, body) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`POST ${path4} \u2192 ${res.status}`);
+}
+async function checkForUpdate(currentVersion, logger) {
+  try {
+    const res = await fetch("https://registry.npmjs.org/@cfio/cohort-sync/latest", {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return;
+    const data = await res.json();
+    const latest = data.version;
+    if (latest && latest !== currentVersion) {
+      logger.warn(
+        `cohort-sync: update available (${currentVersion} \u2192 ${latest}) \u2014 run "npm install -g @cfio/cohort-sync" to update`
+      );
+    }
+  } catch {
+  }
+}
+async function syncAgentStatus(agentName, status, model, cfg, logger) {
+  try {
+    const data = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
+    const agents = data?.data ?? [];
+    const agent = agents.find(
+      (a) => a.name.toLowerCase() === agentName.toLowerCase()
+    );
+    if (!agent) {
+      const available = agents.map((a) => a.name).join(", ") || "(none)";
+      logger.warn(
+        `cohort-sync: agent "${agentName}" not found in workspace \u2014 skipping status sync. Available agents: [${available}]. Configure agentNameMap in your plugin config to map OpenClaw agent IDs to Cohort names.`
+      );
+      return;
+    }
+    await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${agent.id}`, {
+      status: normalizeStatus(status),
+      model
+    });
+    logger.info(`cohort-sync: agent "${agentName}" \u2192 ${normalizeStatus(status)}`);
+  } catch (err) {
+    logger.warn(`cohort-sync: syncAgentStatus failed: ${String(err)}`);
+  }
+}
+async function syncSkillsToV1(skills, cfg, logger) {
+  for (const skill of skills) {
+    try {
+      await v1Post(cfg.apiUrl, cfg.apiKey, "/api/v1/skills", {
+        name: skill.name,
+        description: skill.description
+      });
+    } catch (err) {
+      logger.warn(`cohort-sync: failed to sync skill "${skill.name}": ${String(err)}`);
+    }
+  }
+}
+var lastKnownRoster = [];
+function getLastKnownRoster() {
+  return lastKnownRoster;
+}
+async function reconcileRoster(openClawAgents, cfg, logger) {
+  const data = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
+  const cohortAgents = data?.data ?? [];
+  const cohortByName = new Map(cohortAgents.map((a) => [a.name.toLowerCase(), a]));
+  const openClawNames = new Set(
+    openClawAgents.map((a) => {
+      const nameMap = cfg.agentNameMap;
+      return (nameMap?.[a.id] ?? a.identity?.name ?? a.id).toLowerCase();
+    })
+  );
+  for (const oc of openClawAgents) {
+    const agentName = (cfg.agentNameMap?.[oc.id] ?? oc.identity?.name ?? oc.id).toLowerCase();
+    const existing = cohortByName.get(agentName);
+    if (!existing) {
+      try {
+        await v1Post(cfg.apiUrl, cfg.apiKey, "/api/v1/agents", {
+          name: agentName,
+          displayName: oc.identity?.name ?? agentName,
+          emoji: oc.identity?.emoji ?? "\u{1F916}",
+          model: oc.model,
+          status: "idle"
+        });
+        logger.info(`cohort-sync: provisioned new agent "${agentName}"`);
+      } catch (err) {
+        logger.warn(`cohort-sync: failed to provision agent "${agentName}": ${String(err)}`);
+      }
+    } else {
+      const updates = {
+        model: oc.model,
+        status: "idle"
+      };
+      if (oc.identity?.name) {
+        updates.displayName = oc.identity.name;
+      }
+      if (oc.identity?.emoji) {
+        updates.emoji = oc.identity.emoji;
+      }
+      try {
+        await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${existing.id}`, updates);
+      } catch (err) {
+        logger.warn(`cohort-sync: failed to update agent "${agentName}": ${String(err)}`);
+      }
+    }
+  }
+  for (const cohort of cohortAgents) {
+    if (!openClawNames.has(cohort.name.toLowerCase())) {
+      if (cohort.status === "archived" || cohort.status === "deleted" || cohort.status === "unreachable") {
+        continue;
+      }
+      try {
+        await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${cohort.id}`, {
+          status: "unreachable"
+        });
+        logger.info(`cohort-sync: marked agent "${cohort.name}" as unreachable`);
+      } catch (err) {
+        logger.warn(
+          `cohort-sync: failed to mark agent "${cohort.name}" as unreachable: ${String(err)}`
+        );
+      }
+    }
+  }
+  const updatedData = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
+  const finalRoster = updatedData?.data ?? cohortAgents;
+  lastKnownRoster = finalRoster;
+  return finalRoster;
+}
+async function markAllUnreachable(cfg, logger) {
+  const roster = getLastKnownRoster();
+  if (roster.length === 0) {
+    logger.warn("cohort-sync: no cached roster \u2014 skipping markAllUnreachable");
+    return;
+  }
+  for (const agent of roster) {
+    if (agent.status === "unreachable" || agent.status === "archived" || agent.status === "deleted") {
+      continue;
+    }
+    try {
+      await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${agent.id}`, {
+        status: "unreachable"
+      });
+    } catch (err) {
+      logger.warn(`cohort-sync: failed to mark "${agent.name}" as unreachable: ${String(err)}`);
+    }
+  }
+  logger.info("cohort-sync: all agents marked unreachable");
+}
+async function fullSync(agentName, model, cfg, logger, openClawAgents) {
+  logger.info("cohort-sync: full sync starting");
+  if (openClawAgents && openClawAgents.length > 0) {
+    try {
+      await reconcileRoster(openClawAgents, cfg, logger);
+    } catch (err) {
+      logger.warn(`cohort-sync: roster reconciliation failed: ${String(err)}`);
+    }
+  } else {
+    await syncAgentStatus(agentName, "working", model, cfg, logger);
+  }
+  const skills = fetchSkills(logger);
+  if (skills.length > 0) {
+    await syncSkillsToV1(skills, cfg, logger);
+  }
+  logger.info("cohort-sync: full sync complete");
+}
 
 // ../../node_modules/.pnpm/convex@1.33.0_patch_hash=l43bztwr6e2lbmpd6ao6hmcg24_react@19.2.1/node_modules/convex/dist/esm/index.js
 var version = "1.33.0";
@@ -7630,14 +7860,14 @@ var require_node_gyp_build = __commonJS({
   "../common/temp/node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
     var fs4 = __require("fs");
     var path4 = __require("path");
-    var os3 = __require("os");
+    var os4 = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
     var abi = process.versions.modules;
     var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-    var arch = process.env.npm_config_arch || os3.arch();
-    var platform = process.env.npm_config_platform || os3.platform();
+    var arch = process.env.npm_config_arch || os4.arch();
+    var platform = process.env.npm_config_platform || os4.platform();
     var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
     var uv = (process.versions.uv || "").split(".")[0];
@@ -11542,127 +11772,125 @@ function reverseResolveAgentName(cohortName, forwardMap) {
   return cohortName;
 }
 
-// src/subscription.ts
-function deriveConvexUrl(apiUrl) {
-  return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
-}
-var DEFAULT_BEHAVIORAL_PROMPT = `BEFORE RESPONDING:
-- Does your planned response address the task's stated scope? If not, do not comment.
-- Do not post acknowledgment-only responses ("got it", "sounds good", "confirmed"). If you have no new information to add, do not comment.
-- If the work is complete, transition the task to "waiting" and set noReply=true on your final comment, then stop working on this task.`;
-function buildNotificationMessage(n) {
-  let header;
-  let cta;
-  switch (n.type) {
-    case "comment":
-      if (n.isMentioned) {
-        header = `You were @mentioned on task #${n.taskNumber} "${n.taskTitle}"
-By: ${n.actorName}`;
-        cta = "You were directly mentioned. Read the comment and respond using the cohort_comment tool.";
-      } else {
-        header = `New comment on task #${n.taskNumber} "${n.taskTitle}"
-From: ${n.actorName}`;
-        cta = "Read the comment thread and respond using the cohort_comment tool if appropriate.";
-      }
-      break;
-    case "assignment":
-      header = `You were assigned to task #${n.taskNumber} "${n.taskTitle}"
-By: ${n.actorName}`;
-      cta = "Review the task description and begin working on it.";
-      break;
-    case "status_change":
-      header = `Status changed on task #${n.taskNumber} "${n.taskTitle}"
-By: ${n.actorName}`;
-      cta = "Review the status change and take any follow-up action needed.";
-      break;
-    default:
-      header = `Notification on task #${n.taskNumber} "${n.taskTitle}"
-From: ${n.actorName}`;
-      cta = "Check the task and respond if needed.";
-  }
-  const body = n.preview ? `
-Comment: "${n.preview}"` : "";
-  let scope = "";
-  if (n.taskDescription && n.type === "comment") {
-    const truncated = n.taskDescription.length > 500 ? n.taskDescription.slice(0, 500) + "..." : n.taskDescription;
-    scope = `
-
-Scope: ${truncated}`;
-  }
-  const prompt = n.behavioralPrompt ? `${n.behavioralPrompt}
-
-${DEFAULT_BEHAVIORAL_PROMPT}` : DEFAULT_BEHAVIORAL_PROMPT;
-  const promptBlock = n.type === "comment" ? `
-
----
-${prompt}` : "";
-  return `${header}${scope}${body}
-
-${cta}${promptBlock}`;
-}
-async function injectNotification(port, hooksToken, n, agentId = "main") {
-  const response = await fetch(`http://localhost:${port}/hooks/agent`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${hooksToken}`
-    },
-    body: JSON.stringify({
-      message: buildNotificationMessage(n),
-      name: "Cohort",
-      agentId,
-      deliver: false,
-      sessionKey: `hook:cohort:task-${n.taskNumber}`
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`/hooks/agent returned ${response.status} ${response.statusText}`);
+// src/commands.ts
+var cronRunNowPoll = null;
+async function executeCommand(cmd, gwClient, cfg, resolveAgentName, logger) {
+  if (cmd.type === "restart") {
+    logger.info("cohort-sync: restart command, terminating in 500ms");
+    await new Promise((r) => setTimeout(r, 500));
+    process.kill(process.pid, "SIGTERM");
+    return;
   }
-}
-var getUndeliveredForPlugin = makeFunctionReference("notifications:getUndeliveredForPlugin");
-var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredByPlugin");
-var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTelemetryFromPlugin");
-var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
-var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
-var upsertCronSnapshotFromPluginRef = makeFunctionReference("telemetryPlugin:upsertCronSnapshotFromPlugin");
-var getPendingCommandsForPlugin = makeFunctionReference("gatewayCommands:getPendingForPlugin");
-var acknowledgeCommandRef = makeFunctionReference("gatewayCommands:acknowledgeCommand");
-var addCommentFromPluginRef = makeFunctionReference("comments:addCommentFromPlugin");
-var HOT_KEY = "__cohort_sync__";
-function getHotState() {
-  let state = globalThis[HOT_KEY];
-  if (!state) {
-    state = {
-      tracker: null,
-      client: null,
-      convexUrl: null,
-      unsubscribers: [],
-      lastKnownRoster: [],
-      intervals: { heartbeat: null, activityFlush: null },
-      activityBuffer: [],
-      channelAgentBridge: {},
-      gatewayPort: null,
-      gatewayToken: null,
-      gatewayProtocolClient: null,
-      commandSubscription: null
-    };
-    globalThis[HOT_KEY] = state;
+  if (cmd.type.startsWith("cron")) {
+    if (!gwClient || !gwClient.isAlive()) {
+      logger.warn(`cohort-sync: no gateway client, cannot execute ${cmd.type}`);
+      return;
+    }
+    const nameMap = cfg.agentNameMap ?? {};
+    switch (cmd.type) {
+      case "cronEnable":
+        await gwClient.request("cron.update", {
+          jobId: cmd.payload?.jobId,
+          patch: { enabled: true }
+        });
+        break;
+      case "cronDisable":
+        await gwClient.request("cron.update", {
+          jobId: cmd.payload?.jobId,
+          patch: { enabled: false }
+        });
+        break;
+      case "cronDelete":
+        await gwClient.request("cron.remove", {
+          jobId: cmd.payload?.jobId
+        });
+        break;
+      case "cronRunNow": {
+        const runResult = await gwClient.request(
+          "cron.run",
+          { jobId: cmd.payload?.jobId }
+        );
+        if (runResult?.ok && runResult?.ran) {
+          const jobId = cmd.payload?.jobId;
+          let polls = 0;
+          if (cronRunNowPoll) clearInterval(cronRunNowPoll);
+          const pollInterval = setInterval(async () => {
+            polls++;
+            if (polls >= 15) {
+              clearInterval(pollInterval);
+              cronRunNowPoll = null;
+              return;
+            }
+            try {
+              if (!gwClient || !gwClient.isAlive()) {
+                clearInterval(pollInterval);
+                cronRunNowPoll = null;
+                return;
+              }
+              const pollResult = await gwClient.request("cron.list");
+              const freshJobs = Array.isArray(pollResult) ? pollResult : pollResult?.jobs ?? [];
+              const job = freshJobs.find((j) => j.id === jobId);
+              if (job && !job.state?.runningAtMs) {
+                clearInterval(pollInterval);
+                cronRunNowPoll = null;
+                const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
+                await pushCronSnapshot(cfg.apiKey, mapped);
+              }
+            } catch {
+            }
+          }, 2e3);
+          cronRunNowPoll = pollInterval;
+        }
+        break;
+      }
+      case "cronCreate": {
+        const agentId = reverseResolveAgentName(cmd.payload?.agentId ?? "main", nameMap);
+        await gwClient.request("cron.add", {
+          job: {
+            agentId,
+            name: cmd.payload?.name,
+            enabled: true,
+            schedule: cmd.payload?.schedule,
+            payload: { kind: "agentTurn", message: cmd.payload?.message },
+            sessionTarget: "isolated",
+            wakeMode: "now"
+          }
+        });
+        break;
+      }
+      case "cronUpdate": {
+        const patch = {};
+        if (cmd.payload?.name) patch.name = cmd.payload.name;
+        if (cmd.payload?.schedule) patch.schedule = cmd.payload.schedule;
+        if (cmd.payload?.message) patch.payload = { kind: "agentTurn", message: cmd.payload.message };
+        if (cmd.payload?.agentId) patch.agentId = reverseResolveAgentName(cmd.payload.agentId, nameMap);
+        await gwClient.request("cron.update", {
+          jobId: cmd.payload?.jobId,
+          patch
+        });
+        break;
+      }
+      default:
+        logger.warn(`cohort-sync: unknown cron command type: ${cmd.type}`);
+    }
+    if (gwClient.isAlive()) {
+      try {
+        const snapResult = await gwClient.request("cron.list");
+        const freshJobs = Array.isArray(snapResult) ? snapResult : snapResult?.jobs ?? [];
+        const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
+        await pushCronSnapshot(cfg.apiKey, mapped);
+      } catch (snapErr) {
+        logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
+      }
+    }
+    return;
   }
-  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) {
-  getHotState().lastKnownRoster = roster;
+  logger.warn(`cohort-sync: unknown command type: ${cmd.type}`);
 }
-function getRosterHotState() {
-  return getHotState().lastKnownRoster;
+
+// src/convex-bridge.ts
+function deriveConvexUrl(apiUrl) {
+  return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
 }
 var savedLogger = null;
 function setLogger(logger) {
@@ -11678,266 +11906,18 @@ function getLogger() {
 var client = null;
 var savedConvexUrl = null;
 var unsubscribers = [];
-function setConvexUrl(cfg) {
-  const url = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
-  savedConvexUrl = url;
-  getHotState().convexUrl = url;
-}
-function restoreFromHotReload(logger) {
-  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 && 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 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})`);
-  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 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})`);
+function createClient(convexUrl) {
+  if (client) {
+    client.close();
   }
-  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).`
-    );
-    return;
-  }
-  const agentNames = cfg.agentNameMap ? Object.values(cfg.agentNameMap) : ["main"];
-  const reverseNameMap = {};
-  if (cfg.agentNameMap) {
-    for (const [openclawId, cohortName] of Object.entries(cfg.agentNameMap)) {
-      reverseNameMap[cohortName] = openclawId;
-    }
-  }
-  for (const agentName of agentNames) {
-    const openclawAgentId = reverseNameMap[agentName] ?? agentName;
-    logger.info(`cohort-sync: subscribing to notifications for agent "${agentName}" (openclawId: "${openclawAgentId}")`);
-    let processing = false;
-    const unsubscribe = client.onUpdate(
-      getUndeliveredForPlugin,
-      { agent: agentName, apiKey: cfg.apiKey },
-      async (notifications) => {
-        if (processing) return;
-        processing = true;
-        try {
-          for (const n of notifications) {
-            try {
-              await injectNotification(port, hooksToken, n, openclawAgentId);
-              logger.info(`cohort-sync: injected notification for task #${n.taskNumber} (${agentName})`);
-              await client.mutation(markDeliveredByPlugin, {
-                notificationId: n._id,
-                apiKey: cfg.apiKey
-              });
-            } catch (err) {
-              logger.warn(`cohort-sync: failed to inject notification ${n._id}: ${String(err)}`);
-            }
-          }
-        } finally {
-          processing = false;
-        }
-      },
-      (err) => {
-        logger.error(`cohort-sync: subscription error for "${agentName}": ${String(err)}`);
-      }
-    );
-    unsubscribers.push(unsubscribe);
-  }
-  state.unsubscribers = [...unsubscribers];
-}
-function initCommandSubscription(cfg, logger, resolveAgentName) {
-  const c = getOrCreateClient();
-  if (!c) {
-    logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
-    return null;
-  }
-  let processing = false;
-  const unsubscribe = c.onUpdate(
-    getPendingCommandsForPlugin,
-    { apiKey: cfg.apiKey },
-    async (commands) => {
-      if (processing) return;
-      if (commands.length === 0) return;
-      processing = true;
-      try {
-        for (const cmd of commands) {
-          logger.info(`cohort-sync: processing command: ${cmd.type} (${cmd._id})`);
-          try {
-            await c.mutation(acknowledgeCommandRef, {
-              commandId: cmd._id,
-              apiKey: cfg.apiKey
-            });
-            if (cmd.type === "restart") {
-              logger.info("cohort-sync: restart acknowledged, terminating in 500ms");
-              await new Promise((r) => setTimeout(r, 500));
-              process.kill(process.pid, "SIGTERM");
-              return;
-            }
-            if (cmd.type.startsWith("cron")) {
-              const hotState = getHotState();
-              const port = hotState.gatewayPort;
-              const token = hotState.gatewayToken;
-              if (!port || !token) {
-                logger.warn(`cohort-sync: no gateway port/token, cannot execute ${cmd.type}`);
-                continue;
-              }
-              const gwClient = new GatewayClient(port, token, logger);
-              try {
-                await gwClient.connect();
-                const nameMap = cfg.agentNameMap ?? {};
-                switch (cmd.type) {
-                  case "cronEnable":
-                    await gwClient.request("cron.update", {
-                      jobId: cmd.payload?.jobId,
-                      patch: { enabled: true }
-                    });
-                    break;
-                  case "cronDisable":
-                    await gwClient.request("cron.update", {
-                      jobId: cmd.payload?.jobId,
-                      patch: { enabled: false }
-                    });
-                    break;
-                  case "cronDelete":
-                    await gwClient.request("cron.remove", {
-                      jobId: cmd.payload?.jobId
-                    });
-                    break;
-                  case "cronRunNow": {
-                    const runResult = await gwClient.request(
-                      "cron.run",
-                      { jobId: cmd.payload?.jobId }
-                    );
-                    if (runResult?.ok && runResult?.ran) {
-                      const jobId = cmd.payload?.jobId;
-                      let polls = 0;
-                      const pollInterval = setInterval(async () => {
-                        polls++;
-                        if (polls >= 15) {
-                          clearInterval(pollInterval);
-                          return;
-                        }
-                        try {
-                          const pollClient = getHotState().gatewayProtocolClient;
-                          if (!pollClient || !pollClient.isAlive()) {
-                            clearInterval(pollInterval);
-                            return;
-                          }
-                          const pollResult = await pollClient.request("cron.list");
-                          const freshJobs = Array.isArray(pollResult) ? pollResult : pollResult?.jobs ?? [];
-                          const job = freshJobs.find((j) => j.id === jobId);
-                          if (job && !job.state?.runningAtMs) {
-                            clearInterval(pollInterval);
-                            const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
-                            await pushCronSnapshot(cfg.apiKey, mapped);
-                          }
-                        } catch {
-                        }
-                      }, 2e3);
-                    }
-                    break;
-                  }
-                  case "cronCreate": {
-                    const agentId = reverseResolveAgentName(cmd.payload?.agentId ?? "main", nameMap);
-                    await gwClient.request("cron.add", {
-                      job: {
-                        agentId,
-                        name: cmd.payload?.name,
-                        enabled: true,
-                        schedule: cmd.payload?.schedule,
-                        payload: { kind: "agentTurn", message: cmd.payload?.message },
-                        sessionTarget: "isolated",
-                        wakeMode: "now"
-                      }
-                    });
-                    break;
-                  }
-                  case "cronUpdate": {
-                    const patch = {};
-                    if (cmd.payload?.name) patch.name = cmd.payload.name;
-                    if (cmd.payload?.schedule) patch.schedule = cmd.payload.schedule;
-                    if (cmd.payload?.message) patch.payload = { kind: "agentTurn", message: cmd.payload.message };
-                    if (cmd.payload?.agentId) patch.agentId = reverseResolveAgentName(cmd.payload.agentId, nameMap);
-                    await gwClient.request("cron.update", {
-                      jobId: cmd.payload?.jobId,
-                      patch
-                    });
-                    break;
-                  }
-                  default:
-                    logger.warn(`cohort-sync: unknown cron command type: ${cmd.type}`);
-                }
-                if (gwClient.isAlive()) {
-                  try {
-                    const snapResult = await gwClient.request("cron.list");
-                    const freshJobs = Array.isArray(snapResult) ? snapResult : snapResult?.jobs ?? [];
-                    const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
-                    await pushCronSnapshot(cfg.apiKey, mapped);
-                  } catch (snapErr) {
-                    logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
-                  }
-                }
-              } finally {
-                gwClient.close();
-              }
-            } else {
-              logger.warn(`cohort-sync: unknown command type: ${cmd.type}`);
-            }
-          } catch (err) {
-            logger.error(`cohort-sync: failed to process command ${cmd._id}: ${String(err)}`);
-          }
-        }
-      } finally {
-        processing = false;
-      }
-    },
-    (err) => {
-      logger.error(`cohort-sync: command subscription error: ${String(err)}`);
-    }
-  );
-  logger.info("cohort-sync: command subscription active");
-  return unsubscribe;
+  savedConvexUrl = convexUrl;
+  client = new ConvexClient(convexUrl);
+  return client;
 }
-async function callAddCommentFromPlugin(apiKey, args) {
-  const c = getOrCreateClient();
-  if (!c) {
-    throw new Error("Convex client not initialized \u2014 subscription may not be active");
-  }
-  return await c.mutation(addCommentFromPluginRef, {
-    apiKey,
-    taskNumber: args.taskNumber,
-    agentName: args.agentName,
-    content: args.content,
-    noReply: args.noReply
-  });
+function getClient() {
+  return client;
 }
-function closeSubscription() {
+function closeBridge() {
   for (const unsub of unsubscribers) {
     try {
       unsub();
@@ -11945,33 +11925,32 @@ function closeSubscription() {
     }
   }
   unsubscribers.length = 0;
-  const state = getHotState();
-  for (const unsub of state.unsubscribers) {
+  if (commandUnsubscriber) {
     try {
-      unsub();
+      commandUnsubscriber();
     } catch {
     }
+    commandUnsubscriber = null;
   }
-  if (state.commandSubscription) {
-    try {
-      state.commandSubscription();
-    } catch {
-    }
-    state.commandSubscription = null;
-  }
-  if (state.gatewayProtocolClient) {
-    try {
-      state.gatewayProtocolClient.close();
-    } catch {
-    }
-    state.gatewayProtocolClient = null;
+  if (client) {
+    client.close();
+    client = null;
   }
-  client?.close();
-  client = null;
-  clearHotState();
+  savedConvexUrl = null;
 }
+var commandUnsubscriber = null;
+var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTelemetryFromPlugin");
+var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
+var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
+var upsertCronSnapshotFromPluginRef = makeFunctionReference("telemetryPlugin:upsertCronSnapshotFromPlugin");
+var getUndeliveredForPlugin = makeFunctionReference("notifications:getUndeliveredForPlugin");
+var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredByPlugin");
+var getPendingCommandsForPlugin = makeFunctionReference("gatewayCommands:getPendingForPlugin");
+var acknowledgeCommandRef = makeFunctionReference("gatewayCommands:acknowledgeCommand");
+var failCommandRef = makeFunctionReference("gatewayCommands:failCommand");
+var addCommentFromPluginRef = makeFunctionReference("comments:addCommentFromPlugin");
 async function pushTelemetry(apiKey, data) {
-  const c = getOrCreateClient();
+  const c = getClient();
   if (!c) return;
   try {
     await c.mutation(upsertTelemetryFromPlugin, { apiKey, ...data });
@@ -11980,7 +11959,7 @@ async function pushTelemetry(apiKey, data) {
   }
 }
 async function pushSessions(apiKey, agentName, sessions) {
-  const c = getOrCreateClient();
+  const c = getClient();
   if (!c) return;
   try {
     await c.mutation(upsertSessionsFromPlugin, { apiKey, agentName, sessions });
@@ -11990,7 +11969,7 @@ async function pushSessions(apiKey, agentName, sessions) {
 }
 async function pushActivity(apiKey, entries) {
   if (entries.length === 0) return;
-  const c = getOrCreateClient();
+  const c = getClient();
   if (!c) return;
   try {
     await c.mutation(pushActivityFromPluginRef, { apiKey, entries });
@@ -11999,271 +11978,203 @@ async function pushActivity(apiKey, entries) {
   }
 }
 async function pushCronSnapshot(apiKey, jobs) {
-  const c = getOrCreateClient();
-  if (!c) return;
+  const c = getClient();
+  if (!c) return false;
   try {
     await c.mutation(upsertCronSnapshotFromPluginRef, { apiKey, jobs });
+    return true;
   } catch (err) {
     getLogger().error(`cohort-sync: pushCronSnapshot failed: ${err}`);
+    return false;
   }
 }
-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 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
-function extractJson(raw) {
-  const jsonStart = raw.search(/[\[{]/);
-  const jsonEndBracket = raw.lastIndexOf("]");
-  const jsonEndBrace = raw.lastIndexOf("}");
-  const jsonEnd = Math.max(jsonEndBracket, jsonEndBrace);
-  if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart) {
-    throw new Error("No JSON found in output");
-  }
-  return raw.slice(jsonStart, jsonEnd + 1);
-}
-function fetchSkills(logger) {
-  try {
-    const raw = execSync("openclaw skills list --json", {
-      encoding: "utf8",
-      timeout: 3e4,
-      stdio: ["ignore", "pipe", "ignore"],
-      env: { ...process.env, NO_COLOR: "1" }
-    });
-    const parsed = JSON.parse(extractJson(raw));
-    const list = Array.isArray(parsed) ? parsed : parsed?.skills ?? [];
-    return list.map((s) => ({
-      name: String(s.name ?? s.id ?? "unknown"),
-      description: String(s.description ?? ""),
-      source: String(s.source ?? s.origin ?? "unknown"),
-      ...s.emoji ? { emoji: String(s.emoji) } : {}
-    }));
-  } catch (err) {
-    logger.warn(`cohort-sync: failed to fetch skills: ${String(err)}`);
-    return [];
+async function callAddCommentFromPlugin(apiKey, args) {
+  const c = getClient();
+  if (!c) {
+    throw new Error("Convex client not initialized \u2014 subscription may not be active");
   }
-}
-var VALID_STATUSES = /* @__PURE__ */ new Set(["idle", "working", "waiting"]);
-function normalizeStatus(status) {
-  return VALID_STATUSES.has(status) ? status : "idle";
-}
-async function v1Get(apiUrl, apiKey, path4) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
-    headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) throw new Error(`GET ${path4} \u2192 ${res.status}`);
-  return res.json();
-}
-async function v1Patch(apiUrl, apiKey, path4, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
-    method: "PATCH",
-    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(1e4)
+  return await c.mutation(addCommentFromPluginRef, {
+    apiKey,
+    taskNumber: args.taskNumber,
+    agentName: args.agentName,
+    content: args.content,
+    noReply: args.noReply
   });
-  if (!res.ok) throw new Error(`PATCH ${path4} \u2192 ${res.status}`);
 }
-async function v1Post(apiUrl, apiKey, path4, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path4}`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) throw new Error(`POST ${path4} \u2192 ${res.status}`);
-}
-async function checkForUpdate(currentVersion, logger) {
-  try {
-    const res = await fetch("https://registry.npmjs.org/@cfio/cohort-sync/latest", {
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!res.ok) return;
-    const data = await res.json();
-    const latest = data.version;
-    if (latest && latest !== currentVersion) {
-      logger.warn(
-        `cohort-sync: update available (${currentVersion} \u2192 ${latest}) \u2014 run "npm install -g @cfio/cohort-sync" to update`
-      );
-    }
-  } catch {
-  }
-}
-async function syncAgentStatus(agentName, status, model, cfg, logger) {
-  try {
-    const data = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
-    const agents = data?.data ?? [];
-    const agent = agents.find(
-      (a) => a.name.toLowerCase() === agentName.toLowerCase()
-    );
-    if (!agent) {
-      const available = agents.map((a) => a.name).join(", ") || "(none)";
-      logger.warn(
-        `cohort-sync: agent "${agentName}" not found in workspace \u2014 skipping status sync. Available agents: [${available}]. Configure agentNameMap in your plugin config to map OpenClaw agent IDs to Cohort names.`
-      );
-      return;
-    }
-    await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${agent.id}`, {
-      status: normalizeStatus(status),
-      model
-    });
-    logger.info(`cohort-sync: agent "${agentName}" \u2192 ${normalizeStatus(status)}`);
-  } catch (err) {
-    logger.warn(`cohort-sync: syncAgentStatus failed: ${String(err)}`);
-  }
-}
-async function syncSkillsToV1(skills, cfg, logger) {
-  for (const skill of skills) {
-    try {
-      await v1Post(cfg.apiUrl, cfg.apiKey, "/api/v1/skills", {
-        name: skill.name,
-        description: skill.description
-      });
-    } catch (err) {
-      logger.warn(`cohort-sync: failed to sync skill "${skill.name}": ${String(err)}`);
-    }
+var DEFAULT_BEHAVIORAL_PROMPT = `BEFORE RESPONDING:
+- Does your planned response address the task's stated scope? If not, do not comment.
+- Do not post acknowledgment-only responses ("got it", "sounds good", "confirmed"). If you have no new information to add, do not comment.
+- If the work is complete, transition the task to "waiting" and set noReply=true on your final comment, then stop working on this task.`;
+function buildNotificationMessage(n) {
+  let header;
+  let cta;
+  switch (n.type) {
+    case "comment":
+      if (n.isMentioned) {
+        header = `You were @mentioned on task #${n.taskNumber} "${n.taskTitle}"
+By: ${n.actorName}`;
+        cta = "You were directly mentioned. Read the comment and respond using the cohort_comment tool.";
+      } else {
+        header = `New comment on task #${n.taskNumber} "${n.taskTitle}"
+From: ${n.actorName}`;
+        cta = "Read the comment thread and respond using the cohort_comment tool if appropriate.";
+      }
+      break;
+    case "assignment":
+      header = `You were assigned to task #${n.taskNumber} "${n.taskTitle}"
+By: ${n.actorName}`;
+      cta = "Review the task description and begin working on it.";
+      break;
+    case "status_change":
+      header = `Status changed on task #${n.taskNumber} "${n.taskTitle}"
+By: ${n.actorName}`;
+      cta = "Review the status change and take any follow-up action needed.";
+      break;
+    default:
+      header = `Notification on task #${n.taskNumber} "${n.taskTitle}"
+From: ${n.actorName}`;
+      cta = "Check the task and respond if needed.";
   }
-}
-var lastKnownRoster = [];
-function getLastKnownRoster() {
-  return lastKnownRoster;
-}
-function restoreRosterFromHotReload(hotRoster, logger) {
-  if (hotRoster && hotRoster.length > 0 && lastKnownRoster.length === 0) {
-    lastKnownRoster = hotRoster;
-    logger.info(`cohort-sync: recovered roster (${hotRoster.length} agents) after hot-reload`);
+  const body = n.preview ? `
+Comment: "${n.preview}"` : "";
+  let scope = "";
+  if (n.taskDescription && n.type === "comment") {
+    const truncated = n.taskDescription.length > 500 ? n.taskDescription.slice(0, 500) + "..." : n.taskDescription;
+    scope = `
+
+Scope: ${truncated}`;
   }
+  const prompt = n.behavioralPrompt ? `${n.behavioralPrompt}
+
+${DEFAULT_BEHAVIORAL_PROMPT}` : DEFAULT_BEHAVIORAL_PROMPT;
+  const promptBlock = n.type === "comment" ? `
+
+---
+${prompt}` : "";
+  return `${header}${scope}${body}
+
+${cta}${promptBlock}`;
 }
-async function reconcileRoster(openClawAgents, cfg, logger) {
-  const data = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
-  const cohortAgents = data?.data ?? [];
-  const cohortByName = new Map(cohortAgents.map((a) => [a.name.toLowerCase(), a]));
-  const openClawNames = new Set(
-    openClawAgents.map((a) => {
-      const nameMap = cfg.agentNameMap;
-      return (nameMap?.[a.id] ?? a.identity?.name ?? a.id).toLowerCase();
-    })
-  );
-  for (const oc of openClawAgents) {
-    const agentName = (cfg.agentNameMap?.[oc.id] ?? oc.identity?.name ?? oc.id).toLowerCase();
-    const existing = cohortByName.get(agentName);
-    if (!existing) {
-      try {
-        await v1Post(cfg.apiUrl, cfg.apiKey, "/api/v1/agents", {
-          name: agentName,
-          displayName: oc.identity?.name ?? agentName,
-          emoji: oc.identity?.emoji ?? "\u{1F916}",
-          model: oc.model,
-          status: "idle"
-        });
-        logger.info(`cohort-sync: provisioned new agent "${agentName}"`);
-      } catch (err) {
-        logger.warn(`cohort-sync: failed to provision agent "${agentName}": ${String(err)}`);
-      }
-    } else {
-      const updates = {
-        model: oc.model,
-        status: "idle"
-      };
-      if (oc.identity?.name) {
-        updates.displayName = oc.identity.name;
-      }
-      if (oc.identity?.emoji) {
-        updates.emoji = oc.identity.emoji;
-      }
-      try {
-        await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${existing.id}`, updates);
-      } catch (err) {
-        logger.warn(`cohort-sync: failed to update agent "${agentName}": ${String(err)}`);
-      }
-    }
-  }
-  for (const cohort of cohortAgents) {
-    if (!openClawNames.has(cohort.name.toLowerCase())) {
-      if (cohort.status === "archived" || cohort.status === "deleted" || cohort.status === "unreachable") {
-        continue;
-      }
-      try {
-        await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${cohort.id}`, {
-          status: "unreachable"
-        });
-        logger.info(`cohort-sync: marked agent "${cohort.name}" as unreachable`);
-      } catch (err) {
-        logger.warn(
-          `cohort-sync: failed to mark agent "${cohort.name}" as unreachable: ${String(err)}`
-        );
-      }
-    }
+async function injectNotification(port, hooksToken, n, agentId = "main") {
+  const response = await fetch(`http://localhost:${port}/hooks/agent`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${hooksToken}`
+    },
+    body: JSON.stringify({
+      message: buildNotificationMessage(n),
+      name: "Cohort",
+      agentId,
+      deliver: false,
+      sessionKey: `hook:cohort:task-${n.taskNumber}`
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`/hooks/agent returned ${response.status} ${response.statusText}`);
   }
-  const updatedData = await v1Get(cfg.apiUrl, cfg.apiKey, "/api/v1/agents?limit=100");
-  const finalRoster = updatedData?.data ?? cohortAgents;
-  lastKnownRoster = finalRoster;
-  setRosterHotState(finalRoster);
-  return finalRoster;
 }
-async function markAllUnreachable(cfg, logger) {
-  const roster = getLastKnownRoster();
-  if (roster.length === 0) {
-    logger.warn("cohort-sync: no cached roster \u2014 skipping markAllUnreachable");
+async function startNotificationSubscription(port, cfg, hooksToken, logger) {
+  const c = getClient();
+  if (!c) {
+    logger.warn("cohort-sync: no ConvexClient \u2014 notification subscription skipped");
     return;
   }
-  for (const agent of roster) {
-    if (agent.status === "unreachable" || agent.status === "archived" || agent.status === "deleted") {
-      continue;
-    }
-    try {
-      await v1Patch(cfg.apiUrl, cfg.apiKey, `/api/v1/agents/${agent.id}`, {
-        status: "unreachable"
-      });
-    } catch (err) {
-      logger.warn(`cohort-sync: failed to mark "${agent.name}" as unreachable: ${String(err)}`);
-    }
+  if (!hooksToken) {
+    logger.warn(
+      `cohort-sync: hooks.token not configured \u2014 real-time notifications disabled (telemetry will still be pushed).`
+    );
+    return;
   }
-  logger.info("cohort-sync: all agents marked unreachable");
-}
-async function fullSync(agentName, model, cfg, logger, openClawAgents) {
-  logger.info("cohort-sync: full sync starting");
-  if (openClawAgents && openClawAgents.length > 0) {
-    try {
-      await reconcileRoster(openClawAgents, cfg, logger);
-    } catch (err) {
-      logger.warn(`cohort-sync: roster reconciliation failed: ${String(err)}`);
+  const agentNames = cfg.agentNameMap ? Object.values(cfg.agentNameMap) : ["main"];
+  const reverseNameMap = {};
+  if (cfg.agentNameMap) {
+    for (const [openclawId, cohortName] of Object.entries(cfg.agentNameMap)) {
+      reverseNameMap[cohortName] = openclawId;
     }
-  } else {
-    await syncAgentStatus(agentName, "working", model, cfg, logger);
   }
-  const skills = fetchSkills(logger);
-  if (skills.length > 0) {
-    await syncSkillsToV1(skills, cfg, logger);
+  for (const agentName of agentNames) {
+    const openclawAgentId = reverseNameMap[agentName] ?? agentName;
+    logger.info(`cohort-sync: subscribing to notifications for agent "${agentName}" (openclawId: "${openclawAgentId}")`);
+    let processing = false;
+    const unsubscribe = c.onUpdate(
+      getUndeliveredForPlugin,
+      { agent: agentName, apiKey: cfg.apiKey },
+      async (notifications) => {
+        if (processing) return;
+        processing = true;
+        try {
+          for (const n of notifications) {
+            try {
+              await injectNotification(port, hooksToken, n, openclawAgentId);
+              logger.info(`cohort-sync: injected notification for task #${n.taskNumber} (${agentName})`);
+              await c.mutation(markDeliveredByPlugin, {
+                notificationId: n._id,
+                apiKey: cfg.apiKey
+              });
+            } catch (err) {
+              logger.warn(`cohort-sync: failed to inject notification ${n._id}: ${String(err)}`);
+            }
+          }
+        } finally {
+          processing = false;
+        }
+      },
+      (err) => {
+        logger.error(`cohort-sync: subscription error for "${agentName}": ${String(err)}`);
+      }
+    );
+    unsubscribers.push(unsubscribe);
   }
-  logger.info("cohort-sync: full sync complete");
+}
+function startCommandSubscription(cfg, logger, resolveAgentName, gwClient) {
+  const c = getClient();
+  if (!c) {
+    logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
+    return null;
+  }
+  let processing = false;
+  const unsubscribe = c.onUpdate(
+    getPendingCommandsForPlugin,
+    { apiKey: cfg.apiKey },
+    async (commands) => {
+      if (processing) return;
+      if (commands.length === 0) return;
+      processing = true;
+      try {
+        for (const cmd of commands) {
+          logger.info(`cohort-sync: processing command: ${cmd.type} (${cmd._id})`);
+          try {
+            await c.mutation(acknowledgeCommandRef, {
+              commandId: cmd._id,
+              apiKey: cfg.apiKey
+            });
+            await executeCommand(cmd, gwClient, cfg, resolveAgentName, logger);
+            if (cmd.type === "restart") return;
+          } catch (err) {
+            logger.error(`cohort-sync: failed to process command ${cmd._id}: ${String(err)}`);
+            try {
+              await c.mutation(failCommandRef, {
+                commandId: cmd._id,
+                apiKey: cfg.apiKey,
+                reason: String(err).slice(0, 500)
+              });
+            } catch (failErr) {
+              logger.error(`cohort-sync: failed to mark command ${cmd._id} as failed: ${String(failErr)}`);
+            }
+          }
+        }
+      } finally {
+        processing = false;
+      }
+    },
+    (err) => {
+      logger.error(`cohort-sync: command subscription error: ${String(err)}`);
+    }
+  );
+  commandUnsubscriber = unsubscribe;
+  logger.info("cohort-sync: command subscription active");
+  return unsubscribe;
 }
 
 // src/gateway-client.ts
@@ -12450,13 +12361,7 @@ function parseHelloOk(response) {
     snapshot: payload.snapshot
   };
 }
-function getPendingRequests() {
-  const g = globalThis;
-  const hot = g.__cohort_sync__ ?? (g.__cohort_sync__ = {});
-  if (!hot.pendingGatewayRequests) hot.pendingGatewayRequests = /* @__PURE__ */ new Map();
-  return hot.pendingGatewayRequests;
-}
-var GatewayClient2 = class {
+var GatewayClient = class {
   port;
   logger;
   ws = null;
@@ -12470,9 +12375,12 @@ var GatewayClient2 = class {
   tickIntervalMs = 15e3;
   // default; overwritten by hello-ok response
   deviceIdentity;
+  pendingRequests = /* @__PURE__ */ new Map();
   /** Public Sets populated from hello-ok — consumers can inspect gateway capabilities */
   availableMethods = /* @__PURE__ */ new Set();
   availableEvents = /* @__PURE__ */ new Set();
+  /** Called after a successful reconnection (WebSocket re-established after drop) */
+  onReconnect = null;
   /**
    * @param port - Gateway WebSocket port
    * @param token - Auth token (stored in closure via constructor param, NOT on this or globalThis)
@@ -12599,12 +12507,11 @@ var GatewayClient2 = class {
         this.stopTickWatchdog();
         diag("GW_CLIENT_WS_CLOSED", { port: this.port });
         this.logger.warn("cohort-sync: gateway client WebSocket closed");
-        const pending = getPendingRequests();
-        for (const [, entry] of pending) {
+        for (const [, entry] of this.pendingRequests) {
           clearTimeout(entry.timer);
           entry.reject(new Error("Gateway WebSocket closed"));
         }
-        pending.clear();
+        this.pendingRequests.clear();
         if (!settled) {
           settle(new Error("Gateway WebSocket closed during handshake"));
         }
@@ -12635,6 +12542,18 @@ var GatewayClient2 = class {
     }
     handlers.add(handler);
   }
+  /**
+   * Remove an event handler previously registered with on().
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.eventHandlers.delete(event);
+      }
+    }
+  }
   /**
    * Send a request to the gateway and wait for the response.
    *
@@ -12655,13 +12574,12 @@ var GatewayClient2 = class {
       method,
       params
     };
-    const pending = getPendingRequests();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
-        pending.delete(id);
+        this.pendingRequests.delete(id);
         reject(new Error(`Gateway method "${method}" timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      pending.set(id, {
+      this.pendingRequests.set(id, {
         resolve,
         reject,
         timer
@@ -12680,12 +12598,11 @@ var GatewayClient2 = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
-    const pending = getPendingRequests();
-    for (const [, entry] of pending) {
+    for (const [, entry] of this.pendingRequests) {
       clearTimeout(entry.timer);
       entry.reject(new Error("Gateway client closed"));
     }
-    pending.clear();
+    this.pendingRequests.clear();
     if (this.ws) {
       this.ws.close();
       this.ws = null;
@@ -12715,10 +12632,9 @@ var GatewayClient2 = class {
     }
   }
   handleResponse(frame) {
-    const pending = getPendingRequests();
-    const entry = pending.get(frame.id);
+    const entry = this.pendingRequests.get(frame.id);
     if (!entry) return;
-    pending.delete(frame.id);
+    this.pendingRequests.delete(frame.id);
     clearTimeout(entry.timer);
     if (frame.ok) {
       entry.resolve(frame.payload);
@@ -12793,6 +12709,7 @@ var GatewayClient2 = class {
         diag("GW_CLIENT_RECONNECTING", { attempt: this.reconnectAttempts });
         await this.connect();
         diag("GW_CLIENT_RECONNECTED", { attempt: this.reconnectAttempts });
+        this.onReconnect?.();
       } catch (err) {
         diag("GW_CLIENT_RECONNECT_FAILED", {
           attempt: this.reconnectAttempts,
@@ -12803,6 +12720,94 @@ var GatewayClient2 = class {
   }
 };
 
+// src/micro-batch.ts
+var MicroBatch = class {
+  buffer = [];
+  timer = null;
+  destroyed = false;
+  maxSize;
+  maxDelayMs;
+  flushFn;
+  onError;
+  constructor(options) {
+    this.maxSize = options.maxSize;
+    this.maxDelayMs = options.maxDelayMs;
+    this.flushFn = options.flush;
+    this.onError = options.onError ?? ((err) => console.error("MicroBatch flush error:", err));
+  }
+  /**
+   * Add an item to the batch.
+   *
+   * If the buffer was empty before this add, schedules an immediate flush
+   * on the next tick (setTimeout 0). If the buffer already had items (burst),
+   * starts a coalescing timer that fires after maxDelayMs.
+   *
+   * If the buffer reaches maxSize, flushes immediately.
+   */
+  add(item) {
+    if (this.destroyed) return;
+    const wasEmpty = this.buffer.length === 0;
+    this.buffer.push(item);
+    if (this.buffer.length >= this.maxSize) {
+      this.clearTimer();
+      this.doFlush();
+      return;
+    }
+    if (wasEmpty) {
+      this.clearTimer();
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.doFlush();
+      }, 0);
+    } else if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.doFlush();
+      }, this.maxDelayMs);
+    }
+  }
+  /**
+   * Flush all remaining items. Used for graceful shutdown.
+   * No-op when buffer is empty.
+   */
+  drain() {
+    this.clearTimer();
+    if (this.buffer.length > 0) {
+      this.doFlush();
+    }
+  }
+  /**
+   * Clear any pending timer and discard buffered items.
+   * The batch will not accept new items after destroy.
+   */
+  destroy() {
+    this.destroyed = true;
+    this.clearTimer();
+    this.buffer = [];
+  }
+  doFlush() {
+    if (this.buffer.length === 0) return;
+    const items = this.buffer;
+    this.buffer = [];
+    try {
+      const result = this.flushFn(items);
+      if (result && typeof result.catch === "function") {
+        result.catch((err) => {
+          this.onError(err);
+        });
+      }
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+  clearTimer() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
 // src/agent-state.ts
 import { basename } from "node:path";
 
@@ -13051,6 +13056,16 @@ function buildActivityEntry(agentName, hook, context) {
       return null;
   }
 }
+var channelAgentBridge = /* @__PURE__ */ new Map();
+function setChannelAgent(channelId, agentName) {
+  channelAgentBridge.set(channelId, agentName);
+}
+function getChannelAgent(channelId) {
+  return channelAgentBridge.get(channelId) ?? null;
+}
+function getChannelAgentBridge() {
+  return channelAgentBridge;
+}
 var AgentStateTracker = class {
   agents = /* @__PURE__ */ new Map();
   activityBuffer = [];
@@ -13301,11 +13316,26 @@ var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
 `;
 
 // src/hooks.ts
-var BUILD_ID = "B9-ACCOUNTID-20260311";
+var REDACT_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "apikey",
+  "secret",
+  "password",
+  "credential",
+  "authorization",
+  "accesstoken",
+  "refreshtoken",
+  "bearer",
+  "privatekey"
+]);
 function dumpCtx(ctx) {
   if (!ctx || typeof ctx !== "object") return { _raw: String(ctx) };
   const out = {};
   for (const key of Object.keys(ctx)) {
+    if (REDACT_KEYS.has(key.toLowerCase())) {
+      out[key] = "[REDACTED]";
+      continue;
+    }
     const val = ctx[key];
     if (typeof val === "function") {
       out[key] = "[Function]";
@@ -13331,8 +13361,7 @@ try {
   PLUGIN_VERSION = pkgJson.version ?? "unknown";
 } catch {
 }
-diag("MODULE_LOADED", { BUILD_ID, PLUGIN_VERSION });
-var lastCronSnapshotJson = "";
+diag("MODULE_LOADED", { PLUGIN_VERSION });
 function resolveGatewayToken(api) {
   const rawToken = api.config?.gateway?.auth?.token;
   if (typeof rawToken === "string") return rawToken;
@@ -13341,26 +13370,6 @@ function resolveGatewayToken(api) {
   }
   return null;
 }
-async function quickCronSync(port, token, cfg, resolveAgentName, logger) {
-  const client2 = new GatewayClient2(port, token, logger, PLUGIN_VERSION);
-  try {
-    await client2.connect();
-    const result = await client2.request("cron.list", { includeDisabled: true });
-    diag("GW_CLIENT_CRON_LIST_RESULT", { type: typeof result, isArray: Array.isArray(result), keys: result && typeof result === "object" ? Object.keys(result) : [], length: Array.isArray(result) ? result.length : void 0 });
-    const jobs = Array.isArray(result) ? result : result?.jobs ?? [];
-    const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
-    const serialized = JSON.stringify(mapped);
-    if (serialized !== lastCronSnapshotJson) {
-      await pushCronSnapshot(cfg.apiKey, mapped);
-      lastCronSnapshotJson = serialized;
-      diag("HEARTBEAT_CRON_PUSHED", { count: mapped.length });
-    } else {
-      diag("HEARTBEAT_CRON_UNCHANGED", {});
-    }
-  } finally {
-    client2.close();
-  }
-}
 function registerCronEventHandlers(client2, cfg, resolveAgentName) {
   if (client2.availableEvents.has("cron")) {
     let debounceTimer = null;
@@ -13412,26 +13421,25 @@ function resolveIdentity(configIdentity, workspaceDir) {
     avatar: configIdentity?.avatar ?? fileIdentity?.avatar
   };
 }
+var tracker = null;
 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 = path3.join(
-  path3.dirname(new URL(import.meta.url).pathname),
-  ".session-state.json"
-);
-function saveSessionsToDisk(tracker) {
+  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) {
   try {
-    const state = tracker.exportState();
+    const state = tracker2.exportState();
     const data = {
       sessions: [],
       sessionKeyToAgent: Object.fromEntries(state.sessionKeyToAgent),
-      channelAgents: { ...globalThis["__cohort_sync_channel_agent__"] ?? {} },
+      channelAgents: Object.fromEntries(getChannelAgentBridge()),
       savedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     for (const [name, agent] of state.agents) {
@@ -13443,7 +13451,7 @@ function saveSessionsToDisk(tracker) {
   } catch {
   }
 }
-function loadSessionsFromDisk(tracker, logger) {
+function loadSessionsFromDisk(tracker2, logger) {
   try {
     if (!fs3.existsSync(STATE_FILE_PATH)) return;
     const data = JSON.parse(fs3.readFileSync(STATE_FILE_PATH, "utf8"));
@@ -13453,13 +13461,13 @@ function loadSessionsFromDisk(tracker, logger) {
     }
     let count = 0;
     for (const { agentName, key } of data.sessions) {
-      if (!tracker.hasSession(agentName, key)) {
-        tracker.addSession(agentName, key);
+      if (!tracker2.hasSession(agentName, key)) {
+        tracker2.addSession(agentName, key);
         count++;
       }
     }
     for (const [key, agent] of Object.entries(data.sessionKeyToAgent)) {
-      tracker.setSessionAgent(key, agent);
+      tracker2.setSessionAgent(key, agent);
     }
     for (const [channelId, agent] of Object.entries(data.channelAgents ?? {})) {
       setChannelAgent(channelId, agent);
@@ -13487,15 +13495,48 @@ async function fetchAgentContext(apiKey, apiUrl, logger) {
     return POCKET_GUIDE;
   }
 }
+async function initGatewayClient(port, token, cfg, resolveAgentName, logger) {
+  const client2 = new GatewayClient(port, token, logger, PLUGIN_VERSION);
+  await client2.connect();
+  persistentGwClient = client2;
+  gwClientInitialized = true;
+  registerCronEventHandlers(client2, cfg, resolveAgentName);
+  if (client2.availableEvents.has("shutdown")) {
+    client2.on("shutdown", () => {
+      diag("GW_CLIENT_SHUTDOWN_EVENT", {});
+      logger.info("cohort-sync: gateway shutdown event received");
+    });
+  }
+  client2.onReconnect = async () => {
+    diag("GW_CLIENT_RECONNECTED_RESUBSCRIBE", {});
+    registerCronEventHandlers(client2, cfg, resolveAgentName);
+    try {
+      const cronResult2 = await client2.request("cron.list", { includeDisabled: true });
+      const jobs2 = Array.isArray(cronResult2) ? cronResult2 : cronResult2?.jobs ?? [];
+      const mapped2 = jobs2.map((j) => mapCronJob(j, resolveAgentName));
+      await pushCronSnapshot(cfg.apiKey, mapped2);
+      diag("GW_CLIENT_RECONNECT_CRON_PUSH", { count: mapped2.length });
+    } catch (err) {
+      diag("GW_CLIENT_RECONNECT_CRON_FAILED", { error: String(err) });
+    }
+  };
+  diag("GW_CLIENT_CONNECTED", { methods: client2.availableMethods.size, events: client2.availableEvents.size });
+  const cronResult = await client2.request("cron.list", { includeDisabled: true });
+  const jobs = Array.isArray(cronResult) ? cronResult : cronResult?.jobs ?? [];
+  const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
+  await pushCronSnapshot(cfg.apiKey, mapped);
+  diag("GW_CLIENT_INITIAL_CRON_PUSH", { count: mapped.length });
+}
 function registerHooks(api, cfg) {
+  STATE_FILE_PATH = path3.join(cfg.stateDir, "session-state.json");
   const { logger, config } = api;
   const nameMap = cfg.agentNameMap;
-  const tracker = getOrCreateTracker();
-  let heartbeatInterval = null;
-  let activityFlushInterval = null;
-  logger.info(`cohort-sync: registerHooks [${BUILD_ID}]`);
+  const tracker2 = getOrCreateTracker();
+  const convexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
+  createClient(convexUrl);
+  setLogger(logger);
+  logger.info(`cohort-sync: registerHooks v${PLUGIN_VERSION}`);
   diag("REGISTER_HOOKS", {
-    BUILD_ID,
     PLUGIN_VERSION,
     hasNameMap: !!nameMap,
     nameMapKeys: nameMap ? Object.keys(nameMap) : [],
@@ -13504,10 +13545,6 @@ function registerHooks(api, cfg) {
     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 identityNameMap = {};
   const mainIdentity = parseIdentityFile(process.cwd());
   if (mainIdentity?.name) {
@@ -13520,14 +13557,14 @@ function registerHooks(api, cfg) {
     }
   }
   diag("IDENTITY_NAME_MAP", { identityNameMap });
-  if (tracker.getAgentNames().length === 0) {
-    loadSessionsFromDisk(tracker, logger);
-    const restoredAgents = tracker.getAgentNames();
+  if (tracker2.getAgentNames().length === 0) {
+    loadSessionsFromDisk(tracker2, logger);
+    const restoredAgents = tracker2.getAgentNames();
     for (const agentName of restoredAgents) {
-      const sessSnapshot = tracker.getSessionsSnapshot(agentName);
+      const sessSnapshot = tracker2.getSessionsSnapshot(agentName);
       if (sessSnapshot.length > 0) {
         pushSessions(cfg.apiKey, agentName, sessSnapshot).then(() => {
-          tracker.markSessionsPushed(agentName);
+          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)}`);
@@ -13558,7 +13595,7 @@ function registerHooks(api, cfg) {
     }
     const sessionKey = ctx.sessionKey ?? ctx.sessionId;
     if (sessionKey && typeof sessionKey === "string") {
-      const mapped = tracker.getSessionAgent(sessionKey);
+      const mapped = tracker2.getSessionAgent(sessionKey);
       if (mapped) {
         diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "sessionKey_mapped", sessionKey, mapped });
         return mapped;
@@ -13580,10 +13617,10 @@ function registerHooks(api, cfg) {
     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 } });
+        diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "channelId_bridge", channelId, channelAgent, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
         return channelAgent;
       }
-      diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "channelId_raw", channelId, bridgeState: { ...getHotState().channelAgentBridge } });
+      diag("RESOLVE_AGENT_FROM_CTX_RESULT", { method: "channelId_raw", channelId, bridgeState: Object.fromEntries(getChannelAgentBridge()) });
       return String(channelId);
     }
     const resolved = resolveAgentName("main");
@@ -13604,47 +13641,20 @@ function registerHooks(api, cfg) {
     }
     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)");
-  {
-    const hotState = getHotState();
-    if (hotState.commandSubscription) {
-      hotState.commandSubscription();
-      hotState.commandSubscription = null;
-    }
-    const unsub = initCommandSubscription(cfg, logger, resolveAgentName);
-    hotState.commandSubscription = unsub;
-  }
+  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;
   {
-    const port = api.config?.gateway?.port;
-    const token = resolveGatewayToken(api);
-    if (port && token) {
-      const hotState = getHotState();
-      hotState.gatewayPort = port;
-      hotState.gatewayToken = token;
-      diag("REGISTER_HOOKS_CRON_SYNC", { port });
-      quickCronSync(port, token, cfg, resolveAgentName, logger).catch((err) => {
-        diag("REGISTER_HOOKS_CRON_SYNC_FAILED", { error: String(err) });
-      });
+    if (commandUnsubscriber2) {
+      commandUnsubscriber2();
+      commandUnsubscriber2 = null;
     }
+    const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
+    commandUnsubscriber2 = unsub;
   }
   api.registerTool((toolCtx) => {
     const agentId = toolCtx.agentId ?? "main";
@@ -13760,52 +13770,6 @@ Do not attempt to make more comments until ${resetAt}.`
     if (m.includes("deepseek")) return 128e3;
     return 2e5;
   }
-  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 {
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
-        if (snapshot) {
-          await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-        } else {
-          logger.info(`cohort-sync: heartbeat skipped ${agentName} \u2014 no snapshot in tracker`);
-        }
-      } catch (err) {
-        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 = drainActivityFromHot();
-    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) => {
     diag("HOOK_gateway_start", { port: event.port, eventKeys: Object.keys(event) });
     try {
@@ -13831,24 +13795,20 @@ Do not attempt to make more comments until ${resetAt}.`
         setChannelAgent(mp, agentName);
       }
     }
-    diag("GATEWAY_START_BRIDGE_AFTER_SEED", { bridge: { ...getHotState().channelAgentBridge } });
-    const hotState = getHotState();
-    hotState.gatewayPort = event.port;
+    diag("GATEWAY_START_BRIDGE_AFTER_SEED", { bridge: Object.fromEntries(getChannelAgentBridge()) });
+    gatewayPort = event.port;
     const token = resolveGatewayToken(api);
     if (token) {
+      gatewayToken = token;
       diag("GW_CLIENT_CONNECTING", { port: event.port, hasToken: true });
       try {
-        const client2 = new GatewayClient2(event.port, token, logger, PLUGIN_VERSION);
-        await client2.connect();
-        hotState.gatewayProtocolClient = client2;
-        registerCronEventHandlers(client2, cfg, resolveAgentName);
-        diag("GW_CLIENT_CONNECTED", { methods: client2.availableMethods.size, events: client2.availableEvents.size });
-        const cronResult = await client2.request("cron.list", { includeDisabled: true });
-        const jobs = Array.isArray(cronResult) ? cronResult : cronResult?.jobs ?? [];
-        const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
-        await pushCronSnapshot(cfg.apiKey, mapped);
-        lastCronSnapshotJson = JSON.stringify(mapped);
-        diag("GW_CLIENT_INITIAL_CRON_PUSH", { count: mapped.length });
+        await initGatewayClient(event.port, token, cfg, resolveAgentName, logger);
+        if (commandUnsubscriber2) {
+          commandUnsubscriber2();
+          commandUnsubscriber2 = null;
+        }
+        const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
+        commandUnsubscriber2 = unsub;
       } catch (err) {
         diag("GW_CLIENT_CONNECT_FAILED", { error: String(err) });
         logger.error(`cohort-sync: gateway client connect failed: ${String(err)}`);
@@ -13857,7 +13817,7 @@ Do not attempt to make more comments until ${resetAt}.`
       diag("GW_CLIENT_NO_TOKEN", {});
       logger.warn("cohort-sync: no gateway auth token \u2014 cron operations disabled");
     }
-    await initSubscription(
+    await startNotificationSubscription(
       event.port,
       cfg,
       api.config.hooks?.token,
@@ -13869,31 +13829,48 @@ Do not attempt to make more comments until ${resetAt}.`
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);
       try {
-        tracker.setModel(agentName, resolveModel(agentId));
-        tracker.updateStatus(agentName, "idle");
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        tracker2.setModel(agentName, resolveModel(agentId));
+        tracker2.updateStatus(agentName, "idle");
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker.markTelemetryPushed(agentName);
+          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.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 {
-      tracker.updateStatus(agentName, "idle");
+      tracker2.updateStatus(agentName, "idle");
       await syncAgentStatus(agentName, "idle", resolveModel(agentId), cfg, logger);
-      if (tracker.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+      if (tracker2.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker.markTelemetryPushed(agentName);
+          tracker2.markTelemetryPushed(agentName);
         }
       }
       if (event.success === false) {
@@ -13903,7 +13880,7 @@ Do not attempt to make more comments until ${resetAt}.`
           durationMs: event.durationMs,
           sessionKey: ctx.sessionKey
         });
-        if (entry) addActivityToHot(entry);
+        if (entry) activityBatch.add(entry);
       }
     } catch (err) {
       logger.warn(`cohort-sync: agent_end sync failed: ${String(err)}`);
@@ -13928,31 +13905,31 @@ Do not attempt to make more comments until ${resetAt}.`
     const agentName = resolveAgentName(agentId);
     try {
       const sessionKey = ctx.sessionKey;
-      tracker.updateFromLlmOutput(agentName, sessionKey, {
+      tracker2.updateFromLlmOutput(agentName, sessionKey, {
         model,
         tokensIn: usage.input ?? 0,
         tokensOut: usage.output ?? 0,
         contextTokens,
         contextLimit
       });
-      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
-        tracker.addSession(agentName, sessionKey);
+      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.setSessionAgent(sessionKey, agentName);
+        tracker2.setSessionAgent(sessionKey, agentName);
       }
-      if (tracker.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+      if (tracker2.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker.markTelemetryPushed(agentName);
+          tracker2.markTelemetryPushed(agentName);
         }
       }
-      if (tracker.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
+      if (tracker2.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker.markSessionsPushed(agentName);
+        tracker2.markSessionsPushed(agentName);
       }
     } catch (err) {
       logger.warn(`cohort-sync: llm_output telemetry failed: ${String(err)}`);
@@ -13963,15 +13940,15 @@ Do not attempt to make more comments until ${resetAt}.`
     const agentId = ctx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
     try {
-      tracker.updateFromCompaction(agentName, {
+      tracker2.updateFromCompaction(agentName, {
         contextTokens: event.tokenCount ?? 0,
         contextLimit: getModelContextLimit(resolveModel(agentId))
       });
-      if (tracker.shouldPushTelemetry(agentName)) {
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+      if (tracker2.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker.markTelemetryPushed(agentName);
+          tracker2.markTelemetryPushed(agentName);
         }
       }
       const entry = buildActivityEntry(agentName, "after_compaction", {
@@ -13979,7 +13956,7 @@ Do not attempt to make more comments until ${resetAt}.`
         compactedCount: event.compactedCount,
         sessionKey: ctx.sessionKey
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: after_compaction telemetry failed: ${String(err)}`);
     }
@@ -13990,26 +13967,39 @@ Do not attempt to make more comments until ${resetAt}.`
     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)) {
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+      if (!gwClientInitialized && gatewayPort && gatewayToken) {
+        try {
+          await initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, logger);
+          if (commandUnsubscriber2) {
+            commandUnsubscriber2();
+            commandUnsubscriber2 = null;
+          }
+          const unsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
+          commandUnsubscriber2 = unsub;
+        } catch (err) {
+          diag("GW_CLIENT_LAZY_INIT_FAILED", { error: String(err) });
+        }
+      }
+      tracker2.updateStatus(agentName, "working");
+      if (tracker2.shouldPushTelemetry(agentName)) {
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
-          tracker.markTelemetryPushed(agentName);
+          tracker2.markTelemetryPushed(agentName);
         }
       }
       const sessionKey = ctx.sessionKey;
-      if (sessionKey && !tracker.hasSession(agentName, sessionKey)) {
-        tracker.addSession(agentName, sessionKey);
-        tracker.setSessionAgent(sessionKey, agentName);
+      if (sessionKey && !tracker2.hasSession(agentName, sessionKey)) {
+        tracker2.addSession(agentName, sessionKey);
+        tracker2.setSessionAgent(sessionKey, agentName);
         logger.info(`cohort-sync: inferred session for ${agentName} (${sessionKey})`);
-        if (tracker.shouldPushSessions(agentName)) {
-          const sessSnapshot = tracker.getSessionsSnapshot(agentName);
+        if (tracker2.shouldPushSessions(agentName)) {
+          const sessSnapshot = tracker2.getSessionsSnapshot(agentName);
           await pushSessions(cfg.apiKey, agentName, sessSnapshot);
-          tracker.markSessionsPushed(agentName);
+          tracker2.markSessionsPushed(agentName);
         }
       } else if (sessionKey) {
-        tracker.setSessionAgent(sessionKey, agentName);
+        tracker2.setSessionAgent(sessionKey, agentName);
       }
       const ctxChannelId = ctx.channelId;
       if (ctxChannelId) {
@@ -14029,11 +14019,11 @@ Do not attempt to make more comments until ${resetAt}.`
     const agentName = resolveAgentName(agentId);
     try {
       const sessionKey = ctx.sessionId ?? String(Date.now());
-      tracker.addSession(agentName, sessionKey);
-      if (tracker.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
+      tracker2.addSession(agentName, sessionKey);
+      if (tracker2.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker.markSessionsPushed(agentName);
+        tracker2.markSessionsPushed(agentName);
       }
       const parsed = parseSessionKey(sessionKey);
       const entry = buildActivityEntry(agentName, "session_start", {
@@ -14041,7 +14031,7 @@ Do not attempt to make more comments until ${resetAt}.`
         sessionKey,
         resumedFrom: event.resumedFrom
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: session_start tracking failed: ${String(err)}`);
     }
@@ -14052,18 +14042,18 @@ Do not attempt to make more comments until ${resetAt}.`
     const agentName = resolveAgentName(agentId);
     try {
       const sessionKey = ctx.sessionId ?? "";
-      tracker.removeSession(agentName, sessionKey);
-      if (tracker.shouldPushSessions(agentName)) {
-        const sessionsSnapshot = tracker.getSessionsSnapshot(agentName);
+      tracker2.removeSession(agentName, sessionKey);
+      if (tracker2.shouldPushSessions(agentName)) {
+        const sessionsSnapshot = tracker2.getSessionsSnapshot(agentName);
         await pushSessions(cfg.apiKey, agentName, sessionsSnapshot);
-        tracker.markSessionsPushed(agentName);
+        tracker2.markSessionsPushed(agentName);
       }
       const entry = buildActivityEntry(agentName, "session_end", {
         sessionKey,
         messageCount: event.messageCount,
         durationMs: event.durationMs
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: session_end tracking failed: ${String(err)}`);
     }
@@ -14080,7 +14070,7 @@ Do not attempt to make more comments until ${resetAt}.`
         sessionKey: ctx.sessionKey,
         model: resolveModel(ctx.agentId ?? "main")
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: after_tool_call activity failed: ${String(err)}`);
     }
@@ -14089,7 +14079,7 @@ Do not attempt to make more comments until ${resetAt}.`
     diag("HOOK_message_received_RAW", {
       ctx: dumpCtx(ctx),
       event: dumpEvent(_event),
-      bridgeStateBefore: { ...getHotState().channelAgentBridge }
+      bridgeStateBefore: Object.fromEntries(getChannelAgentBridge())
     });
     const agentName = resolveAgentFromContext(ctx);
     const channel = ctx.channelId;
@@ -14104,7 +14094,7 @@ Do not attempt to make more comments until ${resetAt}.`
       const entry = buildActivityEntry(agentName, "message_received", {
         channel: channel ?? "unknown"
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: message_received activity failed: ${String(err)}`);
     }
@@ -14113,7 +14103,7 @@ Do not attempt to make more comments until ${resetAt}.`
     diag("HOOK_message_sent_RAW", {
       ctx: dumpCtx(ctx),
       event: dumpEvent(event),
-      bridgeStateBefore: { ...getHotState().channelAgentBridge }
+      bridgeStateBefore: Object.fromEntries(getChannelAgentBridge())
     });
     const agentName = resolveAgentFromContext(ctx);
     const channel = ctx.channelId;
@@ -14132,7 +14122,7 @@ Do not attempt to make more comments until ${resetAt}.`
         success: event.success,
         error: event.error
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: message_sent activity failed: ${String(err)}`);
     }
@@ -14145,7 +14135,7 @@ Do not attempt to make more comments until ${resetAt}.`
       const entry = buildActivityEntry(agentName, "before_compaction", {
         sessionKey: ctx.sessionKey
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: before_compaction activity failed: ${String(err)}`);
     }
@@ -14159,25 +14149,24 @@ Do not attempt to make more comments until ${resetAt}.`
         reason: event.reason,
         sessionKey: ctx.sessionKey
       });
-      if (entry) addActivityToHot(entry);
+      if (entry) activityBatch.add(entry);
     } catch (err) {
       logger.warn(`cohort-sync: before_reset activity failed: ${String(err)}`);
     }
   });
   api.on("gateway_stop", async () => {
-    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)}`);
-    });
+    diag("HOOK_gateway_stop", { bridgeState: Object.fromEntries(getChannelAgentBridge()) });
+    if (keepaliveInterval) {
+      clearInterval(keepaliveInterval);
+      keepaliveInterval = null;
+    }
+    activityBatch.drain();
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);
       try {
-        tracker.updateStatus(agentName, "unreachable");
-        const snapshot = tracker.getTelemetrySnapshot(agentName);
+        tracker2.updateStatus(agentName, "unreachable");
+        const snapshot = tracker2.getTelemetrySnapshot(agentName);
         if (snapshot) {
           await pushTelemetry(cfg.apiKey, { ...snapshot, pluginVersion: PLUGIN_VERSION });
         }
@@ -14185,15 +14174,20 @@ Do not attempt to make more comments until ${resetAt}.`
         logger.warn(`cohort-sync: final unreachable push failed for ${agentName}: ${String(err)}`);
       }
     }
-    saveSessionsToDisk(tracker);
+    saveSessionsToDisk(tracker2);
+    if (persistentGwClient) {
+      persistentGwClient.close();
+      persistentGwClient = null;
+      gwClientInitialized = false;
+    }
     try {
       await markAllUnreachable(cfg, logger);
     } catch (err) {
       logger.warn(`cohort-sync: markAllUnreachable failed: ${String(err)}`);
     }
-    tracker.clear();
-    closeSubscription();
-    logger.info("cohort-sync: subscription closed");
+    tracker2.clear();
+    closeBridge();
+    logger.info("cohort-sync: gateway stopped, all resources cleaned up");
   });
 }
 
@@ -14299,7 +14293,7 @@ function registerCohortCli(ctx, cfg) {
         agents.push({ id, name });
       }
     } else {
-      agents.push({ id: "main", name: "openclaw-cohort-sync" });
+      agents.push({ id: "main", name: "main" });
     }
     const manifest = { agents };
     logger.info("cohort: Starting device authorization...");
@@ -14359,40 +14353,10 @@ function registerCohortCli(ctx, cfg) {
 // index.ts
 init_keychain();
 var DEFAULT_API_URL = "https://fortunate-chipmunk-286.convex.site";
-async function doActivate(api) {
-  const cfg = api.pluginConfig;
-  const apiUrl = cfg?.apiUrl ?? DEFAULT_API_URL;
-  api.logger.info(`cohort-sync: activating (api: ${apiUrl})`);
-  let apiKey = cfg?.apiKey;
-  if (!apiKey) {
-    try {
-      apiKey = await getCredential(apiUrl) ?? void 0;
-    } catch (err) {
-      api.logger.error(
-        `cohort-sync: keychain lookup failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  if (!apiKey) {
-    api.logger.warn(
-      "cohort-sync: no API key found \u2014 run 'openclaw cohort auth' to authenticate"
-    );
-    return;
-  }
-  api.logger.info(`cohort-sync: activated (api: ${apiUrl})`);
-  registerHooks(api, {
-    apiUrl,
-    apiKey,
-    agentNameMap: cfg?.agentNameMap
-  });
-}
 var plugin = {
   id: "cohort-sync",
   name: "Cohort Sync",
   description: "Syncs agent status and skills to Cohort dashboard",
-  // register() is synchronous — the SDK does not await it.
-  // We register CLI here, then self-activate async (the gateway does not
-  // call activate() for extension-directory plugins).
   register(api) {
     const cfg = api.pluginConfig;
     const apiUrl = cfg?.apiUrl ?? DEFAULT_API_URL;
@@ -14404,15 +14368,39 @@ var plugin = {
       }),
       { commands: ["cohort"] }
     );
-    doActivate(api).catch(
-      (err) => api.logger.error(
-        `cohort-sync: self-activation failed: ${err instanceof Error ? err.message : String(err)}`
-      )
-    );
-  },
-  // activate() kept for forward-compatibility if gateway adds activate() support.
-  async activate(api) {
-    return doActivate(api);
+    api.registerService({
+      id: "cohort-sync-core",
+      async start(svcCtx) {
+        api.logger.info(`cohort-sync: service starting (api: ${apiUrl})`);
+        let apiKey = cfg?.apiKey;
+        if (!apiKey) {
+          try {
+            apiKey = await getCredential(apiUrl) ?? void 0;
+          } catch (err) {
+            api.logger.error(
+              `cohort-sync: keychain lookup failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        if (!apiKey) {
+          api.logger.warn(
+            "cohort-sync: no API key found \u2014 run 'openclaw cohort auth' to authenticate"
+          );
+          return;
+        }
+        api.logger.info(`cohort-sync: activated (api: ${apiUrl})`);
+        registerHooks(api, {
+          apiUrl,
+          apiKey,
+          stateDir: svcCtx.stateDir,
+          agentNameMap: cfg?.agentNameMap
+        });
+      },
+      async stop() {
+        closeBridge();
+        api.logger.info("cohort-sync: service stopped");
+      }
+    });
   }
 };
 var index_default = plugin;