@cfio/cohort-sync 0.4.8 → 0.6.0

package/dist/index.js

@@ -88,9 +88,8 @@ var init_keychain = __esm({
 });
 
 // src/hooks.ts
-import fs2 from "node:fs";
-import os2 from "node:os";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
@@ -2700,9 +2699,6 @@ var Type = type_exports2;
 
 // src/sync.ts
 import { execSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 
 // ../../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";
@@ -4558,12 +4554,12 @@ function createApi(pathParts = []) {
             `API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`${found}\``
           );
         }
-        const path3 = pathParts.slice(0, -1).join("/");
+        const path4 = pathParts.slice(0, -1).join("/");
         const exportName = pathParts[pathParts.length - 1];
         if (exportName === "default") {
-          return path3;
+          return path4;
         } else {
-          return path3 + ":" + exportName;
+          return path4 + ":" + exportName;
         }
       } else if (prop === Symbol.toStringTag) {
         return "FunctionReference";
@@ -7632,8 +7628,8 @@ var require_constants = __commonJS({
 });
 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 fs3 = __require("fs");
-    var path3 = __require("path");
+    var fs4 = __require("fs");
+    var path4 = __require("path");
     var os3 = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars = process.config && process.config.variables || {};
@@ -7650,21 +7646,21 @@ var require_node_gyp_build = __commonJS({
       return runtimeRequire(load.resolve(dir));
     }
     load.resolve = load.path = function(dir) {
-      dir = path3.resolve(dir || ".");
+      dir = path4.resolve(dir || ".");
       try {
-        var name = runtimeRequire(path3.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        var name = runtimeRequire(path4.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
         if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
       } catch (err) {
       }
       if (!prebuildsOnly) {
-        var release = getFirst(path3.join(dir, "build/Release"), matchBuild);
+        var release = getFirst(path4.join(dir, "build/Release"), matchBuild);
         if (release) return release;
-        var debug = getFirst(path3.join(dir, "build/Debug"), matchBuild);
+        var debug = getFirst(path4.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
       var prebuild = resolve(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve(path3.dirname(process.execPath));
+      var nearby = resolve(path4.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform,
@@ -7681,26 +7677,26 @@ var require_node_gyp_build = __commonJS({
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
       function resolve(dir2) {
-        var tuples = readdirSync(path3.join(dir2, "prebuilds")).map(parseTuple);
+        var tuples = readdirSync(path4.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple) return;
-        var prebuilds = path3.join(dir2, "prebuilds", tuple.name);
+        var prebuilds = path4.join(dir2, "prebuilds", tuple.name);
         var parsed = readdirSync(prebuilds).map(parseTags);
         var candidates = parsed.filter(matchTags(runtime, abi));
         var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path3.join(prebuilds, winner.file);
+        if (winner) return path4.join(prebuilds, winner.file);
       }
     };
     function readdirSync(dir) {
       try {
-        return fs3.readdirSync(dir);
+        return fs4.readdirSync(dir);
       } catch (err) {
         return [];
       }
     }
     function getFirst(dir, filter) {
       var files = readdirSync(dir).filter(filter);
-      return files[0] && path3.join(dir, files[0]);
+      return files[0] && path4.join(dir, files[0]);
     }
     function matchBuild(name) {
       return /\.node$/.test(name);
@@ -7787,7 +7783,7 @@ var require_node_gyp_build = __commonJS({
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
     function isAlpine(platform2) {
-      return platform2 === "linux" && fs3.existsSync("/etc/alpine-release");
+      return platform2 === "linux" && fs4.existsSync("/etc/alpine-release");
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -11506,8 +11502,47 @@ var _systemSchema = defineSchema({
   })
 });
 
+// src/cron-mapping.ts
+function formatSchedule(s) {
+  switch (s.kind) {
+    case "cron":
+      return s.expr ?? "";
+    case "every":
+      return `every ${humanizeMs(s.everyMs ?? 0)}`;
+    case "at":
+      return `once at ${s.at ?? ""}`;
+    default:
+      return s.kind;
+  }
+}
+function humanizeMs(ms) {
+  if (ms >= 864e5) return `${Math.round(ms / 864e5)}d`;
+  if (ms >= 36e5) return `${Math.round(ms / 36e5)}h`;
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function mapCronJob(job, resolveAgentName) {
+  return {
+    id: job.id,
+    text: job.name,
+    schedule: formatSchedule(job.schedule),
+    enabled: job.enabled,
+    agentId: resolveAgentName(job.agentId ?? "main"),
+    nextRun: job.state?.nextRunAtMs,
+    lastRun: job.state?.lastRunAtMs,
+    lastStatus: job.state?.lastRunStatus,
+    lastError: job.state?.lastError ?? null
+  };
+}
+function reverseResolveAgentName(cohortName, forwardMap) {
+  const lower = cohortName.toLowerCase();
+  for (const [openclawId, name] of Object.entries(forwardMap)) {
+    if (name.toLowerCase() === lower) return openclawId;
+  }
+  return cohortName;
+}
+
 // src/subscription.ts
-import { execFileSync } from "node:child_process";
 function deriveConvexUrl(apiUrl) {
   return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
 }
@@ -11605,7 +11640,11 @@ function getHotState() {
       lastKnownRoster: [],
       intervals: { heartbeat: null, activityFlush: null },
       activityBuffer: [],
-      channelAgentBridge: {}
+      channelAgentBridge: {},
+      gatewayPort: null,
+      gatewayToken: null,
+      gatewayProtocolClient: null,
+      commandSubscription: null
     };
     globalThis[HOT_KEY] = state;
   }
@@ -11736,7 +11775,7 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
   const c = getOrCreateClient();
   if (!c) {
     logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
-    return;
+    return null;
   }
   let processing = false;
   const unsubscribe = c.onUpdate(
@@ -11760,19 +11799,113 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
               process.kill(process.pid, "SIGTERM");
               return;
             }
-            if (cmd.type.startsWith("cron") && cmd.payload?.jobId) {
-              handleCronCommand(cmd.type, cmd.payload.jobId, logger);
+            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 {
-                const freshJobs = fetchCronJobs(logger);
-                if (freshJobs !== null) {
-                  const resolvedJobs = resolveAgentName ? freshJobs.map((j) => ({ ...j, agentId: j.agentId ? resolveAgentName(j.agentId) : j.agentId })) : freshJobs;
-                  await pushCronSnapshot(cfg.apiKey, resolvedJobs);
+                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)}`);
+                  }
                 }
-              } catch (snapErr) {
-                logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
+              } finally {
+                gwClient.close();
               }
-            } else if (cmd.type.startsWith("cron")) {
-              logger.warn(`cohort-sync: cron command missing jobId: ${cmd.type}`);
             } else {
               logger.warn(`cohort-sync: unknown command type: ${cmd.type}`);
             }
@@ -11788,34 +11921,8 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
       logger.error(`cohort-sync: command subscription error: ${String(err)}`);
     }
   );
-  unsubscribers.push(unsubscribe);
-  getHotState().unsubscribers = [...unsubscribers];
   logger.info("cohort-sync: command subscription active");
-}
-function handleCronCommand(type, jobId, logger) {
-  const subcommandMap = {
-    cronEnable: ["cron", "enable", jobId],
-    cronDisable: ["cron", "disable", jobId],
-    cronRunNow: ["cron", "run", jobId],
-    cronDelete: ["cron", "delete", jobId, "--force"]
-  };
-  const args = subcommandMap[type];
-  if (!args) {
-    logger.warn(`cohort-sync: unknown cron command type: ${type}`);
-    return;
-  }
-  const timeout = type === "cronRunNow" ? 3e4 : 15e3;
-  try {
-    execFileSync("openclaw", args, {
-      encoding: "utf8",
-      timeout,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    logger.info(`cohort-sync: cron command ${type} executed for job ${jobId}`);
-  } catch (err) {
-    logger.error(`cohort-sync: cron command ${type} failed for job ${jobId}: ${String(err)}`);
-    throw err;
-  }
+  return unsubscribe;
 }
 async function callAddCommentFromPlugin(apiKey, args) {
   const c = getOrCreateClient();
@@ -11845,6 +11952,20 @@ function closeSubscription() {
     } catch {
     }
   }
+  if (state.commandSubscription) {
+    try {
+      state.commandSubscription();
+    } catch {
+    }
+    state.commandSubscription = null;
+  }
+  if (state.gatewayProtocolClient) {
+    try {
+      state.gatewayProtocolClient.close();
+    } catch {
+    }
+    state.gatewayProtocolClient = null;
+  }
   client?.close();
   client = null;
   clearHotState();
@@ -11918,10 +12039,6 @@ function getChannelAgent(channelId) {
 }
 
 // src/sync.ts
-var cronStorePath = null;
-function setCronStorePath(p) {
-  cronStorePath = p;
-}
 function extractJson(raw) {
   const jsonStart = raw.search(/[\[{]/);
   const jsonEndBracket = raw.lastIndexOf("]");
@@ -11953,73 +12070,35 @@ function fetchSkills(logger) {
     return [];
   }
 }
-function fetchCronJobs(logger) {
-  try {
-    const storePath = cronStorePath ?? path.join(os.homedir(), ".openclaw", "cron", "jobs.json");
-    if (!fs.existsSync(storePath)) {
-      logger.warn(`cohort-sync: cron store not found at ${storePath}`);
-      return null;
-    }
-    const raw = fs.readFileSync(storePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
-    return jobs.map((j) => ({
-      id: String(j.id ?? "unknown"),
-      text: String(j.name ?? ""),
-      schedule: formatSchedule(j.schedule),
-      ...j.state?.nextRunAtMs != null ? { nextRun: Number(j.state.nextRunAtMs) } : {},
-      ...j.state?.lastRunAtMs != null ? { lastRun: Number(j.state.lastRunAtMs) } : {},
-      ...j.state?.lastStatus ? { lastStatus: String(j.state.lastStatus) } : {},
-      enabled: j.enabled !== false,
-      ...j.agentId != null ? { agentId: String(j.agentId) } : {}
-    }));
-  } catch (err) {
-    logger.warn(`cohort-sync: failed to read cron store: ${String(err)}`);
-    return null;
-  }
-}
-function formatSchedule(schedule) {
-  if (typeof schedule === "string") return schedule;
-  if (schedule && typeof schedule === "object") {
-    const s = schedule;
-    if (s.kind === "cron" && typeof s.expr === "string") return s.expr;
-    if (s.kind === "interval" && typeof s.everyMs === "number") {
-      const mins = Math.floor(Number(s.everyMs) / 6e4);
-      if (mins > 0) return `*/${mins} * * * *`;
-      return `every ${s.everyMs}ms`;
-    }
-  }
-  return String(schedule);
-}
 var VALID_STATUSES = /* @__PURE__ */ new Set(["idle", "working", "waiting"]);
 function normalizeStatus(status) {
   return VALID_STATUSES.has(status) ? status : "idle";
 }
-async function v1Get(apiUrl, apiKey, path3) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+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 ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`GET ${path4} \u2192 ${res.status}`);
   return res.json();
 }
-async function v1Patch(apiUrl, apiKey, path3, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+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 ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`PATCH ${path4} \u2192 ${res.status}`);
 }
-async function v1Post(apiUrl, apiKey, path3, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+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 ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`POST ${path4} \u2192 ${res.status}`);
 }
 async function checkForUpdate(currentVersion, logger) {
   try {
@@ -12187,6 +12266,543 @@ async function fullSync(agentName, model, cfg, logger, openClawAgents) {
   logger.info("cohort-sync: full sync complete");
 }
 
+// src/gateway-client.ts
+import crypto2 from "node:crypto";
+
+// src/diag.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+var LOG_DIR = path.join(os.homedir(), ".openclaw", "logs", "cohort-sync");
+var LOG_PATH = path.join(LOG_DIR, "diag.log");
+var LOG_PATH_ROTATED = path.join(LOG_DIR, "diag.log.1");
+var MAX_LOG_SIZE = 5 * 1024 * 1024;
+var isDebug = process.env.COHORT_SYNC_DEBUG === "1";
+try {
+  fs.mkdirSync(LOG_DIR, { recursive: true, mode: 448 });
+} catch {
+}
+var writesSinceCheck = 0;
+function diag(label, data) {
+  if (!isDebug && !label.startsWith("HOOK_") && !label.startsWith("MODULE_") && !label.startsWith("REGISTER_") && !label.startsWith("GW_WS_AUTH") && !label.startsWith("GW_WS_CLOSED") && !label.startsWith("GW_WS_ERROR") && !label.startsWith("GW_CLIENT_") && !label.startsWith("HEARTBEAT_CRON")) {
+    return;
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const sanitized = data ? " " + JSON.stringify(data, (_k, v2) => {
+    if (typeof v2 === "string" && v2.length > 200) return v2.slice(0, 200) + "\u2026";
+    return v2;
+  }) : "";
+  const line = `[${ts}] ${label}${sanitized}
+`;
+  try {
+    fs.appendFileSync(LOG_PATH, line, { mode: 384 });
+    if (++writesSinceCheck >= 100) {
+      writesSinceCheck = 0;
+      const stat = fs.statSync(LOG_PATH);
+      if (stat.size > MAX_LOG_SIZE) {
+        try {
+          fs.unlinkSync(LOG_PATH_ROTATED);
+        } catch {
+        }
+        fs.renameSync(LOG_PATH, LOG_PATH_ROTATED);
+      }
+    }
+  } catch {
+  }
+}
+
+// src/device-identity-crypto.ts
+import crypto from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+import os2 from "node:os";
+var IDENTITY_PATH = path2.join(os2.homedir(), ".openclaw", "extensions", "cohort-sync", ".device-identity.json");
+function loadOrCreateDeviceIdentity() {
+  try {
+    const data = JSON.parse(fs2.readFileSync(IDENTITY_PATH, "utf-8"));
+    if (data.deviceId && data.publicKeyPem && data.privateKeyPem) {
+      diag("GW_CLIENT_DEVICE_IDENTITY_LOADED", { deviceId: data.deviceId });
+      return data;
+    }
+  } catch {
+  }
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const publicKeyDer = publicKey.export({ type: "spki", format: "der" });
+  const rawPublicKey = publicKeyDer.subarray(publicKeyDer.length - 32);
+  const deviceId = crypto.createHash("sha256").update(rawPublicKey).digest("hex");
+  const identity = { deviceId, publicKeyPem, privateKeyPem };
+  try {
+    fs2.writeFileSync(IDENTITY_PATH, JSON.stringify(identity, null, 2), { mode: 384 });
+    diag("GW_CLIENT_DEVICE_IDENTITY_CREATED", { deviceId });
+  } catch (err) {
+    diag("GW_CLIENT_DEVICE_IDENTITY_WRITE_FAILED", { error: String(err) });
+  }
+  return identity;
+}
+function normalizeMetadata(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  return trimmed.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
+}
+function buildDeviceAuthPayloadV3(params) {
+  return [
+    "v3",
+    params.deviceId,
+    params.clientId,
+    params.clientMode,
+    params.role,
+    params.scopes.join(","),
+    String(params.signedAtMs),
+    params.token ?? "",
+    params.nonce,
+    normalizeMetadata(params.platform),
+    normalizeMetadata(params.deviceFamily)
+  ].join("|");
+}
+function signPayload(privateKeyPem, payload) {
+  const key = crypto.createPrivateKey(privateKeyPem);
+  const signature = crypto.sign(null, Buffer.from(payload, "utf-8"), key);
+  return signature.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+
+// src/gateway-client.ts
+var ALLOWED_METHODS = /* @__PURE__ */ new Set([
+  "cron.list",
+  "cron.add",
+  "cron.update",
+  "cron.remove",
+  "cron.run",
+  "cron.runs",
+  "cron.status",
+  "channels.status",
+  "sessions.list",
+  "sessions.preview",
+  "agent",
+  "snapshot",
+  "system.presence"
+]);
+function buildConnectFrame(id, token, pluginVersion, identity, nonce) {
+  const signedAtMs = Date.now();
+  const payload = buildDeviceAuthPayloadV3({
+    deviceId: identity.deviceId,
+    clientId: "gateway-client",
+    clientMode: "backend",
+    role: "operator",
+    scopes: ["operator.read", "operator.write"],
+    signedAtMs,
+    token,
+    nonce,
+    platform: process.platform,
+    deviceFamily: null
+  });
+  const signature = signPayload(identity.privateKeyPem, payload);
+  return {
+    type: "req",
+    id,
+    method: "connect",
+    params: {
+      minProtocol: 3,
+      maxProtocol: 3,
+      client: {
+        id: "gateway-client",
+        version: pluginVersion,
+        platform: process.platform,
+        mode: "backend"
+      },
+      role: "operator",
+      scopes: ["operator.read", "operator.write"],
+      auth: { token },
+      device: {
+        id: identity.deviceId,
+        publicKey: identity.publicKeyPem,
+        signature,
+        signedAt: signedAtMs,
+        nonce
+      },
+      locale: "en-US",
+      userAgent: `cohort-sync/${pluginVersion}`
+    }
+  };
+}
+function parseHelloOk(response) {
+  if (!response.ok) {
+    const msg = response.error?.message ?? "unknown error";
+    throw new Error(`Gateway connect error: ${msg}`);
+  }
+  const payload = response.payload;
+  if (payload?.type === "hello-error") {
+    const msg = payload.message ?? "unknown error";
+    throw new Error(`hello-error: ${msg}`);
+  }
+  if (payload?.type !== "hello-ok") {
+    throw new Error(`Unexpected payload type: ${String(payload?.type ?? "missing")}`);
+  }
+  const policy = payload.policy ?? {};
+  const methods = payload.methods ?? [];
+  const events = payload.events ?? [];
+  return {
+    methods: new Set(methods),
+    events: new Set(events),
+    tickIntervalMs: policy.tickIntervalMs ?? 15e3,
+    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 {
+  port;
+  logger;
+  ws = null;
+  alive = false;
+  tickWatchdog = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  closed = false;
+  eventHandlers = /* @__PURE__ */ new Map();
+  pluginVersion;
+  tickIntervalMs = 15e3;
+  // default; overwritten by hello-ok response
+  deviceIdentity;
+  /** Public Sets populated from hello-ok — consumers can inspect gateway capabilities */
+  availableMethods = /* @__PURE__ */ new Set();
+  availableEvents = /* @__PURE__ */ new Set();
+  /**
+   * @param port - Gateway WebSocket port
+   * @param token - Auth token (stored in closure via constructor param, NOT on this or globalThis)
+   * @param logger - RuntimeLogger from plugin SDK
+   * @param pluginVersion - Version string for the connect frame userAgent
+   */
+  constructor(port, token, logger, pluginVersion = "0.5.0") {
+    this.port = port;
+    this.logger = logger;
+    this.pluginVersion = pluginVersion;
+    this.deviceIdentity = loadOrCreateDeviceIdentity();
+    this._getToken = () => token;
+  }
+  /** Token accessor — closure over constructor param */
+  _getToken;
+  /**
+   * Connect to the gateway, perform the protocol v3 handshake, and start
+   * the tick watchdog.
+   *
+   * Flow:
+   *  1. Open WebSocket to ws://127.0.0.1:{port}
+   *  2. Wait up to 500ms for connect.challenge event (optional)
+   *  3. Send connect request frame
+   *  4. Wait for hello-ok response
+   *  5. Start tick watchdog at 2.5x tickIntervalMs
+   */
+  async connect() {
+    if (this.closed) throw new Error("GatewayClient has been closed");
+    diag("GW_CLIENT_CONNECTING", { port: this.port });
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${this.port}`);
+      this.ws = ws;
+      let settled = false;
+      const settle = (err) => {
+        if (settled) return;
+        settled = true;
+        if (err) {
+          this.alive = false;
+          reject(err);
+        } else {
+          resolve();
+        }
+      };
+      const handshakeTimeout = setTimeout(() => {
+        settle(new Error("Gateway handshake timed out after 10000ms"));
+        ws.close();
+      }, 1e4);
+      ws.addEventListener("open", () => {
+        diag("GW_CLIENT_WS_OPEN", { port: this.port });
+        let challengeReceived = false;
+        let challengeNonce = "";
+        const challengeTimer = setTimeout(() => {
+          if (!challengeReceived) {
+            diag("GW_CLIENT_NO_CHALLENGE", { waited: 500 });
+            sendConnect();
+          }
+        }, 500);
+        const onChallengeMessage = (event) => {
+          try {
+            const data = JSON.parse(String(event.data));
+            if (data.type === "event" && data.event === "connect.challenge") {
+              challengeReceived = true;
+              clearTimeout(challengeTimer);
+              challengeNonce = data.payload?.nonce ?? "";
+              diag("GW_CLIENT_CHALLENGE_RECEIVED", { hasNonce: !!challengeNonce });
+              sendConnect();
+            }
+          } catch {
+          }
+        };
+        ws.addEventListener("message", onChallengeMessage);
+        const sendConnect = () => {
+          ws.removeEventListener("message", onChallengeMessage);
+          const id = crypto2.randomUUID();
+          const frame = buildConnectFrame(
+            id,
+            this._getToken(),
+            this.pluginVersion,
+            this.deviceIdentity,
+            challengeNonce
+          );
+          diag("GW_CLIENT_SENDING_CONNECT", { id, protocol: 3 });
+          ws.send(JSON.stringify(frame));
+          const onHelloMessage = (event) => {
+            try {
+              const data = JSON.parse(String(event.data));
+              if (data.type === "res" && data.id === id) {
+                ws.removeEventListener("message", onHelloMessage);
+                clearTimeout(handshakeTimeout);
+                try {
+                  const result = parseHelloOk(data);
+                  this.availableMethods = result.methods;
+                  this.availableEvents = result.events;
+                  this.tickIntervalMs = result.tickIntervalMs;
+                  this.alive = true;
+                  this.reconnectAttempts = 0;
+                  diag("GW_CLIENT_HELLO_OK", {
+                    methods: result.methods.size,
+                    events: result.events.size,
+                    tickIntervalMs: result.tickIntervalMs
+                  });
+                  this.startTickWatchdog(result.tickIntervalMs);
+                  ws.addEventListener("message", (ev) => this.handleMessage(ev));
+                  if (result.snapshot) {
+                    this.emit("snapshot", result.snapshot);
+                  }
+                  this.logger.info("cohort-sync: gateway client connected (protocol v3)");
+                  settle();
+                } catch (err) {
+                  diag("GW_CLIENT_HELLO_FAILED", { error: String(err) });
+                  settle(err instanceof Error ? err : new Error(String(err)));
+                  ws.close();
+                }
+              }
+            } catch {
+            }
+          };
+          ws.addEventListener("message", onHelloMessage);
+        };
+      });
+      ws.addEventListener("close", () => {
+        clearTimeout(handshakeTimeout);
+        this.alive = false;
+        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) {
+          clearTimeout(entry.timer);
+          entry.reject(new Error("Gateway WebSocket closed"));
+        }
+        pending.clear();
+        if (!settled) {
+          settle(new Error("Gateway WebSocket closed during handshake"));
+        }
+        if (!this.closed) {
+          this.scheduleReconnect();
+        }
+      });
+      ws.addEventListener("error", (err) => {
+        diag("GW_CLIENT_WS_ERROR", { error: String(err) });
+        this.logger.error(`cohort-sync: gateway client WS error: ${String(err)}`);
+      });
+    });
+  }
+  /**
+   * Whether the WebSocket is open and the handshake completed successfully.
+   */
+  isAlive() {
+    return this.alive && this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Register an event handler for gateway events (tick, cron.changed, etc.).
+   */
+  on(event, handler) {
+    let handlers = this.eventHandlers.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.eventHandlers.set(event, handlers);
+    }
+    handlers.add(handler);
+  }
+  /**
+   * Send a request to the gateway and wait for the response.
+   *
+   * Validates the method against ALLOWED_METHODS to prevent accidentally
+   * calling admin or unauthorized methods.
+   */
+  async request(method, params, timeoutMs = 1e4) {
+    if (!ALLOWED_METHODS.has(method)) {
+      throw new Error(`Method "${method}" is not in ALLOWED_METHODS`);
+    }
+    if (!this.isAlive()) {
+      throw new Error("Gateway client is not connected");
+    }
+    const id = crypto2.randomUUID();
+    const frame = {
+      type: "req",
+      id,
+      method,
+      params
+    };
+    const pending = getPendingRequests();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Gateway method "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      pending.set(id, {
+        resolve,
+        reject,
+        timer
+      });
+      this.ws.send(JSON.stringify(frame));
+    });
+  }
+  /**
+   * Clean shutdown — close WebSocket, clear timers, reject pending requests.
+   */
+  close() {
+    this.closed = true;
+    this.alive = false;
+    this.stopTickWatchdog();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const pending = getPendingRequests();
+    for (const [, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("Gateway client closed"));
+    }
+    pending.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    diag("GW_CLIENT_CLOSED", { port: this.port });
+    this.logger.info("cohort-sync: gateway client closed");
+  }
+  // -------------------------------------------------------------------------
+  // Private methods
+  // -------------------------------------------------------------------------
+  /**
+   * Route incoming WebSocket messages to the appropriate handler.
+   *
+   * Frame types:
+   *  - "res" → resolve/reject a pending request
+   *  - "event" → dispatch to registered event handlers; reset tick watchdog on tick
+   */
+  handleMessage(event) {
+    try {
+      const data = JSON.parse(String(event.data));
+      if (data.type === "res") {
+        this.handleResponse(data);
+      } else if (data.type === "event") {
+        this.handleEvent(data);
+      }
+    } catch {
+    }
+  }
+  handleResponse(frame) {
+    const pending = getPendingRequests();
+    const entry = pending.get(frame.id);
+    if (!entry) return;
+    pending.delete(frame.id);
+    clearTimeout(entry.timer);
+    if (frame.ok) {
+      entry.resolve(frame.payload);
+    } else {
+      entry.reject(new Error(`Gateway method failed: ${frame.error?.message ?? "unknown error"}`));
+    }
+  }
+  handleEvent(frame) {
+    if (frame.event === "tick") {
+      this.resetTickWatchdog();
+    }
+    this.emit(frame.event, frame.payload);
+  }
+  emit(event, payload) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(payload);
+        } catch (err) {
+          this.logger.error(`cohort-sync: event handler error for "${event}": ${String(err)}`);
+        }
+      }
+    }
+  }
+  /**
+   * Start the tick watchdog timer.
+   *
+   * The gateway sends tick events at tickIntervalMs. If we don't receive
+   * one within 2.5x that interval, the connection is considered dead.
+   */
+  startTickWatchdog(tickIntervalMs) {
+    this.stopTickWatchdog();
+    const watchdogMs = Math.round(tickIntervalMs * 2.5);
+    this.tickWatchdog = setTimeout(() => {
+      diag("GW_CLIENT_TICK_TIMEOUT", { watchdogMs });
+      this.logger.warn(`cohort-sync: tick watchdog expired after ${watchdogMs}ms \u2014 closing connection`);
+      this.alive = false;
+      this.ws?.close();
+    }, watchdogMs);
+  }
+  resetTickWatchdog() {
+    if (this.tickWatchdog) {
+      this.startTickWatchdog(this.tickIntervalMs);
+    }
+  }
+  stopTickWatchdog() {
+    if (this.tickWatchdog) {
+      clearTimeout(this.tickWatchdog);
+      this.tickWatchdog = null;
+    }
+  }
+  /**
+   * Schedule a reconnection attempt with exponential backoff and jitter.
+   *
+   * Backoff: 1s base, doubles each attempt, capped at 30s.
+   * Jitter: +/- 25% randomization to avoid thundering herd.
+   */
+  scheduleReconnect() {
+    if (this.closed) return;
+    const baseMs = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    const jitter = baseMs * 0.25 * (Math.random() * 2 - 1);
+    const delayMs = Math.round(Math.max(baseMs + jitter, 1e3));
+    this.reconnectAttempts++;
+    diag("GW_CLIENT_RECONNECT_SCHEDULED", {
+      attempt: this.reconnectAttempts,
+      delayMs
+    });
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        diag("GW_CLIENT_RECONNECTING", { attempt: this.reconnectAttempts });
+        await this.connect();
+        diag("GW_CLIENT_RECONNECTED", { attempt: this.reconnectAttempts });
+      } catch (err) {
+        diag("GW_CLIENT_RECONNECT_FAILED", {
+          attempt: this.reconnectAttempts,
+          error: String(err)
+        });
+      }
+    }, delayMs);
+  }
+};
+
 // src/agent-state.ts
 import { basename } from "node:path";
 
@@ -12686,20 +13302,6 @@ var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
 
 // src/hooks.ts
 var BUILD_ID = "B9-ACCOUNTID-20260311";
-var DIAG_LOG_PATH = "/tmp/cohort-sync-diag.log";
-function diag(label, data) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const payload = data ? " " + JSON.stringify(data, (_k, v2) => {
-    if (typeof v2 === "string" && v2.length > 200) return v2.slice(0, 200) + "\u2026";
-    return v2;
-  }) : "";
-  const line = `[${ts}] ${label}${payload}
-`;
-  try {
-    fs2.appendFileSync(DIAG_LOG_PATH, line);
-  } catch {
-  }
-}
 function dumpCtx(ctx) {
   if (!ctx || typeof ctx !== "object") return { _raw: String(ctx) };
   const out = {};
@@ -12724,16 +13326,64 @@ function dumpEvent(event) {
 }
 var PLUGIN_VERSION = "unknown";
 try {
-  const pkgPath = path2.join(path2.dirname(new URL(import.meta.url).pathname), "package.json");
-  const pkgJson = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+  const pkgPath = path3.join(path3.dirname(new URL(import.meta.url).pathname), "package.json");
+  const pkgJson = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
   PLUGIN_VERSION = pkgJson.version ?? "unknown";
 } catch {
 }
 diag("MODULE_LOADED", { BUILD_ID, PLUGIN_VERSION });
+var lastCronSnapshotJson = "";
+function resolveGatewayToken(api) {
+  const rawToken = api.config?.gateway?.auth?.token;
+  if (typeof rawToken === "string") return rawToken;
+  if (rawToken && typeof rawToken === "object" && rawToken.source === "env") {
+    return process.env[rawToken.id] ?? null;
+  }
+  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;
+    client2.on("cron", () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        try {
+          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("CRON_EVENT_PUSHED", { count: mapped.length });
+        } catch (err) {
+          diag("CRON_EVENT_PUSH_FAILED", { error: String(err) });
+        }
+      }, 2e3);
+    });
+  }
+}
 function parseIdentityFile(workspaceDir) {
   try {
-    const filePath = path2.join(workspaceDir, "IDENTITY.md");
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const filePath = path3.join(workspaceDir, "IDENTITY.md");
+    const content = fs3.readFileSync(filePath, "utf-8");
     const identity = {};
     for (const line of content.split(/\r?\n/)) {
       const cleaned = line.trim().replace(/^\s*-\s*/, "");
@@ -12771,8 +13421,8 @@ function getOrCreateTracker() {
   state.tracker = fresh;
   return fresh;
 }
-var STATE_FILE_PATH = path2.join(
-  path2.dirname(new URL(import.meta.url).pathname),
+var STATE_FILE_PATH = path3.join(
+  path3.dirname(new URL(import.meta.url).pathname),
   ".session-state.json"
 );
 function saveSessionsToDisk(tracker) {
@@ -12789,14 +13439,14 @@ function saveSessionsToDisk(tracker) {
         data.sessions.push({ agentName: name, key });
       }
     }
-    fs2.writeFileSync(STATE_FILE_PATH, JSON.stringify(data));
+    fs3.writeFileSync(STATE_FILE_PATH, JSON.stringify(data));
   } catch {
   }
 }
 function loadSessionsFromDisk(tracker, logger) {
   try {
-    if (!fs2.existsSync(STATE_FILE_PATH)) return;
-    const data = JSON.parse(fs2.readFileSync(STATE_FILE_PATH, "utf8"));
+    if (!fs3.existsSync(STATE_FILE_PATH)) return;
+    const data = JSON.parse(fs3.readFileSync(STATE_FILE_PATH, "utf8"));
     if (Date.now() - new Date(data.savedAt).getTime() > 864e5) {
       logger.info("cohort-sync: disk session state too old (>24h), skipping");
       return;
@@ -12854,9 +13504,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 }))
   });
-  const cronPath = path2.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
-  setCronStorePath(cronPath);
-  diag("CRON_STORE_PATH", { cronPath, exists: fs2.existsSync(cronPath) });
   setConvexUrl(cfg);
   setLogger(logger);
   restoreFromHotReload(logger);
@@ -12977,6 +13624,28 @@ function registerHooks(api, cfg) {
   }, 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 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) });
+      });
+    }
+  }
   api.registerTool((toolCtx) => {
     const agentId = toolCtx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
@@ -13126,18 +13795,6 @@ Do not attempt to make more comments until ${resetAt}.`
       }
     }
     saveSessionsToDisk(tracker);
-    try {
-      const cronJobs2 = fetchCronJobs(logger);
-      if (cronJobs2 !== null) {
-        const resolvedJobs = cronJobs2.map((job) => ({
-          ...job,
-          agentId: job.agentId ? resolveAgentName(job.agentId) : job.agentId
-        }));
-        await pushCronSnapshot(cfg.apiKey, resolvedJobs);
-      }
-    } catch (err) {
-      logger.warn(`cohort-sync: heartbeat cron push failed: ${String(err)}`);
-    }
     logger.info(`cohort-sync: heartbeat pushed for ${allAgentIds.length} agents`);
   }
   async function flushActivityBuffer() {
@@ -13175,6 +13832,31 @@ Do not attempt to make more comments until ${resetAt}.`
       }
     }
     diag("GATEWAY_START_BRIDGE_AFTER_SEED", { bridge: { ...getHotState().channelAgentBridge } });
+    const hotState = getHotState();
+    hotState.gatewayPort = event.port;
+    const token = resolveGatewayToken(api);
+    if (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 });
+      } catch (err) {
+        diag("GW_CLIENT_CONNECT_FAILED", { error: String(err) });
+        logger.error(`cohort-sync: gateway client connect failed: ${String(err)}`);
+      }
+    } else {
+      diag("GW_CLIENT_NO_TOKEN", {});
+      logger.warn("cohort-sync: no gateway auth token \u2014 cron operations disabled");
+    }
     await initSubscription(
       event.port,
       cfg,
@@ -13183,7 +13865,6 @@ Do not attempt to make more comments until ${resetAt}.`
     ).catch((err) => {
       logger.error(`cohort-sync: subscription init failed: ${String(err)}`);
     });
-    initCommandSubscription(cfg, logger, resolveAgentName);
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);

package/dist/package.json

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

package/package.json

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