tianshu-harness 3.23.0

package/dist/chunk-R43HJCDX.js

@@ -0,0 +1,2711 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  extractChangedFiles,
+  shapeWriteBudgetForProfile
+} from "./chunk-D4PTYFOG.js";
+import {
+  routeReviewWorkflow
+} from "./chunk-NH6VIOAR.js";
+import {
+  LARGE_FILE_WARN_THRESHOLD,
+  classifyChangeScale,
+  formatCaseSensitivityReviewStance,
+  formatMethodologyVerificationStance,
+  formatObjectiveReviewStance,
+  formatPathBoundaryReviewStance,
+  formatWeighingReviewStance,
+  formatWiringEffectivenessReviewStance,
+  isCrossModule,
+  isFixContext
+} from "./chunk-S4K4L6IM.js";
+import {
+  clearCheckpoint,
+  deriveTeamGroupId,
+  loadCheckpoint,
+  saveCheckpoint
+} from "./chunk-3VGD2FXB.js";
+import {
+  detectOverlapWithoutOrder,
+  validateTaskGraph
+} from "./chunk-TVHW77C7.js";
+import {
+  LinUCBBandit,
+  buildGatedInfluenceAuditEvent,
+  buildTeamEpisodeFromStore,
+  buildTeamWaveScopeHealth,
+  buildTeamWaveTelemetry,
+  evaluateSkillGate,
+  extractRequiredSkills,
+  formatSkillGateBlock,
+  formatTeamDelivery,
+  getInvokedSkills,
+  hashTeamObjective,
+  isSkillGateEnabled,
+  persistGatedInfluenceAudit,
+  persistTeamScopeHealth,
+  recordTeamEpisodeClosureFromStore
+} from "./chunk-EHHUASO5.js";
+import {
+  evaluateWaveGate,
+  formatWaveGate,
+  getWaveGate,
+  isWaveGateEnabled,
+  runChangedFilesTypecheckMemo,
+  setWaveGate,
+  typecheckGateEnabled
+} from "./chunk-LA6IPTGH.js";
+import {
+  dependencyId,
+  extractJsonCandidates
+} from "./chunk-4QJ3Y5JM.js";
+import {
+  deriveAuthority,
+  starDomainRegistry
+} from "./chunk-CGOADM2X.js";
+import {
+  skillRegistry
+} from "./chunk-OHSV42QB.js";
+import {
+  debugLog
+} from "./chunk-CI4R6P2B.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/team-grouping.ts
+init_esm_shims();
+var MAX_WRITE_WORKERS = 3;
+var MAX_READ_WORKERS = 3;
+function touchFiles(task) {
+  return task.touchSet.length > 0 ? task.touchSet : task.files;
+}
+function isReadOnly(task) {
+  return task.profile === "code_scout" || task.profile === "doc_scout" || task.profile === "reviewer" && task.kind === "review";
+}
+function topologicalSort(tasks) {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const task = taskMap.get(id);
+    if (task) {
+      for (const dep of task.dependsOn) {
+        const depId = dependencyId(dep);
+        if (taskMap.has(depId)) visit(depId);
+      }
+    }
+    result.push(id);
+  }
+  for (const t of tasks) visit(t.id);
+  return result;
+}
+function validateTaskDependencies(tasks) {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const dangling = [];
+  for (const t of tasks) {
+    for (const dep of t.dependsOn) {
+      const depId = dependencyId(dep);
+      if (!taskMap.has(depId)) dangling.push({ taskId: t.id, missingDep: depId });
+    }
+  }
+  const cycles = [];
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  function dfs(id) {
+    state.set(id, "gray");
+    stack.push(id);
+    const task = taskMap.get(id);
+    if (task) {
+      for (const dep of task.dependsOn) {
+        const depId = dependencyId(dep);
+        if (!taskMap.has(depId)) continue;
+        const depState = state.get(depId);
+        if (depState === "gray") {
+          const start = stack.indexOf(depId);
+          if (start >= 0) cycles.push(stack.slice(start));
+        } else if (depState !== "black") {
+          dfs(depId);
+        }
+      }
+    }
+    stack.pop();
+    state.set(id, "black");
+  }
+  for (const t of tasks) {
+    if (!state.has(t.id)) dfs(t.id);
+  }
+  return { dangling, cycles };
+}
+function isTestFor(testFile, sourceFile) {
+  const base = sourceFile.replace(/\.[^./\\]+$/, "");
+  const testBase = testFile.replace(/\.test\.[^./\\]+$/, "").replace(/\/__tests__/, "");
+  return base === testBase;
+}
+function bindSourceTestPairs(tasks) {
+  const result = [];
+  const consumed = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    if (consumed.has(task.id)) continue;
+    consumed.add(task.id);
+    const files2 = touchFiles(task);
+    if (files2.length === 0) {
+      result.push(task);
+      continue;
+    }
+    let merged = false;
+    for (const other of tasks) {
+      if (consumed.has(other.id)) continue;
+      if (other.profile !== "patcher") continue;
+      const otherFiles = touchFiles(other);
+      if (otherFiles.length === 0) continue;
+      const allTestPairs = otherFiles.every(
+        (of) => files2.some((f) => isTestFor(of, f))
+      );
+      if (allTestPairs) {
+        consumed.add(other.id);
+        const mergedFiles = [.../* @__PURE__ */ new Set([...files2, ...otherFiles])];
+        result.push({
+          ...task,
+          files: mergedFiles,
+          touchSet: mergedFiles,
+          verification: [...task.verification, ...other.verification],
+          objective: [task.objective, other.objective].join("\n")
+        });
+        merged = true;
+        break;
+      }
+    }
+    if (!merged) {
+      result.push(task);
+    }
+  }
+  return result;
+}
+function groupTeamTasks(tasks, options) {
+  if (tasks.length === 0) return [];
+  const maxWrite = options?.maxWriteWorkers ?? MAX_WRITE_WORKERS;
+  const maxRead = options?.maxReadWorkers ?? MAX_READ_WORKERS;
+  const bound = bindSourceTestPairs(tasks);
+  const taskMap = new Map(bound.map((t) => [t.id, t]));
+  const diag = validateTaskDependencies(bound);
+  const danglingByTask = /* @__PURE__ */ new Map();
+  for (const d of diag.dangling) {
+    const arr = danglingByTask.get(d.taskId) ?? [];
+    arr.push(d.missingDep);
+    danglingByTask.set(d.taskId, arr);
+  }
+  const topoOrder = topologicalSort(bound);
+  const waves = [];
+  let waveCounter = 0;
+  const completed = /* @__PURE__ */ new Set();
+  const remaining = [...topoOrder];
+  while (remaining.length > 0) {
+    const ready = [];
+    const notReady = [];
+    for (const id of remaining) {
+      const task = taskMap.get(id);
+      if (!task) {
+        notReady.push(id);
+        continue;
+      }
+      const depsMet = task.dependsOn.every((dep) => {
+        const depId = dependencyId(dep);
+        return completed.has(depId) || !taskMap.has(depId);
+      });
+      if (depsMet) {
+        ready.push(id);
+      } else {
+        notReady.push(id);
+      }
+    }
+    if (ready.length === 0) {
+      const forced = remaining[0];
+      const cycle = diag.cycles.find((c) => c.includes(forced));
+      const reason = cycle ? `forced: dependency cycle ${cycle.join("\u2192")}\u2192${cycle[0]}` : "forced: unresolvable dependency order";
+      waves.push({
+        id: `W${++waveCounter}`,
+        taskIds: [forced],
+        reason,
+        parallelLimit: 1,
+        risk: "high"
+      });
+      completed.add(forced);
+      remaining.shift();
+      continue;
+    }
+    const writeReady = [];
+    const readReady = [];
+    for (const id of ready) {
+      const task = taskMap.get(id);
+      if (isReadOnly(task)) {
+        readReady.push(id);
+      } else {
+        writeReady.push(id);
+      }
+    }
+    const waveWriteTasks = [];
+    const writeFilesInWave = /* @__PURE__ */ new Set();
+    const deferredWrites = [];
+    for (const id of writeReady) {
+      const task = taskMap.get(id);
+      if (hasFileOverlapWithSet(task, writeFilesInWave)) {
+        deferredWrites.push(id);
+        continue;
+      }
+      if (waveWriteTasks.length >= maxWrite) {
+        deferredWrites.push(id);
+        continue;
+      }
+      waveWriteTasks.push(id);
+      for (const f of touchFiles(task)) writeFilesInWave.add(f);
+    }
+    const waveReadTasks = readReady.slice(0, maxRead);
+    const deferredReads = readReady.slice(maxRead);
+    const waveTaskIds = [...waveWriteTasks, ...waveReadTasks];
+    if (waveTaskIds.length > 0) {
+      const danglingNotes = waveTaskIds.filter((id) => danglingByTask.has(id)).map((id) => `${id} has unknown dep(s) ${danglingByTask.get(id).join(", ")}`);
+      const waveRisk = waveTaskIds.some((id) => taskMap.get(id)?.riskTier === "high") ? "high" : waveTaskIds.some((id) => taskMap.get(id)?.riskTier === "medium") || danglingNotes.length > 0 ? "medium" : "low";
+      const writeCount = waveWriteTasks.length;
+      const readCount = waveReadTasks.length;
+      const baseReason = writeCount > 0 && readCount > 0 ? `${writeCount} write + ${readCount} read tasks` : writeCount > 0 ? `${writeCount} write tasks` : `${readCount} read tasks`;
+      const reason = danglingNotes.length > 0 ? `${baseReason} (\u26A0 ${danglingNotes.join("; ")})` : baseReason;
+      waves.push({
+        id: `W${++waveCounter}`,
+        taskIds: waveTaskIds,
+        reason,
+        parallelLimit: waveTaskIds.length,
+        risk: waveRisk
+      });
+      for (const id of waveTaskIds) completed.add(id);
+    }
+    remaining.length = 0;
+    remaining.push(...deferredWrites, ...deferredReads, ...notReady);
+  }
+  return waves;
+}
+function hasFileOverlapWithSet(task, filesInWave) {
+  const taskFiles2 = touchFiles(task);
+  if (taskFiles2.length === 0 || filesInWave.size === 0) return false;
+  return taskFiles2.some((f) => filesInWave.has(f));
+}
+
+// src/agent/team-plan.ts
+init_esm_shims();
+var TASK_HEADING_RE = /^\s*(?:#{1,6}\s*)?(?:[-*]\s*)?(?:\[[ xX]\]\s*)?(?:\*\*)?(?:(Task\s+\d+[A-Za-z]?|T\d+[A-Za-z]?|Step\s+\d+[A-Za-z]?)(?:\s*[:：.\-–—]\s*|\s+)(.*)|((?:Task|Step)\s+\d+[A-Za-z]?|T\d+[A-Za-z]?))\*?\*?\s*$/i;
+var FILE_PATH_RE = /(?:`([^`]+)`|\b((?:src|docs|specs|test|tests|\.rivet)\/[\w./@+-]+(?:\.(?:ts|tsx|js|jsx|json|md|yml|yaml|toml|css|scss))?))/g;
+function normalizeTaskId(raw) {
+  return raw.trim().replace(/\s+/g, " ");
+}
+function unique(values) {
+  return [...new Map(values.map((v) => [JSON.stringify(v), v])).values()];
+}
+function stripLineNoise(line) {
+  return line.replace(/^\s*(?:#{1,6}|[-*]|\d+\.)\s*/, "").replace(/\s+/g, " ").trim();
+}
+function extractFiles(text) {
+  const files2 = [];
+  for (const match of text.matchAll(FILE_PATH_RE)) {
+    const captured = (match[1] ?? match[2] ?? "").trim();
+    if (!captured) continue;
+    for (const raw of captured.split(/[,，、;；\s]+/)) {
+      const candidate = raw.replace(/[(),.;:]+$/g, "").trim();
+      if (!candidate) continue;
+      if (!/^(src|docs|specs|test|tests|\.rivet)\//.test(candidate)) continue;
+      files2.push(candidate);
+    }
+  }
+  return unique(files2);
+}
+function classifyTask(title) {
+  const lower = title.toLowerCase();
+  if (/审查|验收|review|squadron|inspector/.test(lower)) {
+    return { profile: "reviewer", kind: "review" };
+  }
+  if (/^验证$|^verify$|^verification$|验证任务|verify task/i.test(lower)) {
+    return { profile: "adversarial_verifier", kind: "verify" };
+  }
+  if (/调研|搜索|查找|scout|research|定位/.test(lower)) {
+    return { profile: "code_scout", kind: "code_search" };
+  }
+  return { profile: "patcher", kind: "patch_proposal" };
+}
+function classifyRiskTier(text) {
+  const lower = text.toLowerCase();
+  if (/auth|security|concurrency|persist|public.?api|config.*schema|schema.*config|migration/i.test(lower)) {
+    return "high";
+  }
+  if (/refactor|renam|mov|restructure/i.test(lower)) {
+    return "medium";
+  }
+  return "low";
+}
+function extractVerification(lines) {
+  const COMMAND_RE = /\b(?:npm|npx|node|tsx|tsc|run_tests|typecheck|pnpm|yarn|jest|vitest|make)\b/i;
+  return unique(lines.map(stripLineNoise).filter((line) => COMMAND_RE.test(line) || /`[^`]+`/.test(line)));
+}
+function parseDependencyRef(raw) {
+  const m = raw.match(/^([A-Za-z0-9_-]+)\(onFailure:(skip|alternate)(?::([A-Za-z0-9_-]+))?\)$/);
+  if (!m) return raw;
+  const id = m[1];
+  const onFailure = m[2];
+  const alternateId = m[3];
+  if (onFailure === "alternate" && !alternateId) return raw;
+  return {
+    dependsOn: id,
+    onFailure,
+    ...alternateId ? { alternateOrderId: alternateId } : {}
+  };
+}
+function extractDependencies(lines) {
+  const deps = [];
+  for (const line of lines) {
+    const m = line.match(/(?:depends?\s*(?:on)?|依赖|前置)\s*[:：]?\s*(.+)/i);
+    if (m) {
+      const refs = m[1].split(/[,，、;；\s]+/).filter((r) => r && r.toLowerCase() !== "none");
+      deps.push(...refs.map(parseDependencyRef));
+    }
+  }
+  return unique(deps);
+}
+function sectionToDraft(section) {
+  const content = section.content.join("\n").trim();
+  const objective = [section.title, content].filter(Boolean).join("\n").trim() || section.id;
+  const classification = classifyTask(section.title || section.id);
+  return {
+    id: section.id,
+    title: section.title || section.id,
+    objective,
+    files: extractFiles(objective),
+    profile: classification.profile,
+    kind: classification.kind,
+    verification: extractVerification(section.content)
+  };
+}
+function draftToTeamTask(draft, sectionContent) {
+  const fullText = [draft.title, ...sectionContent].join("\n").toLowerCase();
+  return {
+    ...draft,
+    dependsOn: extractDependencies(sectionContent),
+    riskTier: classifyRiskTier(fullText),
+    touchSet: [...draft.files],
+    groupId: void 0,
+    routeHint: void 0
+  };
+}
+function parseTeamTaskDrafts(markdown) {
+  const sections = [];
+  let current = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = line.match(TASK_HEADING_RE);
+    if (match) {
+      if (current) sections.push(current);
+      const rawId = match[1] ?? match[3] ?? "Task";
+      const tail = (match[2] ?? "").trim();
+      const id = normalizeTaskId(rawId);
+      current = { id, title: tail || id, content: [] };
+      continue;
+    }
+    if (current) current.content.push(line);
+  }
+  if (current) sections.push(current);
+  return sections.map(sectionToDraft);
+}
+function parseTeamTasks(markdown) {
+  const sections = [];
+  let current = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = line.match(TASK_HEADING_RE);
+    if (match) {
+      if (current) sections.push(current);
+      const rawId = match[1] ?? match[3] ?? "Task";
+      const tail = (match[2] ?? "").trim();
+      const id = normalizeTaskId(rawId);
+      current = { id, title: tail || id, content: [] };
+      continue;
+    }
+    if (current) current.content.push(line);
+  }
+  if (current) sections.push(current);
+  return sections.map((section) => {
+    const draft = sectionToDraft(section);
+    return draftToTeamTask(draft, section.content);
+  });
+}
+function hasOverlappingFiles(a, b) {
+  if (a.files.length === 0 || b.files.length === 0) return false;
+  const bFiles = new Set(b.files);
+  return a.files.some((file) => bFiles.has(file));
+}
+
+// src/agent/council/council-seal.ts
+init_esm_shims();
+import { createHash } from "crypto";
+function contractDigest(plan) {
+  const normalizeTask = (t) => ({
+    id: t.id,
+    objective: t.objective,
+    files: [...t.files].sort(),
+    dependsOn: [...t.dependsOn].sort(),
+    verification: [...t.verification ?? []].sort(),
+    riskTier: t.riskTier
+  });
+  const body = JSON.stringify({
+    objective: plan.objective,
+    tasks: [...plan.tasks].sort((a, b) => a.id.localeCompare(b.id)).map(normalizeTask)
+  });
+  return createHash("sha256").update(body).digest("hex").slice(0, 16);
+}
+function sealPlan(plan, now = Date.now()) {
+  const existing = plan.seal;
+  if (existing) throw new Error(`plan already sealed (v${existing.version}) \u2014 \u4FEE\u8BA2\u8D70 revisePlanSeal \u8C41\u514D\u534F\u8BAE\uFF0C\u4E0D\u53EF\u91CD\u5C01`);
+  return {
+    ...plan,
+    seal: { version: 1, digest: contractDigest(plan), sealedAt: now, exemptions: [] }
+  };
+}
+function verifyPlanSeal(plan) {
+  if (!plan.seal) return { status: "unsealed" };
+  const actual = contractDigest(plan);
+  if (actual === plan.seal.digest) return { status: "intact", version: plan.seal.version };
+  return { status: "broken", version: plan.seal.version, expected: plan.seal.digest, actual };
+}
+function formatSealStatus(plan) {
+  if (!plan.seal) return "\u5951\u7EA6\u672A\u5BC6\u5C01";
+  const check = verifyPlanSeal(plan);
+  const lineage = plan.seal.exemptions.length > 0 ? `\uFF08${plan.seal.exemptions.length} \u6B21\u8C41\u514D\u4FEE\u8BA2\uFF0C\u6700\u8FD1\uFF1A${plan.seal.exemptions.at(-1).reason}\uFF09` : "";
+  return check.status === "intact" ? `\u{1F50F} \u5951\u7EA6\u5DF2\u5BC6\u5C01 v${plan.seal.version} \xB7 ${plan.seal.digest}${lineage}` : `\u26D4 \u5951\u7EA6\u5BC6\u5C01\u7834\u635F v${plan.seal.version}\uFF1A\u5185\u5BB9\u4E0E\u5BC6\u5C01\u6458\u8981\u4E0D\u7B26\uFF08expected ${plan.seal.digest}, actual ${check.actual}\uFF09\u2014\u2014\u5DF2\u5BC6\u5C01\u5951\u7EA6\u4E0D\u53EF\u9759\u9ED8\u6539\u5199\uFF0C\u8D70 revisePlanSeal \u8C41\u514D\u534F\u8BAE`;
+}
+
+// src/agent/orchestration-outcome.ts
+init_esm_shims();
+var WORKER_ROW_CAP = 40;
+function firstLineCap(text, cap) {
+  if (!text) return "";
+  const line = text.split("\n", 1)[0].trim();
+  return line.length > cap ? `${line.slice(0, cap - 1)}\u2026` : line;
+}
+function taskOf(workOrderId) {
+  const idx = workOrderId.lastIndexOf(":");
+  return idx >= 0 && idx < workOrderId.length - 1 ? workOrderId.slice(idx + 1) : workOrderId;
+}
+function buildWorkerRows(results) {
+  const rows = results.map((r) => ({
+    id: r.workOrderId ?? "",
+    task: taskOf(r.workOrderId ?? ""),
+    status: r.status,
+    ...r.failureReason ? { failureReason: r.failureReason } : {},
+    summary: firstLineCap(r.summary, 100),
+    ...r.objective ? { objective: firstLineCap(r.objective, 60) } : {},
+    changedCount: r.changedFiles?.length ?? 0,
+    ...r.changedFiles && r.changedFiles.length > 0 ? { changedFiles: r.changedFiles.slice(0, 3).map((f) => f.split("/").pop() ?? f) } : {},
+    ...r.diffArtifactId ? { diffArtifactId: r.diffArtifactId } : {},
+    ...r.evidenceStatus ? { evidenceStatus: r.evidenceStatus } : {},
+    ...r.usage && (typeof r.usage.input_tokens === "number" || typeof r.usage.output_tokens === "number") ? { usage: { input: r.usage.input_tokens ?? 0, output: r.usage.output_tokens ?? 0 } } : {},
+    ...typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}
+  }));
+  rows.sort((a, b) => (a.status === "passed" ? 1 : 0) - (b.status === "passed" ? 1 : 0));
+  return rows.length > WORKER_ROW_CAP ? rows.slice(0, WORKER_ROW_CAP) : rows;
+}
+function buildTeamOutcome(summary, fromWave, run) {
+  const results = summary.run?.results ?? [];
+  const total = results.length;
+  const passed = results.filter((r) => r.status === "passed").length;
+  const totalWaves = summary.waves.length;
+  const allFailed = total > 0 && passed === 0;
+  const isLastWave = fromWave + 1 >= totalWaves;
+  const hasRun = summary.run !== void 0;
+  let stoppedReason;
+  if (hasRun) {
+    if (allFailed) stoppedReason = "all-failed";
+    else if (run.gate && !run.gate.passed) stoppedReason = "wave-gate";
+    else if (run.reviewVerdict === "rejected") stoppedReason = "review-rejected";
+    else if (isLastWave) stoppedReason = "completed";
+    else if (passed < total) stoppedReason = "partial";
+    else stoppedReason = "more-waves";
+  }
+  return {
+    kind: "team",
+    dispatched: summary.dispatched,
+    wave: fromWave,
+    totalWaves,
+    workers: { total, passed },
+    // 已成功执行完的波次数：整波失败时本波未成功完成（= fromWave），
+    // 其余情况本波已完成（= fromWave + 1）。末波完成时 === totalWaves。
+    ...hasRun ? { completedWaves: allFailed ? fromWave : fromWave + 1, stoppedReason } : {},
+    ...run.gate ? { waveGate: { passed: run.gate.passed, failures: run.gate.failures } } : {},
+    ...run.reviewVerdict ? { reviewVerdict: run.reviewVerdict } : {},
+    ...total > 0 ? { workerRows: buildWorkerRows(results) } : {}
+  };
+}
+
+// src/agent/plan-executor.ts
+init_esm_shims();
+import { isAbsolute } from "path";
+
+// src/agent/review-coordinator-deps.ts
+init_esm_shims();
+var REVIEW_PARENT_TURN_ID = "deliver_task:review-router";
+function files(change) {
+  return [...change.files];
+}
+function objectiveReviewStanceBlock() {
+  return [
+    "\u5BA2\u89C2\u5BA1\u67E5\u59FF\u6001\uFF08\u6765\u81EA\u5916\u90E8 Claude Code Opus \u5BA1\u8BA1\u7ECF\u9A8C\u7684\u5185\u5316\uFF1B\u4E0D\u4F9D\u8D56\u5916\u90E8\u8F85\u52A9\u5728\u573A\uFF09\uFF1A",
+    formatObjectiveReviewStance()
+  ].join("\n");
+}
+function dataflowVerifierBlock() {
+  return [
+    "\u6570\u636E\u6D41\u9A8C\u8BC1\u59FF\u6001\uFF08\u590D\u6742 spec \u7684 P4-c \u6559\u8BAD\uFF09\uFF1A",
+    "1. \u4E0D\u8981\u628A spec \u6761\u6B3E\u5F53\u6210\u6241\u5E73\u6E05\u5355\u6838\u5BF9\uFF1B\u4ECE spec \u5B57\u6BB5/\u7EA6\u675F\u51FA\u53D1\uFF0C\u91CD\u6784\u4E8B\u5B9E\u6D41\u56FE\uFF1A\u751F\u4EA7\u8005 \u2192 \u4E2D\u95F4\u7ED3\u6784 \u2192 \u6D88\u8D39\u8005/\u5199\u5165\u76EE\u6807 \u2192 \u65AD\u8A00\u3002",
+    "2. \u68C0\u67E5\u7EC4\u5408\u95E8\u63A7\u7684\u6761\u4EF6\u77E9\u9635\uFF0C\u5982 source \xD7 severity \xD7 apply\uFF1B\u5D4C\u5957\u7EA6\u675F\u4E0D\u80FD\u62CD\u5E73\u6210\u72EC\u7ACB\u7684 if\u3002",
+    "3. \u8981\u6C42\u53CD\u4F8B\u8986\u76D6\uFF1A\u5982\u679C\u5B9E\u73B0\u53EA\u5904\u7406\u4E86 happy path\u3001\u5FD8\u4E86\u8C03\u7528\u5408\u7EA6\u3001\u58F0\u660E\u4E86\u7C7B\u578B\u5374\u4E0D\u6D88\u8D39\u3001\u6216\u7528 truthy/falsy \u54E8\u5175\uFF08\u5982 !waveId\uFF09\uFF0C\u54EA\u4E2A\u5DF2\u5B58\u5728\u6216\u65B0\u589E\u7684\u6D4B\u8BD5\u4F1A\u5931\u8D25\uFF1F",
+    "4. \u6D4B\u8BD5\u5168\u7EFF\u4E0D\u591F\u2014\u2014\u5B83\u5FC5\u987B\u80FD\u8BA9\u9519\u8BEF/\u521D\u7248\u5B9E\u73B0\u5728\u76F8\u5173 spec \u8DEF\u5F84\u4E0A\u53D8\u7EA2\u3002",
+    "5. \u865A\u5047\u7EFF\u706F/fixture \u5951\u7EA6\u5BA1\u8BA1\uFF1A\u5BF9\u6D4B\u8BD5 mock/fixture \u5728\u4F9D\u8D56\u8F93\u51FA\u4E0A\u8D4B\u503C\u7684\u6BCF\u4E2A\u5B57\u6BB5\uFF0C\u9A8C\u8BC1\u771F\u5B9E\u751F\u4EA7\u4EE3\u7801\u662F\u5426\u786E\u5B9E\u4EA7\u51FA\u8BE5\u5F62\u72B6\uFF08grep \u5199\u5165\u70B9\uFF0C\u4E0D\u662F\u53EA\u770B\u7C7B\u578B\u58F0\u660E\uFF09\u3002\u5BF9\u751F\u4EA7\u4EE3\u7801\u6E32\u67D3/\u6D88\u8D39\u7684\u6BCF\u4E2A\u5B57\u6BB5\uFF0C\u8FFD\u8E2A\u5176\u751F\u4EA7\u5199\u5165\u70B9\u53CA\u8BE5\u5199\u5165\u7684\u8FD0\u884C\u65F6\u6761\u4EF6\u662F\u5426\u771F\u7684\u80FD\u89E6\u53D1\uFF08`raw.x ?` \u5B88\u536B\u7684\u5199\u5165\u884C\uFF0C\u5982\u679C\u6570\u636E\u6E90\u4ECE\u4E0D\u643A\u5E26 x\uFF0C\u4ECD\u7136\u662F\u6B7B\u7684\uFF09\u3002fixture \u865A\u6784\u4E86\u4E00\u4E2A\u771F\u5B9E\u7CFB\u7EDF\u4ECE\u4E0D\u4EA7\u51FA\u7684\u5F62\u72B6\u2014\u2014\u6216\u53CC\u65B9\u5404\u81EA mock \u8FB9\u754C\u5374\u65E0\u4E00\u4EFD\u5408\u7EA6\u6D4B\u8BD5\u65AD\u8A00\u771F\u5B9E\u751F\u4EA7\u8005\u7684\u8F93\u51FA\u2014\u2014\u5C31\u662F\u865A\u5047\u7EFF\u706F\uFF0C\u4E0A\u62A5 HIGH\u3002"
+  ].join("\n");
+}
+function pathBoundaryReviewBlock() {
+  return [
+    "\u8DEF\u5F84\u8FB9\u754C/\u6CE8\u610F\u529B\u95E8\u63A7\u5BA1\u67E5\u59FF\u6001\uFF08T7/MeridianIndexer \u6559\u8BAD\uFF1B\u59CB\u7EC8\u9002\u7528\u4E8E path\u3001classifier\u3001discovery\u3001indexer\u3001watcher\u3001git-status\u3001ownership \u76F8\u5173\u6539\u52A8\uFF09\uFF1A",
+    formatPathBoundaryReviewStance()
+  ].join("\n");
+}
+function weighingReviewBlock() {
+  return [
+    "\u79F0\u91CF\u5BA1\u67E5\u59FF\u6001\uFF08\u5929\u6743\u79F0\u91CF\u8005\u6559\u8BAD\uFF1B\u9002\u7528\u4E8E\u91CD\u6784\u3001\u63D0\u53D6\u3001\u5C01\u88C5/\u4F5C\u7528\u57DF\u53D8\u66F4\u2014\u2014\u65E2\u9A8C\u771F\u4F2A\uFF0C\u4E5F\u79F0\u91CF\u4EE3\u4EF7\uFF09\uFF1A",
+    formatWeighingReviewStance()
+  ].join("\n");
+}
+function wiringEffectivenessBlock() {
+  return [
+    '\u63A5\u7EBF\u6709\u6548\u6027\u5BA1\u67E5\u59FF\u6001\uFF082026-06-12 \u566A\u97F3\u6CBB\u7406\u590D\u5BA1\u6559\u8BAD\uFF1B"built \u2260 wired \u2260 effective"\u2014\u2014\u9002\u7528\u4E8E\u6BCF\u6B21 feature/config/param/bus/gate \u65B0\u589E\uFF09\uFF1A',
+    formatWiringEffectivenessReviewStance()
+  ].join("\n");
+}
+function methodologyVerificationBlock() {
+  return [
+    '\u65B9\u6CD5\u8BBA\u9A8C\u8BC1\u59FF\u6001\uFF082026-06-14 PlanDesignIntentRouter \u5BF9\u6297\u5BA1\u67E5\u53CD\u63A8\uFF1B"\u65B9\u6CD5\u8BBA\u6587\u6863\u5373\u4EE3\u7801\u2014\u2014\u53EF\u6267\u884C\u6307\u4EE4\u9700\u5B9E\u8BC1\u9A8C\u8BC1"\u2014\u2014\u9002\u7528\u4E8E\u5BA1\u67E5\u77E5\u8BC6\u6587\u4EF6\u3001\u8BA1\u5212\u6A21\u677F\u3001\u89C4\u5219\u3001\u81EA\u68C0\u6E05\u5355\uFF09\uFF1A',
+    formatMethodologyVerificationStance()
+  ].join("\n");
+}
+function caseSensitivityReviewBlock() {
+  return [
+    "\u5927\u5C0F\u5199\u5BA1\u67E5\u59FF\u6001\uFF08macOS APFS \u5927\u5C0F\u5199\u4E0D\u654F\u611F\u2192\u5F00\u53D1\u673A\u4E0D\u62A5\u9519\uFF0CLinux/CI \u5D29\u6E83\u2014\u2014\u4E13\u6293 import \u8DEF\u5F84\u3001API \u6807\u8BC6\u7B26\u3001\u5168\u5C40\u53D8\u91CF\u5927\u5C0F\u5199\u4E0D\u4E00\u81F4\uFF09\uFF1A",
+    formatCaseSensitivityReviewStance()
+  ].join("\n");
+}
+function childReviewDepth(options) {
+  return (options.reviewDepth ?? 0) + 1;
+}
+function scope(change) {
+  return { files: files(change), overlapsPrimary: true };
+}
+function request(input) {
+  const reviewDepth = childReviewDepth(input.options);
+  return {
+    parentTurnId: input.options.parentTurnId ?? REVIEW_PARENT_TURN_ID,
+    objective: [
+      input.objective,
+      "",
+      `\u5BA1\u67E5\u6DF1\u5EA6: ${reviewDepth}\u3002\u5BA1\u67E5 worker \u4E0D\u5F97\u8C03\u7528 deliver_task\uFF1B\u4EC5\u62A5\u544A verdict/evidence \u5373\u53EF\u3002`
+    ].join("\n"),
+    kind: input.kind,
+    profile: input.profile,
+    scope: scope(input.change),
+    reviewDepth,
+    ...input.onActivity ? { onActivity: input.onActivity } : {}
+  };
+}
+function verificationEvidence(result) {
+  if (!result.verification) return void 0;
+  const v = result.verification;
+  return `ran: ${v.command} \u2192 ${v.status} (${v.passed ?? 0} passed, ${v.failed ?? 0} failed, ${v.skipped ?? 0} skipped)`;
+}
+function formatFinding(finding) {
+  const prefix = finding.evidenceKind === "firsthand" ? "[\u4E00\u624B] " : finding.evidenceKind === "inferred" ? "[\u8F6C\u8FF0] " : "";
+  const refs = finding.evidenceRefs && finding.evidenceRefs.length > 0 ? ` (${finding.evidenceRefs.join(", ")})` : "";
+  return `${prefix}${finding.claim} \u2014 ${finding.evidence}${refs}`;
+}
+function summarizeResult(result) {
+  const parts = [
+    verificationEvidence(result),
+    result.summary,
+    ...result.findings.slice(0, 3).map(formatFinding),
+    ...result.risks.slice(0, 3).map((risk) => `risk: ${risk}`)
+  ].filter((part) => Boolean(part && part.trim().length > 0));
+  return parts.join("\n");
+}
+function summarizeRun(run) {
+  if (run.status === "skipped") return "review worker skipped: objective did not pass delegation budget gate";
+  const summaries = run.results.map(summarizeResult).filter(Boolean);
+  return summaries.length > 0 ? summaries.join("\n---\n") : "review worker returned no evidence";
+}
+function extractSeverity(text) {
+  if (/\bCRITICAL\b|\bC\d+\b/i.test(text)) return "CRITICAL";
+  if (/\bHIGH\b|\bH\d+\b/i.test(text)) return "HIGH";
+  if (/\bMEDIUM\b|\bM\d+\b/i.test(text)) return "MEDIUM";
+  if (/\bLOW\b|\bL\d+\b/i.test(text)) return "LOW";
+  return void 0;
+}
+function mapWorkerFinding(result, finding) {
+  const text = `${finding.claim}
+${finding.evidence}
+${result.summary}`;
+  return {
+    severity: extractSeverity(text),
+    claim: finding.claim,
+    evidence: finding.evidence,
+    // 极性透传：worker 未上报时缺席，blocking 判定按 defect 处理（fail-closed）。
+    ...finding.polarity ? { polarity: finding.polarity } : {}
+  };
+}
+function mapSquadronFindings(run) {
+  const findings = [];
+  for (const result of run.results) {
+    if (result.status !== "passed") continue;
+    for (const finding of result.findings) {
+      findings.push(mapWorkerFinding(result, finding));
+    }
+  }
+  return findings;
+}
+function formatReportSource(source) {
+  switch (source) {
+    case "salvaged":
+      return "[\u6765\u6E90: \u5B57\u6BB5\u7EA7\u6253\u635E\uFF0Cunverified] ";
+    case "blocked":
+      return "[\u6765\u6E90: \u7ED3\u6784\u5316\u963B\u585E] ";
+    case "repaired":
+      return "[\u6765\u6E90: \u65E0\u5386\u53F2\u4FEE\u590D\u8F6E\uFF0C\u4EC5\u4F9B\u53C2\u8003] ";
+    default:
+      return "";
+  }
+}
+function classifyInfraFailure(result) {
+  switch (result.failureReason) {
+    case "json_parse":
+    case "schema_mismatch":
+      return "json";
+    case "max_turns":
+      return "budget";
+    case "timeout":
+      return "timeout";
+    default:
+      break;
+  }
+  const summary = result.summary;
+  if (/did not contain a JSON object|schema-valid JSON|parse/i.test(summary)) return "json";
+  if (/max.?turns|exhausted without a final turn/i.test(summary)) return "budget";
+  if (/timeout|timed out/i.test(summary)) return "timeout";
+  if (/skipped/i.test(summary)) return "skip";
+  return "worker";
+}
+function mapSquadronInfraFailures(run) {
+  if (run.status === "skipped") {
+    return [{ kind: "skip", claim: "Review Squadron skipped before producing findings" }];
+  }
+  const failures = [];
+  for (const result of run.results) {
+    if (result.status === "passed") continue;
+    const salvaged = result.findings.length > 0 ? result.findings.slice(0, 8).map((f) => ({ claim: f.claim, confidence: f.confidence })) : void 0;
+    failures.push({
+      kind: classifyInfraFailure(result),
+      claim: `${formatReportSource(result.reportSource)}${result.summary}`,
+      ...salvaged !== void 0 ? { salvagedFindings: salvaged } : {}
+    });
+  }
+  return failures;
+}
+function verifierResult(run) {
+  const verified = run.status === "completed" && run.results.some((result) => result.status === "passed" && result.evidenceStatus === "verified");
+  return {
+    verdict: verified ? "verified" : "rejected",
+    evidence: summarizeRun(run)
+  };
+}
+function patcherResult(run) {
+  const patchedRun = run.status === "completed" ? run.results.find((result) => result.status === "passed" && (result.changedFiles.length > 0 || Boolean(result.patchSummary))) : void 0;
+  if (!patchedRun) return { patched: false };
+  return {
+    patched: true,
+    ...patchedRun.changedFiles.length > 0 ? { changedFiles: [...patchedRun.changedFiles] } : {},
+    ...patchedRun.patchSummary ? { patchSummary: patchedRun.patchSummary } : {},
+    // 落盘句柄必须跟着回流：隔离 worktree 会被清理，句柄是主控取回补丁的唯一途径。
+    // 在这一层丢掉它，披露行就只能说「改了什么」而给不出补丁。
+    ...patchedRun.diffArtifactId ? { diffArtifactId: patchedRun.diffArtifactId } : {}
+  };
+}
+function verifierObjective(change) {
+  const largeWarn = formatLargeFileWarnings(change);
+  return [
+    "\u5728\u4EA4\u4ED8\u524D\u72EC\u7ACB\u5BF9\u6297\u6027\u9A8C\u8BC1\u6B64\u6539\u52A8\u3002",
+    objectiveReviewStanceBlock(),
+    dataflowVerifierBlock(),
+    pathBoundaryReviewBlock(),
+    weighingReviewBlock(),
+    wiringEffectivenessBlock(),
+    caseSensitivityReviewBlock(),
+    methodologyVerificationBlock(),
+    `\u8303\u56F4\u6587\u4EF6: ${files(change).join(", ") || "(\u65E0)"}`,
+    ...change.focusHint ? [`**\u5BA1\u67E5\u91CD\u70B9**: ${change.focusHint}`] : [],
+    ...largeWarn ? [largeWarn] : [],
+    "\u5C3D\u53EF\u80FD\u8FD0\u884C\u76F8\u5173\u7684\u65E2\u6709\u6D4B\u8BD5\uFF0C\u8FD4\u56DE\u547D\u4EE4 + \u89C2\u6D4B\u5230\u7684\u8F93\u51FA\u4F5C\u4E3A\u8BC1\u636E\u3002",
+    "\u4E0D\u8981\u6B62\u6B65\u4E8E\u6D4B\u8BD5\u7EFF\uFF1A\u5BF9\u53D8\u66F4\u6587\u4EF6\u81F3\u5C11\u5C1D\u8BD5\u4E00\u4E2A\u53CD\u4F8B\u6216\u8FB9\u754C/\u9519\u8BEF\u8DEF\u5F84\u63A2\u9488\u3002",
+    "\u5BF9 spec/\u96C6\u6210\u7C7B\u53D8\u66F4\uFF0C\u663E\u5F0F\u62A5\u544A\u4E8B\u5B9E\u6D41\u95ED\u73AF\u3001\u6761\u4EF6\u77E9\u9635\u8986\u76D6\u3001\u4EE5\u53CA\u4E00\u4E2A\u80FD\u8BA9\u7EAF\u6E05\u5355\u5F0F\u5B9E\u73B0\u5931\u8D25\u7684\u6D4B\u8BD5\u7528\u4F8B\u3002",
+    '\u4EC5\u5F53\u9A8C\u8BC1\u786E\u5B9E\u8FD0\u884C\u3001\u901A\u8FC7\u3001\u4E14\u672A\u53D1\u73B0\u53CD\u4F8B\u65F6\uFF0C\u8FD4\u56DE evidenceStatus="verified" \u7684 WorkerResult JSON\u3002'
+  ].join("\n");
+}
+function patcherObjective(change, verifier) {
+  return [
+    "\u5728\u9694\u79BB\u7684 worker worktree \u4E2D\u4FEE\u590D\u88AB\u5BF9\u6297\u9A8C\u8BC1\u62D2\u7EDD\u7684\u6539\u52A8\u3002",
+    "\u4FEE\u590D\u9A8C\u8BC1\u5668\u6307\u51FA\u7684\u6839\u56E0\uFF1B\u4E0D\u8981\u5F31\u5316\u6D4B\u8BD5\u6216\u4EC5\u538B\u5236\u75C7\u72B6\u3002",
+    `\u8303\u56F4\u6587\u4EF6: ${files(change).join(", ") || "(\u65E0)"}`,
+    `\u9A8C\u8BC1\u5668\u5224\u51B3: ${verifier.verdict}`,
+    `\u9A8C\u8BC1\u5668\u8BC1\u636E: ${verifier.evidence}`,
+    "\u8FD4\u56DE\u5E26 changedFiles \u548C patchSummary \u7684 WorkerResult JSON\u3002"
+  ].join("\n");
+}
+var WIRING_INSPECTOR_METHOD = [
+  "\u65B9\u6CD5\uFF08\u9010\u9879\uFF0C\u9644 file:line\uFF09\uFF1A",
+  "1. \u4ECE\u751F\u4EA7\u5165\u53E3\u6B63\u5411\u8FFD\u95ED\u73AF\uFF1A\u5165\u53E3\u2192\u7EC4\u5408\u6839\u2192\u6539\u52A8\u70B9\u3002\u6D4B\u8BD5/\u811A\u672C\u4E2D\u7684\u6302\u70B9\u4E0D\u7B97\u3002\u65AD\u7EBF=HIGH\u3002",
+  "2. \u65B0\u589E\u53C2\u6570/\u5B57\u6BB5/setter\u2192grep \u6240\u6709\u8C03\u7528\u65B9\u3002\u96F6\u8C03\u7528\u65B9\u4F20\u503C/\u8BFB\u53D6=\u6B7B\u63A5\u7EBF\u3002",
+  "3. \u95E8\u63A7\u6761\u4EF6\u2192\u679A\u4E3E\u771F\u5B9E\u8F93\u5165\u5F62\u72B6(\u7A7A\u96C6\u5408/\u53EF\u9009\u5B57\u6BB5\u7F3A\u5931/\u81EA\u7531\u6587\u672C)\u2192\u4F30\u7B97\u901A\u8FC7\u7387\u3002~0%\u6216~100%\u5747\u65E0\u6548\u3002",
+  "4. \u6539\u52A8\u58F0\u79F0\u76EE\u6807\u2192\u6784\u9020\u6539\u524D/\u6539\u540E\u573A\u666F\u9A8C\u8BC1\u6307\u6807\u786E\u5B9E\u671D\u58F0\u79F0\u65B9\u5411\u79FB\u52A8\u3002",
+  "5. \u88AB\u79FB\u9664\u8C03\u7528\u70B9\u2192\u68C0\u67E5\u9057\u7559\u751F\u4EA7\u8005/setter/\u5B57\u6BB5\u662F\u5426\u4E5F\u6709\u6D3B\u6D88\u8D39\u8005\u3002"
+].join("\n");
+var SILENCE_INSPECTOR_METHOD = [
+  "\u65B9\u6CD5\uFF08\u9010\u9879\u6267\u884C\uFF0C\u6BCF\u9879\u9644 file:line \u8BC1\u636E\uFF09\uFF1A",
+  "1. \u7A7A catch/\u88AB\u541E\u9519\u8BEF\uFF1A\u7528 ast_grep \u67E5\u627E\u7A7A\u4F53\u6216\u65E0\u64CD\u4F5C\u4F53\u7684 catch \u5757\u2014\u2014\u6A21\u5F0F `try { $$A } catch ($E) { }`\uFF08\u7A7A\u4F53\uFF09\u548C `try { $$A } catch ($E) { $$B }`\uFF0C\u7136\u540E\u8BFB\u53D6\u6BCF\u4E2A $B \u68C0\u67E5\u662F\u5426\u53EA\u6253\u4E86\u65E5\u5FD7/\u541E\u6389\u9519\u8BEF\u800C\u6CA1\u6709\u91CD\u65B0\u629B\u51FA\u6216\u4E0A\u6D6E\u3002grep \u65E0\u6CD5\u533A\u5206 catch \u4F53\u548C\u5468\u56F4\u4EE3\u7801\uFF1Bast_grep \u80FD\u7CBE\u786E\u5B9A\u4F4D\u7ED3\u6784\u5F62\u72B6\u3002",
+  "2. \u65E0 rejection \u5904\u7406\u5668\u7684 Promise\uFF1Aast_grep \u6A21\u5F0F `$$P.then($F)` \u548C `async $F($$) { $$ }`\u2014\u2014\u4EA4\u53C9\u5F15\u8BC1\u786E\u8BA4\u6BCF\u6761\u5F02\u6B65\u8DEF\u5F84\u90FD\u6709 .catch \u6216 try-catch\u3002rejected promise \u4E0A\u88F8 `.then` \u65E0 `.catch` = \u88AB\u541E\u6389\u7684 rejection\u3002",
+  '3. \u5BF9"\u6D4B\u8BD5\u5DF2\u901A\u8FC7/\u5DF2\u4FEE\u590D"\u7C7B\u58F0\u660E\uFF1A\u8981\u6C42\u63D0\u4F9B\u786E\u5207\u547D\u4EE4 + \u89C2\u6D4B\u5230\u7684\u901A\u8FC7\u6570\u3002\u53EA\u8986\u76D6 happy path\uFF08\u65E0\u9519\u8BEF\u8DEF\u5F84\u65AD\u8A00\uFF09\u7684\u7EFF\u8272\u662F\u865A\u5047\u7EFF\u706F\u2014\u2014\u6807\u8BB0\u5B83\u3002'
+].join("\n");
+var INSPECTORS = [
+  {
+    name: "\u5B89\u5168\u5BA1\u67E5",
+    objective: "\u5BA1\u67E5\u8BA4\u8BC1\u3001\u6388\u6743\u3001\u8DEF\u5F84\u6821\u9A8C\u3001\u5BC6\u94A5\u6CC4\u9732\u3001\u4EE5\u53CA fail-open/fail-closed \u884C\u4E3A\u3002",
+    stances: ["pathBoundary"]
+  },
+  {
+    name: "\u751F\u547D\u5468\u671F",
+    objective: "\u5BA1\u67E5\u72B6\u6001\u8F6C\u6362\u3001\u5F02\u6B65\u7ADE\u6001\u3001\u53D6\u6D88\u4F20\u64AD\u3001\u8D85\u65F6\u4F20\u9012\u3001\u4EE5\u53CA load-check-save \u539F\u5B50\u6027\u3002\u9A8C\u8BC1\u5916\u5C42\u8D85\u65F6\u4E25\u683C\u652F\u914D\u5185\u5C42\u9884\u7B97\uFF08\u5185\u5C42\u5FC5\u987B\u5148\u89E6\u53D1\u4EE5\u4FDD\u7559\u90E8\u5206\u7ED3\u679C\uFF09\u3002",
+    stances: ["dataflow"]
+  },
+  {
+    name: "\u6570\u636E\u6D41",
+    objective: "\u5BA1\u67E5\u53C2\u6570\u4F20\u64AD\u3001\u767D\u540D\u5355/\u5DE5\u5177\u4F5C\u7528\u57DF\u4F20\u64AD\u3001\u6301\u4E45\u5316\u8DEF\u5F84\u3001\u4EE5\u53CA\u6570\u636E\u4E22\u5931\u98CE\u9669\u3002",
+    stances: ["dataflow", "pathBoundary"]
+  },
+  {
+    name: "\u9759\u9ED8\u5BA1\u67E5",
+    objective: '\u5BA1\u67E5\u88AB\u541E\u6389\u7684\u9519\u8BEF\u3001\u7A7A catch \u5757\u3001\u7F3A\u5931\u7684\u8BCA\u65AD\u4FE1\u606F\u3001\u4EE5\u53CA\u865A\u5047\u7EFF\u706F\u9A8C\u8BC1\u58F0\u660E\u3002\u5C06"\u6D4B\u8BD5\u5DF2\u901A\u8FC7/\u5DF2\u4FEE\u590D"\u7C7B\u65AD\u8A00\u4F5C\u4E3A\u6700\u9AD8\u4F18\u5148\u7EA7\u5BA1\u67E5\u76EE\u6807\uFF1A\u8981\u6C42\u63D0\u4F9B\u786E\u5207\u547D\u4EE4 + \u89C2\u6D4B\u5230\u7684\u8F93\u51FA\u3002\u540C\u65F6\u6807\u8BB0 fixture \u865A\u6784\u7684\u865A\u5047\u7EFF\u706F\uFF1A\u6D4B\u8BD5\u65AD\u8A00\u4E86\u4E00\u4E2A\u751F\u4EA7\u4EE3\u7801\u4ECE\u672A\u5199\u5165\u8FC7\u771F\u5B9E\u503C\u7684\u5B57\u6BB5/\u5F62\u72B6\u2014\u2014\u53EA\u6709 fixture \u5728\u5199\u2014\u2014\u5BFC\u81F4\u8BE5\u529F\u80FD\u7EFF\u706F\u4F46\u5B9E\u9645\u5DF2\u6B7B\u3002',
+    stances: [],
+    method: SILENCE_INSPECTOR_METHOD
+  },
+  {
+    name: "\u63A5\u7EBF\u5BA1\u67E5",
+    objective: '\u5BA1\u67E5\u7AEF\u5230\u7AEF\u63A5\u7EBF\u4E0E\u6709\u6548\u6027\u2014\u2014"\u6784\u5EFA \u2260 \u63A5\u7EBF \u2260 \u6709\u6548"\u3002\u6392\u67E5\uFF1A\u8BA1\u5212\u9879\u534A\u6210\u54C1\uFF08\u5B57\u6BB5\u52A0\u4E86\u4F46\u4ECE\u672A\u5F3A\u5236\u751F\u6548\uFF09\u3001\u65B0\u589E\u53EF\u9009\u53C2\u6570\u5374\u65E0\u8C03\u7528\u65B9\u3001setter/\u603B\u7EBF/\u914D\u7F6E\u6807\u5FD7\u4ECE\u672A\u88AB\u8BFB\u53D6\u6216\u51B2\u5237\u3001\u95E8\u7981\u88AB\u771F\u5B9E\u6570\u636E\u5F62\u72B6\u8FC7\u6EE4\u6389\u51E0\u4E4E\u6240\u6709\u8F93\u5165\uFF08\u9759\u9ED8\u7279\u6027\u6740\u622E\uFF09\u3001\u4EE5\u53CA\u6539\u52A8\u4E0E\u5176\u58F0\u79F0\u76EE\u6807\u80CC\u9053\u800C\u9A70\uFF08\u4F8B\u5982\u65E7\u901A\u9053\u4E0E\u65B0\u901A\u9053\u5E76\u5B58\u2014\u2014\u964D\u566A\u6539\u52A8\u91CC\u51FA\u73B0\u91CD\u590D\u6E32\u67D3\uFF09\u3002',
+    stances: ["wiring"],
+    method: WIRING_INSPECTOR_METHOD
+  }
+];
+function stanceBlocks(stances) {
+  const blocks = [];
+  if (stances.includes("dataflow")) blocks.push(dataflowVerifierBlock());
+  if (stances.includes("pathBoundary")) blocks.push(pathBoundaryReviewBlock());
+  if (stances.includes("wiring")) blocks.push(wiringEffectivenessBlock());
+  if (stances.includes("methodology")) blocks.push(methodologyVerificationBlock());
+  return blocks;
+}
+var FINDING_CONTRACT = [
+  '\u6BCF\u9879\u53D1\u73B0\u987B\u62A5\u544A\u4E25\u91CD\u7EA7\u522B CRITICAL/HIGH/MEDIUM/LOW\u3001\u7ED3\u8BBA\u3001\u8BC1\u636E\uFF08file:line\uFF09\u3001\u4EE5\u53CA\u6700\u5C0F\u4FEE\u590D\u5EFA\u8BAE\u3002\u82E5\u8BE5\u5BA1\u67E5\u7EF4\u5EA6\u65E0\u95EE\u9898\uFF0C\u987B\u660E\u786E\u62A5\u544A"\u672A\u53D1\u73B0\u5F02\u5E38"\u2014\u2014\u6C89\u9ED8\u4E0D\u7B49\u4E8E\u901A\u8FC7\u3002',
+  'severity \u8BED\u4E49\uFF1ACRITICAL/HIGH \u53EA\u7528\u4E8E\u5FC5\u987B\u4FEE\u590D\u7684\u7F3A\u9677\u3002\u786E\u8BA4\u6027\u7ED3\u8BBA\uFF08\u5DF2\u6838\u5B9E\u65E0\u95EE\u9898\u3001\u94FE\u8DEF\u95ED\u5408\u3001\u53E3\u5F84\u5BF9\u9F50\uFF09\u4E0D\u662F\u7F3A\u9677\u2014\u2014\u5728\u8BE5 finding \u4E0A\u6807 "polarity": "confirmation"\uFF0C\u5B83\u4F1A\u8FDB\u5165\u300C\u5DF2\u6838\u5B9E\u6E05\u5355\u300D\u800C\u975E blocking findings\uFF1B\u7F3A\u9677\u53EF\u663E\u5F0F\u6807 "defect"\uFF08\u7F3A\u7701\u6309 defect \u5904\u7406\uFF09\u3002',
+  "status \u8BED\u4E49\uFF1Astatus \u8868\u793A\u4F60\u7684\u5BA1\u67E5\u4EFB\u52A1\u662F\u5426\u5B8C\u6210\uFF0C\u4E0D\u662F\u88AB\u5BA1\u4EE3\u7801\u7684\u5224\u5B9A\u3002\u53D1\u73B0 CRITICAL \u7F3A\u9677\u65F6 status \u4ECD\u4E3A passed\u2014\u2014\u7F3A\u9677\u7ECF findings \u8868\u8FBE\uFF1Bfailed/blocked \u53EA\u7528\u4E8E\u4F60\u81EA\u5DF1\u6CA1\u5B8C\u6210\u5BA1\u67E5\uFF08\u9884\u7B97\u8017\u5C3D\u3001\u8BFB\u4E0D\u5230\u4EE3\u7801\u7B49\uFF09\u3002"
+].join("\n");
+function formatLargeFileWarnings(change) {
+  if (!change.largeFiles || change.largeFiles.length === 0) return null;
+  const lines = [
+    `\u26A0\uFE0F  ${change.largeFiles.length} \u4E2A\u6587\u4EF6\u8D85\u51FA ${Math.round(LARGE_FILE_WARN_THRESHOLD / 1e3)}KB \u5BA1\u67E5\u9608\u503C\uFF1A`
+  ];
+  for (const lf of change.largeFiles) {
+    const kb = Math.round(lf.sizeBytes / 1e3);
+    lines.push(`  - ${lf.path} (${kb}KB)`);
+  }
+  lines.push(
+    "",
+    '\u4E0D\u8981\u6574\u6587\u4EF6\u8BFB\u53D6\u4E0A\u8FF0\u6587\u4EF6\u2014\u2014\u5148\u7528 grep/repo_graph \u6216 read_file(focus="\u5BA1\u67E5\u91CD\u70B9") \u5B9A\u4F4D\u5173\u952E\u7247\u6BB5\u3002',
+    "\u82E5\u9700\u7CBE\u786E\u6838\u9A8C\uFF0C\u518D\u7528 read_file + offset/limit \u53EA\u8BFB\u6539\u52A8\u884C\u9644\u8FD1\u7684\u76F8\u5173\u6BB5\u843D\u3002"
+  );
+  return lines.join("\n");
+}
+function inspectorObjective(inspector, change) {
+  const largeWarn = formatLargeFileWarnings(change);
+  const fileList = files(change).join(", ") || "(\u65E0)";
+  const header = change.commitMessage ? `\u3010${inspector.name}\u3011${change.commitMessage}` : `\u3010${inspector.name}\u3011${inspector.objective}`;
+  const intro = change.commitMessage ? inspector.objective : "";
+  return [
+    header,
+    `\u8303\u56F4: ${fileList}`,
+    ...intro ? [intro] : [],
+    objectiveReviewStanceBlock(),
+    ...stanceBlocks(inspector.stances),
+    ...inspector.method ? [inspector.method] : [],
+    ...change.focusHint ? [`\u5BA1\u67E5\u91CD\u70B9: ${change.focusHint}`] : [],
+    ...largeWarn ? [largeWarn] : [],
+    ...inspector.stances.includes("dataflow") ? ["For spec/integration changes, review the fact-flow graph, condition matrix, and counterexample tests before accepting checklist-style coverage."] : [],
+    FINDING_CONTRACT,
+    "",
+    "\u56DE\u590D\u8BED\u8A00: \u4E2D\u6587\u3002\u6240\u6709\u53D1\u73B0\u3001\u6458\u8981\u3001risks \u5747\u7528\u4E2D\u6587\u64B0\u5199\u3002"
+  ].join("\n");
+}
+function squadronRequests(change, options, onActivity) {
+  return INSPECTORS.map((inspector) => request({
+    change,
+    options,
+    kind: "review",
+    profile: "reviewer",
+    objective: inspectorObjective(inspector, change),
+    onActivity
+  }));
+}
+function computeAutoReviewBudget(change) {
+  const n = change.files.length;
+  if (n <= 3) return { maxTurns: 20, timeoutMs: 3e5 };
+  if (n <= 10) return { maxTurns: 28, timeoutMs: 36e4 };
+  return { maxTurns: 36, timeoutMs: 48e4 };
+}
+function earlyConvergenceHint(maxTurns, timeoutMs) {
+  const timeoutS = Math.round(timeoutMs / 1e3);
+  const draftDeadline = Math.max(3, Math.floor(maxTurns * 0.5));
+  const finalDeadline = maxTurns - 1;
+  if (maxTurns <= 15) {
+    return [
+      `\u9884\u7B97\u7EA6\u675F(${maxTurns} \u8F6E/${timeoutS}s)\u2014\u2014\u8FD9\u662F\u5C0F\u6539\u52A8\u5BA1\u67E5,\u4E25\u7981\u6269\u6563\u63A2\u7D22:`,
+      `1) \u9996\u8F6E git diff / git show \u9501\u5B9A\u6539\u52A8,\u53EA\u8BFB\u53D8\u66F4\u6587\u4EF6;`,
+      `2) \u7B2C ${draftDeadline} \u8F6E\u524D\u5FC5\u987B\u4EA7\u51FA\u7ED3\u8BBA\u8349\u6848;`,
+      `3) \u7B2C ${finalDeadline} \u8F6E\u505C\u6B62\u4E00\u5207\u5DE5\u5177\u8C03\u7528,\u8F93\u51FA verdict JSON\u2014\u2014\u672A\u8986\u76D6\u9879\u663E\u5F0F\u6807\u6CE8,best-effort > \u65E0\u7ED3\u8BBA\u3002`
+    ].join("\n");
+  }
+  return [
+    `\u9884\u7B97\u7EA6\u675F(${maxTurns} \u8F6E/${timeoutS}s),\u6309\u6B64\u8282\u594F\u6536\u655B:`,
+    `1) \u9996\u8F6E\u5148 git diff/git show \u9501\u5B9A\u6539\u52A8\u533A\u95F4,\u518D\u51B3\u5B9A\u8BFB\u4EC0\u4E48;`,
+    `2) \u9996\u6B21\u9605\u8BFB\u5148\u7528 grep/repo_graph \u6216 read_file(focus="\u5BA1\u67E5\u91CD\u70B9")\uFF0C\u53EA\u628A\u9AD8\u76F8\u5173\u7247\u6BB5\u653E\u5165\u4E0A\u4E0B\u6587\uFF1B\u5DF2\u77E5\u884C\u53F7\u540E\u518D\u7528 offset+limit(limit\u2264200) \u7CBE\u8BFB\u3002\u7981\u6B62\u65E0\u7126\u70B9\u6574\u6587\u4EF6 read\uFF1B\u770B\u533A\u6BB5\u53EF\u7528 read_section;`,
+    `3) \u7B2C ${draftDeadline} \u8F6E\u524D\u4EA7\u51FA\u7ED3\u8BBA\u8349\u6848;`,
+    `4) \u7B2C ${finalDeadline} \u8F6E\u505C\u6B62\u4E00\u5207\u63A2\u7D22,\u8F93\u51FA verdict JSON\u2014\u2014\u672A\u8986\u76D6\u9879\u663E\u5F0F\u6807\u6CE8,best-effort \u7ED3\u8BBA\u4F18\u4E8E\u65E0\u7ED3\u8BBA\u3002`
+  ].join("\n");
+}
+function createCoordinatorReviewDeps(coordinator, options = {}) {
+  return {
+    spawnVerifier: async (change, _signal, onActivity) => {
+      const run = await coordinator.delegate(request({
+        change,
+        options,
+        kind: "verify",
+        profile: "adversarial_verifier",
+        objective: verifierObjective(change),
+        onActivity
+      }), options.abortSignal);
+      return verifierResult(run);
+    },
+    spawnPatcher: async (change, verifier, _signal, onActivity) => {
+      const run = await coordinator.delegate(request({
+        change,
+        options,
+        kind: "patch_proposal",
+        profile: "patcher",
+        objective: patcherObjective(change, verifier),
+        onActivity
+      }), options.abortSignal);
+      return patcherResult(run);
+    },
+    spawnSquadron: async (change, _signal, onActivity) => {
+      const requests = squadronRequests(change, options, onActivity);
+      const run = coordinator.delegateBatch ? await coordinator.delegateBatch(requests, "all_required", options.abortSignal) : await runSquadronSerially(coordinator, requests, options.abortSignal);
+      return { findings: mapSquadronFindings(run), infraFailures: mapSquadronInfraFailures(run) };
+    },
+    spawnWiringReviewer: async (change, _signal, onActivity) => {
+      const budget = computeAutoReviewBudget(change);
+      const wiring = INSPECTORS.find((i) => i.name === "\u63A5\u7EBF\u5BA1\u67E5");
+      const silence = INSPECTORS.find((i) => i.name === "\u9759\u9ED8\u5BA1\u67E5");
+      const requests = [wiring, silence].map((inspector) => ({
+        ...request({
+          change,
+          options,
+          kind: "review",
+          profile: "reviewer",
+          objective: [
+            inspectorObjective(inspector, change),
+            earlyConvergenceHint(budget.maxTurns, budget.timeoutMs)
+          ].join("\n"),
+          onActivity
+        }),
+        budget
+      }));
+      const run = coordinator.delegateBatch ? await coordinator.delegateBatch(requests, "all_required", options.abortSignal) : await runSquadronSerially(coordinator, requests, options.abortSignal);
+      return { findings: mapSquadronFindings(run), infraFailures: mapSquadronInfraFailures(run) };
+    }
+  };
+}
+async function runSquadronSerially(coordinator, requests, abortSignal) {
+  const results = [];
+  for (const req of requests) {
+    const run = await coordinator.delegate(req, abortSignal);
+    results.push(...run.results);
+  }
+  return {
+    status: "completed",
+    results,
+    packet: results.map((result) => result.summary).join("\n"),
+    aggregationPolicy: "all_required"
+  };
+}
+
+// src/agent/team-orchestrator.ts
+init_esm_shims();
+
+// src/agent/team-wave-feedback.ts
+init_esm_shims();
+var MAX_FEEDBACK_ENTRIES = 5;
+var MAX_FEEDBACK_ENTRY_CHARS = 90;
+var MAX_LEAKED_FILES = 3;
+function taskIdOf(workOrderId) {
+  const i = workOrderId.lastIndexOf(":");
+  return i >= 0 ? workOrderId.slice(i + 1) : workOrderId;
+}
+function clip(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+}
+function reasonOf(result) {
+  if (result.failureReason) return result.failureReason;
+  const risk = result.risks?.[0];
+  if (typeof risk === "string" && risk.trim()) return risk;
+  if (result.summary?.trim()) return result.summary;
+  return "";
+}
+function buildPriorWaveFeedback(input) {
+  const out = [];
+  const failed = (input.priorResults ?? []).filter((r) => r.status !== "passed");
+  for (const r of failed) {
+    const reason = reasonOf(r);
+    const head = `\u4E0A\u4E00\u6CE2 ${taskIdOf(r.workOrderId)} ${r.status}`;
+    out.push(clip(reason ? `${head}\uFF1A${reason}` : head, MAX_FEEDBACK_ENTRY_CHARS));
+  }
+  const gateFailures = (input.waveGateFailures ?? []).filter((f) => f.trim());
+  if (gateFailures.length > 0) {
+    out.push(clip(`\u4E0A\u4E00\u6CE2\u95E8\u7981\u672A\u8FC7\uFF1A${gateFailures.join("\uFF1B")}`, MAX_FEEDBACK_ENTRY_CHARS));
+  }
+  const leaks = (input.scopeLeaks ?? []).filter((f) => f.trim());
+  if (leaks.length > 0) {
+    const named = leaks.slice(0, MAX_LEAKED_FILES).join("\u3001");
+    const more = leaks.length > MAX_LEAKED_FILES ? ` \u7B49 ${leaks.length} \u5904` : "";
+    out.push(clip(`\u4E0A\u4E00\u6CE2\u6709\u8BA1\u5212\u5916\u6539\u52A8\uFF1A${named}${more}\u2014\u2014\u672C\u6CE2\u52FF\u6269\u5927\u8303\u56F4`, MAX_FEEDBACK_ENTRY_CHARS));
+  }
+  if (out.length <= MAX_FEEDBACK_ENTRIES) return out;
+  const kept = out.slice(0, MAX_FEEDBACK_ENTRIES - 1);
+  kept.push(`\uFF08\u53E6\u6709 ${out.length - kept.length} \u6761\u4E0A\u4E00\u6CE2\u56DE\u6267\u5DF2\u7701\u7565\uFF09`);
+  return kept;
+}
+
+// src/agent/team-scheduler-bandit.ts
+init_esm_shims();
+var CONTEXT_DIMENSION = 8;
+var SCHEDULER_ARMS = [
+  "parallelism:1",
+  "parallelism:2",
+  "parallelism:3",
+  "parallelism:4",
+  "parallelism:5"
+];
+function clampUnit(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function clampReward(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(-1, value));
+}
+function teamSchedulerArmForParallelism(parallelism) {
+  const safe = Math.max(1, Math.min(5, Math.trunc(parallelism)));
+  return `parallelism:${safe}`;
+}
+function parallelismForTeamSchedulerArm(arm) {
+  return Number.parseInt(arm.split(":")[1] ?? "1", 10);
+}
+function normalizeTeamSchedulerContext(context) {
+  return [
+    clampUnit(context.taskCount),
+    clampUnit(context.writeTaskCount),
+    clampUnit(context.readTaskCount),
+    clampUnit(context.dependencyDepth),
+    clampUnit(context.crossModuleScore),
+    clampUnit(context.highRiskRatio),
+    clampReward(context.historicalReward),
+    clampUnit(context.scopeLeakRate)
+  ];
+}
+function computeTeamSchedulerReward(input) {
+  return clampReward(
+    clampReward(input.teamWaveReward) - 0.3 * clampUnit(input.conflictRate) - 0.3 * clampUnit(input.scopeLeakRate) - 0.6 * (input.falseGreen ? 1 : 0)
+  );
+}
+function createTeamSchedulerBandit() {
+  const bandit = new LinUCBBandit({ dimension: CONTEXT_DIMENSION, alpha: 1.2, minConfidence: 0.05 });
+  for (const arm of SCHEDULER_ARMS) bandit.addArm(arm);
+  return bandit;
+}
+function recommendTeamSchedulerArm(bandit, context) {
+  const rec = bandit.recommend(normalizeTeamSchedulerContext(context));
+  if (!rec) return { arm: "parallelism:1", score: 0, confidence: 0 };
+  const arm = SCHEDULER_ARMS.includes(rec.armId) ? rec.armId : "parallelism:1";
+  return { arm, score: rec.score, confidence: rec.confidence };
+}
+function emptyTeamSchedulerState() {
+  return {
+    totalSamples: 0,
+    arms: Object.fromEntries(SCHEDULER_ARMS.map((arm) => [arm, { samples: 0, totalReward: 0, averageReward: 0 }]))
+  };
+}
+function summarizeTeamSchedulerBandit(bandit) {
+  const stats = bandit.getStats();
+  const state = emptyTeamSchedulerState();
+  for (const stat of stats) {
+    if (!SCHEDULER_ARMS.includes(stat.id)) continue;
+    const arm = stat.id;
+    const totalReward = stat.avgReward * stat.pulls;
+    state.arms[arm] = { samples: stat.pulls, totalReward, averageReward: stat.avgReward };
+    state.totalSamples += stat.pulls;
+  }
+  return state;
+}
+function parsePersistedSchedulerReward(json) {
+  try {
+    const record = JSON.parse(json);
+    if (!SCHEDULER_ARMS.includes(record.arm)) return null;
+    if (typeof record.reward !== "number" || !Number.isFinite(record.reward)) return null;
+    return { arm: record.arm, reward: clampReward(record.reward) };
+  } catch {
+    return null;
+  }
+}
+function buildHistoricalTeamSchedulerState(store, limit = 200) {
+  const state = emptyTeamSchedulerState();
+  if (!store?.loadBanditStatesByPrefix) return state;
+  const rows = store.loadBanditStatesByPrefix("team_scheduler_reward:", limit);
+  for (const row of rows) {
+    const parsed = parsePersistedSchedulerReward(row.json);
+    if (!parsed) continue;
+    const current = state.arms[parsed.arm];
+    current.samples += 1;
+    current.totalReward += parsed.reward;
+    current.averageReward = current.totalReward / current.samples;
+    state.totalSamples += 1;
+  }
+  return state;
+}
+
+// src/agent/team-scheduler-gate.ts
+init_esm_shims();
+var MIN_TOTAL_SAMPLES = 30;
+var MIN_ARM_SAMPLES = 5;
+var REWARD_MARGIN = 0.05;
+var MAX_FALSE_GREEN_RATE = 0;
+var MIN_RULE_AGREEMENT = 0.8;
+function safeNumber(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+function makeDecision(input, gateOpen, applied, reason, evidenceWindow, vetoSignals = []) {
+  return {
+    gateOpen,
+    applied,
+    reason,
+    evidenceWindow: {
+      source: "team_scheduler_bandit",
+      totalSamples: input.state.totalSamples,
+      minTotalSamples: MIN_TOTAL_SAMPLES,
+      candidateArm: input.candidateArm,
+      candidateSamples: input.state.arms[input.candidateArm]?.samples ?? 0,
+      minArmSamples: MIN_ARM_SAMPLES,
+      ruleParallelism: Math.max(1, Math.min(5, Math.trunc(input.ruleParallelism))),
+      featureFlagEnabled: input.featureFlagEnabled === true,
+      ...evidenceWindow
+    },
+    vetoSignals
+  };
+}
+function evaluateTeamSchedulerGate(input) {
+  const candidate = input.state.arms[input.candidateArm];
+  const candidateParallelism = parallelismForTeamSchedulerArm(input.candidateArm);
+  const ruleParallelism = Math.max(1, Math.min(5, Math.trunc(input.ruleParallelism)));
+  if (input.state.totalSamples < MIN_TOTAL_SAMPLES) {
+    return makeDecision(input, false, false, `shadow: total samples ${input.state.totalSamples}/${MIN_TOTAL_SAMPLES}`, {}, ["insufficient_samples"]);
+  }
+  if (!candidate || candidate.samples < MIN_ARM_SAMPLES) {
+    return makeDecision(input, false, false, `shadow: arm samples ${candidate?.samples ?? 0}/${MIN_ARM_SAMPLES}`, {}, ["insufficient_arm_samples"]);
+  }
+  const margin = safeNumber(candidate.averageReward) - safeNumber(input.ruleBaselineReward);
+  if (margin < REWARD_MARGIN) {
+    return makeDecision(input, false, false, `shadow: reward margin ${margin.toFixed(3)} < ${REWARD_MARGIN}`, { rewardMargin: margin, minRewardMargin: REWARD_MARGIN }, ["reward_margin"]);
+  }
+  if (safeNumber(input.recentFalseGreenRate) > MAX_FALSE_GREEN_RATE) {
+    return makeDecision(input, false, false, "shadow: false-green observed", { recentFalseGreenRate: safeNumber(input.recentFalseGreenRate) }, ["false_green"]);
+  }
+  if (safeNumber(input.ruleAgreementRate) < MIN_RULE_AGREEMENT) {
+    return makeDecision(input, false, false, `shadow: rule agreement ${input.ruleAgreementRate.toFixed(2)} < ${MIN_RULE_AGREEMENT}`, { ruleAgreementRate: safeNumber(input.ruleAgreementRate), minRuleAgreement: MIN_RULE_AGREEMENT }, ["rule_agreement"]);
+  }
+  if (!input.hardGateSafe || candidateParallelism > ruleParallelism) {
+    return makeDecision(input, false, false, "shadow: hard gate blocks candidate", { candidateParallelism, hardGateSafe: input.hardGateSafe }, ["hard_safety_floor", ...candidateParallelism > ruleParallelism ? ["down_only"] : []]);
+  }
+  const gateOpen = true;
+  if (!input.featureFlagEnabled) return makeDecision(input, gateOpen, false, "shadow: feature flag disabled", { rewardMargin: margin, candidateParallelism }, ["explicit_flag_closed"]);
+  return makeDecision(input, gateOpen, true, `applied: ${input.candidateArm} within rule parallelism ${ruleParallelism}`, { rewardMargin: margin, candidateParallelism });
+}
+function applyTeamSchedulerInfluence(ruleParallelism, candidateArm, gate) {
+  const safeRule = Math.max(1, Math.min(5, Math.trunc(ruleParallelism)));
+  if (!gate.applied) return safeRule;
+  return Math.max(1, Math.min(safeRule, parallelismForTeamSchedulerArm(candidateArm), 5));
+}
+
+// src/agent/team-scheduler-shadow.ts
+init_esm_shims();
+function teamSchedulerShadowKind(event) {
+  return `team_scheduler_shadow:${event.sessionId}:${event.waveId}:${event.timestamp}`;
+}
+function teamSchedulerRewardKind(event) {
+  return `team_scheduler_reward:${event.sessionId}:${event.waveId}:${event.timestamp}`;
+}
+function buildTeamSchedulerShadowEvent(input) {
+  const timestamp = input.timestamp ?? Date.now();
+  const objectiveHash = hashTeamObjective(input.objective);
+  return {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    objectiveHash,
+    waveId: input.waveId,
+    ruleParallelism: Math.max(1, Math.min(5, Math.trunc(input.ruleParallelism))),
+    recommendedArm: input.recommendedArm,
+    applied: input.applied,
+    gateOpen: input.gateOpen,
+    reason: input.reason,
+    pendingRewardId: `team_scheduler_reward:${objectiveHash}:${input.sessionId}:${input.waveId}:${timestamp}`,
+    timestamp
+  };
+}
+function buildTeamSchedulerRewardEvent(input) {
+  const reward = computeTeamSchedulerReward(input.rewardInput);
+  return {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    objectiveHash: hashTeamObjective(input.objective),
+    waveId: input.waveId,
+    arm: input.arm,
+    reward,
+    components: {
+      teamWaveReward: input.rewardInput.teamWaveReward,
+      conflictRate: input.rewardInput.conflictRate,
+      scopeLeakRate: input.rewardInput.scopeLeakRate,
+      falseGreen: input.rewardInput.falseGreen,
+      parallelism: parallelismForTeamSchedulerArm(input.arm)
+    },
+    timestamp: input.timestamp ?? Date.now()
+  };
+}
+function persistTeamSchedulerShadow(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(teamSchedulerShadowKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+function persistTeamSchedulerReward(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(teamSchedulerRewardKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+
+// src/agent/team-perspectives.ts
+init_esm_shims();
+
+// src/agent/expert-router.ts
+init_esm_shims();
+var DOMAIN_MERGE_ROLE = {
+  tianquan: "base",
+  tianshu: "base",
+  tianfu: "constraint",
+  tianliang: "constraint",
+  tianji: "challenger",
+  tianxuan: "challenger",
+  pojun: "challenger",
+  wenqu: "specialist",
+  fu: "specialist"
+};
+var DEFAULT_BASE = "tianquan";
+var DEFAULT_CONSTRAINT = "tianfu";
+var DEFAULT_CHALLENGER = "tianxuan";
+var MAX_COUNCIL_EXPERTS = 5;
+var DEFAULT_COUNCIL_EXPERTS = 3;
+function mergeRoleFor(domainId) {
+  return DOMAIN_MERGE_ROLE[domainId] ?? "specialist";
+}
+function rankDomains(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  const scored = [];
+  for (const domain of starDomainRegistry.list()) {
+    let score = 0;
+    for (const keyword of domain.keywords) {
+      if (lower.includes(keyword.toLowerCase())) score++;
+    }
+    if (score > 0) scored.push({ id: domain.id, score, role: mergeRoleFor(domain.id) });
+  }
+  scored.sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  return scored;
+}
+function selectExpertSet(taskDescription, opts) {
+  const budget = clampBudget(opts?.maxExperts);
+  const ranked = rankDomains(taskDescription);
+  const known = new Set(starDomainRegistry.getDomainIds());
+  const pickTop = (role) => ranked.find((d) => d.role === role)?.id;
+  const selected = [];
+  const add = (id) => {
+    if (!id || selected.length >= budget) return;
+    if (!known.has(id)) return;
+    if (!selected.includes(id)) selected.push(id);
+  };
+  add(pickTop("base") ?? DEFAULT_BASE);
+  add(pickTop("constraint") ?? DEFAULT_CONSTRAINT);
+  add(pickTop("challenger") ?? DEFAULT_CHALLENGER);
+  for (const d of ranked) {
+    if (d.role === "specialist") add(d.id);
+  }
+  for (const d of ranked) add(d.id);
+  if (selected.length === 0) selected.push(DEFAULT_BASE);
+  return selected.slice(0, budget);
+}
+function clampBudget(maxExperts) {
+  const n = maxExperts ?? DEFAULT_COUNCIL_EXPERTS;
+  if (!Number.isFinite(n)) return DEFAULT_COUNCIL_EXPERTS;
+  return Math.max(1, Math.min(MAX_COUNCIL_EXPERTS, Math.floor(n)));
+}
+
+// src/agent/team-perspectives.ts
+function dependencyKey(dep) {
+  return typeof dep === "string" ? `plain:${dep}` : `edge:${dep.dependsOn}:${dep.onFailure ?? ""}:${dep.alternateOrderId ?? ""}`;
+}
+function dedupeDependencyRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of refs) {
+    const key2 = dependencyKey(r);
+    if (seen.has(key2)) continue;
+    seen.add(key2);
+    out.push(typeof r === "string" ? r : { ...r });
+  }
+  return out;
+}
+function normalizePerspective(perspective, raw) {
+  return {
+    perspective,
+    summary: raw.summary ?? `${perspective} perspective plan`,
+    tasks: raw.tasks ?? [],
+    dependencyNotes: raw.dependencyNotes ?? [],
+    risks: raw.risks ?? [],
+    verification: raw.verification ?? [],
+    blockers: raw.blockers ?? [],
+    alternatives: raw.alternatives ?? []
+  };
+}
+function domainName(perspective) {
+  return starDomainRegistry.get(perspective)?.name ?? perspective;
+}
+function mergePerspectivesByRole(perspectives) {
+  const base = perspectives.find((p) => mergeRoleFor(p.perspective) === "base") ?? perspectives[0];
+  if (!base) {
+    return { tasks: [], dependencyNotes: [], risks: [], verification: [], accepted: [], rejected: [], deferred: [], augmented: [], conflicts: [] };
+  }
+  const others = perspectives.filter((p) => p !== base);
+  const roleOf = (p) => mergeRoleFor(p.perspective);
+  const constraints = others.filter((p) => roleOf(p) === "constraint");
+  const challengers = others.filter((p) => roleOf(p) === "challenger");
+  const specialists = others.filter((p) => roleOf(p) === "specialist" || roleOf(p) === "base");
+  const tasks = base.tasks.map((t) => ({
+    ...t,
+    files: [...t.files],
+    touchSet: [...t.touchSet],
+    dependsOn: dedupeDependencyRefs(t.dependsOn),
+    verification: [...t.verification]
+  }));
+  const taskIndex = new Map(tasks.map((t) => [t.id, t]));
+  const accepted = [];
+  const rejected = [];
+  const deferred = [];
+  const augmented = [];
+  const conflicts = [];
+  const verification = base.verification.map((v) => ({ taskId: v.taskId, command: v.command, expected: v.expected }));
+  for (const c of constraints) {
+    for (const risk of c.risks) {
+      if (risk.taskId && taskIndex.has(risk.taskId)) {
+        const task = taskIndex.get(risk.taskId);
+        if (riskSeverityRank(risk.severity) > riskSeverityRank(task.riskTier)) {
+          task.riskTier = risk.severity;
+          accepted.push({ source: c.perspective, title: `Risk upgrade: ${risk.taskId} \u2192 ${risk.severity}`, reason: risk.claim });
+        }
+      }
+    }
+    for (const v of c.verification) {
+      if (!verification.some((ev) => ev.command === v.command)) {
+        verification.push({ taskId: v.taskId, command: v.command, expected: v.expected });
+        accepted.push({ source: c.perspective, title: `Verification: ${v.command}`, reason: `${domainName(c.perspective)} added verification gate` });
+      }
+    }
+  }
+  const baseTaskIds = new Set(base.tasks.map((t) => t.id));
+  for (const ch of challengers) {
+    for (const c of constraints) {
+      for (const cRisk of c.risks) {
+        const riskTaskId = cRisk.taskId?.toLowerCase();
+        const alt = riskTaskId ? ch.alternatives.find((a) => a.title.toLowerCase().includes(riskTaskId)) : void 0;
+        if (alt && alt.recommendation === "accept") {
+          conflicts.push({
+            description: `Risk vs alternative conflict on ${cRisk.taskId ?? "unknown"}`,
+            tianquan: "no position",
+            tianfu: cRisk.claim,
+            tianxuan: alt.tradeoff
+          });
+        }
+      }
+    }
+    for (const chTask of ch.tasks) {
+      const baseTask = base.tasks.find((t) => t.id === chTask.id);
+      if (baseTask && !sameDependencySet(chTask.dependsOn.map(dependencyId), baseTask.dependsOn.map(dependencyId))) {
+        if (chTask.dependsOn.length > 0 || baseTask.dependsOn.length > 0) {
+          conflicts.push({
+            description: `Dependency conflict on ${chTask.id}`,
+            tianquan: `depends: [${baseTask.dependsOn.map(dependencyId).join(", ")}]`,
+            tianfu: "(no position)",
+            tianxuan: `depends: [${chTask.dependsOn.map(dependencyId).join(", ")}]`
+          });
+        }
+      }
+    }
+    for (const alt of ch.alternatives) {
+      const entry = { source: ch.perspective, title: alt.title, reason: alt.tradeoff };
+      if (alt.recommendation === "accept") accepted.push(entry);
+      else if (alt.recommendation === "defer") deferred.push(entry);
+      else rejected.push(entry);
+    }
+    for (const blocker of ch.blockers) {
+      accepted.push({ source: ch.perspective, title: `Blind spot: ${blocker.slice(0, 80)}`, reason: `${domainName(ch.perspective)} identified potential blocker` });
+    }
+  }
+  for (const sp of specialists) {
+    for (const alt of sp.alternatives) {
+      deferred.push({ source: sp.perspective, title: alt.title, reason: alt.tradeoff });
+    }
+    for (const blocker of sp.blockers) {
+      deferred.push({ source: sp.perspective, title: `Advisory: ${blocker.slice(0, 80)}`, reason: `${domainName(sp.perspective)} domain note` });
+    }
+  }
+  const existingIds = new Set(tasks.map((t) => t.id));
+  for (const src of [...challengers, ...specialists]) {
+    const extras = src.tasks.filter((t) => t.id && !existingIds.has(t.id) && !baseTaskIds.has(t.id));
+    if (extras.length === 0) continue;
+    const consumed = /* @__PURE__ */ new Set();
+    for (const b of [...tasks]) {
+      if (!existingIds.has(b.id)) continue;
+      const bFiles = filesOfTask(b);
+      if (bFiles.length < 2) continue;
+      const bSet = new Set(bFiles);
+      const parts = extras.filter((e) => {
+        if (consumed.has(e)) return false;
+        const ef = filesOfTask(e);
+        return ef.length > 0 && ef.every((f) => bSet.has(f));
+      });
+      if (parts.length < 2 || !pairwiseDisjoint(parts.map(filesOfTask))) continue;
+      const shards = parts.map((p) => adoptShard(p, existingIds));
+      for (const s of shards) {
+        s.dependsOn = dedupeDependencyRefs([...s.dependsOn, ...b.dependsOn]).filter((d) => dependencyId(d) !== b.id && dependencyId(d) !== s.id);
+        existingIds.add(s.id);
+      }
+      const bi = tasks.findIndex((t) => t.id === b.id);
+      tasks.splice(bi, 1, ...shards);
+      taskIndex.delete(b.id);
+      existingIds.delete(b.id);
+      for (const s of shards) taskIndex.set(s.id, s);
+      const replacementIds = shards.map((s) => s.id);
+      for (const t of tasks) {
+        if (!t.dependsOn.some((d) => dependencyId(d) === b.id)) continue;
+        const kept = t.dependsOn.filter((d) => dependencyId(d) !== b.id);
+        const reconnected = [];
+        for (const d of t.dependsOn) {
+          if (dependencyId(d) !== b.id) continue;
+          for (const id of replacementIds) {
+            if (typeof d === "string") reconnected.push(id);
+            else reconnected.push({
+              dependsOn: id,
+              ...d.onFailure ? { onFailure: d.onFailure } : {},
+              ...d.alternateOrderId !== void 0 ? { alternateOrderId: d.alternateOrderId } : {}
+            });
+          }
+        }
+        t.dependsOn = dedupeDependencyRefs([...kept, ...reconnected]);
+      }
+      for (const p of parts) consumed.add(p);
+      augmented.push({ source: src.perspective, title: `Monolith-split: ${b.id} \u2192 [${replacementIds.join(", ")}]`, reason: `${domainName(src.perspective)} cleanly partitioned a coarse base shard into parallel orthogonal shards` });
+    }
+    for (const e of extras) {
+      if (consumed.has(e)) continue;
+      const ef = filesOfTask(e);
+      if (ef.length === 0) {
+        deferred.push({ source: src.perspective, title: `Extra task: ${e.id}`, reason: "No files declared; cannot verify orthogonality \u2014 deferred for manual review" });
+        continue;
+      }
+      if (tasks.every((t) => fileSetsDisjoint(ef, filesOfTask(t)))) {
+        const adopted = adoptShard(e, existingIds);
+        tasks.push(adopted);
+        taskIndex.set(adopted.id, adopted);
+        existingIds.add(adopted.id);
+        augmented.push({ source: src.perspective, title: `Gap-fill shard: ${adopted.id}`, reason: `${domainName(src.perspective)} orthogonal shard touches only disjoint files; folded into the execution graph for parallelism` });
+      } else {
+        deferred.push({ source: src.perspective, title: `Extra task: ${e.id}`, reason: "Overlaps base files without a clean split; deferred to avoid double-write" });
+      }
+    }
+  }
+  const augmentedGraph = {
+    mission: base.summary,
+    nodes: tasks.map((t) => ({ id: t.id, title: t.title, objective: t.objective, profile: t.profile, kind: t.kind, files: t.files, dependsOn: t.dependsOn.map(dependencyId), riskTier: t.riskTier })),
+    createdAt: 0
+  };
+  if (!validateTaskGraph(augmentedGraph).valid) {
+    const liveIds = new Set(tasks.map((t) => t.id));
+    for (const t of tasks) t.dependsOn = t.dependsOn.filter((d) => liveIds.has(dependencyId(d)));
+  }
+  const risks = base.risks.map((r) => ({ taskId: r.taskId, severity: r.severity, claim: r.claim, mitigation: r.mitigation }));
+  for (const p of [...constraints, ...specialists]) {
+    for (const r of p.risks) {
+      if (!risks.some((er) => er.taskId === r.taskId && (er.claim === r.claim || er.claim === `[${domainName(p.perspective)}] ${r.claim}`))) {
+        risks.push({ taskId: r.taskId, severity: r.severity, claim: `[${domainName(p.perspective)}] ${r.claim}`, mitigation: r.mitigation });
+      }
+    }
+  }
+  const dependencyNotes = [...base.dependencyNotes];
+  for (const p of others) {
+    for (const d of p.dependencyNotes) {
+      if (!dependencyNotes.some((td) => td.from === d.from && td.to === d.to)) dependencyNotes.push(d);
+    }
+  }
+  return { tasks, dependencyNotes, risks, verification, accepted, rejected, deferred, augmented, conflicts };
+}
+function filesOfTask(t) {
+  return t.touchSet && t.touchSet.length > 0 ? t.touchSet : t.files ?? [];
+}
+function fileSetsDisjoint(a, b) {
+  if (a.length === 0 || b.length === 0) return false;
+  const setB = new Set(b);
+  return !a.some((f) => setB.has(f));
+}
+function pairwiseDisjoint(groups) {
+  for (let i = 0; i < groups.length; i++) {
+    for (let j = i + 1; j < groups.length; j++) {
+      if (!fileSetsDisjoint(groups[i], groups[j])) return false;
+    }
+  }
+  return true;
+}
+function adoptShard(raw, existingIds) {
+  const files2 = [...raw.files ?? []];
+  const touchSet = raw.touchSet && raw.touchSet.length > 0 ? [...raw.touchSet] : [...files2];
+  const baseId = raw.id || "shard";
+  let id = baseId;
+  let suffix = 2;
+  while (existingIds.has(id)) id = `${baseId}__aug${suffix++}`;
+  return {
+    id,
+    title: raw.title ?? id,
+    objective: raw.objective ?? "",
+    files: files2,
+    profile: raw.profile ?? "patcher",
+    kind: raw.kind ?? "patch_proposal",
+    verification: [...raw.verification ?? []],
+    dependsOn: [...raw.dependsOn ?? []],
+    riskTier: raw.riskTier ?? "medium",
+    touchSet
+  };
+}
+function foldVerificationIntoTasks(tasks, verification) {
+  if (verification.length === 0) return tasks;
+  const gatesByTask = /* @__PURE__ */ new Map();
+  for (const gate of verification) {
+    if (!gate.taskId) continue;
+    const command = gate.command.trim();
+    if (!command) continue;
+    const arr = gatesByTask.get(gate.taskId) ?? [];
+    arr.push(command);
+    gatesByTask.set(gate.taskId, arr);
+  }
+  if (gatesByTask.size === 0) return tasks;
+  return tasks.map((task) => {
+    const extra = gatesByTask.get(task.id);
+    if (!extra || extra.length === 0) return task;
+    const merged = [.../* @__PURE__ */ new Set([...task.verification, ...extra])];
+    return { ...task, verification: merged };
+  });
+}
+function riskSeverityRank(severity) {
+  switch (severity) {
+    case "low":
+      return 0;
+    case "medium":
+      return 1;
+    case "high":
+      return 2;
+  }
+}
+function sameDependencySet(a, b) {
+  if (a.length !== b.length) return false;
+  const setB = new Set(b);
+  return a.every((dep) => setB.has(dep));
+}
+var ROLE_BRIEFS = {
+  base: "\u804C\u8D23\uFF1A\u628A\u4EFB\u52A1\u6A2A\u5411\u5207\u6210\u6B63\u4EA4\u81EA\u5305\u542B\u5206\u7247\uFF0C\u4EA7\u51FA\u4EFB\u52A1\u4E3B\u56FE\u3002\u6BCF\u7247\u662F\u4E00\u4E2A\u5B8C\u6574\u3001\u72EC\u7ACB\u7684\u4EA4\u4ED8\u5355\u5143\uFF0C\u7531\u4E00\u4E2A\u80FD\u529B\u5F3A\u7684 flash \u7AEF\u5230\u7AEF\u72EC\u5360\uFF08\u5B9E\u73B0 + \u81EA\u8DD1 tsc/lint/\u76F8\u5173\u6D4B\u8BD5\u81F3\u5168\u7EFF\uFF09\u3002\u6309\u6A21\u5757/\u5173\u6CE8\u70B9\u8FB9\u754C\u5207\uFF0C\u5206\u7247\u95F4\u6587\u4EF6\u5C3D\u91CF\u4E24\u4E24\u4E0D\u76F8\u4EA4\u4EE5\u4FBF\u5E76\u884C\uFF1B\u53EA\u6709\u771F\u6709\u5148\u540E\u4F9D\u8D56\u65F6\u624D\u6807 dependsOn\u3002\u7981\u6B62\u6309\u5DE5\u5E8F\u7AD6\u5207\uFF08\u4E0D\u8981\u628A explore/patch/import/test/lint/type/verify \u62C6\u6210\u72EC\u7ACB\u89D2\u8272\u4EFB\u52A1\uFF09\u3002\u5B81\u53EF\u51E0\u4E2A\u5206\u91CF\u8DB3\u7684\u5206\u7247\uFF0C\u4E0D\u8981\u4E00\u5806\u5DE5\u5E8F\u788E\u7247\u3002",
+  constraint: "\u804C\u8D23\uFF1A\u805A\u7126\u8DE8\u5206\u7247\u7684\u96C6\u6210\u9A8C\u8BC1\u95E8\u7981\u4E0E\u4E32\u884C\u7EA6\u675F\uFF08\u6BCF\u7247\u5DF2\u81EA\u9A8C\uFF0C\u4F60\u8865\u7684\u662F\u5206\u7247\u4E4B\u95F4\u7684\uFF09\u3002\u6307\u51FA\u54EA\u4E9B\u5206\u7247\u56E0\u5171\u4EAB\u6587\u4EF6/\u63A5\u53E3\u5FC5\u987B\u4E32\u884C\u5E76\u6807 dependsOn\uFF1B\u8BC4\u4F30\u98CE\u9669\u3001\u56DE\u5F52\u6D4B\u8BD5\uFF1B\u9047\u6B67\u4E49 fail-closed\u3002\u4E0D\u8981\u91CD\u65B0\u7AD6\u5207\u522B\u4EBA\u7684\u5206\u7247\u3002",
+  challenger: "\u804C\u8D23\uFF1A\u5B9A\u5411\u53CD\u8BC1\u3001\u76F2\u533A\u53D1\u73B0\u3001\u8D28\u7591\u524D\u63D0\uFF1B\u5E76\u4E14\u2014\u2014\u5F53 base \u628A\u67D0\u4E2A\u5206\u7247\u62C6\u5F97\u8FC7\u7C97\uFF08\u4E00\u4E2A\u5206\u7247\u585E\u4E86\u591A\u4E2A\u672C\u53EF\u5E76\u884C\u7684\u6B63\u4EA4\u6A21\u5757\uFF09\u65F6\uFF0C\u63D0\u51FA\u66F4\u7EC6\u7684\u6B63\u4EA4\u5206\u7247\u66FF\u4EE3\uFF0C\u6BCF\u7247\u6807\u660E files\uFF08\u53D6\u81EA\u771F\u5B9E\u4EE3\u7801\u800C\u975E\u731C\u6D4B\uFF09\uFF0C\u8FD9\u4E9B\u5206\u7247\u53EF\u88AB\u91C7\u7EB3\u8FDB\u6267\u884C\u56FE\u3002",
+  specialist: "\u804C\u8D23\uFF1A\u4ECE\u4F60\u7684\u4E13\u4E1A\u9886\u57DF\u89C6\u89D2\u7ED9\u51FA\u5EFA\u8BAE\u4E0E\u7EA6\u675F\uFF08\u9ED8\u8BA4\u8FDB\u5165 advisory\uFF09\u3002"
+};
+function perspectiveBrief(perspective) {
+  const role = mergeRoleFor(perspective);
+  const domain = starDomainRegistry.get(perspective);
+  const name = domain?.name ?? perspective;
+  const personaLine = domain?.volatileBlock.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+  const head = `\u4F60\u662F${name} planner\u3002${ROLE_BRIEFS[role]}`;
+  return personaLine ? `${head}
+\u8BA4\u77E5\u573A\uFF1A${personaLine}` : head;
+}
+function buildPlannerObjective(perspective, mission) {
+  return [
+    perspectiveBrief(perspective),
+    "",
+    `Mission: ${mission}`,
+    "",
+    "Read the relevant code, then return a JSON WorkerResult whose `artifacts` contains ONE entry:",
+    '{ "kind": "note", "title": "perspective-plan", "content": "<a JSON string of your TeamPerspectivePlan>" }',
+    "",
+    "TeamPerspectivePlan = { perspective, summary, tasks, dependencyNotes, risks, verification, blockers, alternatives }.",
+    "Each task = { id, title, objective, files, profile, kind, verification, dependsOn, riskTier, touchSet }.",
+    '\u5206\u7247\u5951\u7EA6\uFF1A\u6BCF\u4E2A task \u662F\u4E00\u4E2A\u6A2A\u5411\u6B63\u4EA4\u3001\u81EA\u5305\u542B\u7684\u4EA4\u4ED8\u5206\u7247 \u2014\u2014 \u4E00\u4E2A flash \u7AEF\u5230\u7AEF\u505A\u5B8C\uFF08\u5B9E\u73B0 + \u81EA\u8DD1 tsc/lint/\u76F8\u5173\u6D4B\u8BD5\u81F3\u5168\u7EFF\uFF09\uFF0Cprofile \u7528 "patcher"\u3001kind \u7528 "patch_proposal"\u3002\u5206\u7247\u95F4 files \u5C3D\u91CF\u4E24\u4E24\u4E0D\u76F8\u4EA4\u4EE5\u4FBF\u5E76\u884C\uFF1B\u4E24\u7247\u5FC5\u987B\u6539\u540C\u4E00\u6587\u4EF6\u65F6\u7528 dependsOn \u6392\u5E8F\uFF0C\u4E0D\u8981\u5E76\u53D1\u62A2\u5199\u3002\u7981\u6B62\u6309\u5DE5\u5E8F\u7AD6\u5207\u6210 explore/lint/type/import/test \u7B49\u72EC\u7ACB\u89D2\u8272\u4EFB\u52A1\u3002files \u586B\u8BE5\u5206\u7247\u771F\u6B63\u4F1A\u6539\u7684\u771F\u5B9E\u8DEF\u5F84\uFF08\u6765\u81EA\u4EE3\u7801\u67E5\u8BC1\uFF0C\u4E0D\u8981\u731C\uFF09\u3002',
+    `Set perspective to "${perspective}".`
+  ].join("\n");
+}
+function parsePerspectiveResult(perspective, result) {
+  const artifact = result.artifacts.find((a) => a.title === "perspective-plan");
+  if (artifact) {
+    try {
+      for (const candidate of extractJsonCandidates(artifact.content)) {
+        try {
+          const raw = JSON.parse(candidate);
+          return normalizePerspective(perspective, raw);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return normalizePerspective(perspective, { summary: result.summary, blockers: result.risks });
+}
+
+// src/agent/team-plan-cache.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+var TEAM_PLAN_CACHE_PREFIX = "team_plan_cache:";
+var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var SIMILARITY_THRESHOLD = 0.6;
+var SCAN_LIMIT = 100;
+function hashPlanObjective(objective) {
+  return createHash2("sha256").update(objective.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+function teamPlanCacheKind(objectiveHash) {
+  return `${TEAM_PLAN_CACHE_PREFIX}${objectiveHash}`;
+}
+function extractPlanKeywords(text) {
+  return text.toLowerCase().replace(/[^a-z0-9_\-./\u4e00-\u9fff]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && w.length < 40).filter((w, i, arr) => arr.indexOf(w) === i).slice(0, 16);
+}
+function isValidTask(task) {
+  if (!task || typeof task !== "object") return false;
+  const t = task;
+  return typeof t.id === "string" && t.id.length > 0 && typeof t.objective === "string" && t.objective.length > 0 && typeof t.profile === "string" && typeof t.kind === "string" && Array.isArray(t.files) && Array.isArray(t.dependsOn) && (t.riskTier === "low" || t.riskTier === "medium" || t.riskTier === "high");
+}
+function parseSkeleton(json) {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed?.schemaVersion !== 1) return null;
+    if (typeof parsed.objectiveHash !== "string" || !Array.isArray(parsed.keywords)) return null;
+    if (parsed.mode !== "standard" && parsed.mode !== "max") return null;
+    if (!Array.isArray(parsed.tasks) || parsed.tasks.length === 0) return null;
+    if (!parsed.tasks.every(isValidTask)) return null;
+    if (typeof parsed.createdAt !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveTeamPlanSkeleton(store, input) {
+  if (!store?.saveBanditState || input.tasks.length === 0) return;
+  const skeleton = {
+    schemaVersion: 1,
+    objectiveHash: hashPlanObjective(input.objective),
+    keywords: extractPlanKeywords(input.objective),
+    mode: input.mode,
+    tasks: input.tasks,
+    createdAt: input.timestamp ?? Date.now()
+  };
+  try {
+    store.saveBanditState(teamPlanCacheKind(skeleton.objectiveHash), JSON.stringify(skeleton));
+  } catch {
+  }
+}
+function loadTeamPlanSkeleton(store, objective, mode, options = {}) {
+  if (!store?.loadBanditStatesByPrefix) return null;
+  const maxAgeMs = options.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+  const now = options.now ?? Date.now();
+  const fresh = (s) => now - s.createdAt <= maxAgeMs && s.mode === mode;
+  try {
+    const hash = hashPlanObjective(objective);
+    for (const row of store.loadBanditStatesByPrefix(teamPlanCacheKind(hash), 1)) {
+      const skeleton = parseSkeleton(row.json);
+      if (skeleton && fresh(skeleton)) return skeleton;
+    }
+    const keywords = extractPlanKeywords(objective);
+    if (keywords.length === 0) return null;
+    let best = null;
+    let bestScore = 0;
+    for (const row of store.loadBanditStatesByPrefix(TEAM_PLAN_CACHE_PREFIX, SCAN_LIMIT)) {
+      const skeleton = parseSkeleton(row.json);
+      if (!skeleton || !fresh(skeleton)) continue;
+      const overlap = keywords.filter((k) => skeleton.keywords.includes(k)).length;
+      const score = overlap / Math.max(keywords.length, skeleton.keywords.length);
+      if (score >= SIMILARITY_THRESHOLD && score > bestScore) {
+        bestScore = score;
+        best = skeleton;
+      }
+    }
+    return best;
+  } catch {
+    return null;
+  }
+}
+
+// src/agent/team-orchestrator.ts
+function isFileScopedPatcher(task) {
+  return task.profile === "patcher" && task.files.length > 0;
+}
+function buildExecutionObjective(task) {
+  if (task.profile !== "patcher") return task.objective;
+  return `\u4F60\u662F\u5929\u6881\u6267\u884C\u8005\u3002\u53EA\u6267\u884C\u672C task\uFF0C\u4E0D\u6269\u5C55\u8303\u56F4\uFF0C\u4E0D\u91CD\u5199\u8BA1\u5212\u3002
+
+${task.objective}`;
+}
+function taskAuthority(task) {
+  if (task.profile === "patcher") return "tianliang";
+  if (task.profile === "reviewer" || task.profile === "adversarial_verifier") return "tianquan";
+  const derived = deriveAuthority(task.objective);
+  debugLog(`[team-authority] ${derived.authority} \u2014 ${derived.reasons[0] ?? "n/a"}`);
+  return derived.authority;
+}
+function selectDispatchableTeamTasks(tasks, maxParallel = 3) {
+  const selected = [];
+  const blocked = [];
+  const selectedPatchers = [];
+  for (const task of tasks) {
+    if (selected.length >= maxParallel) {
+      blocked.push(`${task.id}: deferred after maxParallel=${maxParallel}`);
+      continue;
+    }
+    if (task.profile === "patcher" && task.files.length === 0) {
+      blocked.push(`${task.id}: patcher task has no file scope`);
+      continue;
+    }
+    if (isFileScopedPatcher(task)) {
+      const conflict = selectedPatchers.find((prev) => hasOverlappingFiles(prev, task));
+      if (conflict) {
+        blocked.push(`${task.id}: overlapping patcher file scope with ${conflict.id}; serialize later`);
+        continue;
+      }
+      selectedPatchers.push(task);
+    }
+    selected.push(task);
+  }
+  return { selected, blocked };
+}
+function teamTasksToDelegationRequests(tasks, parentTurnId = "team") {
+  return tasks.map((task, index) => {
+    const stableId = `team:${task.id || index}`;
+    let deps;
+    if (task.dependsOn && task.dependsOn.length > 0) {
+      deps = task.dependsOn.map((d) => mapTeamDependency(d));
+    }
+    return {
+      parentTurnId: `${parentTurnId}:${stableId}`,
+      objective: buildExecutionObjective(task),
+      kind: task.kind,
+      profile: task.profile,
+      scope: { files: task.files },
+      // 预算发准（2026-08-18）：写工按目标文件数定价，替代 flat 48 轮/600s——
+      // 读工 profile 返回 undefined，行为零变化。
+      budget: shapeWriteBudgetForProfile(task.files, task.profile),
+      dependencies: deps,
+      authority: taskAuthority(task),
+      riskTier: "riskTier" in task ? task.riskTier : void 0
+    };
+  });
+}
+function mapTeamDependency(dep) {
+  if (typeof dep === "string") return `team:${dep}`;
+  return {
+    dependsOn: `team:${dep.dependsOn}`,
+    ...dep.onFailure ? { onFailure: dep.onFailure } : {},
+    ...dep.alternateOrderId ? { alternateOrderId: `team:${dep.alternateOrderId}` } : {}
+  };
+}
+function waveToRequests(wave, taskMap, parentTurnId) {
+  return wave.taskIds.map((id) => taskMap.get(id)).filter((t) => Boolean(t)).map((task) => {
+    const stableId = `team:${task.id}`;
+    const deps = task.dependsOn.length > 0 ? task.dependsOn.map((d) => mapTeamDependency(d)) : void 0;
+    return {
+      parentTurnId: `${parentTurnId}:${stableId}`,
+      objective: buildExecutionObjective(task),
+      kind: task.kind,
+      profile: task.profile,
+      scope: { files: task.files },
+      budget: shapeWriteBudgetForProfile(task.files, task.profile),
+      dependencies: deps,
+      authority: taskAuthority(task),
+      riskTier: task.riskTier
+    };
+  });
+}
+function taskFiles(task) {
+  return task.touchSet.length > 0 ? task.touchSet : task.files;
+}
+function extractTaskIdFromWorkOrderId(woId) {
+  return woId.includes(":") ? woId.slice(woId.lastIndexOf(":") + 1) : woId;
+}
+function buildSchedulerContext(wave, waves, taskMap) {
+  const waveTasks = wave.taskIds.map((id) => taskMap.get(id)).filter((task) => Boolean(task));
+  const writeTasks = waveTasks.filter((task) => !(task.profile === "code_scout" || task.profile === "doc_scout" || task.profile === "reviewer" && task.kind === "review"));
+  const readTasks = waveTasks.length - writeTasks.length;
+  const moduleRoots = new Set(waveTasks.flatMap((task) => taskFiles(task).map((file) => file.split("/").slice(0, 2).join("/"))).filter(Boolean));
+  const highRiskCount = waveTasks.filter((task) => task.riskTier === "high").length;
+  const maxDeps = Math.max(0, ...waveTasks.map((task) => task.dependsOn.length));
+  return {
+    taskCount: Math.min(1, waveTasks.length / 5),
+    writeTaskCount: Math.min(1, writeTasks.length / 5),
+    readTaskCount: Math.min(1, readTasks / 5),
+    dependencyDepth: Math.min(1, maxDeps / Math.max(1, waves.length)),
+    crossModuleScore: Math.min(1, Math.max(0, moduleRoots.size - 1) / 4),
+    highRiskRatio: waveTasks.length > 0 ? highRiskCount / waveTasks.length : 0,
+    historicalReward: 0,
+    scopeLeakRate: 0
+  };
+}
+function resolveSchedulerState(deps) {
+  if (deps.teamSchedulerState) return deps.teamSchedulerState;
+  return summarizeTeamSchedulerBandit(createTeamSchedulerBandit());
+}
+function applySchedulerToWave(wave, waves, ctx) {
+  const ruleParallelism = Math.max(1, Math.min(wave.parallelLimit, wave.taskIds.length, 5));
+  const bandit = createTeamSchedulerBandit();
+  const schedulerContext = buildSchedulerContext(wave, waves, ctx.taskMap);
+  const state = resolveSchedulerState(ctx.deps);
+  const shadowRecommendation = recommendTeamSchedulerArm(bandit, schedulerContext);
+  const bestObservedArm = Object.entries(state.arms).filter(([, stat]) => stat.samples > 0).sort((a, b) => b[1].averageReward - a[1].averageReward)[0]?.[0];
+  const recommended = { ...shadowRecommendation, arm: bestObservedArm ?? shadowRecommendation.arm };
+  const candidateAvg = state.arms[recommended.arm]?.averageReward ?? 0;
+  const baselineAvg = state.arms[teamSchedulerArmForParallelism(ruleParallelism)]?.averageReward ?? 0;
+  const decision = evaluateTeamSchedulerGate({
+    state,
+    candidateArm: recommended.arm,
+    ruleParallelism,
+    ruleBaselineReward: baselineAvg,
+    recentFalseGreenRate: 0,
+    ruleAgreementRate: parallelismForTeamSchedulerArm(recommended.arm) <= ruleParallelism ? 1 : 0,
+    hardGateSafe: wave.risk !== "high" || parallelismForTeamSchedulerArm(recommended.arm) <= 1,
+    featureFlagEnabled: ctx.input.teamSchedulerBanditEnabled === true
+  });
+  const parallelLimit = applyTeamSchedulerInfluence(ruleParallelism, recommended.arm, decision);
+  try {
+    ctx.deps.recordTeamSchedulerShadow?.(buildTeamSchedulerShadowEvent({
+      sessionId: ctx.deps.sessionId ?? "unknown",
+      objective: ctx.input.objective,
+      waveId: wave.id,
+      ruleParallelism,
+      recommendedArm: recommended.arm,
+      applied: decision.applied,
+      gateOpen: decision.gateOpen,
+      reason: `${decision.reason}; candidateAvg=${candidateAvg.toFixed(3)} baselineAvg=${baselineAvg.toFixed(3)}`
+    }));
+  } catch {
+  }
+  try {
+    ctx.deps.recordGatedInfluenceAudit?.(buildGatedInfluenceAuditEvent({
+      source: "team_scheduler_bandit",
+      sessionId: ctx.deps.sessionId ?? "unknown",
+      targetId: wave.id,
+      gateOpen: decision.gateOpen,
+      applied: decision.applied,
+      reason: decision.reason,
+      evidenceWindow: {
+        ...decision.evidenceWindow,
+        candidateAverageReward: candidateAvg,
+        baselineAverageReward: baselineAvg
+      },
+      vetoSignals: decision.vetoSignals
+    }));
+  } catch {
+  }
+  if (parallelLimit >= wave.taskIds.length) return { wave: { ...wave, parallelLimit: ruleParallelism }, blocked: [] };
+  const keptTaskIds = wave.taskIds.slice(0, parallelLimit);
+  const deferredTaskIds = wave.taskIds.slice(parallelLimit);
+  return {
+    wave: { ...wave, taskIds: keptTaskIds, parallelLimit, reason: `${wave.reason}; scheduler ${decision.applied ? "applied" : "shadow"} ${recommended.arm}` },
+    blocked: deferredTaskIds.map((id) => `${id}: deferred by scheduler parallelLimit=${parallelLimit} within ${wave.id}`)
+  };
+}
+async function dispatchWaveAt(waves, waveIndex, ctx) {
+  const fromWave = Math.max(0, waveIndex);
+  const { input, planned, tasks, taskMap, deps } = ctx;
+  if (waves.length === 0) {
+    return { mode: input.mode, planned, tasks, waves: [], dispatched: 0, blocked: [], packet: "team: no dispatchable waves." };
+  }
+  if (fromWave >= waves.length) {
+    return { mode: input.mode, planned, tasks, waves, dispatched: 0, blocked: [], packet: `team: all ${waves.length} waves dispatched.` };
+  }
+  const targetWave = waves[fromWave];
+  const scheduled = applySchedulerToWave(targetWave, waves, ctx);
+  let dispatchWave = scheduled.wave;
+  const remainingBlocked = [
+    ...scheduled.blocked,
+    ...waves.slice(fromWave + 1).map((w) => `${w.taskIds.join(", ")}: waiting for wave ${w.id} to complete`)
+  ];
+  const priorResults = input.priorResults;
+  const crossWaveBlocked = [];
+  const crossWaveSkipped = [];
+  const blockedTaskIds = [];
+  const skippedTaskIds = [];
+  const failedIds = new Set(
+    (priorResults ?? []).filter((r) => r.status !== "passed").map((r) => extractTaskIdFromWorkOrderId(r.workOrderId))
+  );
+  const priorPassedIds = new Set(
+    (priorResults ?? []).filter((r) => r.status === "passed").map((r) => extractTaskIdFromWorkOrderId(r.workOrderId)).filter(Boolean)
+  );
+  if (priorResults && priorResults.length > 0) {
+    if (failedIds.size > 0) {
+      const filteredTaskIds = [];
+      for (const taskId of dispatchWave.taskIds) {
+        const task = taskMap.get(taskId);
+        if (!task) {
+          filteredTaskIds.push(taskId);
+          continue;
+        }
+        const failedDepIds = [];
+        const skippedDepIds = [];
+        const waitingAlternates = [];
+        for (const dep of task.dependsOn ?? []) {
+          const depId = dependencyId(dep);
+          if (!failedIds.has(depId)) continue;
+          if (typeof dep === "string") {
+            failedDepIds.push(depId);
+            continue;
+          }
+          if (dep.onFailure === "skip") {
+            skippedDepIds.push(depId);
+            continue;
+          }
+          if (dep.onFailure === "alternate" && dep.alternateOrderId) {
+            const altId = extractTaskIdFromWorkOrderId(dep.alternateOrderId);
+            if (priorPassedIds.has(altId)) continue;
+            if (failedIds.has(altId)) {
+              skippedDepIds.push(depId);
+              continue;
+            }
+            waitingAlternates.push(`${depId}\u2192${dep.alternateOrderId}`);
+            continue;
+          }
+          failedDepIds.push(depId);
+        }
+        if (skippedDepIds.length > 0) {
+          crossWaveSkipped.push(`${taskId}: skipped \u2014 conditional dependency failed (onFailure=skip): ${skippedDepIds.join(", ")}`);
+          skippedTaskIds.push(taskId);
+        } else if (failedDepIds.length > 0) {
+          crossWaveBlocked.push(`${taskId}: blocked by prior wave failure (${failedDepIds.join(", ")})`);
+          blockedTaskIds.push(taskId);
+        } else if (waitingAlternates.length > 0) {
+          crossWaveBlocked.push(`${taskId}: waiting for alternate (${waitingAlternates.join(", ")})`);
+          blockedTaskIds.push(taskId);
+        } else {
+          filteredTaskIds.push(taskId);
+        }
+      }
+      dispatchWave = { ...dispatchWave, taskIds: filteredTaskIds };
+    }
+  }
+  const requests = waveToRequests(dispatchWave, taskMap, input.parentTurnId ?? "team");
+  if (priorResults && priorResults.length > 0) {
+    for (const req of requests) {
+      if (req.dependencies && req.dependencies.length > 0) {
+        const filtered = req.dependencies.filter((d) => {
+          const rawId = dependencyId(d);
+          const depId = rawId.includes(":") ? rawId.slice(rawId.lastIndexOf(":") + 1) : rawId;
+          if (priorPassedIds.has(depId)) return false;
+          if (typeof d === "object" && d.onFailure === "alternate" && d.alternateOrderId) {
+            const altId = extractTaskIdFromWorkOrderId(d.alternateOrderId);
+            if (failedIds.has(depId) && priorPassedIds.has(altId)) return false;
+          }
+          return true;
+        });
+        req.dependencies = filtered.length > 0 ? filtered : void 0;
+      }
+    }
+  }
+  if (input.onActivity) for (const r of requests) r.onActivity = input.onActivity;
+  if (input.planConstraints && input.planConstraints.length > 0) {
+    for (const r of requests) {
+      r.constraints = [...r.constraints ?? [], ...input.planConstraints];
+    }
+  }
+  const priorFeedback = buildPriorWaveFeedback({
+    priorResults,
+    waveGateFailures: input.priorWaveGateFailures,
+    scopeLeaks: input.priorScopeLeaks
+  });
+  if (priorFeedback.length > 0) {
+    for (const r of requests) {
+      r.constraints = [...r.constraints ?? [], ...priorFeedback];
+    }
+  }
+  const buildSyntheticResults = () => {
+    const parentPrefix = input.parentTurnId ?? "team";
+    const synthetic2 = [];
+    for (let i = 0; i < blockedTaskIds.length; i++) {
+      const detail = crossWaveBlocked[i];
+      synthetic2.push({
+        workOrderId: `${parentPrefix}:team:${blockedTaskIds[i]}`,
+        status: "blocked",
+        summary: detail,
+        findings: [],
+        artifacts: [{ kind: "risk", title: "Dependency blocked", content: detail }],
+        changedFiles: [],
+        risks: [],
+        nextActions: [],
+        evidenceStatus: "blocked"
+      });
+    }
+    for (let i = 0; i < skippedTaskIds.length; i++) {
+      const detail = crossWaveSkipped[i];
+      synthetic2.push({
+        workOrderId: `${parentPrefix}:team:${skippedTaskIds[i]}`,
+        status: "blocked",
+        summary: detail,
+        findings: [],
+        artifacts: [{ kind: "risk", title: "Dependency skipped", content: detail }],
+        changedFiles: [],
+        risks: [],
+        nextActions: [],
+        evidenceStatus: "skipped"
+      });
+    }
+    return synthetic2;
+  };
+  if (requests.length === 0) {
+    const synthetic2 = buildSyntheticResults();
+    return {
+      mode: input.mode,
+      planned,
+      tasks,
+      waves,
+      dispatched: 0,
+      blocked: [...remainingBlocked, ...crossWaveBlocked],
+      skipped: crossWaveSkipped.length > 0 ? crossWaveSkipped : void 0,
+      run: synthetic2.length > 0 ? { status: "completed", results: synthetic2, packet: `team: wave ${targetWave.id} produced no dispatchable requests.` } : void 0,
+      packet: `team: wave ${targetWave.id} produced no dispatchable requests.`
+    };
+  }
+  if (input.onPlanReady) {
+    input.onPlanReady({
+      mode: input.mode,
+      planned,
+      tasks,
+      waves,
+      dispatched: requests.length,
+      // 预览与实际派发结果一致（审查 fcb8106b）：跨波 blocked/skipped 同步进预览。
+      blocked: [...remainingBlocked, ...crossWaveBlocked],
+      skipped: crossWaveSkipped.length > 0 ? crossWaveSkipped : void 0,
+      packet: `[wave ${fromWave + 1}/${waves.length}] dispatching ${requests.length} workers\u2026`
+    }, fromWave);
+  }
+  const run = await deps.delegateBatch(requests, "all_required", input.abortSignal);
+  const synthetic = buildSyntheticResults();
+  if (synthetic.length > 0) {
+    run.results = [...run.results ?? [], ...synthetic];
+  }
+  try {
+    deps.recordTeamWaveTelemetry?.(buildTeamWaveTelemetry({
+      sessionId: deps.sessionId ?? "unknown",
+      objective: input.objective,
+      mode: input.mode,
+      fromWave,
+      wave: dispatchWave,
+      waves,
+      taskMap,
+      run,
+      dispatched: requests.length
+    }));
+  } catch {
+  }
+  return {
+    mode: input.mode,
+    planned,
+    tasks,
+    waves,
+    dispatched: requests.length,
+    blocked: [...remainingBlocked, ...crossWaveBlocked],
+    skipped: crossWaveSkipped.length > 0 ? crossWaveSkipped : void 0,
+    packet: `[wave ${fromWave + 1}/${waves.length}] ${run.packet}`,
+    run
+  };
+}
+async function runTeamSkeleton(input, deps) {
+  const maxParallel = Math.max(1, Math.min(input.maxParallel ?? 3, 5));
+  if (input.tasks && input.tasks.length > 0) {
+    const enrichedTasks2 = input.tasks;
+    const waves2 = groupTeamTasks(enrichedTasks2);
+    const taskMap2 = new Map(enrichedTasks2.map((t) => [t.id, t]));
+    if (waves2.length === 0) {
+      return {
+        mode: "standard",
+        planned: [],
+        tasks: enrichedTasks2,
+        waves: [],
+        dispatched: 0,
+        blocked: ["pre-parsed tasks produced no dispatchable waves"],
+        packet: "team: pre-parsed tasks \u2014 no waves to dispatch."
+      };
+    }
+    return dispatchWaveAt(waves2, input.fromWave ?? 0, {
+      taskMap: taskMap2,
+      tasks: enrichedTasks2,
+      planned: [],
+      input,
+      deps
+    });
+  }
+  const drafts = input.mode === "standard" && input.planMarkdown ? parseTeamTaskDrafts(input.planMarkdown) : [];
+  const enrichedTasks = input.planMarkdown ? parseTeamTasks(input.planMarkdown) : [];
+  if (input.mode === "max") {
+    const cached = loadTeamPlanSkeleton(deps.planCacheStore, input.objective, "max");
+    let mergedTasks;
+    let plannerRun;
+    let planMerge;
+    if (cached) {
+      mergedTasks = cached.tasks;
+    } else {
+      const perspectives = selectExpertSet(input.objective);
+      const plannerRequests = perspectives.map((perspective) => ({
+        parentTurnId: `team:planner-${perspective}`,
+        objective: buildPlannerObjective(perspective, input.objective),
+        kind: "plan",
+        profile: "perspective_planner",
+        scope: {},
+        authority: perspective,
+        onActivity: input.onActivity
+      }));
+      plannerRun = await deps.delegateBatch(
+        plannerRequests,
+        "all_required",
+        input.abortSignal,
+        void 0,
+        input.onWorkerSettled
+      );
+      const planFor = (perspective) => {
+        const result = plannerRun.results.find((r) => r.workOrderId.includes(`planner-${perspective}`));
+        return result ? parsePerspectiveResult(perspective, result) : normalizePerspective(perspective, {});
+      };
+      const merged = mergePerspectivesByRole(perspectives.map(planFor));
+      mergedTasks = foldVerificationIntoTasks(merged.tasks, merged.verification);
+      planMerge = { conflicts: merged.conflicts, risks: merged.risks, deferred: merged.deferred, rejected: merged.rejected, augmented: merged.augmented };
+      if (mergedTasks.length > 0) {
+        saveTeamPlanSkeleton(deps.planCacheStore, { objective: input.objective, mode: "max", tasks: mergedTasks });
+      }
+    }
+    const advisories = detectOverlapWithoutOrder(mergedTasks.map((t) => ({ ...t, dependsOn: t.dependsOn.map(dependencyId) })));
+    const waves2 = groupTeamTasks(mergedTasks);
+    const taskMap2 = new Map(mergedTasks.map((t) => [t.id, t]));
+    if (waves2.length === 0) {
+      return {
+        mode: input.mode,
+        planned: [],
+        tasks: mergedTasks,
+        waves: [],
+        dispatched: 0,
+        blocked: ["max planning produced no dispatchable tasks"],
+        packet: "team max: planners returned no tasks to dispatch.",
+        ...plannerRun ? { run: plannerRun } : {},
+        ...cached ? { planCacheHit: true } : {},
+        ...planMerge ? { planMerge } : {},
+        ...advisories.length > 0 ? { advisories } : {}
+      };
+    }
+    const summary = await dispatchWaveAt(waves2, input.fromWave ?? 0, {
+      taskMap: taskMap2,
+      tasks: mergedTasks,
+      planned: [],
+      input,
+      deps
+    });
+    return {
+      ...summary,
+      ...cached ? { planCacheHit: true } : {},
+      ...planMerge ? { planMerge } : {},
+      ...advisories.length > 0 ? { advisories } : {}
+    };
+  }
+  const waves = groupTeamTasks(enrichedTasks);
+  const taskMap = new Map(enrichedTasks.map((t) => [t.id, t]));
+  if (waves.length === 0) {
+    const { selected, blocked } = selectDispatchableTeamTasks(drafts, maxParallel);
+    if (selected.length === 0) {
+      return {
+        mode: input.mode,
+        planned: drafts,
+        tasks: enrichedTasks,
+        waves: [],
+        dispatched: 0,
+        blocked,
+        packet: blocked.length > 0 ? `team skeleton blocked:
+${blocked.join("\n")}` : "team skeleton: no task drafts found to dispatch."
+      };
+    }
+    const requests = teamTasksToDelegationRequests(selected, input.parentTurnId ?? "team");
+    if (input.onActivity) for (const r of requests) r.onActivity = input.onActivity;
+    if (input.planConstraints && input.planConstraints.length > 0) {
+      for (const r of requests) {
+        r.constraints = [...r.constraints ?? [], ...input.planConstraints];
+      }
+    }
+    const run = await deps.delegateBatch(requests, "all_required", input.abortSignal);
+    try {
+      deps.recordTeamWaveTelemetry?.(buildTeamWaveTelemetry({
+        sessionId: deps.sessionId ?? "unknown",
+        objective: input.objective,
+        mode: input.mode,
+        fromWave: input.fromWave ?? 0,
+        wave: { id: `legacy-W${(input.fromWave ?? 0) + 1}`, taskIds: selected.map((task) => task.id), reason: "legacy unstructured plan dispatch", parallelLimit: maxParallel, risk: "medium" },
+        waves: [{ id: `legacy-W${(input.fromWave ?? 0) + 1}`, taskIds: selected.map((task) => task.id), reason: "legacy unstructured plan dispatch", parallelLimit: maxParallel, risk: "medium" }],
+        taskMap: new Map(selected.map((task) => [task.id, {
+          ...task,
+          dependsOn: [],
+          riskTier: "medium",
+          touchSet: [...task.files],
+          groupId: void 0,
+          routeHint: void 0
+        }])),
+        run,
+        dispatched: requests.length
+      }));
+    } catch {
+    }
+    return {
+      mode: input.mode,
+      planned: drafts,
+      tasks: enrichedTasks,
+      waves: [],
+      dispatched: requests.length,
+      blocked,
+      packet: run.packet,
+      run
+    };
+  }
+  return dispatchWaveAt(waves, input.fromWave ?? 0, {
+    taskMap,
+    tasks: enrichedTasks,
+    planned: drafts,
+    input,
+    deps
+  });
+}
+
+// src/agent/wave-results-store.ts
+init_esm_shims();
+var waveResults = /* @__PURE__ */ new Map();
+function key(sessionId) {
+  return sessionId ?? "__default__";
+}
+function setWaveResults(results, sessionId) {
+  waveResults.set(key(sessionId), results);
+}
+function getWaveResults(sessionId) {
+  return waveResults.get(key(sessionId));
+}
+function clearWaveResults(sessionId) {
+  waveResults.delete(key(sessionId));
+}
+
+// src/agent/plan-executor.ts
+function capList(items, n = 8) {
+  return items.length <= n ? items.join(", ") : `${items.slice(0, n).join(", ")} (+${items.length - n} more)`;
+}
+function requireDelegate(deps) {
+  if (!deps.delegate) throw new Error("plan execution review gate requires deps.delegate");
+  return deps.delegate;
+}
+function teamReviewChangedFiles(run) {
+  if (!run) return [];
+  const files2 = /* @__PURE__ */ new Set();
+  for (const result of run.results) {
+    for (const file of result.changedFiles) files2.add(file);
+    for (const artifact of result.artifacts) {
+      if (artifact.kind === "diff") {
+        for (const file of extractChangedFiles(artifact.content)) files2.add(file);
+      }
+    }
+  }
+  return [...files2];
+}
+function teamReviewForceLevel(mode, change, waveTasks) {
+  if (mode === "max") return "L3";
+  const base = classifyChangeScale(change);
+  const hasHighRisk = waveTasks.some((task) => task.riskTier === "high");
+  if (base === "L3" || change.crossModule || waveTasks.length >= 3 || hasHighRisk) return "L3";
+  return base === "L1" ? "L2" : base;
+}
+function teamReviewFocusHint(waveTasks) {
+  const gates = [...new Set(waveTasks.flatMap((task) => task.verification).map((v) => v.trim()).filter(Boolean))];
+  if (gates.length === 0) return void 0;
+  return `Planned acceptance gates (verify these, do not just trust green): ${gates.join("; ")}`;
+}
+function buildWaveCheckpoint(opts, summary, prior) {
+  const taskById = new Map(summary.tasks.map((task) => [task.id, task]));
+  const remainingOrders = summary.waves.slice(opts.fromWave + 1).flatMap((wave) => wave.taskIds).map((id) => taskById.get(id)).filter((task) => Boolean(task)).map((task) => ({
+    id: task.id,
+    objective: task.objective,
+    profile: task.profile,
+    kind: task.kind,
+    scope: { files: task.files },
+    authority: taskAuthority(task),
+    // 依赖随任务存盘——resume 重建计划要靠它恢复剩余任务间的顺序与条件边。
+    ...task.dependsOn.length > 0 ? { dependsOn: task.dependsOn } : {}
+  }));
+  return {
+    groupId: deriveTeamGroupId(opts.objective),
+    timestamp: Date.now(),
+    lastCompletedWave: opts.fromWave,
+    completedResults: [...prior?.completedResults ?? [], ...summary.run?.results ?? []],
+    remainingOrders,
+    objective: opts.objective,
+    totalWaves: summary.waves.length
+  };
+}
+async function executePlan(opts, deps) {
+  let telemetryEvent;
+  if (isSkillGateEnabled() && opts.fromWave === 0) {
+    const required = opts.requiredSkills ?? (opts.planMarkdown ? extractRequiredSkills(opts.planMarkdown) : []);
+    if (required.length > 0) {
+      const verdict = evaluateSkillGate(required, {
+        availableNames: new Set(skillRegistry.list().map((s) => s.name)),
+        invokedNames: getInvokedSkills(opts.sessionId)
+      });
+      if (verdict.missing.length > 0) {
+        throw new Error(formatSkillGateBlock(verdict.missing));
+      }
+    }
+  }
+  if (isWaveGateEnabled() && opts.fromWave > 0) {
+    const prior = getWaveGate(opts.sessionId);
+    if (prior && prior.wave === opts.fromWave - 1 && !prior.passed) {
+      const recheck = await evaluateWaveGate({
+        cwd: opts.cwd,
+        wave: prior.wave,
+        changedFiles: prior.changedFiles,
+        commands: prior.commands,
+        typecheckRunner: deps.getTypecheckRunner?.()
+      });
+      setWaveGate(recheck, opts.sessionId);
+      if (!recheck.passed) {
+        throw new Error(
+          `\u6CE2\u95F4\u786C\u95E8\u7981\uFF1Awave ${prior.wave + 1} \u9A8C\u8BC1\u672A\u901A\u8FC7\uFF0C\u7981\u6B62\u6D3E\u53D1 wave ${opts.fromWave + 1}\u3002
+` + formatWaveGate(recheck).join("\n") + `
+\u5148\u4FEE\u590D\u5931\u8D25\u9879\uFF08\u6216\u91CD\u8DD1\u8BE5\u6CE2\uFF09\uFF0C\u95E8\u7981\u590D\u8BC4\u901A\u8FC7\u540E\u65B9\u53EF\u7EE7\u7EED\u3002\u9003\u751F\u9600\uFF1ARIVET_WAVE_GATE=0\u3002`
+        );
+      }
+    }
+  }
+  const priorResults = opts.fromWave > 0 ? getWaveResults(opts.sessionId) : void 0;
+  const priorWaveGateFailures = opts.fromWave > 0 ? (getWaveGate(opts.sessionId)?.checks ?? []).filter((c) => c.status === "failed" || c.blocking === true && c.status !== "passed").map((c) => c.command) : [];
+  const summary = await runTeamSkeleton(
+    {
+      mode: opts.mode,
+      objective: opts.objective,
+      planMarkdown: opts.planMarkdown,
+      tasks: opts.tasks,
+      maxParallel: opts.maxParallel,
+      fromWave: opts.fromWave,
+      parentTurnId: opts.parentTurnId,
+      abortSignal: opts.abortSignal,
+      priorResults,
+      teamSchedulerBanditEnabled: deps.isTeamSchedulerBanditEnabled?.() === true,
+      onActivity: opts.onActivity,
+      onWorkerSettled: opts.onWorkerSettled,
+      onPlanReady: opts.onPlanReady,
+      // D8 L2：计划约束透传（team-orchestrator 分片在 TeamRunInput 消费并并入
+      // waveToRequests 的 request.constraints）。条件注入——空则不带，fail-open。
+      ...opts.planConstraints && opts.planConstraints.length > 0 ? { planConstraints: opts.planConstraints } : {},
+      // 跨波回执：条件注入，空则不带字段——wave 0 与一切正常的波次行为不变。
+      ...priorWaveGateFailures.length > 0 ? { priorWaveGateFailures } : {},
+      ...opts.priorScopeLeaks && opts.priorScopeLeaks.length > 0 ? { priorScopeLeaks: opts.priorScopeLeaks } : {}
+    },
+    {
+      delegateBatch: (requests, policy, abortSignal, onProgress, onWorkerSettled) => deps.delegateBatch(requests, policy, abortSignal, (completed, total) => {
+        onProgress?.(completed, total);
+        opts.onProgress?.(completed, total);
+      }, onWorkerSettled ?? opts.onWorkerSettled),
+      recordTeamWaveTelemetry: (event) => {
+        telemetryEvent = event;
+        deps.recordTeamWaveTelemetry?.(event);
+      },
+      recordTeamSchedulerShadow: (event) => deps.recordTeamSchedulerShadow?.(event),
+      recordGatedInfluenceAudit: (event) => {
+        if (deps.recordGatedInfluenceAudit) {
+          deps.recordGatedInfluenceAudit(event);
+          return;
+        }
+        const store = deps.getTeamSchedulerRewardStore?.();
+        if (store?.saveBanditState) persistGatedInfluenceAudit({ saveBanditState: store.saveBanditState.bind(store) }, event);
+      },
+      teamSchedulerState: deps.getTeamSchedulerState?.() ?? buildHistoricalTeamSchedulerState(deps.getTeamSchedulerRewardStore?.()),
+      sessionId: deps.getSessionId?.(),
+      // Track 2: 计划骨架缓存与 reward 共用同一 append-only 存储。
+      planCacheStore: deps.getTeamSchedulerRewardStore?.()
+    }
+  );
+  if (summary.run?.results) {
+    setWaveResults(summary.run.results, opts.sessionId);
+  }
+  if (summary.run?.results) {
+    try {
+      const prior = loadCheckpoint(opts.cwd, deriveTeamGroupId(opts.objective));
+      saveCheckpoint(opts.cwd, buildWaveCheckpoint(opts, summary, prior));
+    } catch {
+    }
+  }
+  let reviewNote = "";
+  let deliverySynthesis = "";
+  let impactNote = "";
+  let reviewVerdict;
+  const effectiveFromWave = opts.fromWave;
+  const isLastWave = summary.waves.length > 0 && effectiveFromWave >= summary.waves.length - 1;
+  let scopeHealthNote = "";
+  let scopeLeakedFiles = [];
+  if (telemetryEvent) {
+    try {
+      const health = buildTeamWaveScopeHealth(telemetryEvent);
+      const rewardStore = deps.getTeamSchedulerRewardStore?.();
+      persistTeamScopeHealth(
+        rewardStore?.saveBanditState ? { saveBanditState: rewardStore.saveBanditState.bind(rewardStore) } : void 0,
+        health
+      );
+      if (health.severity === "medium" || health.severity === "high") {
+        scopeLeakedFiles = health.leakedFiles;
+        const parts = [];
+        if (health.leakedFiles.length > 0) parts.push(`leaked (changed, not planned): ${health.leakedFiles.join(", ")}`);
+        if (health.missingFiles.length > 0) parts.push(`missing (planned, untouched): ${health.missingFiles.join(", ")}`);
+        scopeHealthNote = `
+
+Scope health [${health.severity}]: ${parts.join("; ")}`;
+      }
+    } catch {
+    }
+  }
+  const changedFiles = teamReviewChangedFiles(summary.run);
+  if (opts.reviewGate && isLastWave && changedFiles.length > 0 && opts.reviewDepth === 0) {
+    try {
+      const delegate = requireDelegate(deps);
+      const taskById = new Map(summary.tasks.map((task) => [task.id, task]));
+      const waveTasks = (summary.waves[effectiveFromWave]?.taskIds ?? []).map((id) => taskById.get(id)).filter((task) => Boolean(task));
+      const change = {
+        files: changedFiles,
+        crossModule: isCrossModule(changedFiles),
+        isFix: isFixContext(opts.objective)
+      };
+      change.forceLevel = teamReviewForceLevel(opts.mode, change, waveTasks);
+      const baseFocus = teamReviewFocusHint(waveTasks);
+      let impactFocus;
+      try {
+        const analyzer = deps.getMeridianIndexer?.();
+        const observed = (telemetryEvent?.changedFiles.observedChangedFiles ?? []).filter((f) => !isAbsolute(f));
+        if (analyzer && observed.length > 0) {
+          const impact = analyzer.impact(observed);
+          const consumers = [...impact.direct, ...impact.transitive];
+          const seg = [];
+          if (consumers.length > 0) seg.push(`downstream consumers (verify not broken): ${capList(consumers)}`);
+          if (impact.tests.length > 0) seg.push(`related tests to run: ${capList(impact.tests)}`);
+          if (seg.length > 0) {
+            impactFocus = `Blast radius \u2014 ${seg.join("; ")}`;
+            impactNote = `
+
+Blast radius [meridian]: ${seg.join("; ")}`;
+          }
+        }
+      } catch {
+      }
+      let typecheckFocus;
+      const typecheckRunner = deps.getTypecheckRunner?.();
+      if (typecheckGateEnabled() && typecheckRunner) {
+        try {
+          const observed = (telemetryEvent?.changedFiles.observedChangedFiles ?? []).filter((f) => !isAbsolute(f));
+          const tc = await runChangedFilesTypecheckMemo(opts.cwd, observed, typecheckRunner);
+          if (tc) {
+            change.forceLevel = "L3";
+            typecheckFocus = `Typecheck \u2014 ${tc.summary}`;
+            impactNote = `
+
+Typecheck broken [tsc]: ${tc.summary}` + impactNote;
+          }
+        } catch {
+        }
+      }
+      const focusParts = [
+        typecheckFocus,
+        baseFocus,
+        scopeLeakedFiles.length > 0 ? `Scope leak \u2014 files changed outside the plan, scrutinize these: ${scopeLeakedFiles.join(", ")}` : void 0,
+        impactFocus
+      ].filter((s) => Boolean(s));
+      const focusHint = focusParts.length > 0 ? focusParts.join(" | ") : void 0;
+      const reviewDeps = createCoordinatorReviewDeps(
+        {
+          delegate: (request2, abortSignal) => delegate(request2, abortSignal),
+          delegateBatch: (requests, policy, abortSignal, onProgress) => deps.delegateBatch(requests, policy, abortSignal, onProgress)
+        },
+        { reviewDepth: opts.reviewDepth, abortSignal: opts.abortSignal, parentTurnId: `${opts.parentTurnId}:review` }
+      );
+      const outcome = await routeReviewWorkflow(change, reviewDeps, { maxRounds: 3, ...focusHint ? { focusHint } : {} });
+      reviewVerdict = outcome.verdict;
+      reviewNote = `
+
+Review gate [${outcome.tier}]: ${outcome.verdict}${outcome.evidence ? ` \u2014 ${outcome.evidence}` : ""}`;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`review gate failed: ${msg}`);
+    }
+  }
+  let waveGateNote = "";
+  let gate;
+  if (isWaveGateEnabled() && !isLastWave && summary.run) {
+    try {
+      const taskById = new Map(summary.tasks.map((task) => [task.id, task]));
+      const waveTasks = (summary.waves[effectiveFromWave]?.taskIds ?? []).map((id) => taskById.get(id)).filter((task) => Boolean(task));
+      const commands = [...new Set(waveTasks.flatMap((task) => task.verification).map((v) => v.trim()).filter(Boolean))];
+      if (changedFiles.length > 0 || commands.length > 0) {
+        const record = await evaluateWaveGate({
+          cwd: opts.cwd,
+          wave: effectiveFromWave,
+          changedFiles: changedFiles.filter((f) => !isAbsolute(f)),
+          commands,
+          typecheckRunner: deps.getTypecheckRunner?.()
+        });
+        setWaveGate(record, opts.sessionId);
+        waveGateNote = `
+
+${formatWaveGate(record).join("\n")}`;
+        if (!record.passed) {
+          waveGateNote += `
+\u26D4 \u4E0B\u4E00\u6CE2\u6D3E\u53D1\u5C06\u88AB\u786C\u62E6\uFF0C\u5148\u4FEE\u590D\u5931\u8D25\u9879\u3002\u9003\u751F\u9600\uFF1ARIVET_WAVE_GATE=0\u3002`;
+        }
+        gate = {
+          wave: record.wave,
+          passed: record.passed,
+          failures: record.checks.filter((c) => c.status === "failed" || c.blocking && c.status !== "passed").map((c) => `${c.command}${c.detail ? ` \u2014 ${c.detail}` : ""}`)
+        };
+      }
+    } catch {
+    }
+  }
+  if (telemetryEvent) {
+    const closedTelemetry = {
+      ...telemetryEvent,
+      outcome: {
+        ...telemetryEvent.outcome,
+        ...reviewVerdict ? { reviewVerdict } : {}
+      }
+    };
+    try {
+      deps.recordTeamWaveRewardClosure?.(closedTelemetry);
+    } catch {
+    }
+    try {
+      deps.recordTeamSchedulerReward?.(closedTelemetry);
+    } catch {
+    }
+    if (isLastWave) {
+      try {
+        recordTeamEpisodeClosureFromStore(deps.getTeamSchedulerRewardStore?.(), closedTelemetry);
+      } catch {
+      }
+      try {
+        const episode = buildTeamEpisodeFromStore(deps.getTeamSchedulerRewardStore?.(), closedTelemetry);
+        deliverySynthesis = `
+
+${formatTeamDelivery(episode)}`;
+      } catch {
+      }
+    }
+  }
+  if (isLastWave && summary.run?.results && summary.run.results.every((result) => result.status === "passed")) {
+    try {
+      clearCheckpoint(opts.cwd, deriveTeamGroupId(opts.objective));
+    } catch {
+    }
+  }
+  return {
+    summary,
+    reviewVerdict,
+    notes: { reviewNote, scopeHealthNote, impactNote, deliverySynthesis, waveGateNote },
+    ...scopeLeakedFiles.length > 0 ? { scopeLeakedFiles } : {},
+    gate,
+    // P4 fix: reviewVerdict is just a single enum word (e.g. "verified") — the
+    // real content with evidence is reviewNote. Strip leading newlines for the
+    // inline panel display.
+    ...reviewNote ? { reviewDetail: reviewNote.replace(/^\n+/, "").slice(0, 1e3) } : {}
+  };
+}
+var EXECUTE_PLAN_WAVES_GUARDRAIL = 10;
+function classifyWaveStop(outcome, ctx = {}) {
+  if (ctx.abortSignal?.aborted) return true;
+  if (outcome.workers.total > 0 && outcome.workers.passed === 0) return true;
+  if (outcome.waveGate && !outcome.waveGate.passed) return true;
+  if (outcome.reviewVerdict === "rejected" || outcome.reviewVerdict === "inconclusive") return true;
+  return false;
+}
+function aggregatePlanExecutorRuns(runs) {
+  if (runs.length === 0) throw new Error("aggregatePlanExecutorRuns: no runs to aggregate");
+  const summaries = runs.map((run) => run.summary);
+  const lastRun = runs[runs.length - 1];
+  const last = lastRun.summary;
+  const results = summaries.flatMap((summary2) => summary2.run?.results ?? []);
+  const summary = {
+    ...last,
+    dispatched: summaries.reduce((n, s) => n + s.dispatched, 0),
+    run: last.run ? { ...last.run, results } : void 0
+  };
+  const notes = {
+    reviewNote: runs.map((run) => run.notes.reviewNote).filter(Boolean).join("\n"),
+    scopeHealthNote: runs.map((run) => run.notes.scopeHealthNote).filter(Boolean).join("\n"),
+    impactNote: runs.map((run) => run.notes.impactNote).filter(Boolean).join("\n"),
+    deliverySynthesis: runs.map((run) => run.notes.deliverySynthesis).filter(Boolean).join("\n"),
+    waveGateNote: runs.map((run) => run.notes.waveGateNote).filter(Boolean).join("\n")
+  };
+  const gate = [...runs].reverse().find((run) => run.gate)?.gate;
+  const reviewDetail = [...runs].reverse().find((run) => run.reviewDetail)?.reviewDetail;
+  return {
+    summary,
+    reviewVerdict: lastRun.reviewVerdict,
+    notes,
+    ...gate ? { gate } : {},
+    ...reviewDetail ? { reviewDetail } : {}
+  };
+}
+async function executePlanWaves(opts, deps) {
+  const startWave = opts.startWave ?? 0;
+  const autoAdvance = opts.autoAdvance ?? true;
+  const maxWaves = opts.maxWaves ?? startWave + EXECUTE_PLAN_WAVES_GUARDRAIL;
+  if (maxWaves <= startWave) {
+    throw new Error(`executePlanWaves: maxWaves (${maxWaves}) must be > startWave (${startWave})`);
+  }
+  const { startWave: _startWave, autoAdvance: _autoAdvance, maxWaves: _maxWaves, onWave, ...planOpts } = opts;
+  const runs = [];
+  let priorScopeLeaks = [];
+  for (let wave = startWave; wave < maxWaves; wave++) {
+    const run = await executePlan(
+      { ...planOpts, fromWave: wave, ...priorScopeLeaks.length > 0 ? { priorScopeLeaks } : {} },
+      deps
+    );
+    priorScopeLeaks = run.scopeLeakedFiles ?? [];
+    runs.push(run);
+    onWave?.(run, wave);
+    const outcome = buildTeamOutcome(run.summary, wave, run);
+    const stop = classifyWaveStop(outcome, { abortSignal: opts.abortSignal });
+    if (stop || !autoAdvance || wave + 1 >= outcome.totalWaves) break;
+  }
+  return { runs, run: aggregatePlanExecutorRuns(runs) };
+}
+
+// src/tui/frame-codec.ts
+init_esm_shims();
+var registeredPrefixes = [];
+function registerFramePrefix(prefix) {
+  if (!registeredPrefixes.includes(prefix)) {
+    registeredPrefixes.push(prefix);
+  }
+}
+function containsRegisteredFrame(uiContent) {
+  for (const prefix of registeredPrefixes) {
+    if (uiContent.includes(prefix)) return true;
+  }
+  return false;
+}
+function encodeFrame(model, prefix) {
+  return `${prefix}${JSON.stringify(model)}`;
+}
+function decodeFrame(value, prefix, validate) {
+  const at = value.indexOf(prefix);
+  if (at === -1) return null;
+  try {
+    const parsed = JSON.parse(value.slice(at + prefix.length));
+    if (validate(parsed)) return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function decodeFrameLastWins(value, prefix, validate) {
+  let at = value.lastIndexOf(prefix);
+  while (at !== -1) {
+    const start = at + prefix.length;
+    const nl = value.indexOf("\n", start);
+    const body = nl === -1 ? value.slice(start) : value.slice(start, nl);
+    try {
+      const parsed = JSON.parse(body);
+      if (validate(parsed)) return parsed;
+    } catch {
+    }
+    at = at > 0 ? value.lastIndexOf(prefix, at - 1) : -1;
+  }
+  return null;
+}
+
+export {
+  groupTeamTasks,
+  parseTeamTasks,
+  sealPlan,
+  verifyPlanSeal,
+  formatSealStatus,
+  registerFramePrefix,
+  containsRegisteredFrame,
+  encodeFrame,
+  decodeFrame,
+  decodeFrameLastWins,
+  buildTeamOutcome,
+  createCoordinatorReviewDeps,
+  teamSchedulerArmForParallelism,
+  buildTeamSchedulerRewardEvent,
+  persistTeamSchedulerShadow,
+  persistTeamSchedulerReward,
+  clearWaveResults,
+  teamReviewChangedFiles,
+  teamReviewForceLevel,
+  teamReviewFocusHint,
+  executePlan,
+  EXECUTE_PLAN_WAVES_GUARDRAIL,
+  executePlanWaves
+};