@cfio/cohort-sync 0.34.3 → 0.34.5

package/dist/index.js

@@ -2619,11 +2619,13 @@ var Type = type_exports2;
 import { Buffer as Buffer2 } from "node:buffer";
 
 // src/hooks.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os2 from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/sync.ts
+import fs from "node:fs";
+import path from "node:path";
 var VALID_STATUSES = /* @__PURE__ */ new Set(["idle", "working", "waiting"]);
 function normalizeStatus(status) {
   return VALID_STATUSES.has(status) ? status : "idle";
@@ -2632,31 +2634,31 @@ function trimTrailingSlashes(url) {
   while (url.endsWith("/")) url = url.slice(0, -1);
   return url;
 }
-async function v1Get(apiUrl2, apiKey2, path3) {
-  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path3}`, {
+async function v1Get(apiUrl2, apiKey2, path4) {
+  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path4}`, {
     headers: { Authorization: `Bearer ${apiKey2}` },
     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(apiUrl2, apiKey2, path3, body) {
-  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path3}`, {
+async function v1Patch(apiUrl2, apiKey2, path4, body) {
+  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path4}`, {
     method: "PATCH",
     headers: { Authorization: `Bearer ${apiKey2}`, "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(apiUrl2, apiKey2, path3, body) {
-  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path3}`, {
+async function v1Post(apiUrl2, apiKey2, path4, body) {
+  const res = await fetch(`${trimTrailingSlashes(apiUrl2)}${path4}`, {
     method: "POST",
     headers: { Authorization: `Bearer ${apiKey2}`, "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}`);
 }
 function isNewerVersion(a, b) {
   const strip = (v2) => v2.replace(/-.*$/, "");
@@ -2753,7 +2755,12 @@ async function reconcileRoster(openClawAgents, cfg, logger) {
           displayName: oc.identity?.name ?? agentName,
           emoji: oc.identity?.emoji ?? "\u{1F916}",
           model: oc.model,
-          status: "idle"
+          status: "idle",
+          // Role label from the profile SOUL.md, set ONLY at first registration so
+          // agents get a default title. Omitted when absent (the backend skips an
+          // undefined title). Deliberately NOT sent on the update branch below —
+          // an admin-set agentTitle is Cohort-only and must survive gateway_start.
+          title: oc.identity?.title
         });
         logger.info(`cohort-sync: provisioned new agent "${agentName}"`);
       } catch (err) {
@@ -2819,7 +2826,123 @@ async function markAllUnreachable(cfg, logger) {
   }
   logger.info("cohort-sync: all agents marked unreachable");
 }
-async function fullSync(agentName, model, cfg, logger, openClawAgents) {
+var MAX_SKILL_BYTES = 256 * 1024;
+var MAX_SYNC_SKILLS = 500;
+function parseSkillFrontmatter(text) {
+  if (!text) return null;
+  const lines = text.split(/\r?\n/);
+  if (lines.length === 0 || lines[0].trim() !== "---") return null;
+  const fields = {};
+  let closed = false;
+  for (let i2 = 1; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (line.trim() === "---") {
+      closed = true;
+      break;
+    }
+    const first = line.charAt(0);
+    if (line.length === 0 || first === " " || first === "	" || first === "-" || first === "#") {
+      continue;
+    }
+    const colon = line.indexOf(":");
+    if (colon === -1) continue;
+    const key = line.slice(0, colon).trim();
+    if (key !== "name" && key !== "description") continue;
+    fields[key] = stripScalar(line.slice(colon + 1));
+  }
+  if (!closed) return null;
+  const name = fields.name;
+  if (!name) return null;
+  return { name, description: fields.description ?? "" };
+}
+function stripScalar(value) {
+  const v2 = value.trim();
+  if (v2.length >= 2 && v2[0] === v2[v2.length - 1] && (v2[0] === "'" || v2[0] === '"')) {
+    return v2.slice(1, -1);
+  }
+  return v2;
+}
+function enumerateSkills(skillsDir2, source = "hermes") {
+  const byName = /* @__PURE__ */ new Map();
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = fs.statSync(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        visit(full);
+        continue;
+      }
+      if (entry !== "SKILL.md") continue;
+      let text;
+      try {
+        text = fs["read"+"FileSync"](full, "utf-8").slice(0, MAX_SKILL_BYTES);
+      } catch {
+        continue;
+      }
+      const parsed = parseSkillFrontmatter(text);
+      if (!parsed) continue;
+      if (byName.has(parsed.name)) continue;
+      byName.set(parsed.name, {
+        name: parsed.name,
+        description: parsed.description,
+        source,
+        body: text,
+        location: path.relative(skillsDir2, full)
+      });
+    }
+  };
+  visit(skillsDir2);
+  return [...byName.values()];
+}
+function writeSkillBody(skillsDir2, location, body) {
+  if (!skillsDir2) {
+    throw new Error("skillsDir is required for skill writeback");
+  }
+  if (!location || path.isAbsolute(location) || location.split(/[\\/]+/).includes("..")) {
+    throw new Error("Invalid skill location");
+  }
+  if (path.basename(location) !== "SKILL.md") {
+    throw new Error("Skill location must end with SKILL.md");
+  }
+  if (body.length > MAX_SKILL_BYTES) {
+    throw new Error(`Skill body exceeds maximum length of ${MAX_SKILL_BYTES} characters`);
+  }
+  const root = path.resolve(skillsDir2);
+  const target = path.resolve(root, location);
+  const relative = path.relative(root, target);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("Skill location escapes skills directory");
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, body, "utf8");
+  return target;
+}
+function skillsDirExists(skillsDir2) {
+  try {
+    return fs.statSync(skillsDir2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function syncSkills(agentName, skills, cfg, logger) {
+  const capped = skills.slice(0, MAX_SYNC_SKILLS);
+  if (capped.length < skills.length) {
+    logger.warn(`cohort-sync: capping skill sync at ${MAX_SYNC_SKILLS} (had ${skills.length})`);
+  }
+  await v1Post(cfg.apiUrl, cfg.apiKey, "/api/v1/skills/sync", { agentName, skills: capped });
+}
+async function fullSync(agentName, model, cfg, logger, openClawAgents, skillsDir2) {
   logger.info("cohort-sync: full sync starting");
   if (openClawAgents && openClawAgents.length > 0) {
     try {
@@ -2830,7 +2953,21 @@ async function fullSync(agentName, model, cfg, logger, openClawAgents) {
   } else {
     await syncAgentStatus(agentName, "working", model, cfg, logger);
   }
-  logger.info("cohort-sync: skill sync not available in this version");
+  if (skillsDir2) {
+    try {
+      if (!skillsDirExists(skillsDir2)) {
+        logger.info(`cohort-sync: skill sync skipped (skills dir missing or unreadable: ${skillsDir2})`);
+      } else {
+        const skills = enumerateSkills(skillsDir2, "openclaw");
+        await syncSkills(agentName, skills, cfg, logger);
+        logger.info(`cohort-sync: synced ${skills.length} skill(s) from ${skillsDir2}`);
+      }
+    } catch (err) {
+      logger.warn(`cohort-sync: skill sync failed (non-fatal): ${String(err)}`);
+    }
+  } else {
+    logger.info("cohort-sync: skill sync skipped (no skills dir resolved)");
+  }
   logger.info("cohort-sync: full sync complete");
 }
 
@@ -4691,12 +4828,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";
@@ -7765,8 +7902,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 || {};
@@ -7783,21 +7920,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 (define_process_env_default[name + "_PREBUILD"]) dir = define_process_env_default[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,
@@ -7814,26 +7951,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);
@@ -7920,7 +8057,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;
@@ -11784,6 +11921,27 @@ async function executeCommand(cmd, gwClient, cfg, resolveAgentName, logger, cron
     });
     return;
   }
+  if (cmd.type === "skillWrite") {
+    const skillsDir2 = injection?.skillsDir;
+    const agentName = cmd.payload?.agentId;
+    const location = cmd.payload?.location;
+    const body = cmd.payload?.skillBody;
+    if (!skillsDir2) {
+      throw new Error("skillsDir is required for skillWrite");
+    }
+    if (!agentName) {
+      throw new Error("agentId is required for skillWrite");
+    }
+    if (!location) {
+      throw new Error("location is required for skillWrite");
+    }
+    if (typeof body !== "string") {
+      throw new Error("skillBody is required for skillWrite");
+    }
+    writeSkillBody(skillsDir2, location, body);
+    await syncSkills(agentName, enumerateSkills(skillsDir2, "openclaw"), cfg, logger);
+    return;
+  }
   if (cmd.type.startsWith("cron")) {
     if (!gwClient || !gwClient.isAlive()) {
       logger.warn(`cohort-sync: no gateway client, cannot execute ${cmd.type}`);
@@ -11994,6 +12152,7 @@ var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTel
 var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
 var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
 var upsertCronSnapshotFromPluginRef = makeFunctionReference("telemetryPlugin:upsertCronSnapshotFromPlugin");
+var recordGatewayPresenceRef = makeFunctionReference("gatewayPresence:recordGatewayPresence");
 var recordCronRunFromPluginRef = makeFunctionReference("cronRunHistory:recordFromPlugin");
 var getUndeliveredForPlugin = makeFunctionReference("notifications:getUndeliveredForPlugin");
 var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredByPlugin");
@@ -12068,6 +12227,22 @@ async function pushCronSnapshot(apiKey2, jobs) {
     return false;
   }
 }
+async function pushPresence(apiKey2, runtime) {
+  if (authCircuitOpen) return false;
+  const c = getClient();
+  if (!c) return false;
+  try {
+    await c.mutation(recordGatewayPresenceRef, { apiKeyHash: hashApiKey(apiKey2), runtime });
+    return true;
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+      return false;
+    }
+    getLogger().error(`cohort-sync: pushPresence failed: ${err}`);
+    return false;
+  }
+}
 async function recordCronRun(apiKey2, run) {
   if (authCircuitOpen) return false;
   const c = getClient();
@@ -12855,15 +13030,15 @@ import crypto2 from "node:crypto";
 
 // src/device-identity-crypto.ts
 import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import os from "node:os";
-var DATA_DIR = path.join(os.homedir(), ".openclaw", "data", "cohort-sync");
-var IDENTITY_PATH = path.join(DATA_DIR, ".device-identity.json");
-var LEGACY_IDENTITY_PATH = path.join(os.homedir(), ".openclaw", "extensions", "cohort-sync", ".device-identity.json");
+var DATA_DIR = path2.join(os.homedir(), ".openclaw", "data", "cohort-sync");
+var IDENTITY_PATH = path2.join(DATA_DIR, ".device-identity.json");
+var LEGACY_IDENTITY_PATH = path2.join(os.homedir(), ".openclaw", "extensions", "cohort-sync", ".device-identity.json");
 function tryLoadIdentity(filePath) {
   try {
-    const data = JSON.parse(fs["read"+"FileSync"](filePath, "utf-8"));
+    const data = JSON.parse(fs2["read"+"FileSync"](filePath, "utf-8"));
     if (data.deviceId && data.publicKeyPem && data.privateKeyPem) {
       return data;
     }
@@ -12896,8 +13071,8 @@ function loadOrCreateDeviceIdentity() {
 }
 function persistIdentity(identity) {
   try {
-    fs.mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
-    fs.writeFileSync(IDENTITY_PATH, JSON.stringify(identity, null, 2), { mode: 384 });
+    fs2.mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
+    fs2.writeFileSync(IDENTITY_PATH, JSON.stringify(identity, null, 2), { mode: 384 });
   } catch (err) {
     console.debug("cohort-sync: device identity write failed", { error: String(err) });
   }
@@ -14009,6 +14184,28 @@ var AgentStateTracker = class {
 
 // src/types.ts
 var DEFAULT_API_URL = "https://api.cohort.bot";
+function normalizeTriageBrief(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return { error: "brief must be an object with problem, solution (and optional risks)." };
+  }
+  const obj = raw;
+  const requireField = (name) => {
+    const value = obj[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      return { error: `brief.${name} is required and must be a non-empty string.` };
+    }
+    return value.trim();
+  };
+  const problem = requireField("problem");
+  if (typeof problem !== "string") return problem;
+  const solution = requireField("solution");
+  if (typeof solution !== "string") return solution;
+  const brief = { problem, solution };
+  if (typeof obj.risks === "string" && obj.risks.trim().length > 0) {
+    brief.risks = obj.risks.trim();
+  }
+  return { brief };
+}
 
 // src/tool-runtime.ts
 var apiKey = null;
@@ -14119,7 +14316,8 @@ function dumpEvent(event) {
 function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-var PLUGIN_VERSION = true ? "0.34.3" : "unknown";
+var PLUGIN_VERSION = true ? "0.34.5" : "unknown";
+var PRESENCE_PING_INTERVAL_MS = 12e4;
 function resolveGatewayToken(api) {
   const token2 = api.config?.gateway?.auth?.token;
   return typeof token2 === "string" ? token2 : null;
@@ -14149,8 +14347,8 @@ function registerCronEventHandlers(client2, cfg, resolveAgentName, cronTimestamp
 }
 function parseIdentityFile(workspaceDir) {
   try {
-    const filePath = path2.join(workspaceDir, "IDENTITY.md");
-    const content = fs2["read"+"FileSync"](filePath, "utf-8");
+    const filePath = path3.join(workspaceDir, "IDENTITY.md");
+    const content = fs3["read"+"FileSync"](filePath, "utf-8");
     const identity = {};
     for (const line of content.split(/\r?\n/)) {
       const cleaned = line.trim().replace(/^\s*-\s*/, "");
@@ -14169,14 +14367,41 @@ function parseIdentityFile(workspaceDir) {
     return null;
   }
 }
+function parseRoleFromSoul(content) {
+  const MAX_LEN = 80;
+  for (const line of content.split(/\r?\n/)) {
+    const cleaned = line.trim().replace(/^\s*-\s*/, "");
+    const colonIndex = cleaned.indexOf(":");
+    if (colonIndex === -1) continue;
+    const label = cleaned.slice(0, colonIndex).replace(/[*_]/g, "").trim().toLowerCase();
+    if (label !== "role" && label !== "current role") continue;
+    let value = cleaned.slice(colonIndex + 1).replace(/^[*_]+|[*_]+$/g, "").trim();
+    if (!value) continue;
+    const firstSentence = value.split(/\.\s/)[0].trim();
+    if (firstSentence) value = firstSentence;
+    if (value.length > MAX_LEN) value = value.slice(0, MAX_LEN).trim();
+    return value;
+  }
+  return void 0;
+}
+function parseSoulRole(workspaceDir) {
+  try {
+    const content = fs3["read"+"FileSync"](path3.join(workspaceDir, "SOUL.md"), "utf-8");
+    return parseRoleFromSoul(content);
+  } catch {
+    return void 0;
+  }
+}
 function resolveIdentity(configIdentity, workspaceDir) {
   const fileIdentity = workspaceDir ? parseIdentityFile(workspaceDir) : null;
-  if (!configIdentity && !fileIdentity) return void 0;
+  const soulRole = workspaceDir ? parseSoulRole(workspaceDir) : void 0;
+  if (!configIdentity && !fileIdentity && !soulRole) return void 0;
   return {
     name: configIdentity?.name ?? fileIdentity?.name,
     emoji: configIdentity?.emoji ?? fileIdentity?.emoji,
     theme: configIdentity?.theme ?? fileIdentity?.theme,
-    avatar: configIdentity?.avatar ?? fileIdentity?.avatar
+    avatar: configIdentity?.avatar ?? fileIdentity?.avatar,
+    title: configIdentity?.title ?? soulRole
   };
 }
 function saveSessionsToDisk(tracker, stateFilePath) {
@@ -14193,14 +14418,14 @@ function saveSessionsToDisk(tracker, stateFilePath) {
         data.sessions.push({ agentName: name, key });
       }
     }
-    fs2.writeFileSync(stateFilePath, JSON.stringify(data), { mode: 384 });
+    fs3.writeFileSync(stateFilePath, JSON.stringify(data), { mode: 384 });
   } catch {
   }
 }
 function loadSessionsFromDisk(tracker, stateFilePath, logger) {
   try {
-    if (!fs2.existsSync(stateFilePath)) return;
-    const data = JSON.parse(fs2["read"+"FileSync"](stateFilePath, "utf8"));
+    if (!fs3.existsSync(stateFilePath)) return;
+    const data = JSON.parse(fs3["read"+"FileSync"](stateFilePath, "utf8"));
     if (Date.now() - new Date(data.savedAt).getTime() > 864e5) {
       logger.info("cohort-sync: disk session state too old (>24h), skipping");
       return;
@@ -14269,7 +14494,7 @@ async function handleGatewayStart(event, state) {
   if (!state) {
     return;
   }
-  const { cfg, tracker, logger, config, api } = state;
+  const { cfg, tracker, logger, config, api, skillsDir: skillsDir2 } = state;
   try {
     const latestVersion = await checkForUpdate(PLUGIN_VERSION, logger);
     if (latestVersion) {
@@ -14296,7 +14521,14 @@ async function handleGatewayStart(event, state) {
       model: state.resolveModel(a.id),
       identity: resolveIdentity(a.identity, a.workspace)
     }));
-    await fullSync(state.resolveAgentName("main"), state.resolveModel("main"), cfg, logger, agentList);
+    await fullSync(
+      state.resolveAgentName("main"),
+      state.resolveModel("main"),
+      cfg,
+      logger,
+      agentList,
+      skillsDir2
+    );
   } catch (err) {
     logger.error(`cohort-sync: gateway_start sync failed: ${String(err)}`);
   }
@@ -14329,7 +14561,7 @@ async function handleGatewayStart(event, state) {
         state.resolveAgentName,
         state.persistentGwClient,
         state.cronTimestampTracker,
-        { port: state.gatewayPort, hooksToken }
+        { port: state.gatewayPort, hooksToken, skillsDir: skillsDir2 }
       );
       state.commandUnsubscriber = unsub;
     } catch (err) {
@@ -14421,6 +14653,17 @@ async function handleGatewayStart(event, state) {
     saveSessionsToDisk(tracker, state.stateFilePath);
   }, 15e4);
   logger.info("cohort-sync: keepalive interval started (150s)");
+  void pushPresence(cfg.apiKey, "openclaw").catch(() => {
+  });
+  if (state.presenceInterval) clearInterval(state.presenceInterval);
+  state.presenceInterval = setInterval(() => {
+    void pushPresence(cfg.apiKey, "openclaw").catch(() => {
+    });
+  }, PRESENCE_PING_INTERVAL_MS);
+  if (typeof state.presenceInterval.unref === "function") {
+    state.presenceInterval.unref();
+  }
+  logger.info(`cohort-sync: liveness ping interval started (${PRESENCE_PING_INTERVAL_MS / 1e3}s)`);
 }
 function registerHookHandlers(api, logger, getState) {
   function resolveAgentFromContext(state, ctx) {
@@ -14497,7 +14740,7 @@ function registerHookHandlers(api, logger, getState) {
         const parsed = parseSessionKey(sessionKey);
         const routineId = parsed.kind === "cron" ? parsed.identifier : void 0;
         try {
-          const raw = fs2["read"+"FileSync"](state.cronStorePath, "utf8");
+          const raw = fs3["read"+"FileSync"](state.cronStorePath, "utf8");
           const store = JSON.parse(raw);
           const jobs = store.jobs ?? [];
           const mapped = jobs.map((j) => mapCronJob(j, state.resolveAgentName, state.cronTimestampTracker));
@@ -14666,7 +14909,7 @@ function registerHookHandlers(api, logger, getState) {
             state.resolveAgentName,
             state.persistentGwClient,
             state.cronTimestampTracker,
-            { port: state.gatewayPort, hooksToken: state.gatewayToken }
+            { port: state.gatewayPort, hooksToken: state.gatewayToken, skillsDir }
           );
           state.commandUnsubscriber = unsub;
         } catch (err) {
@@ -14881,6 +15124,10 @@ function registerHookHandlers(api, logger, getState) {
       clearInterval(state.keepaliveInterval);
       state.keepaliveInterval = null;
     }
+    if (state.presenceInterval) {
+      clearInterval(state.presenceInterval);
+      state.presenceInterval = null;
+    }
     if (state.updateCheckInterval) {
       clearInterval(state.updateCheckInterval);
       state.updateCheckInterval = null;
@@ -14931,7 +15178,7 @@ function registerHookHandlers(api, logger, getState) {
 }
 function initializeHookState(api, cfg) {
   const { logger, config } = api;
-  const stateFilePath = path2.join(cfg.stateDir, "session-state.json");
+  const stateFilePath = path3.join(cfg.stateDir, "session-state.json");
   const nameMap = cfg.agentNameMap;
   const tracker = new AgentStateTracker();
   const convexUrl = cfg.convexUrl ?? deriveConvexUrl(cfg.apiUrl);
@@ -14965,7 +15212,7 @@ function initializeHookState(api, cfg) {
   function getModelContextLimit2(model) {
     return getModelContextLimit(model);
   }
-  const cronStorePath = api.config?.cron?.store ?? path2.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
+  const cronStorePath = api.config?.cron?.store ?? path3.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
   const activityBatch = new MicroBatch({
     maxSize: 10,
     maxDelayMs: 1e3,
@@ -14975,6 +15222,7 @@ function initializeHookState(api, cfg) {
   const gatewayPort = api.config?.gateway?.port ?? null;
   const gatewayToken = resolveGatewayToken(api);
   const hooksToken = resolveHooksToken(api);
+  const skillsDir2 = api.config?.skills?.dir ?? path3.join(os2.homedir(), ".openclaw", "skills");
   const cronTimestampTracker = new CronTimestampTracker();
   const cronRunStarts = /* @__PURE__ */ new Map();
   let persistentGwClient = null;
@@ -14990,7 +15238,7 @@ function initializeHookState(api, cfg) {
     resolveAgentName,
     persistentGwClient,
     cronTimestampTracker,
-    { port: gatewayPort, hooksToken }
+    { port: gatewayPort, hooksToken, skillsDir: skillsDir2 }
   );
   setToolRuntime({
     apiKey: cfg.apiKey,
@@ -15035,12 +15283,14 @@ function initializeHookState(api, cfg) {
     getModelContextLimit: getModelContextLimit2,
     activityBatch,
     cronStorePath,
+    skillsDir: skillsDir2,
     stateFilePath,
     gatewayPort,
     gatewayToken,
     persistentGwClient,
     gwClientInitialized,
     keepaliveInterval: null,
+    presenceInterval: null,
     commandUnsubscriber: commandUnsub,
     channelsUnsubscriber: null,
     api,
@@ -15084,6 +15334,65 @@ function registerGatewayMethods(api, getGatewayClient) {
   );
 }
 
+// src/triage-pr-files.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function collectChangedFiles(args) {
+  const cwd = args.repoDir || process.cwd();
+  const git = async (gitArgs) => {
+    const { stdout } = await execFileAsync("git", gitArgs, {
+      cwd,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    return stdout;
+  };
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const nameStatus = await git(["diff", "--name-status", "-z", args.baseSha]);
+  const tokens = nameStatus.split("\0");
+  let i2 = 0;
+  while (i2 < tokens.length) {
+    const status = tokens[i2];
+    if (!status) {
+      i2 += 1;
+      continue;
+    }
+    let path4;
+    if (status[0] === "R" || status[0] === "C") {
+      const oldPath = tokens[i2 + 1] ?? "";
+      path4 = tokens[i2 + 2] ?? "";
+      i2 += 3;
+      if (oldPath && !seen.has(oldPath)) {
+        seen.add(oldPath);
+        files.push({ path: oldPath, deleted: true });
+      }
+    } else {
+      path4 = tokens[i2 + 1] ?? "";
+      i2 += 2;
+    }
+    if (!path4 || seen.has(path4)) continue;
+    seen.add(path4);
+    if (status[0] === "D") {
+      files.push({ path: path4, deleted: true });
+    } else {
+      files.push({ path: path4, content: await readRepoFile(cwd, path4) });
+    }
+  }
+  const others = await git(["ls-files", "--others", "--exclude-standard", "-z"]);
+  for (const path4 of others.split("\0")) {
+    if (!path4 || seen.has(path4)) continue;
+    seen.add(path4);
+    files.push({ path: path4, content: await readRepoFile(cwd, path4) });
+  }
+  return files;
+}
+async function readRepoFile(cwd, path4) {
+  return readFile(join(cwd, path4), "utf8");
+}
+
 // src/pocket-guide.ts
 var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
 
@@ -15313,6 +15622,31 @@ async function safeHttpError(response) {
   }
   return "";
 }
+var PR_MAX_FILES = 50;
+var PR_MAX_FILE_BYTES = 1e6;
+var PR_MAX_TOTAL_BYTES = 5e6;
+var PR_BASE_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+function checkPrEnvelope(files) {
+  if (files.length === 0) {
+    return "No changed files to report \u2014 make a change first, then call cohort_triage_pr.";
+  }
+  if (files.length > PR_MAX_FILES) {
+    return `Change too large: ${files.length} files (max ${PR_MAX_FILES}).`;
+  }
+  let total = 0;
+  for (const entry of files) {
+    if ("deleted" in entry) continue;
+    const size = Buffer2.byteLength(entry.content, "utf8");
+    if (size > PR_MAX_FILE_BYTES) {
+      return `File too large: ${entry.path} (max ${PR_MAX_FILE_BYTES} bytes).`;
+    }
+    total += size;
+  }
+  if (total > PR_MAX_TOTAL_BYTES) {
+    return "Change too large (total content size exceeds the limit).";
+  }
+  return null;
+}
 function renderTaskContext(context) {
   if (!context) return "";
   const lines = [];
@@ -16067,7 +16401,7 @@ ${renderGoal(goal)}`, goal);
       return {
         name: "cohort_triage",
         label: "cohort_triage",
-        description: "Report your triage decision on a Cohort triage item back to Cohort. Pass the Triage item ID from your wake task as triage_item_id, the tier (trivial | judgment | feature | not_actionable), whether it is actionable, and your reasoning. SHADOW MODE: do NOT write code or open PRs.",
+        description: "Report your triage decision on a Cohort triage item back to Cohort. Pass the Triage item ID from your wake task as triage_item_id, the tier (trivial | judgment | feature | not_actionable), whether it is actionable, and your reasoning. Also pass a short `title` \u2014 a brief (\u226480 char) issue summary in your own words (a task-name headline of what you read), NOT a paste of the feedback; Cohort uses it as the Build-it task title. SHADOW MODE: do NOT write code or open PRs.",
         parameters: Type.Object({
           triage_item_id: Type.String({ description: "Triage item ID from your wake task (e.g. triageItems:abc123)." }),
           tier: Type.Union([
@@ -16078,7 +16412,8 @@ ${renderGoal(goal)}`, goal);
           ], { description: "Triage tier for this feedback." }),
           actionable: Type.Boolean({ description: "Whether this feedback is actionable." }),
           reasoning: Type.String({ description: "Why you reached this decision." }),
-          confidence: Type.Optional(Type.Number({ description: "Optional confidence in the decision, 0 to 1." }))
+          confidence: Type.Optional(Type.Number({ description: "Optional confidence in the decision, 0 to 1." })),
+          title: Type.Optional(Type.String({ description: "Optional short (\u226480 char) issue summary in your own words \u2014 a task-name headline of the problem, NOT a paste of the feedback. Used as the Build-it task title." }))
         }),
         async execute(_toolCallId, params) {
           const rt = getToolRuntime();
@@ -16098,7 +16433,8 @@ ${renderGoal(goal)}`, goal);
                   tier: params.tier,
                   actionable: params.actionable,
                   reasoning: params.reasoning,
-                  ...params.confidence !== void 0 ? { confidence: params.confidence } : {}
+                  ...params.confidence !== void 0 ? { confidence: params.confidence } : {},
+                  ...params.title !== void 0 ? { title: params.title } : {}
                 }),
                 signal: AbortSignal.timeout(1e4)
               }
@@ -16116,6 +16452,72 @@ ${renderGoal(goal)}`, goal);
         }
       };
     });
+    api.registerTool(() => {
+      return {
+        name: "cohort_triage_pr",
+        label: "cohort_triage_pr",
+        description: "Report a Build-it fix you produced for a Cohort triage item. Pass the Triage item ID, the base commit SHA you branched from (base_sha), and a structured brief (problem, solution, optional risks). The tool collects your changed files from the current worktree and sends them to Cohort; the Cohort spine opens the PR and it auto-merges once CI is green. Do NOT open a PR or merge yourself \u2014 you hold no merge credential.",
+        parameters: Type.Object({
+          triage_item_id: Type.String({ description: "Triage item ID from your wake task (e.g. triageItems:abc123)." }),
+          base_sha: Type.String({ description: "The 40- or 64-char hex commit SHA you branched from." }),
+          brief: Type.Object({
+            problem: Type.String({ description: "What's wrong (the issue being fixed)." }),
+            solution: Type.String({ description: "How the PR fixes it (rendered under the 'Fix' label)." }),
+            risks: Type.Optional(Type.String({ description: "Optional risks/blast radius of the change." }))
+          }),
+          repo_dir: Type.Optional(Type.String({ description: "Optional worktree path to diff (defaults to the current directory)." }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_triage_pr is not ready yet \u2014 the plugin is still starting up.");
+          }
+          if (!PR_BASE_SHA_RE.test(params.base_sha)) {
+            return textResult("Invalid base_sha: must be a 40- or 64-char hex commit SHA.");
+          }
+          const normalized = normalizeTriageBrief(params.brief);
+          if ("error" in normalized) {
+            return textResult(`Invalid brief: ${normalized.error}`);
+          }
+          let files;
+          try {
+            files = await collectChangedFiles({ baseSha: params.base_sha, repoDir: params.repo_dir });
+          } catch (err) {
+            return textResult(`Failed to collect changed files for ${params.triage_item_id}: ${err instanceof Error ? redactSecrets(err.message) : "Unknown error"}`);
+          }
+          const envelopeError = checkPrEnvelope(files);
+          if (envelopeError) {
+            return textResult(envelopeError);
+          }
+          try {
+            const response = await fetch(
+              `${rt.apiUrl}/api/v1/plugin/triage/${encodeURIComponent(params.triage_item_id)}/pr`,
+              {
+                method: "POST",
+                headers: {
+                  "Authorization": `Bearer ${rt.apiKey}`,
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                  brief: normalized.brief,
+                  baseSha: params.base_sha,
+                  files
+                }),
+                signal: AbortSignal.timeout(3e4)
+              }
+            );
+            if (!response.ok) {
+              const message = await safeHttpError(response);
+              return textResult(`Failed to report PR for ${params.triage_item_id}: ${response.status}${message}`);
+            }
+            const result = await response.json();
+            return textResult(`Reported ${files.length} changed file(s) for ${params.triage_item_id}; the spine will open the PR.`, result);
+          } catch (err) {
+            return textResult(`Failed to report PR for ${params.triage_item_id}: ${err instanceof Error ? redactSecrets(err.message) : "Unknown error"}`);
+          }
+        }
+      };
+    });
     api.registerTool(() => {
       return {
         name: "cohort_relate",

package/dist/openclaw.plugin.json

@@ -25,6 +25,7 @@
       "cohort_goal",
       "cohort_transition",
       "cohort_triage",
+      "cohort_triage_pr",
       "cohort_relate",
       "cohort_assign"
     ]
@@ -84,5 +85,5 @@
       }
     }
   },
-  "version": "0.34.3"
+  "version": "0.34.5"
 }

package/dist/package.json

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

package/openclaw.plugin.json

@@ -23,6 +23,7 @@
       "cohort_goal",
       "cohort_transition",
       "cohort_triage",
+      "cohort_triage_pr",
       "cohort_relate",
       "cohort_assign"
     ]

package/package.json

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