chainlesschain 0.45.81 → 0.47.0

package/src/gateways/ws/action-protocol.js

@@ -19,22 +19,51 @@ export async function handleCoworkTask(server, id, ws, message) {
   _runningTasks.set(trackingId, ac);
 
   try {
-    const { runCoworkTask } = await import("../../lib/cowork-task-runner.js");
+    const { runCoworkTask, runCoworkTaskParallel, runCoworkDebate } =
+      await import("../../lib/cowork-task-runner.js");
+    const { getTemplate } = await import("../../lib/cowork-task-templates.js");
+
+    // Determine execution mode: debate > parallel > sequential
+    const template = getTemplate(templateId);
+    const useDebate =
+      message.mode === "debate" ||
+      (message.mode !== "agent" && template.mode === "debate");
+    const useParallel =
+      !useDebate &&
+      (message.parallel === true ||
+        (message.parallel !== false && template.parallelStrategy === "always"));
 
     server._send(ws, {
       id,
       type: "cowork:started",
       templateId,
       trackingId,
+      parallel: useParallel,
+      mode: useDebate ? "debate" : "agent",
     });
 
-    const result = await runCoworkTask({
+    const runner = useDebate
+      ? runCoworkDebate
+      : useParallel
+        ? runCoworkTaskParallel
+        : runCoworkTask;
+
+    const result = await runner({
       templateId,
       userMessage,
       files,
       cwd: server.projectRoot || process.cwd(),
       llmOptions: {},
       signal: ac.signal,
+      ...(useParallel
+        ? {
+            agents: message.agents || 3,
+            strategy: message.strategy,
+          }
+        : {}),
+      ...(useDebate && message.perspectives
+        ? { perspectives: message.perspectives }
+        : {}),
       onProgress: (progress) => {
         server._send(ws, {
           id,
@@ -59,6 +88,17 @@ export async function handleCoworkTask(server, id, ws, message) {
       toolsUsed: result.result?.toolsUsed || [],
       iterationCount: result.result?.iterationCount || 0,
       tokenCount: result.result?.tokenCount || 0,
+      parallel: result.parallel || false,
+      subtaskCount: result.result?.subtaskCount || 0,
+      mode: result.mode || (useDebate ? "debate" : "agent"),
+      ...(useDebate
+        ? {
+            verdict: result.result?.verdict,
+            consensusScore: result.result?.consensusScore,
+            reviews: result.result?.reviews || [],
+            perspectives: result.result?.perspectives || [],
+          }
+        : {}),
     });
   } catch (err) {
     server._send(ws, {
@@ -235,3 +275,143 @@ export async function handleOrchestrate(server, id, ws, message) {
     });
   }
 }
+
+// ─── Workflow (N1) ───────────────────────────────────────────────────────────
+
+function _cwd(server) {
+  return server.projectRoot || process.cwd();
+}
+
+function _sendError(server, ws, id, code, message) {
+  server._send(ws, { id, type: "error", code, message });
+}
+
+export async function handleWorkflowList(server, id, ws) {
+  try {
+    const { listWorkflows } = await import("../../lib/cowork-workflow.js");
+    const workflows = listWorkflows(_cwd(server));
+    server._send(ws, { id, type: "workflow:list", workflows });
+  } catch (err) {
+    _sendError(server, ws, id, "WORKFLOW_LIST_FAILED", err.message);
+  }
+}
+
+export async function handleWorkflowGet(server, id, ws, message) {
+  const { id: wfId } = message || {};
+  if (!wfId) return _sendError(server, ws, id, "MISSING_ID", "id required");
+  try {
+    const { getWorkflow } = await import("../../lib/cowork-workflow.js");
+    const workflow = getWorkflow(_cwd(server), wfId);
+    server._send(ws, { id, type: "workflow:get", workflow: workflow || null });
+  } catch (err) {
+    _sendError(server, ws, id, "WORKFLOW_GET_FAILED", err.message);
+  }
+}
+
+export async function handleWorkflowSave(server, id, ws, message) {
+  const { workflow } = message || {};
+  if (!workflow || typeof workflow !== "object") {
+    return _sendError(
+      server,
+      ws,
+      id,
+      "INVALID_WORKFLOW",
+      "workflow object required",
+    );
+  }
+  try {
+    const { validateWorkflow, saveWorkflow } =
+      await import("../../lib/cowork-workflow.js");
+    const result = validateWorkflow(workflow);
+    if (!result.valid) {
+      return _sendError(
+        server,
+        ws,
+        id,
+        "WORKFLOW_INVALID",
+        result.errors.join("; "),
+      );
+    }
+    saveWorkflow(_cwd(server), workflow);
+    server._send(ws, {
+      id,
+      type: "workflow:save",
+      saved: true,
+      workflowId: workflow.id,
+    });
+  } catch (err) {
+    _sendError(server, ws, id, "WORKFLOW_SAVE_FAILED", err.message);
+  }
+}
+
+export async function handleWorkflowRemove(server, id, ws, message) {
+  const { id: wfId } = message || {};
+  if (!wfId) return _sendError(server, ws, id, "MISSING_ID", "id required");
+  try {
+    const { removeWorkflow } = await import("../../lib/cowork-workflow.js");
+    const removed = removeWorkflow(_cwd(server), wfId);
+    server._send(ws, { id, type: "workflow:remove", removed });
+  } catch (err) {
+    _sendError(server, ws, id, "WORKFLOW_REMOVE_FAILED", err.message);
+  }
+}
+
+export async function handleWorkflowRun(server, id, ws, message) {
+  const { id: wfId } = message || {};
+  if (!wfId) return _sendError(server, ws, id, "MISSING_ID", "id required");
+
+  try {
+    const { getWorkflow, executeWorkflow } =
+      await import("../../lib/cowork-workflow.js");
+    const workflow = getWorkflow(_cwd(server), wfId);
+    if (!workflow) {
+      return _sendError(
+        server,
+        ws,
+        id,
+        "WORKFLOW_NOT_FOUND",
+        `No workflow: ${wfId}`,
+      );
+    }
+
+    const runId = `wf-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    server._send(ws, { id, type: "workflow:started", runId, workflowId: wfId });
+
+    const onStepStart = ({ stepId, message: stepMessage }) => {
+      server._send(ws, {
+        id,
+        type: "workflow:step-start",
+        runId,
+        stepId,
+        message: stepMessage,
+      });
+    };
+    const onStepComplete = (outcome) => {
+      server._send(ws, {
+        id,
+        type: "workflow:step-complete",
+        runId,
+        stepId: outcome?.id,
+        status: outcome?.status,
+        summary: outcome?.result?.summary,
+      });
+    };
+
+    const record = await executeWorkflow({
+      workflow,
+      cwd: _cwd(server),
+      onStepStart,
+      onStepComplete,
+    });
+
+    server._send(ws, {
+      id,
+      type: "workflow:done",
+      runId,
+      status: record?.status || "completed",
+      steps: record?.steps || [],
+    });
+  } catch (err) {
+    _sendError(server, ws, id, "WORKFLOW_RUN_FAILED", err.message);
+  }
+}

package/src/gateways/ws/message-dispatcher.js

@@ -47,6 +47,11 @@ export function createWsMessageDispatcher(server) {
         "cowork-cancel": () => server._handleCoworkCancel(id, ws, message),
         "cowork-templates": () => server._handleCoworkTemplates(id, ws),
         "cowork-history": () => server._handleCoworkHistory(id, ws, message),
+        "workflow-list": () => server._handleWorkflowList(id, ws),
+        "workflow-get": () => server._handleWorkflowGet(id, ws, message),
+        "workflow-save": () => server._handleWorkflowSave(id, ws, message),
+        "workflow-remove": () => server._handleWorkflowRemove(id, ws, message),
+        "workflow-run": () => server._handleWorkflowRun(id, ws, message),
         "tasks-list": () => server._handleTasksList(id, ws),
         "tasks-stop": () => server._handleTasksStop(id, ws, message),
         "tasks-detail": () => server._handleTaskDetail(id, ws, message),

package/src/gateways/ws/ws-server.js

@@ -55,6 +55,11 @@ import {
   handleCoworkCancel,
   handleCoworkTemplates,
   handleCoworkHistory,
+  handleWorkflowList,
+  handleWorkflowGet,
+  handleWorkflowSave,
+  handleWorkflowRemove,
+  handleWorkflowRun,
 } from "./action-protocol.js";
 import {
   handleWorktreeDiff,
@@ -321,6 +326,22 @@ export class ChainlessChainWSServer extends EventEmitter {
     return handleCoworkHistory(this, id, ws, message);
   }
 
+  _handleWorkflowList(id, ws) {
+    return handleWorkflowList(this, id, ws);
+  }
+  _handleWorkflowGet(id, ws, message) {
+    return handleWorkflowGet(this, id, ws, message);
+  }
+  _handleWorkflowSave(id, ws, message) {
+    return handleWorkflowSave(this, id, ws, message);
+  }
+  _handleWorkflowRemove(id, ws, message) {
+    return handleWorkflowRemove(this, id, ws, message);
+  }
+  _handleWorkflowRun(id, ws, message) {
+    return handleWorkflowRun(this, id, ws, message);
+  }
+
   /** @private – list background tasks */
   async _handleTasksList(id, ws) {
     try {