tianshu-harness 3.23.0

package/dist/chunk-EHHUASO5.js

@@ -0,0 +1,1305 @@
+#!/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 {
+  dependencyId
+} from "./chunk-4QJ3Y5JM.js";
+import {
+  matchDomain
+} from "./chunk-CGOADM2X.js";
+import {
+  RETIRED_BUNDLED_SKILLS
+} from "./chunk-OHSV42QB.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/model/capability.ts
+init_esm_shims();
+function score(task, card) {
+  switch (task) {
+    case "repo_summarization":
+      return card.contextWindow / 1e6 + (card.cacheEconomics === "strong" ? 1 : 0);
+    case "code_edit":
+      return card.toolUseReliability * 0.5 + card.editSuccessRate * 0.5;
+    case "test_failure_diagnosis":
+      return card.testRepairRate * 0.7 + card.jsonStability * 0.3;
+    case "compaction":
+      return (card.cacheEconomics === "strong" ? 1 : 0.5) + card.jsonStability;
+    case "risky_refactor":
+      return card.toolUseReliability * 0.4 + card.editSuccessRate * 0.3 + card.testRepairRate * 0.3;
+    case "planning":
+      return card.toolUseReliability * 0.4 + card.jsonStability * 0.3 + (card.cacheEconomics === "strong" ? 0.3 : 0) + card.contextWindow / 1e6;
+  }
+}
+function recommendModelForTask(task, cards) {
+  if (cards.length === 0) throw new Error("No model capability cards configured");
+  return [...cards].sort((a, b) => {
+    const scoreA = score(task, a) + (a.recommendedTasks.includes(task) ? 0.5 : 0);
+    const scoreB = score(task, b) + (b.recommendedTasks.includes(task) ? 0.5 : 0);
+    return scoreB - scoreA;
+  })[0];
+}
+var V4_FLASH_CARD = {
+  toolUseReliability: 0.85,
+  jsonStability: 0.85,
+  editSuccessRate: 0.75,
+  testRepairRate: 0.65,
+  cacheEconomics: "strong",
+  recommendedTasks: ["code_search", "code_edit", "test_failure_diagnosis", "risky_refactor", "planning", "repo_summarization", "compaction"]
+};
+var GLM53_FLASH_CARD = {
+  toolUseReliability: 0.8,
+  jsonStability: 0.8,
+  editSuccessRate: 0.7,
+  testRepairRate: 0.6,
+  cacheEconomics: "strong",
+  recommendedTasks: ["code_search", "code_edit", "test_failure_diagnosis", "risky_refactor", "planning", "repo_summarization", "compaction"]
+};
+function capabilityCardForModel(m) {
+  if (m.id === "deepseek-v4-flash" || m.alias === "v4-flash") {
+    return { model: m.id, contextWindow: m.contextWindow, ...V4_FLASH_CARD };
+  }
+  if (m.id === "glm-5.3-flash" || m.alias === "glm-53-flash") {
+    return { model: m.id, contextWindow: m.contextWindow, ...GLM53_FLASH_CARD };
+  }
+  const isPro = m.id.includes("pro") || m.alias?.includes("pro");
+  const isFlash = m.id.includes("flash") || m.alias?.includes("flash");
+  if (isPro || !isFlash && !isPro) {
+    return {
+      model: m.id,
+      toolUseReliability: 0.8,
+      jsonStability: 0.8,
+      editSuccessRate: 0.7,
+      testRepairRate: 0.6,
+      contextWindow: m.contextWindow,
+      cacheEconomics: "strong",
+      recommendedTasks: ["code_search", "code_edit", "test_failure_diagnosis", "risky_refactor"]
+    };
+  }
+  return {
+    model: m.id,
+    toolUseReliability: 0.6,
+    jsonStability: 0.65,
+    editSuccessRate: 0.5,
+    testRepairRate: 0.45,
+    contextWindow: m.contextWindow,
+    cacheEconomics: "strong",
+    recommendedTasks: ["repo_summarization", "compaction"]
+  };
+}
+function buildModelCards(provider) {
+  return provider.models.map(capabilityCardForModel);
+}
+
+// src/agent/linucb-bandit.ts
+init_esm_shims();
+var DEFAULT_ALPHA = 1.5;
+var DEFAULT_MIN_CONFIDENCE = 0.25;
+var LinUCBBandit = class _LinUCBBandit {
+  arms = /* @__PURE__ */ new Map();
+  d;
+  alpha;
+  minConfidence;
+  totalPulls = 0;
+  constructor(config) {
+    this.d = config.dimension;
+    this.alpha = config.alpha ?? DEFAULT_ALPHA;
+    this.minConfidence = config.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+  }
+  /** Register an arm (action choice) */
+  addArm(id) {
+    if (this.arms.has(id)) return;
+    const A = new Array(this.d * this.d).fill(0);
+    for (let i = 0; i < this.d; i++) A[i * this.d + i] = 1;
+    const b = new Array(this.d).fill(0);
+    this.arms.set(id, { id, A, b, pulls: 0, totalReward: 0 });
+  }
+  /** Select best arm given context features */
+  recommend(context) {
+    if (this.arms.size === 0) return null;
+    if (context.length !== this.d) return null;
+    let bestArm = null;
+    let bestScore = -Infinity;
+    for (const [id, arm] of this.arms) {
+      const score2 = this.ucbScore(arm, context);
+      if (score2 > bestScore) {
+        bestScore = score2;
+        bestArm = id;
+      }
+    }
+    if (!bestArm) return null;
+    const confidence = this.totalPulls > 0 ? this.arms.get(bestArm).pulls / this.totalPulls : 0;
+    return { armId: bestArm, score: bestScore, confidence };
+  }
+  /** Should we suggest this action? (above min confidence threshold) */
+  shouldSuggest(context) {
+    const rec = this.recommend(context);
+    if (!rec) return null;
+    if (this.totalPulls < 10) return rec;
+    return rec.score > this.minConfidence ? rec : null;
+  }
+  /** Update arm with reward signal */
+  update(armId, context, reward) {
+    const arm = this.arms.get(armId);
+    if (!arm || context.length !== this.d) return;
+    for (let i = 0; i < this.d; i++) {
+      for (let j = 0; j < this.d; j++) {
+        arm.A[i * this.d + j] += context[i] * context[j];
+      }
+    }
+    for (let i = 0; i < this.d; i++) {
+      arm.b[i] += reward * context[i];
+    }
+    arm.pulls++;
+    arm.totalReward += reward;
+    this.totalPulls++;
+  }
+  /** Record accept signal (+0.75) */
+  accept(armId, context) {
+    this.update(armId, context, 0.75);
+  }
+  /** Record reject signal (-0.25) */
+  reject(armId, context) {
+    this.update(armId, context, -0.25);
+  }
+  /** Get arm statistics */
+  getStats() {
+    return [...this.arms.values()].map((a) => ({
+      id: a.id,
+      pulls: a.pulls,
+      avgReward: a.pulls > 0 ? a.totalReward / a.pulls : 0
+    }));
+  }
+  /** Serialize state for persistence */
+  serialize() {
+    return JSON.stringify({
+      d: this.d,
+      alpha: this.alpha,
+      totalPulls: this.totalPulls,
+      arms: [...this.arms.entries()]
+    });
+  }
+  /** Restore from serialized state */
+  static deserialize(json, config) {
+    const data = JSON.parse(json);
+    const bandit = new _LinUCBBandit(config);
+    bandit.totalPulls = data.totalPulls ?? 0;
+    for (const [id, arm] of data.arms) {
+      bandit.arms.set(id, arm);
+    }
+    return bandit;
+  }
+  /**
+   * In-place restore of arms + totalPulls from a serialized snapshot.
+   *
+   * Unlike `deserialize` (which builds a NEW instance), this overwrites the
+   * live instance's state so a long-lived bandit reference can pick up
+   * cross-session history. This is a REPLACE, not a merge: a freshly
+   * constructed bandit has no learning worth preserving, so dropping its
+   * cold-start arms in favor of the persisted ones is intentional.
+   *
+   * Throws on malformed JSON / shape; callers persisting non-critical state
+   * should wrap in try/catch.
+   */
+  importState(json) {
+    const data = JSON.parse(json);
+    this.arms = /* @__PURE__ */ new Map();
+    for (const [id, arm] of data.arms) {
+      this.arms.set(id, arm);
+    }
+    this.totalPulls = data.totalPulls ?? 0;
+  }
+  ucbScore(arm, x) {
+    const theta = new Array(this.d).fill(0);
+    for (let i = 0; i < this.d; i++) {
+      const aii = arm.A[i * this.d + i];
+      theta[i] = aii > 0 ? arm.b[i] / aii : 0;
+    }
+    let exploit = 0;
+    let explore = 0;
+    for (let i = 0; i < this.d; i++) {
+      exploit += theta[i] * x[i];
+      const aii = arm.A[i * this.d + i];
+      explore += aii > 0 ? x[i] * x[i] / aii : 0;
+    }
+    return exploit + this.alpha * Math.sqrt(explore);
+  }
+};
+
+// src/agent/skill-gate.ts
+init_esm_shims();
+var SKILL_CALL_RE = /skill\(\s*name\s*=\s*["'「]?([A-Za-z][\w-]*)/g;
+var DIRECTIVE_RE = /(?:使用|调用|加载|遵循|按照|执行|follow(?:ing)?|use|using|load)\s*[`「"']?([A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+)[`」"']?/gi;
+var SUFFIX_RE = /[`「]([A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+)[`」]\s*(?:skill|技能)/gi;
+function extractRequiredSkills(planContent) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const re of [SKILL_CALL_RE, DIRECTIVE_RE, SUFFIX_RE]) {
+    re.lastIndex = 0;
+    for (const m of planContent.matchAll(re)) {
+      const name = m[1];
+      const key2 = name.toLowerCase();
+      if (!seen.has(key2)) seen.set(key2, name);
+    }
+  }
+  return [...seen.values()];
+}
+var invokedBySession = /* @__PURE__ */ new Map();
+function key(sessionId) {
+  return sessionId ?? "__default__";
+}
+function recordSkillInvoked(name, sessionId) {
+  const k = key(sessionId);
+  let set = invokedBySession.get(k);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    invokedBySession.set(k, set);
+  }
+  set.add(name.toLowerCase());
+}
+function getInvokedSkills(sessionId) {
+  return invokedBySession.get(key(sessionId)) ?? /* @__PURE__ */ new Set();
+}
+function clearSkillGate(sessionId) {
+  invokedBySession.delete(key(sessionId));
+}
+function isSkillGateEnabled() {
+  return process.env.RIVET_SKILL_GATE !== "0";
+}
+function evaluateSkillGate(required, opts) {
+  const available = new Set([...opts.availableNames].map((n) => n.toLowerCase()));
+  const invoked = new Set([...opts.invokedNames].map((n) => n.toLowerCase()));
+  const retired = new Set(RETIRED_BUNDLED_SKILLS.map((e) => e.name.toLowerCase()));
+  const missing = [];
+  const unavailable = [];
+  const native = [];
+  for (const name of required) {
+    const k = name.toLowerCase();
+    if (retired.has(k)) {
+      native.push(name);
+    } else if (!available.has(k)) {
+      unavailable.push(name);
+    } else if (!invoked.has(k)) {
+      missing.push(name);
+    }
+  }
+  return { missing, unavailable, native };
+}
+function formatSkillGateBlock(missing) {
+  return `\u6280\u80FD\u95E8\u7981\uFF1A\u8BA1\u5212\u70B9\u540D\u4E86\u6D41\u7A0B skill\u300C${missing.join("\u3001")}\u300D\uFF0C\u4F46\u672C\u4F1A\u8BDD\u5C1A\u672A\u52A0\u8F7D\u3002
+\u8BA1\u5212\u70B9\u540D\u7684 skill \u662F\u8BE5\u8BA1\u5212\u4E13\u5C5E\u7684\u6267\u884C\u5951\u7EA6\uFF0C\u6B63\u6587\u53EA\u542B\u901A\u7528\u7EAA\u5F8B\u4E4B\u5916\u7684\u589E\u91CF\u6D41\u7A0B\u3002
+` + missing.map((n) => `\u5148\u6267\u884C skill(name="${n}") \u52A0\u8F7D\u5E76\u9075\u5FAA\u5176\u6D41\u7A0B\uFF0C`).join("") + `\u518D\u91CD\u65B0\u53D1\u8D77\u6267\u884C\u3002\u9003\u751F\u9600\uFF1ARIVET_SKILL_GATE=0\u3002`;
+}
+
+// src/agent/gated-influence-audit.ts
+init_esm_shims();
+function sanitizeEvidenceWindow(input) {
+  const out = {};
+  if (!input) return out;
+  for (const [key2, value] of Object.entries(input)) {
+    if (value === void 0) continue;
+    if (typeof value === "number" && !Number.isFinite(value)) continue;
+    out[key2] = value;
+  }
+  return out;
+}
+function safeTargetId(value) {
+  return value.replace(/[^a-zA-Z0-9:_@.-]/g, "_").slice(0, 160) || "unknown";
+}
+function gatedInfluenceAuditKind(event) {
+  return `gated_influence_audit:${event.source}:${event.sessionId}:${safeTargetId(event.targetId)}:${event.timestamp}`;
+}
+function buildGatedInfluenceAuditEvent(input) {
+  return {
+    schemaVersion: 1,
+    source: input.source,
+    sessionId: input.sessionId,
+    targetId: input.targetId,
+    gateOpen: input.gateOpen,
+    applied: input.applied,
+    reason: input.reason,
+    evidenceWindow: sanitizeEvidenceWindow(input.evidenceWindow),
+    vetoSignals: [...new Set(input.vetoSignals ?? [])].sort(),
+    timestamp: input.timestamp ?? Date.now()
+  };
+}
+function persistGatedInfluenceAudit(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(gatedInfluenceAuditKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+
+// src/agent/team-wave-telemetry.ts
+init_esm_shims();
+import { createHash } from "crypto";
+function hashTeamObjective(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function teamWaveTelemetryKind(event) {
+  return `team_wave:${event.objectiveHash}:${event.sessionId}:${event.fromWave}:${event.timestamp}`;
+}
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+function extractObservedChangedFilesFromArtifacts(run) {
+  const files = /* @__PURE__ */ new Set();
+  for (const result of run.results) {
+    for (const artifact of result.artifacts) {
+      if (artifact.kind !== "diff") continue;
+      for (const match of artifact.content.matchAll(/^\+\+\+ b\/(.+)$/gm)) {
+        if (match[1]) files.add(match[1]);
+      }
+    }
+  }
+  return [...files].sort();
+}
+function extractReportedChangedFiles(run) {
+  return uniqueSorted(run.results.flatMap((result) => result.changedFiles));
+}
+function taskIdFromWorkOrderId(workOrderId) {
+  if (workOrderId.startsWith("team:")) return workOrderId.slice("team:".length);
+  if (workOrderId.startsWith("task:")) return workOrderId.slice("task:".length);
+  return null;
+}
+function extractObservedChangedFilesFromResult(result) {
+  const files = /* @__PURE__ */ new Set();
+  for (const artifact of result.artifacts) {
+    if (artifact.kind !== "diff") continue;
+    for (const match of artifact.content.matchAll(/^\+\+\+ b\/(.+)$/gm)) {
+      if (match[1]) files.add(match[1]);
+    }
+  }
+  return [...files].sort();
+}
+function buildChangedFilesByTask(run, taskIds) {
+  const taskSet = new Set(taskIds);
+  const reported = /* @__PURE__ */ new Map();
+  const observed = /* @__PURE__ */ new Map();
+  for (const result of run.results) {
+    const taskId = taskIdFromWorkOrderId(result.workOrderId);
+    if (!taskId || !taskSet.has(taskId)) continue;
+    const reportedFiles = uniqueSorted(result.changedFiles);
+    if (reportedFiles.length > 0) reported.set(taskId, reportedFiles);
+    const observedFiles = extractObservedChangedFilesFromResult(result);
+    if (observedFiles.length > 0) observed.set(taskId, observedFiles);
+  }
+  return {
+    reportedChangedFilesByTask: [...reported.entries()].map(([taskId, files]) => ({ taskId, files })).sort((a, b) => a.taskId.localeCompare(b.taskId)),
+    observedChangedFilesByTask: [...observed.entries()].map(([taskId, files]) => ({ taskId, files })).sort((a, b) => a.taskId.localeCompare(b.taskId))
+  };
+}
+function buildTeamWaveTelemetry(input) {
+  const tasks = input.wave.taskIds.map((id) => input.taskMap.get(id)).filter((task) => Boolean(task));
+  const reportedChangedFiles = extractReportedChangedFiles(input.run);
+  const observedChangedFiles = extractObservedChangedFilesFromArtifacts(input.run);
+  const { reportedChangedFilesByTask, observedChangedFilesByTask } = buildChangedFilesByTask(input.run, input.wave.taskIds);
+  const changedFilesSource = observedChangedFiles.length > 0 ? "diff_artifact" : reportedChangedFiles.length > 0 ? "worker_result" : "unknown";
+  const verificationStates = input.run.results.map((result) => result.verification?.status).filter((status) => Boolean(status));
+  const verificationPassed = verificationStates.length > 0 ? verificationStates.every((status) => status === "passed") : void 0;
+  return {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    objectiveHash: hashTeamObjective(input.objective),
+    mode: input.mode,
+    fromWave: input.fromWave,
+    waveId: input.wave.id,
+    waveCount: input.waves.length,
+    timestamp: input.timestamp ?? Date.now(),
+    planned: {
+      taskIds: [...input.wave.taskIds],
+      risk: input.wave.risk,
+      profiles: uniqueSorted(tasks.map((task) => task.profile)),
+      authorities: uniqueSorted(tasks.map((task) => taskAuthority(task))),
+      files: uniqueSorted(tasks.flatMap((task) => task.touchSet.length > 0 ? task.touchSet : task.files)),
+      taskDependencies: tasks.filter((task) => task.dependsOn.length > 0).map((task) => ({ taskId: task.id, dependsOn: uniqueSorted(task.dependsOn.map(dependencyId)) }))
+    },
+    outcome: {
+      dispatched: input.dispatched ?? input.run.results.length,
+      statuses: input.run.results.map((result) => ({
+        workOrderId: result.workOrderId,
+        status: result.status,
+        evidenceStatus: result.evidenceStatus
+      })),
+      ...verificationPassed === void 0 ? {} : { verificationPassed }
+    },
+    changedFiles: {
+      ...reportedChangedFiles.length > 0 ? { reportedChangedFiles } : {},
+      ...observedChangedFiles.length > 0 ? { observedChangedFiles } : {},
+      ...reportedChangedFilesByTask.length > 0 ? { reportedChangedFilesByTask } : {},
+      ...observedChangedFilesByTask.length > 0 ? { observedChangedFilesByTask } : {},
+      changedFilesSource
+    },
+    ...input.run.workerModels && input.run.workerModels.length > 0 ? { workerModels: input.run.workerModels.map((model) => ({ ...model })) } : {},
+    ...input.run.modelTierShadows && input.run.modelTierShadows.length > 0 ? {
+      workerModelTierShadows: input.run.modelTierShadows.map((event) => ({
+        workOrderId: event.workOrderId,
+        recommendedTier: event.recommendedTier,
+        actualTier: event.actualTier,
+        matched: event.matched,
+        reason: event.reason
+      }))
+    } : {}
+  };
+}
+function taskAuthority(task) {
+  if (task.profile === "patcher") return "tianliang";
+  if (task.profile === "reviewer" || task.profile === "adversarial_verifier") return "tianquan";
+  return matchDomain(task.objective) ?? "tianliang";
+}
+function persistTeamWaveTelemetry(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(teamWaveTelemetryKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+
+// src/agent/team-scope-health.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+function shortHash(input) {
+  return createHash2("sha256").update(input).digest("hex").slice(0, 8);
+}
+function uniqueSorted2(values) {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+function selectActualFiles(input) {
+  const observed = uniqueSorted2(input.observedChangedFiles ?? []);
+  if (observed.length > 0) return { actualFiles: observed, source: "diff_artifact", reason: "actual_files_from_observed_diff" };
+  const reported = uniqueSorted2(input.reportedChangedFiles ?? []);
+  if (reported.length > 0) return { actualFiles: reported, source: "worker_result", reason: "actual_files_from_worker_report" };
+  return { actualFiles: [], source: input.changedFilesSource === "mixed" ? "mixed" : "unknown", reason: "no_actual_files_observed" };
+}
+function isHighRiskScopePath(file) {
+  const normalized = file.replace(/\\/g, "/");
+  return /(^|\/)(package-lock\.json|package\.json|tsconfig\.json|\.env(?:\..*)?|schema|schemas|migration|migrations|prompt|prompts|security|auth|config)(\/|$|\.)/.test(normalized);
+}
+function computeSeverity(input) {
+  if (input.actualFiles.length === 0) {
+    input.reasons.push("no_actual_files_observed");
+    return "healthy";
+  }
+  if (input.plannedFiles.length === 0) {
+    input.reasons.push("actual_files_without_planned_scope");
+    return "high";
+  }
+  if (input.leakedFiles.some(isHighRiskScopePath)) {
+    input.reasons.push("high_risk_scope_leak");
+    return "high";
+  }
+  if (input.leakedFiles.length > 0) {
+    input.reasons.push("scope_leak_detected");
+    return "medium";
+  }
+  if (input.missingFiles.length > 0) {
+    input.reasons.push("planned_files_not_observed");
+    return "low";
+  }
+  input.reasons.push("scope_healthy");
+  return "healthy";
+}
+function buildTeamScopeHealth(input) {
+  const plannedFiles = uniqueSorted2(input.plannedFiles);
+  const plannedSet = new Set(plannedFiles);
+  const selected = selectActualFiles(input);
+  const actualFiles = selected.actualFiles;
+  const actualSet = new Set(actualFiles);
+  const coveredFiles = actualFiles.filter((file) => plannedSet.has(file));
+  const leakedFiles = actualFiles.filter((file) => !plannedSet.has(file));
+  const missingFiles = plannedFiles.filter((file) => !actualSet.has(file));
+  const reasons = [selected.reason];
+  const severity = computeSeverity({ plannedFiles, actualFiles, leakedFiles, missingFiles, reasons });
+  return {
+    schemaVersion: 1,
+    sourceKind: input.sourceKind,
+    sourceKey: input.sourceKey,
+    sessionId: input.sessionId,
+    objectiveHash: input.objectiveHash,
+    plannedFiles,
+    actualFiles,
+    coveredFiles,
+    leakedFiles,
+    missingFiles,
+    changedFilesSource: selected.source,
+    scopeLeakRate: actualFiles.length === 0 ? 0 : leakedFiles.length / actualFiles.length,
+    coverageRate: plannedFiles.length === 0 ? 0 : coveredFiles.length / plannedFiles.length,
+    severity,
+    reasons: uniqueSorted2(reasons),
+    timestamp: input.timestamp
+  };
+}
+function buildTeamWaveScopeHealth(event, options = {}) {
+  return buildTeamScopeHealth({
+    sourceKind: "team_wave",
+    sourceKey: teamWaveTelemetryKind(event),
+    sessionId: event.sessionId,
+    objectiveHash: event.objectiveHash,
+    plannedFiles: event.planned.files,
+    reportedChangedFiles: event.changedFiles.reportedChangedFiles,
+    observedChangedFiles: event.changedFiles.observedChangedFiles,
+    changedFilesSource: event.changedFiles.changedFilesSource,
+    timestamp: options.timestamp ?? event.timestamp
+  });
+}
+function buildTeamEpisodeScopeHealth(episode, options = {}) {
+  return buildTeamScopeHealth({
+    sourceKind: "team_episode",
+    sourceKey: episode.episodeKey,
+    sessionId: episode.sessionId,
+    objectiveHash: episode.objectiveHash,
+    plannedFiles: episode.planned.files,
+    reportedChangedFiles: episode.changedFiles.reportedChangedFiles,
+    observedChangedFiles: episode.changedFiles.observedChangedFiles,
+    changedFilesSource: episode.changedFiles.changedFilesSource,
+    timestamp: options.timestamp ?? episode.timestamp
+  });
+}
+function teamScopeHealthPersistKind(event) {
+  const sourceSeed = `${event.sourceKey}:${event.actualFiles.join("|")}:${event.plannedFiles.join("|")}`;
+  return `team_scope_health:${event.objectiveHash}:${event.sessionId}:${event.sourceKind}:${event.timestamp}:${shortHash(sourceSeed)}`;
+}
+function persistTeamScopeHealth(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(teamScopeHealthPersistKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+
+// src/agent/team-reward.ts
+init_esm_shims();
+
+// src/agent/routing-reward.ts
+init_esm_shims();
+var REVIEW_PASS_WEIGHT = 0.3;
+var VERIFICATION_PASS_WEIGHT = 0.3;
+var COST_OVER_BUDGET_WEIGHT = 0.1;
+var LATENCY_SURPRISAL_WEIGHT = 0.1;
+var FALSE_GREEN_WEIGHT = 0.6;
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(max, Math.max(min, value));
+}
+function scoreOptionalBoolean(value) {
+  return value === true ? 1 : 0;
+}
+function scorePenaltyFlag(value) {
+  return value === true ? 1 : 0;
+}
+function normalizeUnitPenalty(value) {
+  return clamp(value ?? 0, 0, 1);
+}
+function computeRoutingReward(input) {
+  const reviewPass = scoreOptionalBoolean(input.reviewPass);
+  const verificationPass = scoreOptionalBoolean(input.verificationPass);
+  const normalizedCostOverBudget = normalizeUnitPenalty(input.normalizedCostOverBudget);
+  const normalizedLatencySurprisal = normalizeUnitPenalty(input.normalizedLatencySurprisal);
+  const falseGreen = scorePenaltyFlag(input.falseGreen);
+  const reward = REVIEW_PASS_WEIGHT * reviewPass + VERIFICATION_PASS_WEIGHT * verificationPass - COST_OVER_BUDGET_WEIGHT * normalizedCostOverBudget - LATENCY_SURPRISAL_WEIGHT * normalizedLatencySurprisal - FALSE_GREEN_WEIGHT * falseGreen;
+  return clamp(reward, -1, 1);
+}
+function buildRoutingRewardRecord(input) {
+  const normalizedCostOverBudget = normalizeUnitPenalty(input.normalizedCostOverBudget);
+  const normalizedLatencySurprisal = normalizeUnitPenalty(input.normalizedLatencySurprisal);
+  const components = {
+    currentModel: input.currentModel,
+    hasRecommendedModel: input.recommendedModel !== void 0,
+    modelMatched: input.recommendedModel !== void 0 && input.currentModel === input.recommendedModel,
+    reviewObserved: input.reviewPass !== void 0,
+    reviewPass: scoreOptionalBoolean(input.reviewPass),
+    verificationObserved: input.verificationPass !== void 0,
+    verificationPass: scoreOptionalBoolean(input.verificationPass),
+    falseGreen: input.falseGreen === true,
+    normalizedCostOverBudget,
+    normalizedLatencySurprisal
+  };
+  if (input.recommendedModel !== void 0) components.recommendedModel = input.recommendedModel;
+  return {
+    schemaVersion: 1,
+    reward: computeRoutingReward({
+      ...input,
+      normalizedCostOverBudget,
+      normalizedLatencySurprisal
+    }),
+    components
+  };
+}
+
+// src/agent/team-reward.ts
+var REVIEW_PASS_WEIGHT2 = 0.3;
+var VERIFICATION_PASS_WEIGHT2 = 0.3;
+var CONFLICT_WEIGHT = 0.15;
+var REWORK_WEIGHT = 0.15;
+var SCOPE_LEAK_WEIGHT = 0.15;
+var COST_OVER_BUDGET_WEIGHT2 = 0.1;
+var LATENCY_SURPRISAL_WEIGHT2 = 0.1;
+var FALSE_GREEN_WEIGHT2 = 0.6;
+function clampReward(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(-1, value));
+}
+function scoreOptionalBoolean2(value) {
+  return value === true ? 1 : 0;
+}
+function normalizeReviewVerdict(verdict) {
+  if (!verdict) return void 0;
+  const normalized = verdict.trim().toLowerCase().replace(/[\s_-]+/g, "-");
+  if (!normalized) return void 0;
+  if (["pass", "passed", "verified", "approve", "approved", "ok", "clean", "green", "no-findings"].includes(normalized)) return true;
+  if (["fail", "failed", "rejected", "reject", "blocked", "changes-requested", "red"].includes(normalized)) return false;
+  return void 0;
+}
+function denominator(event) {
+  return Math.max(event.outcome.dispatched, event.outcome.statuses.length, 1);
+}
+function normalizeScopeLeak(event) {
+  return buildTeamWaveScopeHealth(event).scopeLeakRate;
+}
+function hasFalseGreen(event, reviewPass) {
+  const statuses = event.outcome.statuses;
+  const hasPassedWithoutVerifiedEvidence = statuses.some(
+    (status) => status.status === "passed" && status.evidenceStatus !== "verified"
+  );
+  const allPassed = statuses.length > 0 && statuses.every((status) => status.status === "passed");
+  return hasPassedWithoutVerifiedEvidence || allPassed && event.outcome.verificationPassed === false || allPassed && reviewPass === false;
+}
+function computeTeamWaveReward(input) {
+  const reviewPass = scoreOptionalBoolean2(input.reviewPass);
+  const verificationPass = scoreOptionalBoolean2(input.verificationPass);
+  const normalizedConflict = normalizeUnitPenalty(input.normalizedConflict);
+  const normalizedRework = normalizeUnitPenalty(input.normalizedRework);
+  const normalizedScopeLeak = normalizeUnitPenalty(input.normalizedScopeLeak);
+  const normalizedCostOverBudget = normalizeUnitPenalty(input.normalizedCostOverBudget);
+  const normalizedLatencySurprisal = normalizeUnitPenalty(input.normalizedLatencySurprisal);
+  const falseGreen = input.falseGreen ? 1 : 0;
+  const reward = REVIEW_PASS_WEIGHT2 * reviewPass + VERIFICATION_PASS_WEIGHT2 * verificationPass - CONFLICT_WEIGHT * normalizedConflict - REWORK_WEIGHT * normalizedRework - SCOPE_LEAK_WEIGHT * normalizedScopeLeak - COST_OVER_BUDGET_WEIGHT2 * normalizedCostOverBudget - LATENCY_SURPRISAL_WEIGHT2 * normalizedLatencySurprisal - FALSE_GREEN_WEIGHT2 * falseGreen;
+  return clampReward(reward);
+}
+function deriveTeamWaveRewardInput(event) {
+  const denom = denominator(event);
+  const reviewPass = normalizeReviewVerdict(event.outcome.reviewVerdict);
+  const blockedOrEscalated = event.outcome.statuses.filter(
+    (status) => status.status === "blocked" || status.status === "escalated"
+  ).length;
+  const failedOrFailedEvidence = event.outcome.statuses.filter(
+    (status) => status.status === "failed" || status.evidenceStatus === "failed"
+  ).length;
+  return {
+    verificationPass: event.outcome.verificationPassed,
+    reviewPass,
+    normalizedConflict: normalizeUnitPenalty(blockedOrEscalated / denom),
+    normalizedRework: normalizeUnitPenalty(failedOrFailedEvidence / denom),
+    normalizedScopeLeak: normalizeScopeLeak(event),
+    // P1 has no cost/latency telemetry in TeamWaveTelemetry yet. Missing facts
+    // are neutral rather than guessed.
+    normalizedCostOverBudget: 0,
+    normalizedLatencySurprisal: 0,
+    falseGreen: hasFalseGreen(event, reviewPass)
+  };
+}
+function buildTeamWaveRewardRecord(input) {
+  const normalizedConflict = normalizeUnitPenalty(input.normalizedConflict);
+  const normalizedRework = normalizeUnitPenalty(input.normalizedRework);
+  const normalizedScopeLeak = normalizeUnitPenalty(input.normalizedScopeLeak);
+  const normalizedCostOverBudget = normalizeUnitPenalty(input.normalizedCostOverBudget);
+  const normalizedLatencySurprisal = normalizeUnitPenalty(input.normalizedLatencySurprisal);
+  return {
+    schemaVersion: 1,
+    reward: computeTeamWaveReward({
+      ...input,
+      normalizedConflict,
+      normalizedRework,
+      normalizedScopeLeak,
+      normalizedCostOverBudget,
+      normalizedLatencySurprisal
+    }),
+    components: {
+      reviewObserved: input.reviewPass !== void 0,
+      reviewPass: scoreOptionalBoolean2(input.reviewPass),
+      verificationObserved: input.verificationPass !== void 0,
+      verificationPass: scoreOptionalBoolean2(input.verificationPass),
+      normalizedConflict,
+      normalizedRework,
+      normalizedScopeLeak,
+      normalizedCostOverBudget,
+      normalizedLatencySurprisal,
+      falseGreen: input.falseGreen
+    }
+  };
+}
+
+// src/agent/team-episode.ts
+init_esm_shims();
+import { createHash as createHash3 } from "crypto";
+function teamEpisodeKey(input) {
+  return `team_episode:${input.objectiveHash}:${input.sessionId}:${input.mode}:${input.waveCount}`;
+}
+function shortHash2(input) {
+  return createHash3("sha256").update(input).digest("hex").slice(0, 8);
+}
+function teamEpisodePersistKind(episode) {
+  const sourceSeed = episode.fragments.map((fragment) => fragment.sourceKey).join("|");
+  return `${episode.episodeKey}:${episode.timestamp}:${shortHash2(sourceSeed)}`;
+}
+function uniqueSorted3(values) {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+function riskRank(risk) {
+  return risk === "high" ? 2 : risk === "medium" ? 1 : 0;
+}
+function maxRisk(values) {
+  return values.reduce((max, value) => riskRank(value) > riskRank(max) ? value : max, "low");
+}
+function duplicateIndexes(indexes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const index of indexes) counts.set(index, (counts.get(index) ?? 0) + 1);
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([index]) => index).sort((a, b) => a - b);
+}
+function missingIndexes(indexes, waveCount) {
+  const observed = new Set(indexes);
+  const missing = [];
+  for (let index = 0; index < waveCount; index++) {
+    if (!observed.has(index)) missing.push(index);
+  }
+  return missing;
+}
+function aggregateVerification(values) {
+  if (values.some((value) => value === false)) return false;
+  const observed = values.filter((value) => value !== void 0);
+  if (observed.length > 0 && observed.length === values.length && observed.every(Boolean)) return true;
+  return void 0;
+}
+function normalizeReviewVerdict2(verdict) {
+  if (!verdict) return void 0;
+  const normalized = verdict.trim().toLowerCase().replace(/[\s_-]+/g, "-");
+  if (!normalized) return void 0;
+  if (["pass", "passed", "verified", "approve", "approved", "ok", "clean", "green", "no-findings"].includes(normalized)) return true;
+  if (["fail", "failed", "rejected", "reject", "blocked", "changes-requested", "red"].includes(normalized)) return false;
+  return void 0;
+}
+function aggregateReviewVerdict(values) {
+  const normalized = values.map(normalizeReviewVerdict2);
+  if (normalized.some((value) => value === false)) return { pass: false, verdict: "fail" };
+  const observed = normalized.filter((value) => value !== void 0);
+  if (observed.length > 0 && observed.length === values.length && observed.every(Boolean)) return { pass: true, verdict: "pass" };
+  return {};
+}
+function aggregateChangedFilesSource(sources) {
+  const unique = uniqueSorted3(sources);
+  if (unique.length === 0) return "unknown";
+  if (unique.length === 1) return unique[0];
+  return "mixed";
+}
+function buildTeamEpisode(fragments, options = {}) {
+  if (fragments.length === 0) throw new Error("buildTeamEpisode requires at least one fragment");
+  const first = fragments[0];
+  const mismatchReasons = [];
+  for (const fragment of fragments) {
+    if (fragment.sessionId !== first.sessionId) mismatchReasons.push(`sessionId mismatch: ${fragment.sessionId}`);
+    if (fragment.objectiveHash !== first.objectiveHash) mismatchReasons.push(`objectiveHash mismatch: ${fragment.objectiveHash}`);
+    if (fragment.mode !== first.mode) mismatchReasons.push(`mode mismatch: ${fragment.mode}`);
+    if (fragment.waveCount !== first.waveCount) mismatchReasons.push(`waveCount mismatch: ${fragment.waveCount}`);
+  }
+  const ordered = [...fragments].sort((a, b) => a.fromWave - b.fromWave || a.timestamp - b.timestamp);
+  const observedWaveIndexes = uniqueSorted3(ordered.map((fragment) => String(fragment.fromWave))).map(Number).sort((a, b) => a - b);
+  const duplicateWaveIndexes = duplicateIndexes(ordered.map((fragment) => fragment.fromWave));
+  const missingWaveIndexes = missingIndexes(observedWaveIndexes, first.waveCount);
+  const complete = mismatchReasons.length === 0 && duplicateWaveIndexes.length === 0 && missingWaveIndexes.length === 0 && observedWaveIndexes.length === first.waveCount;
+  const review = aggregateReviewVerdict(ordered.map((fragment) => fragment.outcome.reviewVerdict));
+  const observedChangedFiles = uniqueSorted3(ordered.flatMap((fragment) => fragment.changedFiles.observedChangedFiles ?? []));
+  const reportedChangedFiles = uniqueSorted3(ordered.flatMap((fragment) => fragment.changedFiles.reportedChangedFiles ?? []));
+  const episode = {
+    schemaVersion: 1,
+    sessionId: first.sessionId,
+    objectiveHash: first.objectiveHash,
+    mode: first.mode,
+    episodeKey: teamEpisodeKey({ objectiveHash: first.objectiveHash, sessionId: first.sessionId, mode: first.mode, waveCount: first.waveCount }),
+    complete,
+    waveCount: first.waveCount,
+    observedWaveIndexes,
+    missingWaveIndexes,
+    duplicateWaveIndexes,
+    fragments: ordered.map((telemetry) => ({ sourceKey: teamWaveTelemetryKind(telemetry), telemetry })),
+    planned: {
+      taskIds: uniqueSorted3(ordered.flatMap((fragment) => fragment.planned.taskIds)),
+      files: uniqueSorted3(ordered.flatMap((fragment) => fragment.planned.files)),
+      profiles: uniqueSorted3(ordered.flatMap((fragment) => fragment.planned.profiles)),
+      authorities: uniqueSorted3(ordered.flatMap((fragment) => fragment.planned.authorities)),
+      maxRisk: maxRisk(ordered.map((fragment) => fragment.planned.risk))
+    },
+    outcome: {
+      dispatched: ordered.reduce((sum, fragment) => sum + fragment.outcome.dispatched, 0),
+      statuses: ordered.flatMap((fragment) => fragment.outcome.statuses.map((status) => ({ ...status }))),
+      ...aggregateVerification(ordered.map((fragment) => fragment.outcome.verificationPassed)) === void 0 ? {} : { verificationPassed: aggregateVerification(ordered.map((fragment) => fragment.outcome.verificationPassed)) },
+      ...review.verdict ? { reviewVerdict: review.verdict } : {}
+    },
+    changedFiles: {
+      ...reportedChangedFiles.length > 0 ? { reportedChangedFiles } : {},
+      ...observedChangedFiles.length > 0 ? { observedChangedFiles } : {},
+      changedFilesSource: aggregateChangedFilesSource(ordered.map((fragment) => fragment.changedFiles.changedFilesSource))
+    },
+    mismatchReasons: uniqueSorted3(mismatchReasons),
+    timestamp: options.timestamp ?? Math.max(...ordered.map((fragment) => fragment.timestamp))
+  };
+  return episode;
+}
+function deriveTeamEpisodeRewardInput(episode) {
+  if (!episode.complete) return null;
+  const denom = Math.max(episode.outcome.dispatched, episode.outcome.statuses.length, 1);
+  const blockedOrEscalated = episode.outcome.statuses.filter(
+    (status) => status.status === "blocked" || status.status === "escalated"
+  ).length;
+  const failedOrFailedEvidence = episode.outcome.statuses.filter(
+    (status) => status.status === "failed" || status.evidenceStatus === "failed"
+  ).length;
+  const review = normalizeReviewVerdict2(episode.outcome.reviewVerdict);
+  const waveInputs = episode.fragments.map((fragment) => deriveTeamWaveRewardInput(fragment.telemetry));
+  return {
+    verificationPass: episode.outcome.verificationPassed,
+    reviewPass: review,
+    normalizedConflict: normalizeUnitPenalty(blockedOrEscalated / denom),
+    normalizedRework: normalizeUnitPenalty(failedOrFailedEvidence / denom),
+    normalizedScopeLeak: buildTeamEpisodeScopeHealth(episode).scopeLeakRate,
+    normalizedCostOverBudget: 0,
+    normalizedLatencySurprisal: 0,
+    falseGreen: waveInputs.some((input) => input.falseGreen)
+  };
+}
+function filesTouchedByMultipleWaves(episode) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const fragment of episode.fragments) {
+    const files = fragment.telemetry.changedFiles.observedChangedFiles ?? fragment.telemetry.changedFiles.reportedChangedFiles ?? [];
+    for (const file of new Set(files.filter(Boolean))) counts.set(file, (counts.get(file) ?? 0) + 1);
+  }
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([file]) => file).sort();
+}
+function formatTeamDelivery(episode) {
+  const lines = [];
+  lines.push(
+    `\u56E2\u961F\u4EA4\u4ED8\u7EFC\u5408 \u2014 ${episode.observedWaveIndexes.length}/${episode.waveCount} \u6CE2\uFF0C${episode.outcome.dispatched} \u4E2A worker${episode.complete ? "" : "\uFF08\u672A\u5B8C\u6210\uFF09"}`
+  );
+  for (const fragment of episode.fragments) {
+    const t = fragment.telemetry;
+    const statuses = t.outcome.statuses;
+    const ok = statuses.filter((s) => s.status === "passed" || s.status === "completed").length;
+    const total = statuses.length || t.planned.taskIds.length;
+    const ids = t.planned.taskIds.join(", ") || "\u2014";
+    lines.push(`  \u6CE2 ${t.fromWave + 1}\uFF1A${ids}\uFF08${ok}/${total} \u901A\u8FC7\uFF09`);
+  }
+  const changed = episode.changedFiles.observedChangedFiles ?? episode.changedFiles.reportedChangedFiles ?? [];
+  lines.push(`\u6539\u52A8\u6587\u4EF6\uFF08${changed.length}\uFF09\uFF1A${changed.length > 0 ? changed.join(", ") : "\u65E0"}`);
+  const conflicts = filesTouchedByMultipleWaves(episode);
+  if (conflicts.length > 0) {
+    lines.push(`\u26A0 \u591A\u6CE2\u89E6\u78B0\u7684\u6587\u4EF6\uFF08\u8BF7\u5BA1\u67E5\u51B2\u7A81\uFF09\uFF1A${conflicts.join(", ")}`);
+  }
+  const verification = episode.outcome.verificationPassed;
+  const verdict = episode.outcome.reviewVerdict ?? (verification === true ? "verified" : verification === false ? "verification-failed" : "no-verdict");
+  const verifNote = verification !== void 0 ? ` verification=${verification ? "pass" : "fail"}` : "";
+  lines.push(`\u603B\u4F53\uFF1Areview=${verdict}${verifNote}`);
+  return lines.join("\n");
+}
+function persistTeamEpisode(store, episode) {
+  if (!store) return;
+  try {
+    store.saveBanditState(teamEpisodePersistKind(episode), JSON.stringify(episode));
+  } catch {
+  }
+}
+
+// src/agent/worker-episode.ts
+init_esm_shims();
+import { createHash as createHash4 } from "crypto";
+function hashObjective(objective) {
+  return createHash4("sha256").update(objective).digest("hex").slice(0, 12);
+}
+function workerEpisodeKey(episode) {
+  return `worker_episode:${episode.sessionId}:${episode.orderId.replace(/:/g, "-")}:${episode.timestamp}`;
+}
+function buildWorkerEpisode(input) {
+  const { order, result, writeGate } = input;
+  const exhausted = result.failureReason === "timeout" || result.failureReason === "max_turns";
+  return {
+    schemaVersion: 1,
+    orderId: order.id,
+    sessionId: input.sessionId,
+    objectiveHash: hashObjective(order.objective),
+    model: input.model,
+    ...order.profile ? { profile: order.profile } : {},
+    role: input.role,
+    scopeFileCount: order.scope.files?.length ?? 0,
+    changedFileCount: result.changedFiles.length,
+    status: result.status,
+    ...result.evidenceStatus ? { evidenceStatus: result.evidenceStatus } : {},
+    gateOutcome: writeGate?.report.outcome ?? "not-run",
+    falseGreen: writeGate?.report.falseGreen === true,
+    repairCount: writeGate?.repairCount ?? 0,
+    timestamp: input.timestamp ?? Date.now(),
+    ...input.actuals?.toolUses !== void 0 ? { actualToolUses: input.actuals.toolUses } : {},
+    ...input.actuals?.durationMs !== void 0 ? { durationMs: input.actuals.durationMs } : {},
+    ...exhausted ? { exhausted: true } : {},
+    ...result.failureReason ? { failureReason: result.failureReason } : {},
+    ...input.actuals?.usage && (input.actuals.usage.input > 0 || input.actuals.usage.output > 0) ? { usage: input.actuals.usage } : {},
+    ...input.actuals?.budget ? { budget: input.actuals.budget } : {}
+  };
+}
+function persistWorkerEpisode(store, episode) {
+  if (!store) return;
+  try {
+    store.saveBanditState(workerEpisodeKey(episode), JSON.stringify(episode));
+  } catch {
+  }
+}
+function workerActualKey(objectiveHash, timestamp) {
+  return `worker_actual:${objectiveHash}:${timestamp}`;
+}
+function persistWorkerActualIndex(store, objectiveHash, row) {
+  if (!store) return;
+  try {
+    store.saveBanditState(workerActualKey(objectiveHash, Date.now()), JSON.stringify(row));
+  } catch {
+  }
+}
+function deriveWorkerEpisodeRewardInput(episode) {
+  if (episode.gateOutcome === "blocked") return null;
+  const base = { currentModel: episode.model };
+  if (episode.gateOutcome === "passed") return { ...base, verificationPass: true };
+  if (episode.gateOutcome === "failed") {
+    return { ...base, verificationPass: false, ...episode.falseGreen ? { falseGreen: true } : {} };
+  }
+  return base;
+}
+
+// src/agent/reward-loop.ts
+init_esm_shims();
+import { createHash as createHash6 } from "crypto";
+
+// src/agent/model-routing-shadow.ts
+init_esm_shims();
+import { createHash as createHash5 } from "crypto";
+
+// src/model/task-inferrer.ts
+init_esm_shims();
+function inferTaskType(recentCalls) {
+  if (recentCalls.length === 0) return null;
+  const names = recentCalls.map((c) => c.name);
+  const editCount = names.filter((n) => n === "edit_file" || n === "write_file").length;
+  const testCount = names.filter((n) => n === "run_tests" || n === "bash").length;
+  const searchCount = names.filter((n) => n === "grep" || n === "glob" || n === "read_file").length;
+  const hasTestFailure = recentCalls.some((c) => (c.name === "run_tests" || c.name === "bash") && c.isError);
+  if (testCount > 0 && hasTestFailure) {
+    return { task: "test_failure_diagnosis", reason: "test failure detected, diagnosis mode recommended" };
+  }
+  if (editCount >= 2 && testCount > 0) {
+    return { task: "risky_refactor", reason: "multi-file edit with verification, refactor-capable model recommended" };
+  }
+  if (editCount > 0) {
+    return { task: "code_edit", reason: "file modification, edit-capable model recommended" };
+  }
+  if (searchCount >= 3 && editCount === 0) {
+    return { task: "repo_summarization", reason: "code exploration, context-capable model recommended" };
+  }
+  return null;
+}
+
+// src/agent/model-routing-shadow.ts
+function hashObjective2(input) {
+  return createHash5("sha256").update(input).digest("hex").slice(0, 16);
+}
+function routingShadowKind(event) {
+  return `routing_shadow:${event.sessionId}:${event.turn}:${event.timestamp}`;
+}
+function inferLegacyRoutingRecommendation(recentCalls, modelCards) {
+  if (!modelCards || modelCards.length === 0) return null;
+  const inference = inferTaskType(recentCalls);
+  if (!inference) return null;
+  try {
+    const recommended = recommendModelForTask(inference.task, modelCards);
+    return {
+      task: inference.task,
+      model: recommended.model,
+      reason: inference.reason
+    };
+  } catch {
+    return null;
+  }
+}
+function buildModelRoutingShadowEvent(input) {
+  const legacyReason = input.legacyRouting ? `${input.legacyRouting.task} \xB7 ${input.legacyRouting.model} ${input.legacyRouting.reason}` : "legacy router produced no recommendation";
+  return {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    turn: input.turn,
+    objectiveHash: hashObjective2(input.objective),
+    currentModel: input.currentModel,
+    selectedBy: input.selectedBy ?? "config",
+    ...input.legacyRouting ? { legacyRouterRecommendedModel: input.legacyRouting.model } : {},
+    ...input.efeRecommendedModel ? { efeRecommendedModel: input.efeRecommendedModel } : {},
+    ...input.verificationOutcome ? { verificationOutcome: input.verificationOutcome } : {},
+    sensorium: {
+      complexity: input.sensorium.complexity,
+      pressure: input.sensorium.pressure,
+      confidence: input.sensorium.confidence,
+      stability: input.sensorium.stability
+    },
+    reason: input.reason ?? legacyReason,
+    timestamp: input.timestamp ?? Date.now()
+  };
+}
+function persistModelRoutingShadow(store, event) {
+  if (!store) return;
+  try {
+    store.saveBanditState(routingShadowKind(event), JSON.stringify(event));
+  } catch {
+  }
+}
+
+// src/agent/reward-loop.ts
+var MAX_TRACKED_SESSIONS = 512;
+var lastTimestampBySession = /* @__PURE__ */ new Map();
+function shortHash3(input) {
+  return createHash6("sha256").update(input).digest("hex").slice(0, 8);
+}
+function resolveRewardClosureTimestamp(sessionId, explicitTimestamp) {
+  const last = lastTimestampBySession.get(sessionId) ?? 0;
+  let next;
+  if (explicitTimestamp !== void 0) {
+    next = explicitTimestamp;
+    lastTimestampBySession.set(sessionId, Math.max(last, explicitTimestamp));
+  } else {
+    const now = Date.now();
+    next = now > last ? now : last + 1;
+    lastTimestampBySession.set(sessionId, next);
+  }
+  if (lastTimestampBySession.size > MAX_TRACKED_SESSIONS) {
+    const oldest = lastTimestampBySession.keys().next().value;
+    if (oldest !== void 0) lastTimestampBySession.delete(oldest);
+  }
+  return next;
+}
+function rewardClosureHashSeed(record) {
+  return `${record.sourceKind}:${record.sourceKey}:${record.timestamp}`;
+}
+function rewardClosureKind(record) {
+  return `reward_closure:${record.sourceKind}:${record.sessionId}:${record.timestamp}:${shortHash3(rewardClosureHashSeed(record))}`;
+}
+function buildRewardClosureRecord(input) {
+  const timestamp = resolveRewardClosureTimestamp(input.sessionId, input.timestamp);
+  const id = `${input.sourceKind}:${input.sourceKey}:${timestamp}:${shortHash3(`${input.sourceKind}:${input.sourceKey}:${timestamp}`)}`;
+  return {
+    schemaVersion: 1,
+    id,
+    sourceKind: input.sourceKind,
+    sourceKey: input.sourceKey,
+    ...input.objectiveHash ? { objectiveHash: input.objectiveHash } : {},
+    sessionId: input.sessionId,
+    reward: input.reward,
+    components: input.components,
+    timestamp
+  };
+}
+function routingRewardInputFromEvent(event) {
+  return {
+    currentModel: event.currentModel,
+    recommendedModel: event.efeRecommendedModel ?? event.legacyRouterRecommendedModel,
+    // W4-D2: main-loop verification outcome flows into the shadow reward.
+    // 'blocked' stays undefined — environment-neutral, never a capability signal.
+    ...event.verificationOutcome === "passed" ? { verificationPass: true } : {},
+    ...event.verificationOutcome === "failed" ? { verificationPass: false } : {},
+    normalizedCostOverBudget: 0,
+    normalizedLatencySurprisal: 0
+  };
+}
+function buildRewardClosureRecordFromRoutingShadow(event, options) {
+  const rewardInput = routingRewardInputFromEvent(event);
+  const rewardRecord = buildRoutingRewardRecord(rewardInput);
+  return buildRewardClosureRecord({
+    sourceKind: "routing_shadow",
+    sourceKey: routingShadowKind(event),
+    objectiveHash: event.objectiveHash,
+    sessionId: event.sessionId,
+    reward: rewardRecord.reward,
+    components: {
+      ...rewardRecord.components,
+      turn: event.turn,
+      selectedBy: event.selectedBy,
+      sensoriumComplexity: event.sensorium.complexity,
+      sensoriumPressure: event.sensorium.pressure,
+      sensoriumConfidence: event.sensorium.confidence,
+      sensoriumStability: event.sensorium.stability
+    },
+    timestamp: options?.timestamp
+  });
+}
+function buildRewardClosureRecordFromTeamWave(event, options) {
+  const rewardInput = deriveTeamWaveRewardInput(event);
+  const rewardRecord = buildTeamWaveRewardRecord(rewardInput);
+  return buildRewardClosureRecord({
+    sourceKind: "team_wave",
+    sourceKey: teamWaveTelemetryKind(event),
+    objectiveHash: event.objectiveHash,
+    sessionId: event.sessionId,
+    reward: rewardRecord.reward,
+    components: {
+      ...rewardRecord.components,
+      mode: event.mode,
+      fromWave: event.fromWave,
+      waveId: event.waveId,
+      waveCount: event.waveCount,
+      dispatched: event.outcome.dispatched,
+      ...event.outcome.reviewVerdict ? { reviewVerdict: event.outcome.reviewVerdict } : {},
+      changedFilesSource: event.changedFiles.changedFilesSource,
+      workerModelCount: event.workerModels?.length ?? 0,
+      tierShadowCount: event.workerModelTierShadows?.length ?? 0,
+      tierShadowMatchedCount: event.workerModelTierShadows?.filter((shadow) => shadow.matched).length ?? 0,
+      ...event.workerModels?.length === 1 ? { workerModel: event.workerModels[0].model } : {}
+    },
+    timestamp: options?.timestamp
+  });
+}
+function buildRewardClosureRecordFromTeamEpisode(episode, options) {
+  const rewardInput = deriveTeamEpisodeRewardInput(episode);
+  if (!rewardInput) return null;
+  const rewardRecord = buildTeamWaveRewardRecord(rewardInput);
+  return buildRewardClosureRecord({
+    sourceKind: "team_episode",
+    sourceKey: teamEpisodeKey(episode),
+    objectiveHash: episode.objectiveHash,
+    sessionId: episode.sessionId,
+    reward: rewardRecord.reward,
+    components: {
+      ...rewardRecord.components,
+      mode: episode.mode,
+      waveCount: episode.waveCount,
+      observedWaveCount: episode.observedWaveIndexes.length,
+      dispatched: episode.outcome.dispatched,
+      ...episode.outcome.reviewVerdict ? { reviewVerdict: episode.outcome.reviewVerdict } : {},
+      changedFilesSource: episode.changedFiles.changedFilesSource,
+      fragmentCount: episode.fragments.length,
+      maxRisk: episode.planned.maxRisk
+    },
+    timestamp: options?.timestamp
+  });
+}
+function buildRewardClosureRecordFromWorkerEpisode(episode, options) {
+  const rewardInput = deriveWorkerEpisodeRewardInput(episode);
+  if (!rewardInput) return null;
+  const rewardRecord = buildRoutingRewardRecord(rewardInput);
+  return buildRewardClosureRecord({
+    sourceKind: "worker_episode",
+    sourceKey: workerEpisodeKey(episode),
+    objectiveHash: episode.objectiveHash,
+    sessionId: episode.sessionId,
+    reward: rewardRecord.reward,
+    components: {
+      ...rewardRecord.components,
+      workerModel: episode.model,
+      orderId: episode.orderId,
+      role: episode.role,
+      ...episode.profile ? { profile: episode.profile } : {},
+      status: episode.status,
+      gateOutcome: episode.gateOutcome,
+      repairCount: episode.repairCount,
+      changedFileCount: episode.changedFileCount
+    },
+    timestamp: options?.timestamp
+  });
+}
+function persistRewardClosure(store, record) {
+  if (!store) return;
+  try {
+    store.saveBanditState(rewardClosureKind(record), JSON.stringify(record));
+  } catch {
+  }
+}
+function recordRoutingRewardClosure(store, event, options) {
+  const record = buildRewardClosureRecordFromRoutingShadow(event, options);
+  persistRewardClosure(store, record);
+  return record;
+}
+function recordTeamWaveRewardClosure(store, event, options) {
+  const record = buildRewardClosureRecordFromTeamWave(event, options);
+  persistRewardClosure(store, record);
+  return record;
+}
+function recordWorkerEpisodeClosure(store, episode, options) {
+  persistWorkerEpisode(store, episode);
+  const record = buildRewardClosureRecordFromWorkerEpisode(episode, options);
+  if (!record) return null;
+  persistRewardClosure(store, record);
+  return record;
+}
+function recordTeamEpisodeRewardClosure(store, episode, options) {
+  const record = buildRewardClosureRecordFromTeamEpisode(episode, options);
+  if (!record) return null;
+  persistRewardClosure(store, record);
+  return record;
+}
+function parseWaveFragment(json) {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed?.schemaVersion !== 1 || typeof parsed.fromWave !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function buildTeamEpisodeFromStore(store, lastFragment) {
+  const byWave = /* @__PURE__ */ new Map();
+  if (store?.loadBanditStatesByPrefix) {
+    const prefix = `team_wave:${lastFragment.objectiveHash}:${lastFragment.sessionId}:`;
+    try {
+      for (const row of store.loadBanditStatesByPrefix(prefix, 200)) {
+        const fragment = parseWaveFragment(row.json);
+        if (!fragment) continue;
+        if (fragment.mode !== lastFragment.mode || fragment.waveCount !== lastFragment.waveCount) continue;
+        const existing = byWave.get(fragment.fromWave);
+        if (!existing || fragment.timestamp > existing.timestamp) byWave.set(fragment.fromWave, fragment);
+      }
+    } catch {
+    }
+  }
+  byWave.set(lastFragment.fromWave, lastFragment);
+  return buildTeamEpisode([...byWave.values()]);
+}
+function recordTeamEpisodeClosureFromStore(store, lastFragment) {
+  const episode = buildTeamEpisodeFromStore(store, lastFragment);
+  const persistStore = store?.saveBanditState ? { saveBanditState: store.saveBanditState.bind(store) } : null;
+  persistTeamEpisode(persistStore, episode);
+  return recordTeamEpisodeRewardClosure(persistStore, episode);
+}
+
+export {
+  recommendModelForTask,
+  buildModelCards,
+  LinUCBBandit,
+  inferTaskType,
+  extractRequiredSkills,
+  recordSkillInvoked,
+  getInvokedSkills,
+  clearSkillGate,
+  isSkillGateEnabled,
+  evaluateSkillGate,
+  formatSkillGateBlock,
+  buildGatedInfluenceAuditEvent,
+  persistGatedInfluenceAudit,
+  inferLegacyRoutingRecommendation,
+  buildModelRoutingShadowEvent,
+  persistModelRoutingShadow,
+  hashTeamObjective,
+  buildTeamWaveTelemetry,
+  persistTeamWaveTelemetry,
+  buildTeamWaveScopeHealth,
+  persistTeamScopeHealth,
+  computeTeamWaveReward,
+  deriveTeamWaveRewardInput,
+  formatTeamDelivery,
+  hashObjective,
+  buildWorkerEpisode,
+  persistWorkerActualIndex,
+  recordRoutingRewardClosure,
+  recordTeamWaveRewardClosure,
+  recordWorkerEpisodeClosure,
+  buildTeamEpisodeFromStore,
+  recordTeamEpisodeClosureFromStore
+};