cli-blueprint 0.2.2 → 0.2.4

package/skills/swarm/swarm-runtime.mjs

@@ -0,0 +1,600 @@
+// swarm runtime v0.2.0 — 智能体蜂群编排的确定性运行时（可选 Blueprint 协同规划）
+// 自包含、无外部依赖。通过组织架构规则调度 N 个子智能体，
+// 围绕项目 JSON 完成 派单/认领/回传，红绿灯状态 + 进度/错误汇报，
+// 固定 运维智能体（心跳/回收/接替/继承）与 安全守卫智能体（注入/危险指令检测）。
+const REQUEST_SCHEMA = "swarm.skill.request/1.0";
+const RESPONSE_SCHEMA = "swarm.skill.response/1.0";
+const ERROR_SCHEMA = "swarm.skill.error/1.0";
+const ORG_SCHEMA = "swarm.org-chart/1.0";
+const TASK_SCHEMA = "swarm.tasks/1.0";
+const COMPILER_NAME = "swarm";
+const COMPILER_VERSION = "0.2.0";
+
+const PURE_OPERATIONS = new Set([
+  "capabilities", "help", "intake", "org-chart", "blueprint-bridge", "dispatch", "claim",
+  "report", "swarm-status", "traffic-light", "security-check", "validate-json",
+]);
+
+// ---------- 工具函数 ----------
+function text(value) { return String(value ?? ""); }
+
+function okResponse(requestId, payload) {
+  return { schemaVersion: RESPONSE_SCHEMA, requestId, status: "succeeded", ...payload };
+}
+
+function blockedResponse(requestId, request, findings) {
+  return {
+    schemaVersion: RESPONSE_SCHEMA,
+    requestId,
+    status: "blocked",
+    brainMode: null,
+    requestedBrainMode: request?.requestedBrainMode ?? "ide",
+    brainUsed: false,
+    revision: null,
+    validation: { valid: false, guarantee: "blocked", findings },
+  };
+}
+
+function finding(severity, ruleId, entityRef, message, evidence = {}) {
+  return { severity, ruleId, entityRef, message, evidence };
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function validId(value) {
+  return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(value);
+}
+
+// ---------- 组织架构（org-chart/1.0） ----------
+const ORG_LAYERS = ["board", "management", "execution"];
+const ORG_ROLES = ["board", "dispatcher", "ops", "security-guard", "worker"];
+const ORG_FIXED_ROLES = new Set(["board", "dispatcher", "ops", "security-guard"]);
+
+const ORG_PERMISSIONS = {
+  board: ["dispatch", "accept", "reject", "stop", "reclaim", "replace"],
+  dispatcher: ["dispatch", "reassign", "prioritize"],
+  ops: ["heartbeat", "reclaim", "replace"],
+  "security-guard": ["block", "alert", "quarantine"],
+  worker: ["claim", "report", "request-help"],
+};
+
+/** 生成企业级组织架构（三层）：决策层 + 管理层（dispatcher/ops/security-guard）+ 执行层（N 个 worker） */
+function buildOrgChart(input = {}) {
+  const workerCount = Math.min(50, Math.max(1, Math.floor(Number(input.workerCount) || 4)));
+  const projectName = text(input.projectName || "swarm-run");
+  const org = {
+    schemaVersion: ORG_SCHEMA,
+    projectName,
+    layers: {
+      board: [{ agentId: "board", role: "board", title: "决策层·老板/主智能体" }],
+      management: [
+        { agentId: "dispatcher", role: "dispatcher", title: "管理层·调度智能体", fixed: true },
+        { agentId: "ops", role: "ops", title: "管理层·运维智能体", fixed: true },
+        { agentId: "security-guard", role: "security-guard", title: "管理层·安全守卫智能体", fixed: true },
+      ],
+      execution: Array.from({ length: workerCount }, (_, index) => ({
+        agentId: `worker-${String(index + 1).padStart(3, "0")}`,
+        role: "worker",
+        title: `执行层·子智能体 ${index + 1}`,
+        fixed: false,
+      })),
+    },
+    permissions: ORG_PERMISSIONS,
+  };
+  return org;
+}
+
+/** 校验组织架构 */
+function validateOrgChart(org) {
+  const findings = [];
+  if (!isObject(org)) return [finding("P0", "ORG_OBJECT", "org", "org must be an object")];
+  if (org.schemaVersion !== ORG_SCHEMA) {
+    findings.push(finding("P0", "ORG_SCHEMA_VERSION", "org.schemaVersion", `Expected ${ORG_SCHEMA}`));
+  }
+  for (const layer of ORG_LAYERS) {
+    if (!Array.isArray(org.layers?.[layer])) {
+      findings.push(finding("P0", "ORG_LAYER_ARRAY", `org.layers.${layer}`, "must be an array"));
+    }
+  }
+  return findings;
+}
+
+// ---------- 安全守卫（注入 / 危险指令 / 异常检测） ----------
+const INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?previous\s+instructions/i,
+  /忽略\s*(之前|此前|先前)\s*(的)?(所有)?指令/i,
+  /you\s+are\s+now|act\s+as\s+an?\s+(admin|system|root)/i,
+  /现在你(是|要|必须)/,
+  /(?:系统|system)\s*(提示词|提示|指令)\s*[:：]/,
+];
+const DANGEROUS_PATTERNS = [
+  /\brm\s+-rf\b|\bDROP\s+TABLE\b|\bDELETE\s+FROM\b/i,
+  /\bsudo\b|\bchmod\s+777\b|提权|越权/i,
+  /(?:导出|输出|给出|返回|泄露|外发|发送|上传|回传|读取|获取)[^。\n]{0,24}?(?:api[_-]?\s*key|token|password|secret|密钥|密码|凭据)/i,
+  /(?:api[_-]?\s*key|token|password|secret|密钥|密码|凭据)\s*(?:[:：=]\s*[A-Za-z0-9_\-]{6,}|请\s*(?:输出|给出|返回|提供))/i,
+  /(?:发送|上传|回传|外发)\s*(?:到|至)?\s*https?:\/\//i,
+];
+
+/** 安全守卫检测：返回拦截/警报结果 */
+function securityCheck(content, context = {}) {
+  const input = text(content);
+  const agentId = text(context.agentId || "unknown");
+  const alerts = [];
+  let blocked = false;
+  const injectionHits = INJECTION_PATTERNS
+    .filter((pattern) => pattern.test(input))
+    .map((pattern) => pattern.source);
+  if (injectionHits.length) {
+    blocked = true;
+    alerts.push({
+      alertId: `sec-${Math.random().toString(36).slice(2, 8)}`,
+      severity: "high", rule: "prompt-injection", agentId,
+      source: "task-input", matched: injectionHits, action: "block",
+      at: new Date().toISOString(),
+    });
+  }
+  const dangerHits = DANGEROUS_PATTERNS
+    .filter((pattern) => pattern.test(input))
+    .map((pattern) => pattern.source);
+  if (dangerHits.length) {
+    blocked = true;
+    alerts.push({
+      alertId: `sec-${Math.random().toString(36).slice(2, 8)}`,
+      severity: "high", rule: "dangerous-command", agentId,
+      source: "task-input", matched: dangerHits, action: "block",
+      at: new Date().toISOString(),
+    });
+  }
+  return { allowed: !blocked, blocked, alerts };
+}
+
+// ---------- 任务编排（tasks/1.0） ----------
+const TASK_STATUSES = new Set([
+  "backlog", "assigned", "claimed", "running", "reported", "accepted",
+  "failed", "blocked", "cancelled",
+]);
+
+function validateProjectJson(project) {
+  const findings = [];
+  if (!isObject(project)) return [finding("P0", "PROJECT_OBJECT", "project", "project must be an object")];
+  if (!Array.isArray(project.tasks) || project.tasks.length === 0) {
+    findings.push(finding("P0", "PROJECT_TASKS", "project.tasks", "tasks must be a non-empty array"));
+  }
+  return findings;
+}
+
+/** 项目 JSON → 任务包（backlog 列表） */
+function buildTasks(project, org) {
+  const tasks = (project.tasks ?? []).map((task, index) => ({
+    taskId: validId(task.taskId) ? task.taskId : `task-${String(index + 1).padStart(4, "0")}`,
+    title: text(task.title || task.name || `任务 ${index + 1}`),
+    owner: null,
+    status: "backlog",
+    priority: text(task.priority || "normal"),
+    dependsOn: Array.isArray(task.dependsOn) ? task.dependsOn : [],
+    assignedBy: null,
+    claimedAt: null,
+    reportedAt: null,
+    report: null,
+    progressPercent: 0,
+    progressNote: "",
+    inheritedFrom: null,
+  }));
+  return tasks;
+}
+
+/** 派单：把 backlog 任务派给指定 worker（只有 dispatcher/board 可派） */
+function dispatchTask(tasks, taskId, workerId, actorRole) {
+  if (!ORG_PERMISSIONS[actorRole]?.includes("dispatch")) {
+    return { ok: false, error: `role ${actorRole} cannot dispatch` };
+  }
+  const task = tasks.find((t) => t.taskId === taskId);
+  if (!task) return { ok: false, error: `task ${taskId} not found` };
+  if (task.status !== "backlog") return { ok: false, error: `task ${taskId} is ${task.status}, not backlog` };
+  task.status = "assigned";
+  task.owner = workerId;
+  task.assignedBy = actorRole;
+  return { ok: true, task };
+}
+
+/** 认领：worker 认领 assigned 任务 */
+function claimTask(tasks, taskId, workerId) {
+  const task = tasks.find((t) => t.taskId === taskId);
+  if (!task) return { ok: false, error: `task ${taskId} not found` };
+  if (task.status !== "assigned") return { ok: false, error: `task ${taskId} is ${task.status}, not assigned` };
+  if (task.owner && task.owner !== workerId) return { ok: false, error: `task ${taskId} claimed by another worker` };
+  task.status = "claimed";
+  task.owner = workerId;
+  task.claimedAt = new Date().toISOString();
+  return { ok: true, task };
+}
+
+/** 回传：worker 回传结果 */
+function reportTask(tasks, taskId, workerId, report) {
+  const task = tasks.find((t) => t.taskId === taskId);
+  if (!task) return { ok: false, error: `task ${taskId} not found` };
+  if (task.owner && task.owner !== workerId) return { ok: false, error: `task ${taskId} not owned by ${workerId}` };
+  if (!["claimed", "running"].includes(task.status)) {
+    return { ok: false, error: `task ${taskId} is ${task.status}, cannot report` };
+  }
+  task.status = "reported";
+  task.report = isObject(report) ? report : { output: text(report) };
+  task.reportedAt = new Date().toISOString();
+  return { ok: true, task };
+}
+
+/** 验收：board 验收 */
+function acceptTask(tasks, taskId, accept) {
+  const task = tasks.find((t) => t.taskId === taskId);
+  if (!task) return { ok: false, error: `task ${taskId} not found` };
+  if (task.status !== "reported") return { ok: false, error: `task ${taskId} is ${task.status}, not reported` };
+  task.status = accept ? "accepted" : "failed";
+  return { ok: true, task };
+}
+
+// ---------- 红绿灯 ----------
+function taskTrafficLight(task) {
+  if (["accepted", "reported"].includes(task.status)) return "green";
+  if (task.status === "failed" || task.status === "blocked" || task.status === "cancelled") return "red";
+  if (task.status === "running" || task.status === "claimed") {
+    return task.progressPercent >= 50 ? "green" : "yellow";
+  }
+  return "yellow"; // backlog/assigned 视为待启动
+}
+
+// ---------- 运维（心跳 / 回收 / 接替 / 继承） ----------
+const HEARTBEAT_MISS_LIMIT = 3;
+
+function buildAgents(org, nowIso = null) {
+  const now = nowIso || new Date().toISOString();
+  const agents = [];
+  for (const layer of ORG_LAYERS) {
+    for (const member of org.layers?.[layer] ?? []) {
+      agents.push({
+        agentId: member.agentId,
+        role: member.role,
+        title: member.title,
+        fixed: Boolean(member.fixed),
+        status: "green",
+        lastHeartbeatAt: now,
+        heartbeatMisses: 0,
+        currentTaskId: null,
+        progressPercent: 0,
+        progressNote: "",
+      });
+    }
+  }
+  return agents;
+}
+
+function recordHeartbeat(agents, agentId) {
+  const agent = agents.find((a) => a.agentId === agentId);
+  if (!agent) return { ok: false, error: `agent ${agentId} not found` };
+  agent.lastHeartbeatAt = new Date().toISOString();
+  agent.heartbeatMisses = 0;
+  if (agent.status === "dead" || agent.status === "red") {
+    agent.status = "green";
+  }
+  return { ok: true, agent };
+}
+
+/** 运维心跳扫描：标记心跳停止的 worker 为 red/dead */
+function scanHeartbeats(agents, nowIso = null) {
+  const now = nowIso ? new Date(nowIso).getTime() : Date.now();
+  const dead = [];
+  for (const agent of agents) {
+    if (agent.role !== "worker") continue;
+    const last = new Date(agent.lastHeartbeatAt).getTime();
+    const missedSeconds = (now - last) / 1000;
+    const misses = Math.floor(missedSeconds / 30);
+    agent.heartbeatMisses = Math.max(agent.heartbeatMisses, Math.min(misses, 99));
+    if (agent.heartbeatMisses >= HEARTBEAT_MISS_LIMIT) {
+      if (agent.status !== "dead") {
+        agent.status = "dead";
+        dead.push(agent.agentId);
+      }
+    } else if (agent.heartbeatMisses >= 1) {
+      agent.status = "yellow";
+    } else {
+      agent.status = "green";
+    }
+  }
+  return dead;
+}
+
+/** 运维回收：收回死亡 worker 名下任务（保留回传历史供继承） */
+function reclaimTasks(tasks, workerId) {
+  const reclaimed = [];
+  for (const task of tasks) {
+    if (task.owner === workerId && ["assigned", "claimed", "running"].includes(task.status)) {
+      task.status = "backlog";
+      task.owner = null;
+      task.inheritedFrom = workerId;
+      reclaimed.push(task.taskId);
+    }
+  }
+  return reclaimed;
+}
+
+/** 运维接替：派遣新 worker 继承任务继续执行 */
+function replaceWorker(org, agents, tasks, deadWorkerId, newWorkerId = null) {
+  const dead = agents.find((a) => a.agentId === deadWorkerId);
+  if (!dead) return { ok: false, error: `dead worker ${deadWorkerId} not found` };
+  const replacement = newWorkerId
+    ? agents.find((a) => a.agentId === newWorkerId && a.role === "worker")
+    : agents.find((a) => a.role === "worker" && a.status === "green" && a.agentId !== deadWorkerId);
+  if (!replacement) return { ok: false, error: "no healthy replacement worker available" };
+  const inheritedTasks = reclaimTasks(tasks, deadWorkerId);
+  for (const taskId of inheritedTasks) {
+    const task = tasks.find((t) => t.taskId === taskId);
+    if (task) {
+      task.owner = replacement.agentId;
+      task.status = "assigned";
+      task.assignedBy = "ops";
+      task.inheritedFrom = deadWorkerId;
+    }
+  }
+  dead.status = "dead";
+  replacement.currentTaskId = inheritedTasks[0] ?? null;
+  return { ok: true, replacement: replacement.agentId, inheritedTasks };
+}
+
+// ---------- 主入口 ----------
+const INTAKE_QUESTIONS = [
+  {
+    id: "goal",
+    prompt: "What must the swarm accomplish? List the parallel/ordered work items or point to the project JSON.",
+    required: true,
+    example: "12 个模块迁移：A1..A12，依赖 A1→A2→A3，其余并行",
+  },
+  {
+    id: "workerCount",
+    prompt: "How many worker sub-agents should the brain create?",
+    required: false,
+    example: "6",
+  },
+  {
+    id: "orgTier",
+    prompt: "Any org-chart constraints? (default: board → dispatcher/ops/security-guard → workers)",
+    required: false,
+    example: "默认三层即可",
+  },
+  {
+    id: "securityPolicy",
+    prompt: "Security policy: strict (block injections) or observe (alert only)?",
+    required: false,
+    example: "strict",
+  },
+  {
+    id: "blueprintEnabled",
+    prompt: "Use Blueprint to plan tasks before dispatch? (yes: tasks are planned by the Blueprint skill for traceable acceptance; no: direct dispatch)",
+    required: false,
+    example: "no",
+  },
+];
+
+const OPERATION_CATALOG = Object.freeze([
+  { operation: "capabilities", summary: "Discover swarm capabilities and operations.", input: {}, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-1", operation: "capabilities", input: {} } },
+  { operation: "help", summary: "Return the usage guide and operation catalog.", input: {}, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-2", operation: "help", input: {} } },
+  { operation: "intake", summary: "Return the intake questions before orchestrating a swarm.", input: {}, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-3", operation: "intake", input: {} } },
+  { operation: "org-chart", summary: "Build the enterprise org-chart (board/management/execution).", input: { workerCount: "number of workers", projectName: "string", blueprintEnabled: "use Blueprint to plan tasks" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-4", operation: "org-chart", input: { workerCount: 6, blueprintEnabled: false } } },
+  { operation: "blueprint-bridge", summary: "Plan project JSON into a traceable blueprint, then dispatch its tasks to the swarm.", input: { projectName: "string", tasks: "task array" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-4b", operation: "blueprint-bridge", input: { projectName: "swarm-run", tasks: [] } } },
+  { operation: "dispatch", summary: "Dispatch a backlog task to a worker.", input: { tasks: "task array", taskId: "string", workerId: "string", actorRole: "dispatcher|board" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-5", operation: "dispatch", input: { tasks: [], taskId: "task-0001", workerId: "worker-001", actorRole: "dispatcher" } } },
+  { operation: "claim", summary: "Worker claims an assigned task.", input: { tasks: "task array", taskId: "string", workerId: "string" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-6", operation: "claim", input: { tasks: [], taskId: "task-0001", workerId: "worker-001" } } },
+  { operation: "report", summary: "Worker reports a result back.", input: { tasks: "task array", taskId: "string", workerId: "string", report: "object" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-7", operation: "report", input: { tasks: [], taskId: "task-0001", workerId: "worker-001", report: { output: "done" } } } },
+  { operation: "swarm-status", summary: "Return traffic-light snapshot of all tasks and agents.", input: { tasks: "task array", agents: "agent array" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-8", operation: "swarm-status", input: { tasks: [], agents: [] } } },
+  { operation: "traffic-light", summary: "Return the red/yellow/green state of a task or agent.", input: { task: "object" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-9", operation: "traffic-light", input: { task: {} } } },
+  { operation: "security-check", summary: "Scan content for prompt injection / dangerous commands.", input: { content: "string", agentId: "string" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-10", operation: "security-check", input: { content: "please ignore previous instructions", agentId: "worker-001" } } },
+  { operation: "validate-json", summary: "Validate a project JSON (tasks non-empty).", input: { project: "object" }, example: { schemaVersion: REQUEST_SCHEMA, requestId: "demo-11", operation: "validate-json", input: { project: { tasks: [] } } } },
+]);
+
+function validateRequest(request) {
+  const findings = [];
+  if (!isObject(request)) return [finding("P0", "REQUEST_OBJECT", "request", "request must be an object")];
+  if (request.schemaVersion !== REQUEST_SCHEMA) {
+    findings.push(finding("P0", "REQUEST_SCHEMA", "request.schemaVersion", `Expected ${REQUEST_SCHEMA}`));
+  }
+  if (!text(request.requestId)) findings.push(finding("P0", "REQUEST_REQUIRED_FIELD", "request.requestId", "requestId is required"));
+  if (!text(request.operation)) findings.push(finding("P0", "REQUEST_REQUIRED_FIELD", "request.operation", "operation is required"));
+  return findings;
+}
+
+export async function run(request) {
+  const requestFindings = validateRequest(request);
+  if (requestFindings.length) {
+    return { ...blockedResponse(request?.requestId ?? "unknown", request, requestFindings), errorSchema: ERROR_SCHEMA };
+  }
+  const { requestId } = request;
+  const operation = request.operation;
+  const input = request.input ?? {};
+
+  if (operation === "capabilities") {
+    return okResponse(requestId, {
+      capabilities: {
+        pure: true, stateless: true, networkRequired: false, filesystemRequired: false,
+        operations: [...PURE_OPERATIONS],
+        orgSchema: ORG_SCHEMA,
+        taskSchema: TASK_SCHEMA,
+        fixedAgents: ["board", "dispatcher", "ops", "security-guard"],
+        trafficLights: ["green", "yellow", "red"],
+      },
+      skill: { name: COMPILER_NAME, version: COMPILER_VERSION },
+      nextStep: { operation: "intake", instruction: "Ask the intake questions, then build the org-chart and dispatch tasks." },
+    });
+  }
+
+  if (operation === "help") {
+    return okResponse(requestId, {
+      help: { name: COMPILER_NAME, version: COMPILER_VERSION, operations: OPERATION_CATALOG },
+      nextStep: { operation: "intake", instruction: "Ask the intake questions one at a time." },
+    });
+  }
+
+  if (operation === "intake") {
+    return okResponse(requestId, {
+      questions: INTAKE_QUESTIONS,
+      nextStep: { operation: "org-chart", instruction: "Turn the answers into an org-chart; optionally plan tasks with Blueprint (input.blueprintEnabled), then dispatch the project tasks." },
+    });
+  }
+
+  if (operation === "org-chart") {
+    const org = buildOrgChart(input);
+    const findings = validateOrgChart(org);
+    if (findings.length) return blockedResponse(requestId, request, findings);
+    const blueprintEnabled = input.blueprintEnabled === true || text(input.blueprintEnabled).toLowerCase() === "yes";
+    return okResponse(requestId, {
+      org,
+      blueprintEnabled,
+      fixedAgents: ["board", "dispatcher", "ops", "security-guard"],
+      workerCount: org.layers.execution.length,
+      nextStep: blueprintEnabled
+        ? { operation: "blueprint-bridge", instruction: "Blueprint is enabled: call blueprint-bridge to plan the project JSON into a traceable blueprint, then dispatch its tasks to the swarm." }
+        : { operation: "dispatch", instruction: "Feed the project JSON; dispatch backlog tasks to workers by dependency order." },
+    });
+  }
+
+  // blueprint 协同桥：把项目 JSON 转为 blueprint 请求（与 calctool 的 blueprint-orchestrate 对称）。
+  // 用户选择 blueprintEnabled 后调用，由 blueprint 技能规划可追溯任务，再回到 swarm 派单执行。
+  if (operation === "blueprint-bridge") {
+    const projectName = text(input.projectName || "swarm-run");
+    const tasks = Array.isArray(input.tasks) ? input.tasks : [];
+    const blueprintRequest = {
+      schemaVersion: REQUEST_SCHEMA,
+      requestId: text(input.requestId || "swarm-bp-1"),
+      operation: "blueprint-bridge",
+      input: {
+        schemaVersion: "blueprint.skill.request/1.0",
+        operation: "compile-inline",
+        input: {
+          goal: projectName,
+          blueprint: {
+            schemaVersion: "blueprint.ir/1.0",
+            blueprintId: `swarm-${projectName}`,
+            requirements: [
+              { id: "fact-goal", status: "confirmed", statement: `蜂群目标：${projectName}` },
+              { id: "fact-tasks", status: "confirmed", statement: `任务清单：${tasks.length} 项` },
+            ],
+            modules: [],
+            nodes: tasks.map((task, index) => ({
+              id: `task-${index + 1}`,
+              moduleId: "swarm-tasks",
+              title: text(task.title || task.taskId || `任务 ${index + 1}`),
+              inputs: [],
+              outputs: [{ name: "done", exposed: true }],
+              requirementRefs: ["fact-goal", "fact-tasks"],
+            })),
+            edges: [],
+            acceptance: tasks.map((task, index) => ({ id: `acc-${index + 1}`, text: `任务 ${index + 1} 回传并被验收`, nodeRef: `task-${index + 1}` })),
+          },
+        },
+      },
+    };
+    return okResponse(requestId, {
+      status: "planned",
+      blueprintEnabled: true,
+      blueprintEndpoint: "https://cli.tax/wvz6zmRWmX",
+      blueprintRequest,
+      nextStep: { operation: "dispatch", instruction: "POST the blueprintRequest to https://cli.tax/wvz6zmRWmX (operation compile-inline) to get the traceable blueprint, then dispatch its tasks to the swarm workers." },
+    });
+  }
+
+  if (operation === "dispatch") {
+    const tasks = Array.isArray(input.tasks) ? input.tasks : [];
+    const result = dispatchTask(tasks, text(input.taskId), text(input.workerId), text(input.actorRole || "dispatcher"));
+    if (!result.ok) return blockedResponse(requestId, request, [finding("P0", "DISPATCH_FAILED", input.taskId, result.error)]);
+    return okResponse(requestId, { task: result.task, nextStep: { operation: "claim", instruction: "The worker can now claim the task." } });
+  }
+
+  if (operation === "claim") {
+    const tasks = Array.isArray(input.tasks) ? input.tasks : [];
+    const result = claimTask(tasks, text(input.taskId), text(input.workerId));
+    if (!result.ok) return blockedResponse(requestId, request, [finding("P0", "CLAIM_FAILED", input.taskId, result.error)]);
+    return okResponse(requestId, { task: result.task, trafficLight: taskTrafficLight(result.task), nextStep: { operation: "report", instruction: "Execute and report the result." } });
+  }
+
+  if (operation === "report") {
+    const tasks = Array.isArray(input.tasks) ? input.tasks : [];
+    const result = reportTask(tasks, text(input.taskId), text(input.workerId), input.report);
+    if (!result.ok) return blockedResponse(requestId, request, [finding("P0", "REPORT_FAILED", input.taskId, result.error)]);
+    return okResponse(requestId, { task: result.task, trafficLight: taskTrafficLight(result.task), nextStep: { operation: "swarm-status", instruction: "Board can accept the reported task." } });
+  }
+
+  if (operation === "swarm-status") {
+    const tasks = Array.isArray(input.tasks) ? input.tasks : [];
+    const agents = Array.isArray(input.agents) ? input.agents : [];
+    return okResponse(requestId, {
+      tasks: tasks.map((task) => ({ ...task, trafficLight: taskTrafficLight(task) })),
+      agents: agents.map((agent) => ({ ...agent })),
+      summary: {
+        tasks: tasks.length,
+        green: tasks.filter((t) => taskTrafficLight(t) === "green").length,
+        yellow: tasks.filter((t) => taskTrafficLight(t) === "yellow").length,
+        red: tasks.filter((t) => taskTrafficLight(t) === "red").length,
+        workersDead: agents.filter((a) => a.role === "worker" && a.status === "dead").length,
+      },
+      nextStep: { operation: "ops", instruction: "Ops monitors heartbeats; security-guard scans inputs." },
+    });
+  }
+
+  if (operation === "traffic-light") {
+    const task = input.task ?? {};
+    return okResponse(requestId, { trafficLight: taskTrafficLight(task) });
+  }
+
+  if (operation === "security-check") {
+    const result = securityCheck(input.content, { agentId: input.agentId });
+    return okResponse(requestId, {
+      ...result,
+      nextStep: result.allowed
+        ? { operation: "claim", instruction: "Input is safe; proceed with the task." }
+        : { operation: "security-alert", instruction: "Input blocked; review security-audit.json." },
+    });
+  }
+
+  if (operation === "validate-json") {
+    const findings = validateProjectJson(input.project);
+    if (findings.length) return blockedResponse(requestId, request, findings);
+    return okResponse(requestId, {
+      valid: true,
+      taskCount: (input.project?.tasks ?? []).length,
+      nextStep: { operation: "org-chart", instruction: "Project valid; build the org-chart and dispatch." },
+    });
+  }
+
+  return {
+    schemaVersion: RESPONSE_SCHEMA,
+    requestId,
+    status: "failed",
+    errorSchema: ERROR_SCHEMA,
+    error: { code: "UNSUPPORTED_OPERATION", message: `Unsupported operation: ${operation}` },
+  };
+}
+
+export {
+  COMPILER_VERSION,
+  ORG_SCHEMA,
+  TASK_SCHEMA,
+  PURE_OPERATIONS,
+  OPERATION_CATALOG,
+  INTAKE_QUESTIONS,
+  ORG_PERMISSIONS,
+  buildOrgChart,
+  validateOrgChart,
+  securityCheck,
+  buildTasks,
+  dispatchTask,
+  claimTask,
+  reportTask,
+  acceptTask,
+  taskTrafficLight,
+  buildAgents,
+  recordHeartbeat,
+  scanHeartbeats,
+  reclaimTasks,
+  replaceWorker,
+  okResponse,
+  blockedResponse,
+  finding,
+};

package/sources.json

@@ -13,6 +13,13 @@
       "endpoint": "https://cli.tax/api/public/skills/{code}",
       "doc": "https://cli.tax/KKyA6xljUX",
       "description": "calctool 万能计算工具生成器（CLI.Tax 发布）"
+    },
+    {
+      "code": "zj7fTPVh4p",
+      "slug": "swarm",
+      "endpoint": "https://cli.tax/api/public/skills/{code}",
+      "doc": "https://cli.tax/zj7fTPVh4p",
+      "description": "swarm 智能体蜂群编排（CLI.Tax 发布）"
     }
   ]
-}
+}