@cfio/cohort-sync 0.34.1 → 0.34.2

package/dist/index.js

@@ -14119,7 +14119,7 @@ function dumpEvent(event) {
 function positiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-var PLUGIN_VERSION = true ? "0.34.1" : "unknown";
+var PLUGIN_VERSION = true ? "0.34.2" : "unknown";
 function resolveGatewayToken(api) {
   const token2 = api.config?.gateway?.auth?.token;
   return typeof token2 === "string" ? token2 : null;
@@ -15212,9 +15212,87 @@ function getStorageIdFromUploadResponse(body) {
 function formatMetric(metric) {
   return `${metric.current}/${metric.target} ${metric.unit}`;
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
 function redactSecrets(text) {
   return text.replace(/ch_(?:live|test)_[A-Za-z0-9_-]+/g, "[redacted]");
 }
+function isTaskRelationSummary(value) {
+  if (!isRecord2(value) || !isRecord2(value.task)) return false;
+  return typeof value.id === "string" && (value.type === "blocks" || value.type === "related" || value.type === "duplicate_of") && (value.direction === "incoming" || value.direction === "outgoing") && (value.task.taskNumber === void 0 || typeof value.task.taskNumber === "number") && (value.task.title === void 0 || typeof value.task.title === "string") && typeof value.task.status === "string" && (typeof value.task.assignedTo === "string" || value.task.assignedTo === null);
+}
+function relationTaskLabel(relation) {
+  const id = relation.task.taskNumber !== void 0 ? `#${relation.task.taskNumber}` : relation.task.title ?? "untitled task";
+  return `${id} (${relation.task.status}, ${relation.task.assignedTo ?? "unassigned"})`;
+}
+function formatTaskRelationsSummary(relations) {
+  if (!Array.isArray(relations)) return [];
+  const rows = relations.filter(isTaskRelationSummary);
+  if (rows.length === 0) return [];
+  const groups = [
+    { label: "Blocked by", rows: rows.filter((r) => r.type === "blocks" && r.direction === "incoming") },
+    { label: "Blocks", rows: rows.filter((r) => r.type === "blocks" && r.direction === "outgoing") },
+    { label: "Related", rows: rows.filter((r) => r.type === "related") },
+    { label: "Duplicate of", rows: rows.filter((r) => r.type === "duplicate_of" && r.direction === "outgoing") },
+    { label: "Duplicated by", rows: rows.filter((r) => r.type === "duplicate_of" && r.direction === "incoming") }
+  ];
+  return groups.filter((group) => group.rows.length > 0).map((group) => `${group.label}: ${group.rows.map(relationTaskLabel).join(", ")}`);
+}
+function blockerLine(blocker) {
+  const id = blocker.taskNumber !== void 0 ? `#${blocker.taskNumber}` : "Unnumbered task";
+  return `${id} ${blocker.title} (${blocker.status}, ${blocker.assignedTo ?? "unassigned"})`;
+}
+function getTaskBlockedErrorData(error) {
+  if (!isRecord2(error) || !isRecord2(error.data)) return null;
+  const data = error.data;
+  if (data.code !== "CONFLICT" || data.subcode !== "TASK_BLOCKED" || typeof data.message !== "string") {
+    return null;
+  }
+  const blockers = Array.isArray(data.blockers) ? data.blockers.flatMap((blocker) => {
+    if (!isRecord2(blocker) || typeof blocker.title !== "string" || typeof blocker.status !== "string") {
+      return [];
+    }
+    const assignedTo = typeof blocker.assignedTo === "string" ? blocker.assignedTo : null;
+    return [{
+      ...typeof blocker.taskNumber === "number" ? { taskNumber: blocker.taskNumber } : {},
+      title: blocker.title,
+      status: blocker.status,
+      assignedTo
+    }];
+  }) : void 0;
+  return {
+    code: "CONFLICT",
+    subcode: "TASK_BLOCKED",
+    message: data.message,
+    ...blockers ? { blockers } : {}
+  };
+}
+function formatTaskBlockedError(error) {
+  const data = getTaskBlockedErrorData(error);
+  if (!data) return null;
+  const lines = [data.message];
+  if (data.blockers && data.blockers.length > 0) {
+    lines.push("", "Open blockers:");
+    for (const blocker of data.blockers) {
+      lines.push(`- ${blockerLine(blocker)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function relationMatchesVerb(relation, relationVerb, otherTaskNumber) {
+  if (relation.task.taskNumber !== otherTaskNumber) return false;
+  switch (relationVerb) {
+    case "blocked_by":
+      return relation.type === "blocks" && relation.direction === "incoming";
+    case "blocks":
+      return relation.type === "blocks" && relation.direction === "outgoing";
+    case "related":
+      return relation.type === "related";
+    case "duplicate_of":
+      return relation.type === "duplicate_of" && relation.direction === "outgoing";
+  }
+}
 async function safeHttpError(response) {
   try {
     const body = await response.text();
@@ -15842,10 +15920,17 @@ ${body}`,
               `**Assigned to:** ${task.assignedTo ?? "unassigned"}`,
               `**Created:** ${task.createdAt}`
             ];
+            if (task.blocked === true) {
+              lines.push("**Blocked:** yes");
+            }
             const contextBlock = renderTaskContext(task.context);
             if (contextBlock) {
               lines.push("", contextBlock);
             }
+            const relationsSummary = formatTaskRelationsSummary(task.relations);
+            if (relationsSummary.length > 0) {
+              lines.push("", "## Relations", ...relationsSummary);
+            }
             lines.push("", "## Description", task.description || "(no description)");
             if (params.include_comments !== false) {
               const limit = params.comment_limit ?? 10;
@@ -15961,7 +16046,92 @@ ${renderGoal(goal)}`, goal);
             });
             return textResult(`Task #${params.task_number} transitioned to "${params.status}".`);
           } catch (err) {
-            return textResult(`Failed to transition task #${params.task_number}: ${err instanceof Error ? err.message : String(err)}`);
+            const blockedMessage = formatTaskBlockedError(err);
+            if (blockedMessage) {
+              return textResult(blockedMessage, getTaskBlockedErrorData(err));
+            }
+            const appMessage = getConvexAppErrorMessage(err);
+            return textResult(`Failed to transition task #${params.task_number}: ${appMessage ?? (err instanceof Error ? err.message : String(err))}`);
+          }
+        }
+      };
+    });
+    api.registerTool(() => {
+      return {
+        name: "cohort_relate",
+        label: "cohort_relate",
+        description: "Create or remove Cohort task relations by task number. This is THE way to decompose work into ordered blockers: create blocker tasks, then relate them with blocked_by or blocks so Cohort can sequence handoffs.",
+        parameters: Type.Object({
+          task_number: Type.Number({ description: "Primary task number (e.g. 214)." }),
+          relation: Type.Union([
+            Type.Literal("blocked_by"),
+            Type.Literal("blocks"),
+            Type.Literal("related"),
+            Type.Literal("duplicate_of")
+          ], { description: "Relation from task_number to other_task_number." }),
+          other_task_number: Type.Number({ description: "Other task number to relate to the primary task." }),
+          remove: Type.Optional(Type.Boolean({ description: "Set true to remove the matching relation instead of creating it." }))
+        }),
+        async execute(_toolCallId, params) {
+          const rt = getToolRuntime();
+          if (!rt.isReady) {
+            return textResult("cohort_relate is not ready yet \u2014 the plugin is still starting up.");
+          }
+          if (params.task_number === params.other_task_number) {
+            return textResult("Cannot relate a task to itself.");
+          }
+          try {
+            if (!params.remove) {
+              const response = await fetch(`${rt.apiUrl}/api/v1/tasks/${params.task_number}/relations`, {
+                method: "POST",
+                headers: {
+                  "Authorization": `Bearer ${rt.apiKey}`,
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                  type: params.relation,
+                  taskNumber: params.other_task_number
+                }),
+                signal: AbortSignal.timeout(1e4)
+              });
+              if (!response.ok) {
+                const message = await safeHttpError(response);
+                return textResult(`Failed to relate task #${params.task_number}: ${response.status}${message}`);
+              }
+              const relation2 = await response.json();
+              return textResult(`Related task #${params.task_number} ${params.relation} #${params.other_task_number}.`, relation2);
+            }
+            const taskResponse = await fetch(`${rt.apiUrl}/api/v1/tasks/${params.task_number}`, {
+              headers: { "Authorization": `Bearer ${rt.apiKey}` },
+              signal: AbortSignal.timeout(1e4)
+            });
+            if (!taskResponse.ok) {
+              const message = await safeHttpError(taskResponse);
+              return textResult(`Failed to inspect task #${params.task_number}: ${taskResponse.status}${message}`);
+            }
+            const task = await taskResponse.json();
+            const relations = Array.isArray(task.relations) ? task.relations.filter(isTaskRelationSummary) : [];
+            const relation = relations.find(
+              (candidate) => relationMatchesVerb(candidate, params.relation, params.other_task_number)
+            );
+            if (!relation) {
+              return textResult(`No ${params.relation} relation found between task #${params.task_number} and #${params.other_task_number}.`);
+            }
+            const deleteResponse = await fetch(
+              `${rt.apiUrl}/api/v1/tasks/${params.task_number}/relations/${encodeURIComponent(relation.id)}`,
+              {
+                method: "DELETE",
+                headers: { "Authorization": `Bearer ${rt.apiKey}` },
+                signal: AbortSignal.timeout(1e4)
+              }
+            );
+            if (!deleteResponse.ok) {
+              const message = await safeHttpError(deleteResponse);
+              return textResult(`Failed to remove relation from task #${params.task_number}: ${deleteResponse.status}${message}`);
+            }
+            return textResult(`Removed ${params.relation} relation between task #${params.task_number} and #${params.other_task_number}.`);
+          } catch (err) {
+            return textResult(`Failed to relate task #${params.task_number}: ${err instanceof Error ? redactSecrets(err.message) : "Unknown error"}`);
           }
         }
       };

package/dist/openclaw.plugin.json

@@ -82,5 +82,5 @@
       }
     }
   },
-  "version": "0.34.1"
+  "version": "0.34.2"
 }

package/dist/package.json

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

package/package.json

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