@cfio/cohort-sync 0.32.0 → 0.33.0

package/dist/index.js

@@ -2615,6 +2615,9 @@ __export(type_exports2, {
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
 var Type = type_exports2;
 
+// index.ts
+import { Buffer as Buffer2 } from "node:buffer";
+
 // src/hooks.ts
 import fs2 from "node:fs";
 import os2 from "node:os";
@@ -12000,6 +12003,8 @@ var failCommandRef = makeFunctionReference("gatewayCommands:failCommand");
 var getChannelsForPlugin = makeFunctionReference("cloudGatewayChannels:listForPlugin");
 var addCommentFromPluginRef = makeFunctionReference("comments:addCommentFromPlugin");
 var addRoomMessageFromPluginRef = makeFunctionReference("rooms:addMessageFromPlugin");
+var generateWireUploadUrlFromPluginRef = makeFunctionReference("wire:generateUploadUrl");
+var publishWireFromPluginRef = makeFunctionReference("wire:publish");
 var startModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:startFromPlugin");
 var advanceModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:advanceFromPlugin");
 var cancelModerationSessionFromPluginRef = makeFunctionReference("moderationSessions:cancelFromPlugin");
@@ -12133,6 +12138,60 @@ async function callAddRoomMessageFromPlugin(apiKey2, args) {
     throw err;
   }
 }
+async function callGenerateWireUploadUrlFromPlugin(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(generateWireUploadUrlFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      agentName: args.agentName
+    });
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+    }
+    throw err;
+  }
+}
+async function callPublishWireFromPlugin(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(publishWireFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      agentName: args.agentName,
+      kind: args.kind,
+      title: args.title,
+      brief: args.brief,
+      ...args.body !== void 0 ? { body: args.body } : {},
+      ...args.storageId !== void 0 ? { storageId: args.storageId } : {},
+      ...args.mimeType !== void 0 ? { mimeType: args.mimeType } : {},
+      ...args.filename !== void 0 ? { filename: args.filename } : {},
+      ...args.altText !== void 0 ? { altText: args.altText } : {},
+      ...args.roomId !== void 0 ? { roomId: args.roomId } : {},
+      ...args.taskId !== void 0 ? { taskId: args.taskId } : {}
+    });
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+    }
+    throw err;
+  }
+}
 async function callStartModerationSessionFromPlugin(apiKey2, args) {
   if (authCircuitOpen) {
     throw new Error(
@@ -12279,21 +12338,24 @@ var ATMENTION_RESPONSE_PROMPT = `YOU WERE DIRECTLY @-MENTIONED. RESPOND.
 - 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 roundtable, standup, report-in, or panel response, FIRST use cohort_room_start_moderation_session(room_id, mode, objective, participant_names) to run it as a managed session, then drive it with cohort_room_advance_moderation_session; do not only name agents in prose.
+- 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 a roundtable, standup, report-in, or panel response, contribute your own concise update.
+- 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, 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 round robin or Q&A session
-- cohort_room_advance_moderation_session(session_id, action, ...) \u2014 moderator only: advance, retry, skip, accept, followup, or complete the session
+- 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)
+- wire_publish(kind, title, brief, body?, image_base64?, mime_type?, filename?, alt_text?, room_id?, task_id?, in_response_to_steer_id?, delivery_note?) - publish a report or image to Cohort Wire; include in_response_to_steer_id when a WIRE REQUEST block asks for it
+- wire_decline(steer_id, reason) - decline a Wire request you cannot complete
 - 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
@@ -12322,6 +12384,16 @@ var HANDOFF_ACTION_TERMS = [
   "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, "");
 }
@@ -12337,11 +12409,24 @@ function isHumanHandoffRequest(n) {
   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.wireSteerContext != null && renderWireSteerContext(n.wireSteerContext) !== "") {
+    return "Follow the WIRE REQUEST block in this message \u2014 it is authoritative.";
+  }
   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.`;
   }
@@ -12384,6 +12469,47 @@ function renderModerationContext(ctx) {
   lines.push("[/MODERATION SESSION]");
   return lines.join("\n");
 }
+function renderWireSteerContext(ctx) {
+  if (ctx.version !== 1) return "";
+  const artifact = ctx.artifact;
+  const lines = [
+    `[WIRE REQUEST ${ctx.steerId}]`,
+    `Mode: ${ctx.mode} | Contract: ${ctx.contract} | Source: ${artifact.type} ${ctx.wireItemId}`,
+    `Title: ${artifact.title}`,
+    `Brief: ${artifact.brief}`
+  ];
+  if (artifact.body) {
+    lines.push("Artifact body:", artifact.body);
+  }
+  if (artifact.imageUrl) {
+    lines.push(`Artifact URL: ${artifact.imageUrl}`);
+  }
+  lines.push(`Instruction: ${ctx.instruction}`);
+  if (ctx.comments.length > 0) {
+    lines.push(
+      "Recent thread:",
+      ...ctx.comments.map(
+        (comment) => `- ${comment.authorName} (${comment.authorType}): ${comment.body}`
+      )
+    );
+  } else {
+    lines.push("Recent thread: (none)");
+  }
+  const provenance = [
+    ctx.provenance.roomId ? `roomId=${ctx.provenance.roomId}` : "",
+    ctx.provenance.taskId ? `taskId=${ctx.provenance.taskId}` : "",
+    ctx.provenance.sessionId ? `sessionId=${ctx.provenance.sessionId}` : "",
+    ctx.provenance.revisesItemId ? `revisesItemId=${ctx.provenance.revisesItemId}` : "",
+    ctx.provenance.derivedFromItemId ? `derivedFromItemId=${ctx.provenance.derivedFromItemId}` : ""
+  ].filter(Boolean);
+  lines.push(`Provenance: ${provenance.length > 0 ? provenance.join(" | ") : "(none)"}`);
+  lines.push(`NEXT ACTION: ${ctx.deliveryInstruction}`);
+  lines.push(
+    "Do NOT deliver by commenting. Use wire_publish with inResponseToSteerId so Cohort can link the result.",
+    "[/WIRE REQUEST]"
+  );
+  return lines.join("\n");
+}
 function buildNotificationMessage(n) {
   let header;
   let cta;
@@ -12441,8 +12567,9 @@ Scope: ${truncated}`;
   }
   let prompt;
   if (n.type === "room_message") {
-    const moderationBlock = n.moderationContext != null ? renderModerationContext(n.moderationContext) : "";
-    const preamble = moderationBlock || n.behavioralPrompt;
+    const wireSteerBlock = n.wireSteerContext != null ? renderWireSteerContext(n.wireSteerContext) : "";
+    const moderationBlock = !wireSteerBlock && n.moderationContext != null ? renderModerationContext(n.moderationContext) : "";
+    const preamble = wireSteerBlock || moderationBlock || n.behavioralPrompt;
     prompt = preamble ? `${preamble}
 
 ${ROOM_MESSAGE_RESPONSE_PROMPT}` : ROOM_MESSAGE_RESPONSE_PROMPT;
@@ -13990,7 +14117,7 @@ function dumpEvent(event) {
 function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-var PLUGIN_VERSION = true ? "0.32.0" : "unknown";
+var PLUGIN_VERSION = true ? "0.33.0" : "unknown";
 function resolveGatewayToken(api) {
   const token2 = api.config?.gateway?.auth?.token;
   return typeof token2 === "string" ? token2 : null;
@@ -15010,6 +15137,143 @@ var POCKET_GUIDE = `# Cohort Agent Guide (Pocket Version)
 function textResult(text, details) {
   return { content: [{ type: "text", text }], details: details ?? void 0 };
 }
+var WIRE_TITLE_MAX = 200;
+var WIRE_BRIEF_MAX = 2e3;
+var WIRE_BODY_MAX = 32e3;
+var WIRE_FILENAME_MAX = 200;
+var WIRE_MIME_TYPE_MAX = 100;
+var WIRE_ALT_TEXT_MAX = 1e3;
+var WIRE_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+function wireInvalid(message) {
+  return textResult(`Cannot publish to Wire: ${message}.`);
+}
+function requiredWireString(value, field, maxLength) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return { ok: false, message: `${field} is required` };
+  }
+  const trimmed = value.trim();
+  if (trimmed.length > maxLength) {
+    return { ok: false, message: `${field} too long (max ${maxLength} characters)` };
+  }
+  return { ok: true, value: trimmed };
+}
+function optionalWireString(value, field, maxLength) {
+  if (value === void 0 || value === null) {
+    return { ok: true };
+  }
+  if (typeof value !== "string") {
+    return { ok: false, message: `${field} must be a string` };
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return { ok: true };
+  }
+  if (trimmed.length > maxLength) {
+    return { ok: false, message: `${field} too long (max ${maxLength} characters)` };
+  }
+  return { ok: true, value: trimmed };
+}
+function decodeWireImageBase64(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return { ok: false, message: "image_base64 is required" };
+  }
+  const dataUrlMatch = /^data:[^;,]+;base64,([\s\S]*)$/i.exec(value.trim());
+  const normalized = (dataUrlMatch ? dataUrlMatch[1] : value).replace(/\s/g, "");
+  if (!normalized) {
+    return { ok: false, message: "image_base64 is required" };
+  }
+  if (normalized.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    return { ok: false, message: "image_base64 must be valid base64" };
+  }
+  const bytes = Buffer2.from(normalized, "base64");
+  if (bytes.byteLength === 0) {
+    return { ok: false, message: "image_base64 is required" };
+  }
+  if (bytes.byteLength > WIRE_IMAGE_MAX_BYTES) {
+    return { ok: false, message: `image too large (max ${WIRE_IMAGE_MAX_BYTES} bytes)` };
+  }
+  return { ok: true, bytes };
+}
+function getStorageIdFromUploadResponse(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("storageId" in parsed)) {
+      return null;
+    }
+    const storageId = parsed.storageId;
+    return typeof storageId === "string" && storageId.trim() ? storageId.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function formatMetric(metric) {
+  return `${metric.current}/${metric.target} ${metric.unit}`;
+}
+function redactSecrets(text) {
+  return text.replace(/ch_(?:live|test)_[A-Za-z0-9_-]+/g, "[redacted]");
+}
+async function safeHttpError(response) {
+  try {
+    const body = await response.text();
+    const parsed = JSON.parse(body);
+    if (parsed && typeof parsed === "object") {
+      const record = parsed;
+      const message = typeof record.message === "string" ? record.message : record.error && typeof record.error === "object" && typeof record.error.message === "string" ? record.error.message : typeof record.error === "string" ? record.error : null;
+      return message ? `: ${redactSecrets(message).slice(0, 300)}` : "";
+    }
+  } catch {
+  }
+  return "";
+}
+function renderTaskContext(context) {
+  if (!context) return "";
+  const lines = [];
+  if (context.initiative) {
+    const suffix = context.initiative.description ? ` \u2014 ${context.initiative.description}` : "";
+    lines.push(`**Initiative:** ${context.initiative.name}${suffix}`);
+  }
+  if (context.goal) {
+    const metric = context.goal.metric ? ` \u2014 ${formatMetric(context.goal.metric)}` : "";
+    lines.push(`**Goal:** ${context.goal.title} (${context.goal.status})${metric}`);
+    if (context.goal.test) {
+      lines.push(`**Test:** ${context.goal.test}`);
+    }
+  }
+  if (context.project) {
+    const projectDetails = [context.project.status];
+    if (context.project.progress) {
+      projectDetails.push(`${context.project.progress.done}/${context.project.progress.total} tasks done`);
+    }
+    if (context.project.targetDate) {
+      projectDetails.push(`target ${context.project.targetDate}`);
+    }
+    lines.push(`**Project:** ${context.project.title} (${projectDetails.join(", ")})`);
+  }
+  return lines.length > 0 ? ["## Why this matters", ...lines].join("\n") : "";
+}
+function renderGoal(goal) {
+  const lines = [
+    `# Goal: ${goal.title}`,
+    `**Status:** ${goal.status}`
+  ];
+  if (goal.description) {
+    lines.push("", "## Description", goal.description);
+  }
+  if (goal.test) {
+    lines.push("", `**Test:** ${goal.test}`);
+  }
+  if (goal.metric) {
+    lines.push(`**Metric:** ${formatMetric(goal.metric)}`);
+  }
+  if (goal.lastVerification) {
+    const result = goal.lastVerification.passed ? "passed" : "failed";
+    lines.push(
+      `**Last verification:** ${result} by ${goal.lastVerification.byName} (${goal.lastVerification.byType}) at ${goal.lastVerification.at}`,
+      `**Evidence:** ${goal.lastVerification.evidence}`
+    );
+  }
+  return lines.join("\n");
+}
 var sharedHookState = null;
 var plugin = definePluginEntry({
   id: "cohort-sync",
@@ -15203,21 +15467,127 @@ Do not attempt more comments until tomorrow.`);
         }
       };
     });
+    api.registerTool((toolCtx) => {
+      const agentId = toolCtx.agentId ?? "main";
+      return {
+        name: "wire_publish",
+        label: "wire_publish",
+        description: "Publish a report or image to Cohort Wire. For images, pass base64 bytes plus image metadata; the tool uploads the file before publishing.",
+        parameters: Type.Object({
+          kind: Type.Union([
+            Type.Literal("report"),
+            Type.Literal("image")
+          ], { description: 'Publish kind: "report" for text documents, "image" for image files.' }),
+          title: Type.String({ description: `Title shown in Wire, max ${WIRE_TITLE_MAX} characters.` }),
+          brief: Type.String({ description: `Short summary shown in Wire, max ${WIRE_BRIEF_MAX} characters.` }),
+          body: Type.Optional(Type.String({ description: `Report markdown/body text, max ${WIRE_BODY_MAX} characters. Used with kind=report.` })),
+          image_base64: Type.Optional(Type.String({ description: `Base64 image bytes, max ${WIRE_IMAGE_MAX_BYTES} decoded bytes. Used with kind=image.` })),
+          mime_type: Type.Optional(Type.String({ description: `Image MIME type such as image/png, max ${WIRE_MIME_TYPE_MAX} characters. Used with kind=image.` })),
+          filename: Type.Optional(Type.String({ description: `Original image filename, max ${WIRE_FILENAME_MAX} characters. Used with kind=image.` })),
+          alt_text: Type.Optional(Type.String({ description: `Accessible image description, max ${WIRE_ALT_TEXT_MAX} characters. Used with kind=image.` })),
+          room_id: Type.Optional(Type.String({ description: "Optional Cohort Room ID to link this Wire item to." })),
+          task_id: Type.Optional(Type.String({ description: "Optional Cohort task ID to link this Wire item to." }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("wire_publish is not ready yet - the plugin is still starting up. Try again in a few seconds.");
+          }
+          const title = requiredWireString(params.title, "title", WIRE_TITLE_MAX);
+          if (!title.ok) return wireInvalid(title.message);
+          const brief = requiredWireString(params.brief, "brief", WIRE_BRIEF_MAX);
+          if (!brief.ok) return wireInvalid(brief.message);
+          const roomId = optionalWireString(params.room_id, "room_id", WIRE_TITLE_MAX);
+          if (!roomId.ok) return wireInvalid(roomId.message);
+          const taskId = optionalWireString(params.task_id, "task_id", WIRE_TITLE_MAX);
+          if (!taskId.ok) return wireInvalid(taskId.message);
+          const agentName = rt.resolveAgentName(agentId);
+          if (params.kind === "report") {
+            const body = optionalWireString(params.body, "body", WIRE_BODY_MAX);
+            if (!body.ok) return wireInvalid(body.message);
+            try {
+              const result = await callPublishWireFromPlugin(rt.apiKey, {
+                agentName,
+                kind: "report",
+                title: title.value,
+                brief: brief.value,
+                ...body.value !== void 0 ? { body: body.value } : {},
+                ...roomId.value !== void 0 ? { roomId: roomId.value } : {},
+                ...taskId.value !== void 0 ? { taskId: taskId.value } : {}
+              });
+              return textResult(`Published report to Wire.
+Wire item: ${result.wireItemId}`, result);
+            } catch (err) {
+              const msg = getConvexAppErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+              return textResult(`Failed to publish to Wire: ${msg}`);
+            }
+          }
+          if (params.kind !== "image") {
+            return wireInvalid('kind must be "report" or "image"');
+          }
+          const mimeType = requiredWireString(params.mime_type, "mime_type", WIRE_MIME_TYPE_MAX);
+          if (!mimeType.ok) return wireInvalid(mimeType.message);
+          if (!mimeType.value.startsWith("image/")) {
+            return wireInvalid("mime_type must start with image/");
+          }
+          const filename = requiredWireString(params.filename, "filename", WIRE_FILENAME_MAX);
+          if (!filename.ok) return wireInvalid(filename.message);
+          const altText = requiredWireString(params.alt_text, "alt_text", WIRE_ALT_TEXT_MAX);
+          if (!altText.ok) return wireInvalid(altText.message);
+          const image = decodeWireImageBase64(params.image_base64);
+          if (!image.ok) return wireInvalid(image.message);
+          try {
+            const uploadUrl = await callGenerateWireUploadUrlFromPlugin(rt.apiKey, { agentName });
+            const uploadResponse = await fetch(uploadUrl, {
+              method: "POST",
+              headers: { "Content-Type": mimeType.value },
+              body: new Blob([image.bytes], { type: mimeType.value }),
+              signal: AbortSignal.timeout(3e4)
+            });
+            const uploadBody = await uploadResponse.text();
+            if (!uploadResponse.ok) {
+              return textResult(`Failed to upload image to Wire: ${uploadResponse.status} ${uploadBody.slice(0, 300)}`);
+            }
+            const storageId = getStorageIdFromUploadResponse(uploadBody);
+            if (!storageId) {
+              return textResult("Failed to upload image to Wire: upload response did not include storageId.");
+            }
+            const result = await callPublishWireFromPlugin(rt.apiKey, {
+              agentName,
+              kind: "image",
+              title: title.value,
+              brief: brief.value,
+              storageId,
+              mimeType: mimeType.value,
+              filename: filename.value,
+              altText: altText.value,
+              ...roomId.value !== void 0 ? { roomId: roomId.value } : {},
+              ...taskId.value !== void 0 ? { taskId: taskId.value } : {}
+            });
+            return textResult(`Published image to Wire.
+Wire item: ${result.wireItemId}`, result);
+          } catch (err) {
+            const msg = getConvexAppErrorMessage(err) ?? (err instanceof Error ? err.message : String(err));
+            return textResult(`Failed to publish to Wire: ${msg}`);
+          }
+        }
+      };
+    });
     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. This is THE way to run round robins and moderated Q&A as the Room moderator: the backend prompts each participant in turn, tracks who responded, and tells you when to advance. 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.",
+        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" (each participant responds in turn) or "moderated_qna" (one participant answers a question)' }),
+          ], { 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" }),
-          question_text: Type.Optional(Type.String({ description: "moderated_qna only: the question to ask the participant" })),
+          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) {
@@ -15249,7 +15619,7 @@ Do not attempt more comments until tomorrow.`);
       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 participant, "retry"/"skip"/"accept" resolve a mismatched turn, "followup" asks a target a follow-up question, and "complete" ends the session. 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.',
+        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([
@@ -15259,7 +15629,7 @@ Do not attempt more comments until tomorrow.`);
             Type.Literal("accept"),
             Type.Literal("followup"),
             Type.Literal("complete")
-          ], { description: "next = prompt the next 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 a follow-up question (Q&A only); complete = finish the session (pass summary/decisions/proposed_tasks to create the recap)." }),
+          ], { 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" })),
@@ -15457,11 +15827,13 @@ ${body}`,
               `# Task #${task.taskNumber}: ${task.title}`,
               `**Status:** ${task.status} | **Priority:** ${task.priority ?? "none"} | **Effort:** ${task.effort ?? "none"}`,
               `**Assigned to:** ${task.assignedTo ?? "unassigned"}`,
-              `**Created:** ${task.createdAt}`,
-              "",
-              "## Description",
-              task.description || "(no description)"
+              `**Created:** ${task.createdAt}`
             ];
+            const contextBlock = renderTaskContext(task.context);
+            if (contextBlock) {
+              lines.push("", contextBlock);
+            }
+            lines.push("", "## Description", task.description || "(no description)");
             if (params.include_comments !== false) {
               const limit = params.comment_limit ?? 10;
               const commentsRes = await fetch(
@@ -15492,6 +15864,62 @@ ${body}`,
         }
       };
     });
+    api.registerTool(() => {
+      return {
+        name: "cohort_goal",
+        label: "cohort_goal",
+        description: "Fetch a Cohort goal \u2014 including its test \u2014 or submit a verification result after running the test. A goal's test tells you how to check whether the outcome is achieved.",
+        parameters: Type.Object({
+          goal_id: Type.String({ description: "Goal ID from Cohort." }),
+          verify: Type.Optional(Type.Object({
+            passed: Type.Boolean({ description: "Whether the goal test passed." }),
+            evidence: Type.String({ description: "Evidence from running the test." }),
+            metric_current: Type.Optional(Type.Number({ description: "Updated current metric value, if the goal has a metric." }))
+          }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_goal is not ready yet \u2014 the plugin is still starting up.");
+          }
+          const goalUrl = `${rt.apiUrl}/api/v1/goals/${encodeURIComponent(params.goal_id)}`;
+          try {
+            const response = await fetch(
+              params.verify ? `${goalUrl}/verify` : goalUrl,
+              {
+                method: params.verify ? "POST" : "GET",
+                headers: {
+                  "Authorization": `Bearer ${rt.apiKey}`,
+                  ...params.verify ? { "Content-Type": "application/json" } : {}
+                },
+                ...params.verify ? {
+                  body: JSON.stringify({
+                    passed: params.verify.passed,
+                    evidence: params.verify.evidence,
+                    ...params.verify.metric_current !== void 0 ? { metricCurrent: params.verify.metric_current } : {}
+                  })
+                } : {},
+                signal: AbortSignal.timeout(1e4)
+              }
+            );
+            if (!response.ok) {
+              const message = await safeHttpError(response);
+              return textResult(`Failed to fetch goal ${params.goal_id}: ${response.status}${message}`);
+            }
+            const goal = await response.json();
+            if (!params.verify) {
+              return textResult(renderGoal(goal), goal);
+            }
+            const explanation = goal.status === "verification_pending" ? "Reported. A human will confirm before the goal is marked met." : goal.status === "met" ? "Goal marked met." : `Verification recorded. Goal status: ${goal.status}.`;
+            return textResult(`${explanation}
+
+${renderGoal(goal)}`, goal);
+          } catch (err) {
+            return textResult(`Failed to fetch goal ${params.goal_id}: ${err instanceof Error ? redactSecrets(err.message) : "Unknown error"}`);
+          }
+        }
+      };
+    });
     api.registerTool((toolCtx) => {
       const agentId = toolCtx.agentId ?? "main";
       return {
@@ -15599,5 +16027,6 @@ ${body}`,
 });
 var index_default = plugin;
 export {
-  index_default as default
+  index_default as default,
+  renderTaskContext
 };

package/dist/openclaw.plugin.json

@@ -17,10 +17,12 @@
       "cohort_room_start_moderation_session",
       "cohort_room_advance_moderation_session",
       "cohort_room_cancel_moderation_session",
+      "wire_publish",
       "cohort_context",
       "cohort_briefing_context",
       "cohort_briefing",
       "cohort_task",
+      "cohort_goal",
       "cohort_transition",
       "cohort_assign"
     ]
@@ -80,5 +82,5 @@
       }
     }
   },
-  "version": "0.32.0"
+  "version": "0.33.0"
 }

package/dist/package.json

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

package/openclaw.plugin.json

@@ -15,10 +15,12 @@
       "cohort_room_start_moderation_session",
       "cohort_room_advance_moderation_session",
       "cohort_room_cancel_moderation_session",
+      "wire_publish",
       "cohort_context",
       "cohort_briefing_context",
       "cohort_briefing",
       "cohort_task",
+      "cohort_goal",
       "cohort_transition",
       "cohort_assign"
     ]

package/package.json

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