@cfio/cohort-sync 0.31.13 → 0.32.1

package/dist/index.js

@@ -12000,6 +12000,9 @@ var failCommandRef = makeFunctionReference("gatewayCommands:failCommand");
 var getChannelsForPlugin = makeFunctionReference("cloudGatewayChannels:listForPlugin");
 var addCommentFromPluginRef = makeFunctionReference("comments:addCommentFromPlugin");
 var addRoomMessageFromPluginRef = makeFunctionReference("rooms:addMessageFromPlugin");
+var startModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:startFromPlugin");
+var advanceModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:advanceFromPlugin");
+var cancelModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:cancelFromPlugin");
 var promptAgentsFromPluginRef = makeFunctionReference("rooms:promptAgentsFromPlugin");
 var transitionFromPluginRef = makeFunctionReference("tasks:transitionFromPlugin");
 async function pushTelemetry(apiKey2, data) {
@@ -12119,7 +12122,91 @@ async function callAddRoomMessageFromPlugin(apiKey2, args) {
       apiKeyHash: hashApiKey(apiKey2),
       roomId: args.roomId,
       agentName: args.agentName,
-      body: args.content
+      body: args.content,
+      // Omit (not undefined) when absent — keeps the wire args clean.
+      ...args.turnId !== void 0 ? { turnId: args.turnId } : {}
+    });
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+    }
+    throw err;
+  }
+}
+async function callStartModerationSessionFromPlugin(apiKey2, args) {
+  if (authCircuitOpen) {
+    throw new Error(
+      'cohort-sync: API key rejected \u2014 all outbound mutations disabled until gateway restart.\n  1. Create a new key at https://my.cohort.bot/settings/api-keys\n  2. Run: openclaw config set plugins.entries.cohort-sync.config.apiKey "ch_live_..."'
+    );
+  }
+  const c = getClient();
+  if (!c) {
+    throw new Error("Convex client not initialized \u2014 subscription may not be active");
+  }
+  try {
+    return await c.mutation(startModerationSessionFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      roomId: args.roomId,
+      moderatorAgentName: args.moderatorAgentName,
+      mode: args.mode,
+      objective: args.objective,
+      participantAgentNames: args.participantAgentNames,
+      ...args.questionText !== void 0 ? { questionText: args.questionText } : {},
+      ...args.autoAdvance !== void 0 ? { autoAdvance: args.autoAdvance } : {}
+    });
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+    }
+    throw err;
+  }
+}
+async function callAdvanceModerationSessionFromPlugin(apiKey2, args) {
+  if (authCircuitOpen) {
+    throw new Error(
+      'cohort-sync: API key rejected \u2014 all outbound mutations disabled until gateway restart.\n  1. Create a new key at https://my.cohort.bot/settings/api-keys\n  2. Run: openclaw config set plugins.entries.cohort-sync.config.apiKey "ch_live_..."'
+    );
+  }
+  const c = getClient();
+  if (!c) {
+    throw new Error("Convex client not initialized \u2014 subscription may not be active");
+  }
+  try {
+    return await c.mutation(advanceModerationSessionFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      sessionId: args.sessionId,
+      moderatorAgentName: args.moderatorAgentName,
+      action: args.action,
+      ...args.prompt !== void 0 ? { prompt: args.prompt } : {},
+      ...args.targetAgentName !== void 0 ? { targetAgentName: args.targetAgentName } : {},
+      ...args.summary !== void 0 ? { summary: args.summary } : {},
+      ...args.decisions !== void 0 ? { decisions: args.decisions } : {},
+      ...args.proposedTasks !== void 0 ? { proposedTasks: args.proposedTasks } : {},
+      ...args.followUps !== void 0 ? { followUps: args.followUps } : {}
+    });
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+    }
+    throw err;
+  }
+}
+async function callCancelModerationSessionFromPlugin(apiKey2, args) {
+  if (authCircuitOpen) {
+    throw new Error(
+      'cohort-sync: API key rejected \u2014 all outbound mutations disabled until gateway restart.\n  1. Create a new key at https://my.cohort.bot/settings/api-keys\n  2. Run: openclaw config set plugins.entries.cohort-sync.config.apiKey "ch_live_..."'
+    );
+  }
+  const c = getClient();
+  if (!c) {
+    throw new Error("Convex client not initialized \u2014 subscription may not be active");
+  }
+  try {
+    return await c.mutation(cancelModerationSessionFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      sessionId: args.sessionId,
+      moderatorAgentName: args.moderatorAgentName,
+      ...args.reason !== void 0 ? { reason: args.reason } : {}
     });
   } catch (err) {
     if (isUnauthorizedError(err)) {
@@ -12190,17 +12277,134 @@ var ATMENTION_RESPONSE_PROMPT = `YOU WERE DIRECTLY @-MENTIONED. RESPOND.
 - If the mention is a question, answer it. If it's a request, acknowledge what you'll do (and then do it).
 - For coding requests, do not stop at local implementation; source scripts/agent-dev-env.sh, push your branch, open a PR, enable auto-merge, watch CI until green or red, confirm the PR merged, verify the production deploy with gh run watch, and then comment with the PR link plus verification evidence.
 - Do not stop because Vercel CLI is not authenticated; Cohort deploys through GitHub Actions after merge.`;
+var ROOM_MESSAGE_RESPONSE_PROMPT = `YOU WERE DIRECTLY ASKED IN A COHORT ROOM. RESPOND.
+
+- If you are the Room moderator and a human asks for a question to be routed, FIRST use cohort_room_start_moderation_session with mode: "moderated_qna", one best participant, and question_text; use cohort_room_advance_moderation_session(action: "followup") for additional experts one at a time, then confirm with the asker before complete.
+- If you are the Room moderator and a human asks for a roundtable, standup, report-in, or panel response, FIRST use cohort_room_start_moderation_session with mode: "round_robin" to run it as a managed session, then drive it with cohort_room_advance_moderation_session; do not only name agents in prose.
+- Otherwise, use the cohort_room_message tool to post a reply in the Room. Do NOT just think silently and exit.
+- Reply in your own voice (see your persona in IDENTITY.md).
+- If the human asks for an answer, answer it. If the human asks for a roundtable, standup, report-in, or panel response, contribute your own concise update.
+- If the moderator asks you to answer, answer. If another agent asks for your report, provide it. If your prompt includes a turn_id, echo it in cohort_room_message.
+- A brief, honest reply is better than no reply. If you genuinely have nothing to add, say so explicitly in the Room \u2014 don't go silent.`;
 var TOOLS_REFERENCE = `
 TOOLS: Use these \u2014 do NOT call the REST API directly.
 - cohort_comment(task_number, comment) \u2014 post a comment
-- cohort_room_message(room_id, message) \u2014 post a message in a Cohort Room
+- cohort_room_message(room_id, message, turn_id?) \u2014 post a message in a Cohort Room; pass turn_id when your prompt included one so the reply is attributed to that moderation turn
+- cohort_room_start_moderation_session(room_id, mode, objective, participant_names) \u2014 moderator only: start a managed session; round_robin = ask every participant to report in, moderated_qna = route a question to one selected agent
+- cohort_room_advance_moderation_session(session_id, action, ...) \u2014 moderator only: advance, retry, skip, accept, followup, or complete the session; followup asks one additional Q&A expert after the first answer
+- cohort_room_cancel_moderation_session(session_id, reason?) \u2014 moderator only: cancel an in-flight session
+- cohort_room_prompt_agent(roomId, agentName, prompt) \u2014 moderator only, low-level: ask one Room agent to respond (prefer moderation sessions for multi-step workflows)
+- cohort_room_prompt_agents(roomId, agentNames, prompt) \u2014 moderator only, low-level: ask multiple Room agents to respond (prefer moderation sessions for multi-step workflows)
 - cohort_task(task_number) \u2014 fetch full task details + comments
 - cohort_transition(task_number, status) \u2014 change status
 - cohort_assign(task_number, assignee) \u2014 assign/unassign
 - cohort_context() \u2014 get your session briefing`;
+var HANDOFF_REQUEST_TERMS = [
+  "round robin",
+  "round-robin",
+  "go around",
+  "around the table",
+  "whole team",
+  "everyone",
+  "all hands",
+  "pass the buck",
+  "pass the conch"
+];
+var HANDOFF_TOPIC_TERMS = [
+  "standup",
+  "stand-up",
+  "report in",
+  "report-in",
+  "panel"
+];
+var HANDOFF_ACTION_TERMS = [
+  "moderate",
+  "run",
+  "gather",
+  "ask"
+];
+var QUESTION_ROUTING_TERMS = [
+  "question for the team",
+  "route it",
+  "route this",
+  "ask whoever",
+  "whoever's best suited",
+  "whoever is best suited",
+  "who's best suited",
+  "who is best suited"
+];
 function sanitizePreview(raw) {
   return raw.replace(/<\/?user_comment>/gi, "");
 }
+function isHumanHandoffRequest(n) {
+  if (n.actorType !== "human") {
+    return false;
+  }
+  const preview = (n.preview ?? "").toLowerCase();
+  if (HANDOFF_REQUEST_TERMS.some((term) => preview.includes(term))) {
+    return true;
+  }
+  const hasTopic = HANDOFF_TOPIC_TERMS.some((term) => preview.includes(term));
+  const hasAction = HANDOFF_ACTION_TERMS.some((term) => preview.includes(term));
+  return hasTopic && hasAction;
+}
+function isHumanQuestionRoutingRequest(n) {
+  if (n.actorType !== "human") {
+    return false;
+  }
+  const preview = (n.preview ?? "").toLowerCase();
+  return QUESTION_ROUTING_TERMS.some((term) => preview.includes(term)) || /\bhave\s+[a-z][a-z0-9_-]*\s+answer\b/.test(preview);
+}
+function roomMessageCta(n) {
+  const roomId = n.roomId ?? "unknown";
+  if (n.moderationContext != null && renderModerationContext(n.moderationContext) !== "") {
+    return "Follow the MODERATION SESSION block in this message \u2014 it is authoritative.";
+  }
+  if (isHumanQuestionRoutingRequest(n)) {
+    return `You are moderating a Room Q&A. FIRST use cohort_room_start_moderation_session(room_id: ${roomId}, mode: "moderated_qna", objective: <one-line objective>, participant_names: [<single best agent>], question_text: <the question>) to route the question to one selected expert. If more expertise is needed after the answer, use cohort_room_advance_moderation_session(action: "followup", target_agent_name: <next expert>, prompt: <follow-up question>) for one additional expert at a time (advance(action: "followup")). Then ask the asker whether the answer resolves the question before complete.`;
+  }
+  if (isHumanHandoffRequest(n)) {
+    return `You are moderating a Room round robin. FIRST use cohort_room_start_moderation_session(room_id: ${roomId}, mode: "round_robin", objective: <one-line objective>, participant_names: [<agents>]) to run it as a managed moderation session. Do NOT only post @agent prose and do NOT hand-roll turn-taking with cohort_room_prompt_agent. The session prompts each participant for you and tells you when to advance; finish with cohort_room_advance_moderation_session(action: "complete") to record the outcomes.`;
+  }
+  if (isAgentReplyToModerator(n)) {
+    const actor = n.actorName ?? "the agent";
+    return `If you are the Room moderator continuing a round robin, The <user_comment> preview is the agent's actual Room reply from ${actor}. Check whether the From: agent is the expected participant. If correct and the round robin has more participants, FIRST call cohort_room_prompt_agent for the next participant. If wrong, prompt the correct agent. Only consolidate when the requested sequence is complete. Do NOT stop after posting a commentary message.`;
+  }
+  return `Reply in the Room if you can help. Use the cohort_room_message tool (roomId: ${roomId}).`;
+}
+function isAgentReplyToModerator(n) {
+  if (n.actorType !== "agent") {
+    return false;
+  }
+  const actor = (n.actorName ?? "").trim().toLowerCase();
+  const recipient = (n.recipientAgent ?? "").trim().toLowerCase();
+  const preview = (n.preview ?? "").toLowerCase();
+  if (["please ", "passing the buck to you", "pass the buck to you"].some((term) => preview.includes(term))) {
+    return false;
+  }
+  return Boolean(actor && recipient && actor !== recipient);
+}
+function renderModerationContext(ctx) {
+  if (ctx.version !== 1) return "";
+  const expected = ctx.expectedAgentNames.length > 0 ? ctx.expectedAgentNames.join(", ") : "(none)";
+  const lines = [
+    `[MODERATION SESSION ${ctx.sessionId}]`,
+    `Mode: ${ctx.mode} | Status: ${ctx.status} | Auto-advance: ${ctx.autoAdvance ? "on" : "off"} | Queued behind: ${ctx.queuedCount}`,
+    `Objective: ${ctx.objective}`,
+    `Sequence: ${ctx.sequenceAgentNames.join(" -> ")} (cursor ${ctx.cursor}/${ctx.sequenceAgentNames.length})`,
+    `Expected responder(s): ${expected}`,
+    `Last event: ${ctx.lastEvent}`,
+    `NEXT ACTION: ${ctx.nextActionHint}`,
+    "Do NOT post commentary instead of advancing. Advance or complete via the session tools."
+  ];
+  if (ctx.respondTurnId) {
+    lines.push(
+      `To reply for this turn, call cohort_room_message(room_id: ${ctx.roomId}, message: <your reply>, turn_id: "${ctx.respondTurnId}").`
+    );
+  }
+  lines.push("[/MODERATION SESSION]");
+  return lines.join("\n");
+}
 function buildNotificationMessage(n) {
   let header;
   let cta;
@@ -12208,7 +12412,7 @@ function buildNotificationMessage(n) {
     case "room_message":
       header = `New message in Room "${n.roomName ?? n.roomId ?? "Room"}"
 From: ${n.actorName}`;
-      cta = `Reply in the Room if you can help. Use the cohort_room_message tool (roomId: ${n.roomId ?? "unknown"}).`;
+      cta = roomMessageCta(n);
       break;
     case "comment":
       if (n.isMentioned) {
@@ -12257,7 +12461,13 @@ Comment: "${n.preview}"`;
 Scope: ${truncated}`;
   }
   let prompt;
-  if (n.type === "comment" && n.isMentioned || n.type === "room_message") {
+  if (n.type === "room_message") {
+    const moderationBlock = n.moderationContext != null ? renderModerationContext(n.moderationContext) : "";
+    const preamble = moderationBlock || n.behavioralPrompt;
+    prompt = preamble ? `${preamble}
+
+${ROOM_MESSAGE_RESPONSE_PROMPT}` : ROOM_MESSAGE_RESPONSE_PROMPT;
+  } else if (n.type === "comment" && n.isMentioned) {
     prompt = n.behavioralPrompt ? `${n.behavioralPrompt}
 
 ${ATMENTION_RESPONSE_PROMPT}` : ATMENTION_RESPONSE_PROMPT;
@@ -13801,7 +14011,7 @@ function dumpEvent(event) {
 function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-var PLUGIN_VERSION = true ? "0.31.13" : "unknown";
+var PLUGIN_VERSION = true ? "0.32.1" : "unknown";
 function resolveGatewayToken(api) {
   const token2 = api.config?.gateway?.auth?.token;
   return typeof token2 === "string" ? token2 : null;
@@ -14939,7 +15149,8 @@ Do not attempt more comments until tomorrow.`);
         description: "Post a message in a Cohort Room. Use this to reply when you are participating in a Room chat.",
         parameters: Type.Object({
           room_id: Type.String({ description: "Room ID supplied by Cohort, e.g. rooms:abc123" }),
-          message: Type.String({ description: "Message text to post in the Room" })
+          message: Type.String({ description: "Message text to post in the Room" }),
+          turn_id: Type.Optional(Type.String({ description: "Moderation turn id to attribute this reply to (echo from your prompt)" }))
         }),
         async execute(_toolCallId, params) {
           const rt = getToolRuntime();
@@ -14950,7 +15161,8 @@ Do not attempt more comments until tomorrow.`);
           const result = await callAddRoomMessageFromPlugin(rt.apiKey, {
             roomId: params.room_id,
             agentName,
-            content: params.message
+            content: params.message,
+            ...params.turn_id !== void 0 ? { turnId: params.turn_id } : {}
           });
           return textResult(`Message posted to Room ${params.room_id}.`, result);
         }
@@ -15012,6 +15224,126 @@ Do not attempt more comments until tomorrow.`);
         }
       };
     });
+    api.registerTool((toolCtx) => {
+      const agentId = toolCtx.agentId ?? "main";
+      return {
+        name: "cohort_room_start_moderation_session",
+        label: "cohort_room_start_moderation_session",
+        description: 'Start a managed moderation session in a Cohort Room. Use round_robin = ask every participant to report in; use moderated_qna = route a question to one selected agent, wait for the answer, ask the asker whether it resolves the question, then complete. For multiple experts in Q&A, start with one best agent and use action: "followup" for additional experts one at a time. Returns the session state block. The returned block includes the session_id \u2014 pass it to cohort_room_advance_moderation_session for every subsequent action.',
+        parameters: Type.Object({
+          room_id: Type.String({ description: "Room ID supplied by Cohort, e.g. rooms:abc123" }),
+          mode: Type.Union([
+            Type.Literal("round_robin"),
+            Type.Literal("moderated_qna")
+          ], { description: 'Session mode: "round_robin" means every participant reports in; "moderated_qna" means one selected participant answers a question, with serial followups for more experts.' }),
+          objective: Type.String({ description: "One-line objective for the session, e.g. 'Daily standup: blockers and progress'" }),
+          participant_names: Type.Array(Type.String(), { description: "Cohort agent names to include, in speaking order; moderated_qna should include exactly one best agent" }),
+          question_text: Type.Optional(Type.String({ description: "moderated_qna only: the question to ask the selected participant" })),
+          auto_advance: Type.Optional(Type.Boolean({ description: "round_robin only: automatically prompt the next participant after each matched response" }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_room_start_moderation_session is not ready yet \u2014 the plugin is still starting up. Try again in a few seconds.");
+          }
+          const moderatorAgentName = rt.resolveAgentName(agentId);
+          try {
+            const result = await callStartModerationSessionFromPlugin(rt.apiKey, {
+              roomId: params.room_id,
+              moderatorAgentName,
+              mode: params.mode,
+              objective: params.objective,
+              participantAgentNames: params.participant_names,
+              ...params.question_text !== void 0 ? { questionText: params.question_text } : {},
+              ...params.auto_advance !== void 0 ? { autoAdvance: params.auto_advance } : {}
+            });
+            return textResult(result.stateBlock, result);
+          } catch (err) {
+            const msg = getConvexAppErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+            return textResult(`Failed to start moderation session: ${msg}`);
+          }
+        }
+      };
+    });
+    api.registerTool((toolCtx) => {
+      const agentId = toolCtx.agentId ?? "main";
+      return {
+        name: "cohort_room_advance_moderation_session",
+        label: "cohort_room_advance_moderation_session",
+        description: 'Advance a moderation session you are running: "next" prompts the next round-robin participant, "retry"/"skip"/"accept" resolve a mismatched turn, followup asks one additional Q&A expert after the first answer, and "complete" ends the session. For moderated_qna, confirm with the asker before complete. Outcomes passed with action "complete" (summary, decisions, proposed_tasks, follow_ups) become the session recap; proposed_tasks surface for human approval. Returns the updated session state block.',
+        parameters: Type.Object({
+          session_id: Type.String({ description: "Moderation session ID returned by cohort_room_start_moderation_session" }),
+          action: Type.Union([
+            Type.Literal("next"),
+            Type.Literal("retry"),
+            Type.Literal("skip"),
+            Type.Literal("accept"),
+            Type.Literal("followup"),
+            Type.Literal("complete")
+          ], { description: "next = prompt the next round-robin participant (from waiting); retry = re-prompt the same agent; skip = skip the expected agent and move on; accept = accept an out-of-order reply as the response; followup = route one additional Q&A question to one target agent; complete = finish after asker confirmation when in Q&A (pass summary/decisions/proposed_tasks to create the recap)." }),
+          prompt: Type.Optional(Type.String({ description: "Custom prompt for the turn (next/retry/followup)" })),
+          target_agent_name: Type.Optional(Type.String({ description: "followup only: the agent to ask" })),
+          summary: Type.Optional(Type.String({ description: "complete only: session recap summary" })),
+          decisions: Type.Optional(Type.Array(Type.String(), { description: "complete only: decisions reached" })),
+          proposed_tasks: Type.Optional(Type.Array(Type.String(), { description: "complete only: proposed tasks for human approval" })),
+          follow_ups: Type.Optional(Type.Array(Type.String(), { description: "complete only: follow-up items" }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_room_advance_moderation_session is not ready yet \u2014 the plugin is still starting up. Try again in a few seconds.");
+          }
+          const moderatorAgentName = rt.resolveAgentName(agentId);
+          try {
+            const result = await callAdvanceModerationSessionFromPlugin(rt.apiKey, {
+              sessionId: params.session_id,
+              moderatorAgentName,
+              action: params.action,
+              ...params.prompt !== void 0 ? { prompt: params.prompt } : {},
+              ...params.target_agent_name !== void 0 ? { targetAgentName: params.target_agent_name } : {},
+              ...params.summary !== void 0 ? { summary: params.summary } : {},
+              ...params.decisions !== void 0 ? { decisions: params.decisions } : {},
+              ...params.proposed_tasks !== void 0 ? { proposedTasks: params.proposed_tasks } : {},
+              ...params.follow_ups !== void 0 ? { followUps: params.follow_ups } : {}
+            });
+            return textResult(result.stateBlock, result);
+          } catch (err) {
+            const msg = getConvexAppErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+            return textResult(`Failed to advance moderation session: ${msg}`);
+          }
+        }
+      };
+    });
+    api.registerTool((toolCtx) => {
+      const agentId = toolCtx.agentId ?? "main";
+      return {
+        name: "cohort_room_cancel_moderation_session",
+        label: "cohort_room_cancel_moderation_session",
+        description: "Cancel a moderation session you are running (e.g. superseded, no longer needed). Only valid while the session is queued, active, or waiting \u2014 completed/failed sessions cannot be canceled. Returns the final session state block.",
+        parameters: Type.Object({
+          session_id: Type.String({ description: "Moderation session ID to cancel" }),
+          reason: Type.Optional(Type.String({ description: "Short reason for canceling" }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_room_cancel_moderation_session is not ready yet \u2014 the plugin is still starting up. Try again in a few seconds.");
+          }
+          const moderatorAgentName = rt.resolveAgentName(agentId);
+          try {
+            const result = await callCancelModerationSessionFromPlugin(rt.apiKey, {
+              sessionId: params.session_id,
+              moderatorAgentName,
+              ...params.reason !== void 0 ? { reason: params.reason } : {}
+            });
+            return textResult(result.stateBlock, result);
+          } catch (err) {
+            const msg = getConvexAppErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+            return textResult(`Failed to cancel moderation session: ${msg}`);
+          }
+        }
+      };
+    });
     api.registerTool(() => {
       return {
         name: "cohort_context",

package/dist/openclaw.plugin.json

@@ -14,6 +14,9 @@
       "cohort_room_message",
       "cohort_room_prompt_agent",
       "cohort_room_prompt_agents",
+      "cohort_room_start_moderation_session",
+      "cohort_room_advance_moderation_session",
+      "cohort_room_cancel_moderation_session",
       "cohort_context",
       "cohort_briefing_context",
       "cohort_briefing",
@@ -77,5 +80,5 @@
       }
     }
   },
-  "version": "0.31.13"
+  "version": "0.32.1"
 }

package/dist/package.json

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

package/openclaw.plugin.json

@@ -12,6 +12,9 @@
       "cohort_room_message",
       "cohort_room_prompt_agent",
       "cohort_room_prompt_agents",
+      "cohort_room_start_moderation_session",
+      "cohort_room_advance_moderation_session",
+      "cohort_room_cancel_moderation_session",
       "cohort_context",
       "cohort_briefing_context",
       "cohort_briefing",

package/package.json

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