cli-swarm 7.0.38 → 7.0.39

package/skill/references/org-chart.md

@@ -1,32 +1,11 @@
 # Swarm 组织架构
-## 协议与层级
 
-`org-chart` 返回 `swarm.org-chart/1.0` JSON，包含三层：
+默认主代理执行。org-chart没有任务事实时返回0个worker，nextStep.operation为null，由主代理继续工作。
 
-- `board`：决策层，负责派单、验收、停止和回收等决策。
-- `management`：固定的 `dispatcher`、`ops`、`security-guard`。
-- `execution`：按 `workerCount` 生成的 `worker-NNN` 描述项。
+input可包含workerCount（0–50的整数上限）、projectName、tasks、blueprintEnabled。每个tasks[].facts采用[task-lifecycle.md](task-lifecycle.md)的业务必要性合同。简单、缺失理由、收益不高于协调成本和路径冲突的任务不计入可委派任务。实际数量不超过有依据的独立范围数、依赖图层宽和用户上限，禁止人为夸大估算以增加数量。
 
-返回的 `permissions` 是角色动作表。实际运行时会在 `dispatch`、`accept` 等关键状态迁移中再检查角色，不应只依赖展示用的权限表。
+org.delegationDecisions逐任务记录delegate及拒绝理由；org.executionMode为single-agent或delegated。recommendedWorkerCount为本次规划的数量上限，宿主应只创建当前就绪任务需要的最少执行者，先复用已有负责人。
 
-## 输入与输出
+board是主代理；management包含dispatcher、ops、security-guard、coordinator逻辑职责，hostAgentId均为board。fixedAgents只含board，buildAgents不为这些管理职责添加独立智能体。
 
-`input` 可包含 `workerCount`、`projectName`、`tasks` 和 `blueprintEnabled`。当前 `workerCount` 默认为 4，并限制在 1–50。成功输出包含 `org`、`fixedAgents`、`workerCount`、`blueprintEnabled` 和 `nextStep`。
-
-如果输入中提供非空 `tasks`，运行时会分析依赖图，把每个无环层的最大宽度（上限 50）返回为 `recommendedWorkerCount`。建议值不会覆盖已生成的 execution worker 数量。
-
-## 依赖图错误
-
-以下情况会产生结构化 findings 并阻断 `org-chart`：
-
-- `taskId` 不合法或重复；
-- `dependsOn` 引用不存在的任务；
-- 依赖图存在环。
-
-## 当前边界
-
-`org-chart` 只生成组织 JSON，不创建真实子智能体、不建立心跳连接、不存储状态。调用方负责根据组织描述建立实际执行者，并保存每次返回的完整状态。
-
-## 实现依据
-
-`swarm-runtime.mjs` 的 `ORG_LAYERS`、`ORG_PERMISSIONS`、`analyzeTaskGraph`、`buildOrgChart` 和 `validateOrgChart` 是本文的权威来源。
+重复或非法taskId、缺失依赖和依赖环仍阻断。运行时只生成组织数据，不创建实际智能体，不提供对未接入IDE的物理拦截；宿主必须执行相同门禁。启用Aimlock或Swarm并不代表需要多智能体。

package/skill/references/task-lifecycle.md

@@ -9,10 +9,10 @@
 
 | 操作 | 前置 | 成功结果 |
 |---|---|---|
-| `dispatch` | 调用角色是 `dispatcher` 或 `board`；任务为 `backlog`；所有依赖为 `accepted` | `assigned`，写入 owner 和 assignedBy |
+| `dispatch` | 调用角色是 `dispatcher` 或 `board`；任务为 `backlog`；所有依赖为 `accepted` 且有任务绑定的可信证据；提交符合门槛且无冲突的 `input.facts` | `assigned`，写入 owner 和 assignedBy |
 | `claim` | 任务为 `assigned`；已有 owner 时必须与 workerId 一致 | `claimed`，写入 claimedAt |
 | `report` | 任务为 `claimed` 或 `running`；worker 与 owner 一致；report 至少含非空 output 或 evidence 字段 | `reported`，写入 report 和 reportedAt |
-| `accept` | 只允许 `board`；任务为 `reported`；`accept: true` 时必须有通过的 TestEvidence | `accepted`；拒绝时为 `failed` |
+| `accept` | 只允许 `board`；任务为 `reported`；`accept: true` 时必须有 Validator 验证通过的任务绑定签名 TestEvidence | `accepted`；拒绝时为 `failed` |
 
 操作失败会返回对应的 `DISPATCH_FAILED`、`CLAIM_FAILED`、`REPORT_FAILED` 或 `ACCEPT_FAILED` finding，不返回伪造成功。
 
@@ -20,6 +20,14 @@
 
 `dispatch`、`claim`、`report`、`accept` 会修改调用方传入的 `tasks` 数组并返回整个数组。调用方必须保存该完整返回值，下一次操作时原样传回；服务端无会话状态，不能只合并一个 task 片段。
 
+## 派单事实与可信验收
+
+`input.facts` 必须包含 `ownerId`、`estimatedChangedLines`、`fileCount`、`crossModule`、`parallelSafe` 与精确相对 `targetPaths`。规模至少满足200行、3文件或跨模块之一；文件数必须与路径数一致，活动写入路径不得冲突。规模达标不能代替业务必要性。
+
+还必须包含 `delegation`：非空 `businessNeed`、`deliverable`、`acceptanceCriteria`、`mainAgentWork`；`independent` 与 `substantial` 均为 true；有限非负数 `estimatedSavedMinutes` 严格大于 `coordinationMinutes`。估算包含上下文传递、协调和验收成本，禁止虚增估算。简单工作或缺失依据明确拒绝派单，主代理继续执行。组织规划使用相同的 `tasks[].facts`，并在 `delegationDecisions` 返回逐任务理由。
+
+任务在开始前声明 `validationContext`，其 `validationRunId` 必须等于 `taskId`，并绑定计划与产物。`report.evidence` 的可信签名由 Validator 公钥验证；仅本地自报或命令退出码为0仍不能验收为绿色。Blueprint 编译只提供计划，调用方必须补充实际派单事实和可信执行凭证。
+
 ## Blueprint 桥接
 
 `blueprint-bridge` 要求非空 `projectName`、非空 tasks、每任务 title 和合法依赖图。成功时它生成 `blueprint.ir/1.0` 与 Blueprint `compile-inline` 请求信封，包含任务节点、依赖边和验收标准。

package/skill/references/traffic-light.md

@@ -16,13 +16,13 @@
 
 ## “通过证据”定义
 
-任务的 `report.evidence` 必须非空，每一项都通过上述结构校验且 `exitCode === 0`，才算 passing TestEvidence。`accept: true` 没有满足该条件时会被阻断。
+任务的 `report.evidence` 必须非空且exitCode为0；accept还要求task.validationContext.validationRunId等于taskId，并复用Validator验证subject、artifactSha256、receipt签名、结果与有效期。缺少可信公钥或任一不匹配均阻断。
 
 ## 灯色规则
 
 | 任务状态 | 条件 | 灯色 |
 |---|---|---|
-| `reported` | 有 passing TestEvidence | green |
+| `reported` | 有 passing TestEvidence，尚未验收 | yellow |
 | `reported` | 缺少 passing TestEvidence | yellow |
 | `accepted` | 有 passing TestEvidence | green |
 | `accepted` | 无 passing TestEvidence | red |
@@ -33,7 +33,7 @@
 
 ## 证据信任边界
 
-当前 Swarm 只校验证据字段和 `exitCode`。它不验证签名、receipt、subject 绑定或 runner 身份；`runner: trusted-runner` 仅是字段值，不得据此声称已完成密码学证明。调用方仍需在 Validator 或受信执行层完成强证据绑定。
+Swarm与Validator共享签名验证实现；单独填写runner字段不能通过。validationContext必须由宿主预先锁定，纯函数传入的角色和任务清单仍需宿主认证，不得宣称远端纯函数拥有持久任务身份控制。
 
 ## 实现依据
 

package/skill/skill.json

@@ -6,5 +6,5 @@
   "name": "swarm",
   "schemaVersion": "swarm.skill.request/1.0",
   "type": "Skill",
-  "version": "v7.0.38"
+  "version": "v7.0.39"
 }

package/swarm-coordinator-model.mjs

@@ -5,6 +5,7 @@ const ACTIONS = new Set(['inspect', 'modify', 'build', 'deploy', 'publish', 'wai
 const LOCK_TYPES = new Set(['file', 'build', 'deploy'])
 const MESSAGE_TYPES = new Set([
   'range-declare',
+  'task-continuation',
   'conflict-alert',
   'lock-granted',
   'lock-denied',

package/swarm-runtime.mjs

@@ -1,29 +1,24 @@
-// swarm v7.0.10：自包含、无外部依赖的确定性蜂群编排运行时。
+import { text, isObject, validId, finding, ORG_PERMISSIONS, TEST_EVIDENCE_SCHEMA, SHA256_PATTERN } from "./swarm-task-contract.mjs";
+import { dispatchEligibility, buildTasks, dispatchTask, claimTask, reportTask, acceptTask, taskTrafficLight, validateTestEvidence, normalizeTestEvidence, hasPassingTestEvidence, hasTrustedTestEvidence, reclaimTask } from "./swarm-task-policy.mjs";
+// Reviewed modules are compiled into one deployment artifact by build-swarm-runtime.mjs.
 const REQUEST_SCHEMA = "swarm.skill.request/1.0";
 const ALLOWED_EXTERNAL_ENDPOINTS = { blueprint: "https://cli.tax/wvz6zmRWmX" };
 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 TEST_EVIDENCE_SCHEMA = "cli.tax.test-evidence/1.0";
-const COMPILER_NAME = "swarm"; const COMPILER_VERSION = "v7.0.38";
-const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+const ORG_SCHEMA = "swarm.org-chart/1.0"; const TASK_SCHEMA = "swarm.tasks/1.0";
+const COMPILER_NAME = "swarm"; const COMPILER_VERSION = "v7.0.39";
 const PURE_OPERATIONS = new Set([
   "capabilities", "help", "intake", "org-chart", "blueprint-bridge", "dispatch", "claim",
   "report", "accept", "swarm-status", "traffic-light", "security-check", "validate-json", "heartbeat", "reclaim",
 ]);
-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); }
 const ORG_LAYERS = ["board", "management", "execution"];
 const ORG_ROLES = ["board", "dispatcher", "ops", "security-guard", "coordinator", "worker"];
 const ORG_FIXED_ROLES = new Set(["board", "dispatcher", "ops", "security-guard", "coordinator"]);
-const ORG_PERMISSIONS = { board: ["dispatch", "accept", "reject", "stop", "reclaim", "replace"], dispatcher: ["dispatch", "reassign", "prioritize"], ops: ["heartbeat", "reclaim", "replace"],
-  "security-guard": ["block", "alert", "quarantine"], coordinator: ["conflict-scan", "lock", "queue", "baseline-handshake", "dependency-wait", "wake", "need-human"], worker: ["claim", "report", "request-help"], };
 function analyzeTaskGraph(tasks) {
   const findings = [];
   const ids = new Set();
@@ -53,14 +48,27 @@ function analyzeTaskGraph(tasks) {
   return { findings: [], recommendedWorkerCount: Math.min(50, Math.max(...levels)) };
 }
 function buildOrgChart(input = {}) {
-  const workerCount = Math.min(50, Math.max(1, Math.floor(Number(input.workerCount) || 4)));
   const projectName = text(input.projectName || "swarm-run");
-  let recommendedWorkerCount, recommendationFindings = [];
+  let recommendedWorkerCount = 0, recommendationFindings = [];
+  const delegationDecisions = [];
   if (Array.isArray(input.tasks) && input.tasks.length > 0) {
     const analysis = analyzeTaskGraph(input.tasks);
-    recommendedWorkerCount = analysis.recommendedWorkerCount ?? undefined;
     recommendationFindings = analysis.findings;
+    if (!recommendationFindings.length) {
+      const eligible = [];
+      for (const task of input.tasks) {
+        const reason = dispatchEligibility(eligible, task, task.facts);
+        delegationDecisions.push({ taskId: task.taskId, delegate: reason === null, reason });
+        if (reason === null) eligible.push({ ...task, status: "assigned", dispatch: task.facts });
+      }
+      recommendedWorkerCount = Math.min(analysis.recommendedWorkerCount, eligible.length);
+    }
+  }
+  if (input.workerCount !== undefined && (!Number.isSafeInteger(input.workerCount) || input.workerCount < 0 || input.workerCount > 50)) {
+    recommendationFindings.push(finding("P0", "WORKER_COUNT_INVALID", "input.workerCount", "workerCount must be an integer from 0 to 50"));
   }
+  const workerCount = recommendationFindings.length ? 0
+    : input.workerCount === undefined ? recommendedWorkerCount : Math.min(input.workerCount, recommendedWorkerCount);
   const org = { schemaVersion: ORG_SCHEMA, projectName, layers: { board: [{ agentId: "board", role: "board", title: "决策层·老板/主智能体" }],
       management: [
         { agentId: "dispatcher", role: "dispatcher", title: "管理层·调度智能体", fixed: true },
@@ -68,7 +76,8 @@ function buildOrgChart(input = {}) {
         { agentId: "coordinator", role: "coordinator", title: "管理层·自动协调智能体", fixed: true }, ],
       execution: Array.from({ length: workerCount }, (_, i) => ({ agentId: `worker-${String(i + 1).padStart(3, "0")}`,
         role: "worker", title: `执行层·子智能体 ${i + 1}`, fixed: false })),
-    }, permissions: ORG_PERMISSIONS };
+    }, permissions: ORG_PERMISSIONS, delegationDecisions, executionMode: workerCount === 0 ? "single-agent" : "delegated" };
+  for (const role of org.layers.management) role.hostAgentId = "board";
   if (recommendedWorkerCount !== undefined) org.recommendedWorkerCount = recommendedWorkerCount;
   if (recommendationFindings.length) org.recommendationFindings = recommendationFindings;
   return org;
@@ -113,92 +122,11 @@ function validateProjectJson(project) {
   else findings.push(...analyzeTaskGraph(project.tasks).findings);
   return findings;
 }
-function buildTasks(project, org) {
-  return (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 }));
-}
-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` };
-  for (const dependencyId of Array.isArray(task.dependsOn) ? task.dependsOn : []) {
-    const dependency = tasks.find((candidate) => candidate.taskId === dependencyId);
-    if (!dependency) return { ok: false, error: `dependency ${dependencyId} not found` };
-    if (dependency.status !== "accepted") return { ok: false, error: `dependency ${dependencyId} is ${dependency.status}, not accepted` };
-  }
-  task.status = "assigned"; task.owner = workerId; task.assignedBy = actorRole;
-  return { ok: true, task };
-}
-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 };
-}
-function validateTestEvidence(value, entityRef) {
-  const findings = [];
-  if (!isObject(value)) return [finding("P0", "TEST_EVIDENCE_OBJECT", entityRef, "TestEvidence must be an object")];
-  if (value.schemaVersion !== TEST_EVIDENCE_SCHEMA) findings.push(finding("P0", "TEST_EVIDENCE_SCHEMA", `${entityRef}.schemaVersion`, `Expected ${TEST_EVIDENCE_SCHEMA}`));
-  if (!text(value.evidenceId).trim()) findings.push(finding("P0", "TEST_EVIDENCE_ID", `${entityRef}.evidenceId`, "evidenceId is required"));
-  if (!["test", "build", "lint", "security", "benchmark"].includes(value.kind)) findings.push(finding("P0", "TEST_EVIDENCE_KIND", `${entityRef}.kind`, "kind is unsupported"));
-  if (!["local", "trusted-runner"].includes(value.runner)) findings.push(finding("P0", "TEST_EVIDENCE_RUNNER", `${entityRef}.runner`, "runner must be local or trusted-runner"));
-  if (!text(value.command).trim()) findings.push(finding("P0", "TEST_EVIDENCE_COMMAND", `${entityRef}.command`, "command is required"));
-  if (!Number.isInteger(value.exitCode)) findings.push(finding("P0", "TEST_EVIDENCE_EXIT", `${entityRef}.exitCode`, "exitCode must be an integer"));
-  if (typeof value.durationMs !== "number" || !Number.isFinite(value.durationMs) || value.durationMs < 0) findings.push(finding("P0", "TEST_EVIDENCE_DURATION", `${entityRef}.durationMs`, "durationMs must be a finite number >= 0"));
-  if (!text(value.summary).trim()) findings.push(finding("P0", "TEST_EVIDENCE_SUMMARY", `${entityRef}.summary`, "summary is required"));
-  if (value.artifactSha256 !== undefined && !SHA256_PATTERN.test(value.artifactSha256)) findings.push(finding("P0", "TEST_EVIDENCE_ARTIFACT", `${entityRef}.artifactSha256`, "artifactSha256 must be a lowercase SHA-256 digest"));
-  return findings;
-}
-function normalizeTestEvidence(values) {
-  if (!Array.isArray(values)) return { evidence: [], findings: [finding("P0", "TEST_EVIDENCE_ARRAY", "report.evidence", "evidence must be an array")] };
-  const findings = values.flatMap((value, index) => validateTestEvidence(value, `report.evidence[${index}]`));
-  return findings.length ? { evidence: [], findings } : { evidence: values.map((value) => ({ ...value })), findings: [] };
-}
-function hasPassingTestEvidence(task) {
-  const evidence = task?.report?.evidence;
-  return Array.isArray(evidence) && evidence.length > 0
-    && evidence.every((value, index) => validateTestEvidence(value, `task.report.evidence[${index}]`).length === 0 && value.exitCode === 0);
-}
-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` };
-  if (!isObject(report)) return { ok: false, error: "report must be an object" };
-  if (!text(report.output).trim() && report.evidence === undefined) return { ok: false, error: "report must have output or evidence" };
-  const normalizedReport = { output: text(report.output) };
-  if (report.evidence !== undefined) {
-    const normalized = normalizeTestEvidence(report.evidence);
-    if (normalized.findings.length) return { ok: false, error: "report evidence is invalid", findings: normalized.findings };
-    normalizedReport.evidence = normalized.evidence;
-  }
-  task.status = "reported"; task.report = normalizedReport; task.reportedAt = new Date().toISOString();
-  return { ok: true, task, hasEvidence: hasPassingTestEvidence(task) };
-}
-function acceptTask(tasks, taskId, accept, actorRole) {
-  if (actorRole !== "board") return { ok: false, error: `role ${actorRole} cannot 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` };
-  if (accept && !hasPassingTestEvidence(task)) return { ok: false, error: `task ${taskId} has no passing TestEvidence` };
-  task.status = accept ? "accepted" : "failed";
-  return { ok: true, task };
-}
-function taskTrafficLight(task) {
-  if (task.status === "accepted") return hasPassingTestEvidence(task) ? "green" : "red";
-  if (task.status === "reported") return hasPassingTestEvidence(task) ? "green" : "yellow";
-  if (task.status === "failed" || task.status === "blocked" || task.status === "cancelled") return "red";
-  return "yellow";
-}
 const HEARTBEAT_MISS_LIMIT = 3;
 function buildAgents(org, nowIso = null) {
   const now = nowIso || new Date().toISOString(), agents = [];
   for (const layer of ORG_LAYERS) for (const member of org.layers?.[layer] ?? []) {
+    if (member.hostAgentId === "board") continue;
     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: "" });
@@ -221,6 +149,7 @@ function scanHeartbeats(agents, nowIso = null) {
     const misses = Math.floor((now - new Date(agent.lastHeartbeatAt).getTime()) / 30000);
     agent.heartbeatMisses = Math.max(agent.heartbeatMisses, Math.min(misses, 99));
     if (agent.heartbeatMisses >= HEARTBEAT_MISS_LIMIT && agent.status !== "dead") { agent.status = "dead"; dead.push(agent.agentId); }
+    else if (agent.status === "dead") continue;
     else if (agent.heartbeatMisses >= 1) agent.status = "yellow";
     else agent.status = "green";
   }
@@ -229,16 +158,14 @@ function scanHeartbeats(agents, nowIso = null) {
 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);
-    }
+    if (task.owner === workerId && reclaimTask(task, workerId)) reclaimed.push(task.taskId);
   }
   return reclaimed;
 }
 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")
+  if (!dead || dead.role !== "worker" || dead.status !== "dead") return { ok: false, error: `dead worker ${deadWorkerId} not found` };
+  const replacement = newWorkerId ? agents.find((a) => a.agentId === newWorkerId && a.role === "worker" && a.status === "green" && a.agentId !== deadWorkerId)
     : 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);
@@ -251,7 +178,7 @@ function replaceWorker(org, agents, tasks, deadWorkerId, newWorkerId = 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: "workerCount", prompt: "What is the maximum justified worker count? Omit for task-based sizing; simple work stays with the main agent.", 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" }, ];
@@ -264,13 +191,18 @@ const nullableStringSchema = { type: ["string", "null"] };
 const evidenceSchema = objectSchema({ schemaVersion: { const: TEST_EVIDENCE_SCHEMA }, evidenceId: stringSchema({ minLength: 1 }),
   kind: { enum: ["test", "build", "lint", "security", "benchmark"] }, runner: { enum: ["local", "trusted-runner"] }, command: stringSchema({ minLength: 1 }), exitCode: { type: "integer" }, durationMs: { type: "number", minimum: 0 },
   summary: stringSchema({ minLength: 1 }), artifactSha256: stringSchema({ pattern: SHA256_PATTERN.source }), }, ["schemaVersion", "evidenceId", "kind", "runner", "command", "exitCode", "durationMs", "summary"], { additionalProperties: true });
+const delegationSchema = objectSchema({ businessNeed: stringSchema({ minLength: 1 }), deliverable: stringSchema({ minLength: 1 }),
+  acceptanceCriteria: stringSchema({ minLength: 1 }), mainAgentWork: stringSchema({ minLength: 1 }), independent: { type: "boolean" },
+  substantial: { type: "boolean" }, estimatedSavedMinutes: { type: "number", minimum: 0 }, coordinationMinutes: { type: "number", minimum: 0 },
+}, ["businessNeed", "deliverable", "acceptanceCriteria", "mainAgentWork", "independent", "substantial", "estimatedSavedMinutes", "coordinationMinutes"]);
+const dispatchSchema = objectSchema({ delegation: delegationSchema, estimatedChangedLines: { type: "integer", minimum: 0 }, fileCount: { type: "integer", minimum: 1 }, crossModule: { type: "boolean" }, parallelSafe: { type: "boolean" }, ownerId: stringSchema({ minLength: 1 }), targetPaths: arraySchema(stringSchema({ minLength: 1 }), { minItems: 1 }) }, ["estimatedChangedLines", "fileCount", "crossModule", "parallelSafe", "ownerId", "targetPaths", "delegation"]);
 const reportSchema = objectSchema({ output: stringSchema(), evidence: arraySchema(evidenceSchema) }, [], {
   anyOf: [{ properties: { output: stringSchema({ minLength: 1 }) }, required: ["output"] }, { required: ["evidence"] }],
 });
 const taskSchema = objectSchema({ taskId: stringSchema({ minLength: 1 }), title: stringSchema(), owner: nullableStringSchema,
   status: { enum: [...TASK_STATUSES] }, priority: stringSchema(), dependsOn: arraySchema(stringSchema()), assignedBy: nullableStringSchema, claimedAt: nullableStringSchema, reportedAt: nullableStringSchema,
   report: { anyOf: [{ type: "null" }, reportSchema] }, progressPercent: { type: "number" }, progressNote: stringSchema(), inheritedFrom: nullableStringSchema, trafficLight: { enum: ["green", "yellow", "red"] }, }, ["taskId", "title", "status", "dependsOn"], { additionalProperties: true });
-const projectTaskSchema = objectSchema({ taskId: stringSchema({ minLength: 1 }), title: stringSchema({ minLength: 1 }),
+const projectTaskSchema = objectSchema({ facts: dispatchSchema, taskId: stringSchema({ minLength: 1 }), title: stringSchema({ minLength: 1 }),
   name: stringSchema(), priority: stringSchema(), dependsOn: arraySchema(stringSchema()) }, ["taskId", "title"], { additionalProperties: true });
 const agentSchema = objectSchema({ agentId: stringSchema({ minLength: 1 }), role: { enum: ORG_ROLES }, title: stringSchema(), fixed: { type: "boolean" }, status: { enum: ["green", "yellow", "red", "dead"] }, lastHeartbeatAt: stringSchema({ format: "date-time" }),
   heartbeatMisses: { type: "integer", minimum: 0 }, currentTaskId: nullableStringSchema, progressPercent: { type: "number" }, progressNote: stringSchema() }, ["agentId", "role", "status"], { additionalProperties: true });
@@ -287,9 +219,9 @@ const OPERATION_SCHEMAS = Object.freeze({
   capabilities: operationSchema({}, [], { capabilities: anyObjectSchema, operationSchemas: anyObjectSchema, skill: anyObjectSchema, nextStep: nextSchema }, ["capabilities", "operationSchemas", "skill", "nextStep"]),
   help: operationSchema({}, [], { help: anyObjectSchema, nextStep: nextSchema }, ["help", "nextStep"]),
   intake: operationSchema({}, [], { questions: arraySchema(anyObjectSchema), nextStep: nextSchema }, ["questions", "nextStep"]),
-  "org-chart": operationSchema({ workerCount: { type: "number", minimum: 1, maximum: 50 }, projectName: stringSchema(), blueprintEnabled: { type: ["boolean", "string"] }, tasks: arraySchema(projectTaskSchema) }, [], { org: anyObjectSchema, blueprintEnabled: { type: "boolean" }, fixedAgents: arraySchema(stringSchema()), workerCount: { type: "integer" }, nextStep: nextSchema }, ["org", "blueprintEnabled", "fixedAgents", "workerCount", "nextStep"]),
+  "org-chart": operationSchema({ workerCount: { type: "integer", minimum: 0, maximum: 50 }, projectName: stringSchema(), blueprintEnabled: { type: ["boolean", "string"] }, tasks: arraySchema(projectTaskSchema) }, [], { org: anyObjectSchema, blueprintEnabled: { type: "boolean" }, fixedAgents: arraySchema(stringSchema()), workerCount: { type: "integer" }, nextStep: nextSchema }, ["org", "blueprintEnabled", "fixedAgents", "workerCount", "nextStep"]),
   "blueprint-bridge": operationSchema({ projectName: stringSchema({ minLength: 1 }), tasks: arraySchema(projectTaskSchema, { minItems: 1 }) }, ["projectName", "tasks"], { planningStatus: { const: "planned" }, blueprintEnabled: { const: true }, blueprintEndpoint: stringSchema({ format: "uri" }), blueprintRequest: anyObjectSchema, projectFormat: { const: "swarm.project/1.0" }, nextStep: nextSchema }, ["planningStatus", "blueprintEnabled", "blueprintEndpoint", "blueprintRequest", "projectFormat", "nextStep"]),
-  dispatch: operationSchema({ ...tasksInput, workerId: stringSchema({ minLength: 1 }), actorRole: { enum: ["dispatcher", "board"] } }, ["tasks", "taskId", "workerId", "actorRole"], { ...taskStateOutput, nextStep: nextSchema }, ["task", "tasks", "stateNote", "nextStep"]),
+  dispatch: operationSchema({ ...tasksInput, workerId: stringSchema({ minLength: 1 }), actorRole: { enum: ["dispatcher", "board"] }, facts: dispatchSchema }, ["tasks", "taskId", "workerId", "actorRole", "facts"], { ...taskStateOutput, nextStep: nextSchema }, ["task", "tasks", "stateNote", "nextStep"]),
   claim: operationSchema({ ...tasksInput, workerId: stringSchema({ minLength: 1 }) }, ["tasks", "taskId", "workerId"], { ...taskStateOutput, trafficLight: { enum: ["green", "yellow", "red"] }, nextStep: nextSchema }, ["task", "tasks", "trafficLight", "stateNote", "nextStep"]),
   report: operationSchema({ ...tasksInput, workerId: stringSchema({ minLength: 1 }), report: reportSchema }, ["tasks", "taskId", "workerId", "report"], { ...taskStateOutput, trafficLight: { enum: ["green", "yellow", "red"] }, evidenceRequired: { type: "boolean" }, nextStep: nextSchema }, ["task", "tasks", "trafficLight", "stateNote", "nextStep"]),
   accept: operationSchema({ ...tasksInput, actorRole: { const: "board" }, accept: { type: "boolean" } }, ["tasks", "taskId", "actorRole", "accept"], { ...taskStateOutput, trafficLight: { enum: ["green", "yellow", "red"] }, nextStep: nextSchema }, ["task", "tasks", "trafficLight", "stateNote", "nextStep"]),
@@ -395,7 +327,7 @@ function runMeta(operation, requestId) {
   if (operation === "capabilities") {
     return okResponse(requestId, {
       capabilities: { pure: true, stateless: true, networkRequired: false, filesystemRequired: false,
-        operations: [...PURE_OPERATIONS], orgSchema: ORG_SCHEMA, taskSchema: TASK_SCHEMA, testEvidenceSchema: TEST_EVIDENCE_SCHEMA, fixedAgents: ["board", "dispatcher", "ops", "security-guard", "coordinator"],
+        operations: [...PURE_OPERATIONS], orgSchema: ORG_SCHEMA, taskSchema: TASK_SCHEMA, testEvidenceSchema: TEST_EVIDENCE_SCHEMA, fixedAgents: ["board"],
         trafficLights: ["green", "yellow", "red"], stateHolder: "caller", coordinator: { command: "cli-swarm local", capabilitiesOperation: "capabilities", stateBoundary: ".coord", messageTypes: ["range-declare", "conflict-alert", "lock-granted", "lock-denied", "baseline-handshake", "need-human", "dependency-wait"] },
         workerRecommendation: "maximum acyclic dependency level width, capped at 50" }, operationSchemas: OPERATION_SCHEMAS, skill: { name: COMPILER_NAME, version: COMPILER_VERSION },
       nextStep: { operation: "intake", instruction: "Ask the intake questions, then build the org-chart and dispatch tasks." } });
@@ -409,8 +341,10 @@ function runPlanning(operation, requestId, input, request) {
     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", "coordinator"], workerCount: org.layers.execution.length,
-      nextStep: blueprintEnabled
+    return okResponse(requestId, { org, blueprintEnabled, fixedAgents: ["board"], workerCount: org.layers.execution.length,
+      nextStep: org.layers.execution.length === 0
+        ? { operation: null, instruction: "Continue with the main agent. No justified independent work requires subagents; logical management roles do not create agents." }
+        : 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." } });
   }
@@ -423,7 +357,7 @@ function runPlanning(operation, requestId, input, request) {
 function runTaskMutation(operation, requestId, input, request) {
   const tasks = Array.isArray(input.tasks) ? input.tasks : [], taskId = text(input.taskId);
   if (operation === "dispatch") {
-    const result = dispatchTask(tasks, taskId, text(input.workerId), text(input.actorRole || "dispatcher"));
+    const result = dispatchTask(tasks, taskId, text(input.workerId), text(input.actorRole), input.facts);
     if (!result.ok) return blockedResponse(requestId, request, [finding("P0", "DISPATCH_FAILED", input.taskId, result.error, { example: { taskId: "task-0001", workerId: "worker-001" } })]);
     return okResponse(requestId, { task: result.task, tasks, stateNote: STATE_NOTE, nextStep: { operation: "claim", instruction: "The worker can now claim the task." } });
   }
@@ -455,7 +389,7 @@ function runObservation(operation, requestId, input, request) {
   }
   if (operation === "traffic-light") return okResponse(requestId, { trafficLight: taskTrafficLight(input.task ?? {}),
       rules: {
-        green: "status is reported or accepted and every TestEvidence item is valid with exitCode 0",
+        green: "status is accepted with task-bound signed TestEvidence verified by Validator",
         yellow: "backlog, assigned, claimed, running, or reported without passing TestEvidence",
         red: "status is \"failed\", \"blocked\", or \"cancelled\"" } });
   if (operation === "security-check") {
@@ -480,7 +414,7 @@ function runObservation(operation, requestId, input, request) {
   const task = tasks.find((candidate) => candidate.taskId === taskId);
   if (!task) return blockedResponse(requestId, request, [finding("P0", "RECLAIM_FAILED", taskId, `task ${taskId} not found`, { example: { taskId: "task-0001" } })]);
   if (task.status === "backlog") return blockedResponse(requestId, request, [finding("P1", "RECLAIM_NOOP", taskId, `task ${taskId} is already backlog`, { example: { taskId: "task-0001" } })]);
-  task.status = "backlog"; task.owner = null;
+  if (!reclaimTask(task, task.owner)) return { ...blockedResponse(requestId, request, [finding("P0", "RECLAIM_REQUIRES_RECONCILIATION", taskId, "Only unstarted assignments may be automatically reclaimed")]), task, tasks, stateNote: STATE_NOTE };
   return okResponse(requestId, { reclaimed: true, taskId, reason, task, tasks, stateNote: STATE_NOTE });
 }
 export async function run(request) {

package/swarm-task-contract.mjs

@@ -0,0 +1,8 @@
+export const TEST_EVIDENCE_SCHEMA = 'cli.tax.test-evidence/1.0';
+export const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+export const ORG_PERMISSIONS = { board: ["dispatch", "accept", "reject", "stop", "reclaim", "replace"], dispatcher: ["dispatch", "reassign", "prioritize"], ops: ["heartbeat", "reclaim", "replace"],
+  "security-guard": ["block", "alert", "quarantine"], coordinator: ["conflict-scan", "lock", "queue", "baseline-handshake", "dependency-wait", "wake", "need-human"], worker: ["claim", "report", "request-help"], };
+export function text(value) { return String(value ?? ""); }
+export function isObject(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
+export function validId(value) { return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(value); }
+export function finding(severity, ruleId, entityRef, message, evidence = {}) { return { severity, ruleId, entityRef, message, evidence }; }

package/swarm-task-handoff.mjs

@@ -3,7 +3,7 @@ import { resolve, relative } from 'node:path'
 import { createHash } from 'node:crypto'
 import { withCoordinationState } from './swarm-coordinator-fs.mjs'
 import { requireString } from './swarm-coordinator-model.mjs'
-import { hasActiveWait, pendingDecision, eventRecord, routeEvent } from './swarm-coordinator-waits.mjs'
+import { hasActiveWait, pendingDecision, eventRecord, routeEvent, addMessage } from './swarm-coordinator-waits.mjs'
 import { TASKS_SCHEMA, describedTask, accessRequest, requestedTask, targetRequest, routingError,
   event, requestView, receipt, requests, digest } from './swarm-task-routing-model.mjs'
 
@@ -21,6 +21,20 @@ function revokeTaskLocks(state, taskId, now) {
     queued.resolvedAt = now
   }
 }
+function continuationNotice(state, original, request, phase, now) {
+  const payload = { schemaVersion: 'swarm.task-continuation/1.0', requestId: request.requestId,
+    taskId: original.taskId, chainId: original.chainId, hostId: original.routing.hostId,
+    threadId: original.routing.threadId, goal: original.routing.goal, phase,
+    remainingRequirements: original.routing.requirements.filter(item => !original.routing.completedRequirementIds.includes(item.id)),
+    nextAction: original.routing.nextAction, refetchPaths: request.handoffPaths,
+    requiredAction: phase === 'returned' ? 'handoff-resume' : 'await-handoff-result',
+    freshAimlockSnapshotRequired: true, executionAuthorized: false }
+  const signal = eventRecord(original.agentId, 'handoff-' + phase, payload, now)
+  state.events.push(signal)
+  routeEvent(state, signal)
+  addMessage(state, 'task-continuation', 'coordinator', original.agentId, payload, now)
+  addMessage(state, 'task-continuation', 'coordinator', 'human', payload, now)
+}
 function handoffScope(task, request) {
   const paths = request.targetPaths.length ? request.targetPaths : task.taskScope
   if (!paths.every(path => task.taskScope.some(scope => path === scope || path.startsWith(scope + '/')))) {
@@ -55,6 +69,7 @@ async function releaseHandoff(root, input) {
     original.status = 'waiting'
     revokeTaskLocks(state, original.taskId, now)
     request.handoffPaths = paths
+    continuationNotice(state, original, request, 'paused', now)
     request.previousTargetScope = [...target.taskScope]
     target.taskScope = [...new Set([...target.taskScope, ...paths])]
     target.baselineHandshake = null
@@ -94,8 +109,9 @@ async function completeMessage(root, input) {
       revokeTaskLocks(state, task.taskId, now)
       task.taskScope = request.previousTargetScope
       task.baselineHandshake = null
-      event(request, 'handoff-returned', { originalTaskId: original.taskId, refetchPaths: request.targetPaths,
+      event(request, 'handoff-returned', { originalTaskId: original.taskId, refetchPaths: request.handoffPaths,
         requiredAction: 'refetch-and-verify-baseline-before-resume' })
+      continuationNotice(state, original, request, 'returned', now)
     }
     event(request, 'message-completed', { resultSummary })
     return { state, output: { schemaVersion: TASKS_SCHEMA, request: requestView(request), receipt: receipt(request) },
@@ -145,7 +161,7 @@ async function resumeHandoff(root, input) {
     const task = describedTask(state, input), request = accessRequest(state, task, input.requestId)
     if (request.handoffTaskId !== task.taskId || request.status !== 'completed') routingError('HANDOFF_NOT_COMPLETE', 'only the original task can resume a completed handoff')
     const resumed = request.history.find(item => item.type === 'handoff-resumed')
-    if (resumed) return { state, output: { schemaVersion: TASKS_SCHEMA, ...resumed.details, replayed: true }, audit: [] }
+    if (resumed) return { state, output: { schemaVersion: TASKS_SCHEMA, ...resumed.details, replayed: true, currentStatus: task.status, historicalBaseline: true }, audit: [] }
     if (task.status !== 'blocked' || task.blockedReason !== 'baseline-mismatch' || task.routing.handoff !== null
       || hasActiveWait(state, task) || pendingDecision(state, task)) routingError('TASK_SUSPENDED', 'other task dependencies still prevent resumption')
     const baseline = await baselineFingerprint(root, request.handoffPaths)