tianshu-harness 3.23.0

package/dist/chunk-LA6IPTGH.js

@@ -0,0 +1,709 @@
+#!/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 {
+  runTypecheckShared
+} from "./chunk-HBVF6BWO.js";
+import {
+  spawnHidden
+} from "./chunk-35H7GVNR.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/verify-command.ts
+init_esm_shims();
+var TOKEN_RE = /^[A-Za-z0-9@._+/\\:=,-]+$/;
+function matchPackageRunner(argv) {
+  if (argv[1] === "test") return true;
+  return argv[1] === "run" && argv[2] !== void 0 && argv[2] !== "";
+}
+var VERIFY_FAMILIES = {
+  npx: (argv) => argv[1] !== void 0 && ["tsc", "vitest", "jest", "tsx"].includes(argv[1]),
+  npm: matchPackageRunner,
+  pnpm: matchPackageRunner,
+  yarn: matchPackageRunner,
+  node: (argv) => argv[1] === "--test",
+  cargo: (argv) => argv[1] === "test" || argv[1] === "check",
+  go: (argv) => argv[1] === "test" || argv[1] === "vet" || argv[1] === "build",
+  pytest: () => true,
+  python: (argv) => argv[1] === "-m" && argv[2] === "pytest",
+  make: (argv) => argv[1] === "test" || argv[1] === "check"
+};
+function parseVerifyCommand(command) {
+  const trimmed = command.trim();
+  if (trimmed === "") return null;
+  const argv = trimmed.split(/\s+/);
+  for (const token of argv) {
+    if (!TOKEN_RE.test(token)) return null;
+  }
+  const family = VERIFY_FAMILIES[argv[0]];
+  if (!family || !family(argv)) return null;
+  return argv;
+}
+function spawnVerifyArgv(cwd, argv, options = {}) {
+  if (argv.length === 0 || argv[0] === "") throw new Error("spawnVerifyArgv: empty argv");
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec ?? "cmd.exe";
+    return spawnHidden(comspec, ["/d", "/s", "/c", argv.join(" ")], { cwd, shell: false, ...options });
+  }
+  return spawnHidden(argv[0], argv.slice(1), { cwd, shell: false, ...options });
+}
+
+// src/agent/test-presence.ts
+init_esm_shims();
+function isTestFilePath(path) {
+  return /[\\/]__tests__[\\/]/i.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/i.test(path);
+}
+function isSourceFilePath(path) {
+  if (isTestFilePath(path)) return false;
+  if (/\.d\.[cm]?ts$/i.test(path)) return false;
+  if (!/\.[cm]?[jt]sx?$/i.test(path)) return false;
+  const normalized = path.replace(/\\/g, "/");
+  if (/(^|\/)(docs|doc|examples?|scripts)\//i.test(normalized)) return false;
+  const base = normalized.split("/").pop() ?? "";
+  if (/\.config\.[cm]?[jt]s$/i.test(base)) return false;
+  return true;
+}
+function testPresenceGateEnabled() {
+  return process.env.RIVET_TEST_PRESENCE_GATE !== "0";
+}
+function evaluateTestPresence(changedFiles, threshold = 3) {
+  const sourceFiles = changedFiles.filter(isSourceFilePath);
+  const testFiles = changedFiles.filter(isTestFilePath);
+  if (sourceFiles.length >= threshold && testFiles.length === 0) {
+    const list = sourceFiles.slice(0, 10).join(", ");
+    const more = sourceFiles.length > 10 ? ` (+${sourceFiles.length - 10} more)` : "";
+    return {
+      ok: false,
+      sourceFiles,
+      testFiles,
+      detail: `${sourceFiles.length} \u4E2A\u6E90\u6587\u4EF6\u53D8\u66F4\u4F46\u96F6\u6D4B\u8BD5\u6587\u4EF6\uFF1A${list}${more}\u3002\u4E3A\u6838\u5FC3\u884C\u4E3A\u8865\u6D4B\u8BD5\u6587\u4EF6\uFF08__tests__/*.test.ts \u6216\u540C\u540D *.test.*\uFF09\u540E\u81EA\u52A8\u653E\u884C\u3002`
+    };
+  }
+  return { ok: true, sourceFiles, testFiles };
+}
+
+// src/lsp/server-registry.ts
+init_esm_shims();
+import { execFileSync } from "child_process";
+var LSP_SERVERS = [
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    command: "npx",
+    args: ["-y", "typescript-language-server", "--stdio"],
+    languageId: "typescript",
+    languageIdByExt: {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".mts": "typescript",
+      ".cts": "typescript"
+    },
+    alwaysAvailable: true
+  },
+  { id: "pyright", extensions: [".py", ".pyi"], command: "pyright-langserver", args: ["--stdio"], languageId: "python" },
+  { id: "gopls", extensions: [".go"], command: "gopls", args: [], languageId: "go" },
+  { id: "rust-analyzer", extensions: [".rs"], command: "rust-analyzer", args: [], languageId: "rust" },
+  {
+    id: "clangd",
+    extensions: [".c", ".h", ".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"],
+    command: "clangd",
+    args: [],
+    languageId: "c",
+    languageIdByExt: {
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".hpp": "cpp",
+      ".hh": "cpp",
+      ".hxx": "cpp"
+    }
+  },
+  // jdtls 需要 Java 21+ 运行时（JAVA_HOME 或 PATH 上），且建议用 -data 指定
+  // per-project workspace——这两点由用户的 jdtls 安装/包装脚本决定，天枢不代管。
+  { id: "jdtls", extensions: [".java"], command: "jdtls", args: [], languageId: "java" },
+  // C#：微软官方 roslyn-language-server（VS Code C# 扩展同源）优先，csharp-ls 兜底。
+  { id: "roslyn-language-server", extensions: [".cs"], command: "roslyn-language-server", args: ["--stdio"], languageId: "csharp" },
+  { id: "csharp-ls", extensions: [".cs"], command: "csharp-ls", args: [], languageId: "csharp" },
+  { id: "kotlin-language-server", extensions: [".kt", ".kts"], command: "kotlin-language-server", args: [], languageId: "kotlin" },
+  { id: "sourcekit-lsp", extensions: [".swift"], command: "sourcekit-lsp", args: [], languageId: "swift" },
+  { id: "dart", extensions: [".dart"], command: "dart", args: ["language-server", "--protocol=lsp"], languageId: "dart" },
+  { id: "metals", extensions: [".scala", ".sbt"], command: "metals", args: [], languageId: "scala" },
+  { id: "intelephense", extensions: [".php"], command: "intelephense", args: ["--stdio"], languageId: "php" },
+  { id: "phpactor", extensions: [".php"], command: "phpactor", args: ["language-server"], languageId: "php" },
+  { id: "ruby-lsp", extensions: [".rb", ".rake", ".gemspec"], command: "ruby-lsp", args: [], languageId: "ruby" },
+  { id: "solargraph", extensions: [".rb", ".rake", ".gemspec"], command: "solargraph", args: ["stdio"], languageId: "ruby" },
+  { id: "lua-language-server", extensions: [".lua"], command: "lua-language-server", args: [], languageId: "lua" },
+  { id: "zls", extensions: [".zig", ".zon"], command: "zls", args: [], languageId: "zig" },
+  { id: "bash-language-server", extensions: [".sh", ".bash", ".zsh"], command: "bash-language-server", args: ["start"], languageId: "shellscript" },
+  { id: "terraform-ls", extensions: [".tf", ".tfvars"], command: "terraform-ls", args: ["serve"], languageId: "terraform" },
+  { id: "clojure-lsp", extensions: [".clj", ".cljs", ".cljc", ".edn"], command: "clojure-lsp", args: [], languageId: "clojure" },
+  { id: "ocamllsp", extensions: [".ml", ".mli"], command: "ocamllsp", args: [], languageId: "ocaml" },
+  { id: "haskell-language-server", extensions: [".hs", ".lhs"], command: "haskell-language-server-wrapper", args: ["--lsp"], languageId: "haskell" },
+  { id: "nil", extensions: [".nix"], command: "nil", args: [], languageId: "nix" },
+  { id: "vue-language-server", extensions: [".vue"], command: "vue-language-server", args: ["--stdio"], languageId: "vue" },
+  { id: "svelteserver", extensions: [".svelte"], command: "svelteserver", args: ["--stdio"], languageId: "svelte" }
+];
+var whichCache = /* @__PURE__ */ new Map();
+function probeWhich(bin) {
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [bin], {
+      stdio: ["ignore", "ignore", "ignore"],
+      timeout: 800,
+      windowsHide: true
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultWhich(bin) {
+  const cached = whichCache.get(bin);
+  if (cached !== void 0) return cached;
+  const found = probeWhich(bin);
+  whichCache.set(bin, found);
+  return found;
+}
+function extOf(filePath) {
+  const i = filePath.lastIndexOf(".");
+  return i >= 0 ? filePath.slice(i).toLowerCase() : "";
+}
+function serverDefsForExt(ext) {
+  const e = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+  return LSP_SERVERS.filter((s) => s.extensions.includes(e));
+}
+function serverDefForExt(ext) {
+  return serverDefsForExt(ext)[0] ?? null;
+}
+function isServerAvailable(def, which = defaultWhich) {
+  if (def.alwaysAvailable) return true;
+  return which(def.binary ?? def.command);
+}
+function serverForFile(filePath, which = defaultWhich) {
+  return serverDefsForExt(extOf(filePath)).find((def) => isServerAvailable(def, which)) ?? null;
+}
+function hasServerForFile(filePath) {
+  return serverDefForExt(extOf(filePath)) !== null;
+}
+function languageIdForFile(def, filePath) {
+  return def.languageIdByExt?.[extOf(filePath)] ?? def.languageId;
+}
+function availableServers(which = defaultWhich) {
+  return LSP_SERVERS.filter((s) => isServerAvailable(s, which));
+}
+
+// src/lsp/client.ts
+init_esm_shims();
+
+// src/lsp/diagnostics.ts
+init_esm_shims();
+var TSC_PATTERN = /^(.+?)\((\d+),(\d+)\): (error|warning) TS\d+: (.+)$/;
+function parseDiagnosticOutput(output, _lang) {
+  return output.trim().split("\n").filter(Boolean).map((line) => {
+    const m = TSC_PATTERN.exec(line);
+    if (!m) return null;
+    return {
+      file: m[1],
+      line: parseInt(m[2], 10),
+      col: parseInt(m[3], 10),
+      severity: m[4],
+      message: m[5]
+    };
+  }).filter((d) => d !== null);
+}
+function formatDiagnostics(diags) {
+  if (diags.length === 0) return "";
+  return diags.map((d) => `${d.file}:${d.line}:${d.col} ${d.severity}: ${d.message}`).join("\n");
+}
+
+// src/lsp/client.ts
+import { isAbsolute, relative, join } from "path";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+var _tscPath = void 0;
+var _tscMissingWarned = false;
+function resolveTscPath(cwd) {
+  if (_tscPath !== void 0) return _tscPath;
+  const bin = join(cwd, "node_modules", ".bin");
+  const candidates = process.platform === "win32" ? [join(bin, "tsc.cmd"), join(bin, "tsc")] : [join(bin, "tsc")];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      _tscPath = candidate;
+      return candidate;
+    }
+  }
+  _tscPath = null;
+  return null;
+}
+async function runTypeCheck(cwd, filePath, timeoutMs = 12e4) {
+  const tscPath = resolveTscPath(cwd);
+  if (!tscPath) {
+    if (!_tscMissingWarned) {
+      _tscMissingWarned = true;
+      process.stderr.write(
+        `[rivet] typecheck gate: node_modules/.bin/tsc not found, falling back to in-process ts.createProgram.
+  Install typescript as a devDependency (npm i -D typescript) for subprocess isolation.
+`
+      );
+    }
+    return runTypeCheckInProcess(cwd, filePath);
+  }
+  const result = await runTscShared(tscPath, cwd, timeoutMs);
+  const ranOk = result.status === 0 || result.status === 1;
+  const output = result.stdout + result.stderr;
+  const allDiagnostics = ranOk ? parseDiagnosticOutput(output, "ts") : [];
+  const filtered = filePath === "*" ? allDiagnostics : allDiagnostics.filter((d) => d.file.includes(filePath));
+  return {
+    diagnostics: filtered,
+    formatted: formatDiagnostics(filtered),
+    ranOk
+  };
+}
+var TSC_GATE_ARGS = ["--noEmit", "--pretty", "false"];
+function runTscShared(tscPath, cwd, timeoutMs) {
+  const direct = () => runTscSubprocess(tscPath, cwd, timeoutMs);
+  if (process.env.RIVET_TYPECHECK_SHARE === "0") return direct();
+  return runTypecheckShared({
+    cwd,
+    run: direct,
+    // 与 npm script 的人读格式分桶：回放另一种格式的原始输出会让 parseDiagnosticOutput 解析错乱。
+    variant: TSC_GATE_ARGS.join(" "),
+    // 等待预算给满 tsc 自己的超时，不打折：持锁者跑的是同一份检查，等它出结果
+    // 几乎总快于自己重跑一遍（后者要付全额时间，还抢走它的核心让两边都更慢）。
+    // 打折的后果实测过——等待者集体超时后并发开跑，负载反而更高。
+    waitBudgetMs: timeoutMs
+  });
+}
+function runTscSubprocess(tscPath, cwd, timeoutMs) {
+  return new Promise((resolve2) => {
+    const useShell = process.platform === "win32" && tscPath.toLowerCase().endsWith(".cmd");
+    const command = useShell ? `"${tscPath}"` : tscPath;
+    const child = spawn(command, [...TSC_GATE_ARGS], {
+      cwd,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      shell: useShell
+    });
+    let stdout = "";
+    let stderr = "";
+    const MAX = 10 * 1024 * 1024;
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX) stdout += chunk.toString("utf8").slice(0, MAX - stdout.length);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX) stderr += chunk.toString("utf8").slice(0, MAX - stderr.length);
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve2({ status: null, stdout, stderr });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve2({ status: killed ? null : code, stdout, stderr });
+    });
+  });
+}
+var _tsModule;
+var _tsLoadAttempted = false;
+function loadTsModule() {
+  if (_tsLoadAttempted) return _tsModule;
+  _tsLoadAttempted = true;
+  try {
+    const require2 = createRequire(import.meta.url);
+    _tsModule = require2("typescript");
+  } catch {
+  }
+  return _tsModule;
+}
+async function runTypeCheckInProcess(cwd, filePath) {
+  const ts = loadTsModule();
+  if (!ts) {
+    return { diagnostics: [], formatted: "", ranOk: false };
+  }
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    return { diagnostics: [], formatted: "", ranOk: false };
+  }
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  if (configFile.error) {
+    return { diagnostics: [], formatted: "", ranOk: false };
+  }
+  const parsed = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    cwd
+  );
+  const program = ts.createProgram(parsed.fileNames, {
+    ...parsed.options,
+    noEmit: true,
+    pretty: false
+  });
+  const allDiagnostics = ts.getPreEmitDiagnostics(program);
+  const diagnostics = [];
+  for (const d of allDiagnostics) {
+    const category = ts.DiagnosticCategory;
+    const severity = d.category === category.Error ? "error" : d.category === category.Warning ? "warning" : "info";
+    const file = d.file;
+    if (!file) continue;
+    const absFile = file.fileName;
+    const relFile = isAbsolute(absFile) ? relative(cwd, absFile) : absFile;
+    const lineChar = ts.getLineAndCharacterOfPosition(file, d.start ?? 0);
+    diagnostics.push({
+      file: relFile,
+      line: lineChar.line + 1,
+      col: lineChar.character + 1,
+      severity,
+      message: ts.flattenDiagnosticMessageText(d.messageText, "\n")
+    });
+  }
+  const filtered = filePath === "*" ? diagnostics : diagnostics.filter((d) => d.file.includes(filePath));
+  return {
+    diagnostics: filtered,
+    formatted: formatDiagnostics(filtered),
+    ranOk: true
+  };
+}
+function shouldRunDiagnostics(toolName, filePath) {
+  if (toolName !== "write_file" && toolName !== "edit_file") return false;
+  if (!filePath) return false;
+  return hasServerForFile(filePath);
+}
+var DIAGNOSTIC_CONTEXT_LINES = 3;
+var MODEL_INREGION_CAP = 10;
+var MODEL_OUTREGION_LINE_CAP = 5;
+var UI_DIAGNOSTIC_CAP = 20;
+function formatDiagnosticLine(d) {
+  const kind = d.severity === 1 ? "ERROR" : "WARNING";
+  return `${kind} L${d.range.start.line + 1}: ${d.message}`;
+}
+function filterDiagnosticsForEdit(diagnostics, changedRanges, context = DIAGNOSTIC_CONTEXT_LINES) {
+  const relevant = diagnostics.filter((d) => d.severity <= 2);
+  if (relevant.length === 0) return { modelText: "", uiText: "" };
+  const uiText = relevant.slice(0, UI_DIAGNOSTIC_CAP).map(formatDiagnosticLine).join("\n");
+  if (!changedRanges || changedRanges.length === 0) {
+    const modelText = relevant.slice(0, MODEL_INREGION_CAP).map(formatDiagnosticLine).join("\n");
+    return { modelText, uiText };
+  }
+  const inRegion = (line1) => changedRanges.some((r) => line1 >= r.start - context && line1 <= r.end + context);
+  const inside = [];
+  const outsideErrors = [];
+  for (const d of relevant) {
+    const line1 = d.range.start.line + 1;
+    if (inRegion(line1)) inside.push(d);
+    else if (d.severity === 1) outsideErrors.push(d);
+  }
+  const parts = [];
+  if (inside.length > 0) {
+    parts.push(inside.slice(0, MODEL_INREGION_CAP).map(formatDiagnosticLine).join("\n"));
+  }
+  if (outsideErrors.length > 0) {
+    const lines = outsideErrors.slice(0, MODEL_OUTREGION_LINE_CAP).map((d) => `L${d.range.start.line + 1}`).join(", ");
+    const more = outsideErrors.length > MODEL_OUTREGION_LINE_CAP ? ", \u2026" : "";
+    parts.push(
+      `+${outsideErrors.length} error(s) elsewhere in file (${lines}${more}) \u2014 run typecheck before delivery`
+    );
+  }
+  return { modelText: parts.join("\n"), uiText };
+}
+
+// src/agent/typecheck-gate.ts
+init_esm_shims();
+import { isAbsolute as isAbsolute2, relative as relative2, join as join2 } from "path";
+import { statSync, readFileSync } from "fs";
+var TYPECHECK_CMD_RE = /\b(tsc|type-?check)\b/i;
+var defaultRunner = (cwd) => runTypeCheck(cwd, "*");
+var GATE_TSC_TIMEOUT_MS = 3e5;
+var gateTypecheckRunner = (cwd) => runTypeCheck(cwd, "*", GATE_TSC_TIMEOUT_MS);
+function typecheckGateEnabled() {
+  const v = process.env.RIVET_TYPECHECK_GATE;
+  if (v == null) return true;
+  return !/^(0|false|off|no)$/i.test(v.trim());
+}
+function repoWideEnabled() {
+  const v = process.env.RIVET_TYPECHECK_REPO_WIDE;
+  if (v == null) return true;
+  return !/^(0|false|off|no)$/i.test(v.trim());
+}
+var MAX_FILES = 8;
+var MAX_ERRORS_PER_FILE = 5;
+function normalizeDiagFile(cwd, file) {
+  const rel = isAbsolute2(file) ? relative2(cwd, file) : file;
+  return rel.split("\\").join("/");
+}
+function errorSignature(cwd, d) {
+  return `${normalizeDiagFile(cwd, d.file)}|${d.line}|${d.message}`;
+}
+function loadTypecheckBaseline(cwd) {
+  try {
+    const raw = readFileSync(join2(cwd, ".rivet", "typecheck-baseline.json"), "utf-8");
+    const arr = JSON.parse(raw);
+    if (!Array.isArray(arr)) return /* @__PURE__ */ new Set();
+    return new Set(arr.filter((x) => typeof x === "string"));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function runChangedFilesTypecheckOutcome(cwd, changedFiles, run = defaultRunner, baseline = loadTypecheckBaseline(cwd)) {
+  const rel = changedFiles.filter((f) => !isAbsolute2(f) && /\.(ts|tsx)$/.test(f));
+  if (rel.length === 0) return { status: "clean", result: null, reason: "no changed .ts/.tsx files" };
+  const res = await run(cwd);
+  if (!res.ranOk) return { status: "inconclusive", result: null, reason: "tsc did not run to completion (crash/timeout)" };
+  const byFile = {};
+  const driftByFile = {};
+  let driftCount = 0;
+  const useRepoWide = repoWideEnabled();
+  for (const d of res.diagnostics) {
+    if (d.severity !== "error") continue;
+    if (baseline.has(errorSignature(cwd, d))) continue;
+    const nf = normalizeDiagFile(cwd, d.file);
+    const hit = rel.find((f) => nf === f || nf.endsWith("/" + f));
+    if (hit) {
+      const entry = byFile[hit] ??= [];
+      if (entry.length < MAX_ERRORS_PER_FILE) {
+        entry.push(`L${d.line} ${d.message}`);
+      }
+    } else if (useRepoWide) {
+      driftCount++;
+      const entry = driftByFile[nf] ??= [];
+      if (entry.length < MAX_ERRORS_PER_FILE) {
+        entry.push(`L${d.line} ${d.message}`);
+      }
+    }
+  }
+  const brokenFiles = Object.keys(byFile);
+  const driftFiles = Object.keys(driftByFile);
+  if (brokenFiles.length === 0 && driftFiles.length === 0) return { status: "clean", result: null };
+  const parts = [];
+  if (brokenFiles.length > 0) {
+    const shown = brokenFiles.slice(0, MAX_FILES);
+    const segs = shown.map((f) => {
+      const errs = byFile[f];
+      const more = errs.length >= MAX_ERRORS_PER_FILE ? " (+more)" : "";
+      return `${f}: ${errs.join("; ")}${more}`;
+    });
+    const overflow = brokenFiles.length > MAX_FILES ? ` (+${brokenFiles.length - MAX_FILES} more files)` : "";
+    parts.push(`Typecheck broken in changed files \u2014 ${segs.join(" | ")}${overflow}`);
+  }
+  let repoWide;
+  if (driftFiles.length > 0) {
+    const shown = driftFiles.slice(0, MAX_FILES);
+    const segs = shown.map((f) => {
+      const errs = driftByFile[f];
+      const more = errs.length >= MAX_ERRORS_PER_FILE ? " (+more)" : "";
+      return `${f}: ${errs.join("; ")}${more}`;
+    });
+    const overflow = driftFiles.length > MAX_FILES ? ` (+${driftFiles.length - MAX_FILES} more files)` : "";
+    const driftSummary = `cross-file \u7C7B\u578B\u6F02\u79FB\uFF08\u7591\u4F3C\u4F60\u6539\u7684\u5B9A\u4E49\u5F15\u53D1\u4E0B\u6E38\uFF09\u2014 ${segs.join(" | ")}${overflow}`;
+    parts.push(driftSummary);
+    repoWide = { byFile: driftByFile, count: driftCount, summary: driftSummary };
+  }
+  return { status: "errors", result: { brokenFiles, byFile, summary: parts.join(" || "), repoWide } };
+}
+var memoByCwd = /* @__PURE__ */ new Map();
+function changedFilesSignature(cwd, tsFiles) {
+  if (tsFiles.length === 0) return null;
+  try {
+    return tsFiles.slice().sort().map((f) => {
+      const st = statSync(isAbsolute2(f) ? f : join2(cwd, f));
+      return `${f}:${st.mtimeMs}:${st.size}`;
+    }).join("|");
+  } catch {
+    return null;
+  }
+}
+async function runChangedFilesTypecheckOutcomeMemo(cwd, changedFiles, run = defaultRunner, baseline = loadTypecheckBaseline(cwd)) {
+  const tsFiles = changedFiles.filter((f) => !isAbsolute2(f) && /\.(ts|tsx)$/.test(f));
+  const sig = changedFilesSignature(cwd, tsFiles);
+  if (sig) {
+    const hit = memoByCwd.get(cwd);
+    if (hit && hit.sig === sig) return hit.outcome;
+  }
+  const outcome = await runChangedFilesTypecheckOutcome(cwd, changedFiles, run, baseline);
+  if (sig && outcome.status !== "inconclusive") memoByCwd.set(cwd, { sig, outcome });
+  return outcome;
+}
+async function runChangedFilesTypecheckMemo(cwd, changedFiles, run = defaultRunner, baseline = loadTypecheckBaseline(cwd)) {
+  const outcome = await runChangedFilesTypecheckOutcomeMemo(cwd, changedFiles, run, baseline);
+  return outcome.result;
+}
+
+// src/agent/wave-gate.ts
+init_esm_shims();
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+function isRunnableVerifyCommand(command) {
+  return parseVerifyCommand(command) !== null;
+}
+var gates = /* @__PURE__ */ new Map();
+function key(sessionId) {
+  return sessionId ?? "__default__";
+}
+function setWaveGate(record, sessionId) {
+  gates.set(key(sessionId), record);
+}
+function getWaveGate(sessionId) {
+  return gates.get(key(sessionId));
+}
+function clearWaveGate(sessionId) {
+  gates.delete(key(sessionId));
+}
+function isWaveGateEnabled() {
+  return process.env.RIVET_WAVE_GATE !== "0";
+}
+function defaultRunCommand(cwd, command) {
+  const argv = parseVerifyCommand(command);
+  if (!argv) {
+    return Promise.resolve({ ok: false, detail: "\u975E\u767D\u540D\u5355\u9A8C\u8BC1\u547D\u4EE4\u5F62\u72B6\u2014\u2014\u62D2\u7EDD shell \u6267\u884C" });
+  }
+  return new Promise((resolvePromise) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const tail = () => `${stdout}
+${stderr}`.trim().split("\n").slice(-5).join("\n").slice(0, 500);
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      resolvePromise(result);
+    };
+    try {
+      const child = spawnVerifyArgv(cwd, argv, { stdio: ["ignore", "pipe", "pipe"] });
+      child.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        settle({ ok: false, detail: tail() });
+      }, 3e5);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) settle({ ok: true });
+        else settle({ ok: false, detail: tail() });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        settle({ ok: false, detail: err.message });
+      });
+    } catch (err) {
+      settle({ ok: false, detail: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
+async function evaluateWaveGate(input) {
+  const checks = [];
+  if (typecheckGateEnabled() && input.changedFiles.length > 0) {
+    try {
+      const outcome = await runChangedFilesTypecheckOutcomeMemo(
+        input.cwd,
+        input.changedFiles,
+        input.typecheckRunner ?? gateTypecheckRunner
+      );
+      if (outcome.status === "errors") {
+        checks.push({ command: "tsc --noEmit (scoped)", status: "failed", detail: outcome.result.summary });
+      } else if (outcome.status === "inconclusive") {
+        checks.push({
+          command: "tsc --noEmit (scoped)",
+          status: "unverifiable",
+          detail: `${outcome.reason ?? "tsc did not complete"} \u2014 \u672A\u9A8C\u8BC1\u6309\u5931\u8D25\u62E6\u622A\uFF0C\u590D\u8BC4\u81EA\u52A8\u91CD\u8DD1`,
+          blocking: true
+        });
+      } else {
+        checks.push({ command: "tsc --noEmit (scoped)", status: "passed" });
+      }
+    } catch {
+      checks.push({ command: "tsc --noEmit (scoped)", status: "unverifiable", detail: "typecheck runner unavailable" });
+    }
+  }
+  if (testPresenceGateEnabled() && input.changedFiles.length > 0) {
+    const exists = input.fileExists ?? ((f) => existsSync2(resolve(input.cwd, f)));
+    const presentFiles = input.changedFiles.filter((f) => {
+      try {
+        return exists(f);
+      } catch {
+        return false;
+      }
+    });
+    const presence = evaluateTestPresence(presentFiles);
+    if (!presence.ok) {
+      checks.push({
+        command: "test-presence",
+        status: "unverifiable",
+        detail: presence.detail,
+        blocking: true
+      });
+    } else if (presence.sourceFiles.length > 0) {
+      checks.push({ command: "test-presence", status: "passed" });
+    }
+  }
+  const run = input.runCommand ?? defaultRunCommand;
+  for (const command of input.commands) {
+    if (!isRunnableVerifyCommand(command)) {
+      checks.push({ command, status: "unverifiable", detail: "\u975E\u767D\u540D\u5355\u9A8C\u8BC1\u547D\u4EE4\u5F62\u72B6\u2014\u2014\u8BF7\u4EBA\u5DE5\u6267\u884C\u786E\u8BA4" });
+      continue;
+    }
+    const res = await run(input.cwd, command);
+    checks.push({ command, status: res.ok ? "passed" : "failed", detail: res.detail });
+  }
+  return {
+    wave: input.wave,
+    passed: checks.every((c) => c.status !== "failed" && !(c.blocking && c.status !== "passed")),
+    checks,
+    changedFiles: input.changedFiles,
+    commands: input.commands,
+    checkedAt: Date.now()
+  };
+}
+function formatWaveGate(record) {
+  const lines = [`\u6CE2\u95F4\u95E8\u7981 (wave ${record.wave + 1}): ${record.passed ? "\u2705 \u901A\u8FC7" : "\u274C \u672A\u901A\u8FC7"}`];
+  for (const c of record.checks) {
+    const icon = c.status === "passed" ? "\u2705" : c.status === "failed" ? "\u274C" : "\u2753";
+    lines.push(`  ${icon} ${c.command}${c.detail ? ` \u2014 ${c.detail}` : ""}`);
+  }
+  return lines;
+}
+
+export {
+  defaultWhich,
+  serverForFile,
+  languageIdForFile,
+  availableServers,
+  runTypeCheck,
+  shouldRunDiagnostics,
+  filterDiagnosticsForEdit,
+  parseVerifyCommand,
+  spawnVerifyArgv,
+  TYPECHECK_CMD_RE,
+  GATE_TSC_TIMEOUT_MS,
+  typecheckGateEnabled,
+  runChangedFilesTypecheckMemo,
+  isTestFilePath,
+  isSourceFilePath,
+  testPresenceGateEnabled,
+  evaluateTestPresence,
+  isRunnableVerifyCommand,
+  setWaveGate,
+  getWaveGate,
+  clearWaveGate,
+  isWaveGateEnabled,
+  evaluateWaveGate,
+  formatWaveGate
+};