tianshu-harness 3.23.0

package/dist/chunk-T3ED6BY2.js

@@ -0,0 +1,913 @@
+#!/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 {
+  WRITE_TOOL_NAMES,
+  extractWriteFilePaths
+} from "./chunk-ZU7JZCVP.js";
+import {
+  listPlansSync
+} from "./chunk-ZMZCZNKU.js";
+import {
+  spawnGitSync
+} from "./chunk-THKDVSEC.js";
+import {
+  writeFileAtomicSync
+} from "./chunk-A5MNH4ER.js";
+import {
+  init_paths,
+  memoryDir
+} from "./chunk-BCQXEZPJ.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/regression-inventory.ts
+init_esm_shims();
+var INVENTORY_HEADING_RE = /^#{2,6}\s*(?:回归清单|回归契约|regression\s+inventory\b).*$/im;
+function extractRegressionInventory(markdown) {
+  const headingMatch = markdown.match(INVENTORY_HEADING_RE);
+  if (!headingMatch || headingMatch.index === void 0) return [];
+  const headingLevel = (headingMatch[0].match(/^#+/) ?? ["##"])[0].length;
+  const rest = markdown.slice(headingMatch.index + headingMatch[0].length);
+  const items = [];
+  for (const line of rest.split(/\r?\n/)) {
+    const nextHeading = line.match(/^(#{1,6})\s/);
+    if (nextHeading && nextHeading[1].length <= headingLevel) break;
+    const m = line.match(/^\s*(?:[-*]\s*(?:\[[ xX]\]\s*)?|\d+\.\s+)(.+)$/);
+    if (m && m[1].trim()) items.push(m[1].trim());
+  }
+  return items;
+}
+function findApprovedPlanInventory(cwd) {
+  try {
+    const approved = listPlansSync(cwd).filter((p) => p.status === "approved");
+    if (approved.length === 0) return void 0;
+    const inventory = extractRegressionInventory(approved[0].content);
+    return inventory.length > 0 ? inventory : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function needleForItem(item) {
+  const backtick = item.match(/`([^`]+)`/);
+  return (backtick?.[1] ?? item).trim();
+}
+function gitGrepSearcher(cwd, needle) {
+  try {
+    const res = spawnGitSync(["grep", "-l", "-F", "--", needle], { cwd, encoding: "utf-8", timeout: 1e4 });
+    if (res.status === 0) return "present";
+    if (res.status === 1) return "missing";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function verifyRegressionInventory(cwd, items, searcher = gitGrepSearcher) {
+  return items.map((item) => {
+    const needle = needleForItem(item);
+    return { item, needle, status: needle ? searcher(cwd, needle) : "unknown" };
+  });
+}
+function formatInventoryReport(results) {
+  if (results.length === 0) return [];
+  const missing = results.filter((r) => r.status === "missing");
+  const unknown = results.filter((r) => r.status === "unknown");
+  const lines = ["", `--- \u56DE\u5F52\u6E05\u5355\u6838\u9A8C (${results.length - missing.length - unknown.length}/${results.length} \u4ECD\u5B58\u5728) ---`];
+  for (const r of results) {
+    const icon = r.status === "present" ? "\u2705" : r.status === "missing" ? "\u274C" : "\u2753";
+    lines.push(`  ${icon} ${r.item}${r.status === "missing" ? `\uFF08\u951A\u70B9 \`${r.needle}\` \u5DF2\u6D88\u5931\uFF09` : ""}`);
+  }
+  if (missing.length > 0) {
+    lines.push("", `  \u26A0\uFE0F ${missing.length} \u4E2A\u529F\u80FD\u951A\u70B9\u5728\u6539\u52A8\u540E\u6D88\u5931\u2014\u2014\u8FD9\u6B63\u662F\u91CD\u6784\u4E22\u529F\u80FD\u7684\u5F62\u6001\u3002\u9010\u9879\u786E\u8BA4\u662F\u6709\u610F\u79FB\u9664\u8FD8\u662F\u56DE\u5F52\uFF0C\u56DE\u5F52\u7684\u5FC5\u987B\u4FEE\u590D\u540E\u518D\u4EA4\u4ED8\u3002`);
+  }
+  if (unknown.length > 0) {
+    lines.push(`  \u2753 ${unknown.length} \u9879\u65E0\u6CD5\u81EA\u52A8\u6838\u9A8C\uFF08\u975E git \u4ED3\u5E93\u6216 grep \u5931\u8D25\uFF09\u2014\u2014\u8BF7\u4EBA\u5DE5\u786E\u8BA4\u3002`);
+  }
+  return lines;
+}
+
+// src/agent/hooks/render-verify-hook.ts
+init_esm_shims();
+var UI_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".vue", ".svelte", ".css", ".html"]);
+var VISUAL_TOOLS = /* @__PURE__ */ new Set(["browser", "computer_use", "browser_debug"]);
+function createRenderVerifyHook(deps) {
+  const maxFires = deps.maxFires ?? 2;
+  let fireCount = 0;
+  return {
+    phase: "postTurn",
+    name: "render-verify",
+    run(ctx) {
+      const { snapshot } = ctx;
+      if (!snapshot.touchedUiFiles) return;
+      if (snapshot.sawVisualVerify) return;
+      if (fireCount >= maxFires) return;
+      fireCount++;
+      const visualAvailable = deps.getVisualToolsAvailable?.() ?? true;
+      const advice = visualAvailable ? "UI \u6587\u4EF6\u5DF2\u4FEE\u6539\u4F46\u5C1A\u672A\u68C0\u67E5\u6E32\u67D3\u7ED3\u679C\u3002\u4EA4\u4ED8\u524D\u7528 browser_debug \u81EA\u8BC1\uFF1Aopen \u2192 navigate \u5230 dev server \u2192 screenshot \u770B\u5E03\u5C40 + console \u67E5\u62A5\u9519\uFF1B\u539F\u751F\u684C\u9762\u5E94\u7528\u573A\u666F\u7528 computer_use snapshot\uFF08\u672A\u6302\u8F7D\u65F6\u7ECF /tools enable computer_use \u6216 delegate_task \u6D3E\u53D1\uFF09\u3002\u786E\u8BA4\u6E32\u67D3\u65E0\u8BEF\u540E\u518D\u4EA4\u4ED8\u3002" : "UI \u6587\u4EF6\u5DF2\u4FEE\u6539\uFF0C\u4F46\u5F53\u524D\u73AF\u5883\u7F3A\u5C11\u89C6\u89C9\u9A8C\u8BC1\u5DE5\u5177\uFF08\u65E0 Playwright \u6216\u975E Pro\u2014\u2014browser_debug \u9700\u8981 Playwright\uFF0Ccomputer_use \u9700\u8981 Pro + macOS/Windows\uFF09\u3002\u4EA4\u4ED8\u524D\u8BF7\u4EBA\u5DE5\u8FC7\u76EE\u6E32\u67D3\u7ED3\u679C\uFF0C\u786E\u8BA4\u89C6\u89C9\u65E0\u8BEF\u540E\u518D\u4EA4\u4ED8\u3002";
+      deps.advisoryBus.submit({
+        key: "render-verify",
+        priority: 0.55,
+        category: "discipline",
+        tier: "operational",
+        content: advice,
+        ttl: 1,
+        // 没有 expect 的条目 adopted 恒 0，会被 efficacy 负反馈环当成零采纳
+        // 逐步冷却直至本会话静默——这条提醒一直走在被系统自己掐掉的轨道上。
+        // 精度局限：tool_appears 只认工具名，`browser_debug open`/`navigate`
+        // 这种操作类调用也会记成采纳（谓词表达不了 isVerifyCall 的 action 过滤），
+        // 所以它的 lift 数据偏高，够用来免于静音，别当精确读数。
+        // 工具不可用的分支催的是人工过目，没有工具痕迹可核销，故不挂 expect
+        // （该分支有 fireCount 上限兜底）。
+        ...visualAvailable ? {
+          expect: {
+            kind: "tool_appears",
+            tools: ["browser_debug", "browser", "computer_use"],
+            withinTurns: 3
+          }
+        } : {}
+      });
+    }
+  };
+}
+function isUiFilePath(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.includes("__tests__") || lower.includes(".test.") || lower.includes(".spec.")) return false;
+  if (lower.includes(".rivet/scratch/")) return false;
+  for (const ext of UI_EXTENSIONS) {
+    if (lower.endsWith(ext)) return true;
+  }
+  return false;
+}
+function isVisualVerifyTool(toolName) {
+  return VISUAL_TOOLS.has(toolName);
+}
+
+// src/memory/unified-memory.ts
+init_esm_shims();
+init_paths();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+
+// src/context/project-memory-writer.ts
+init_esm_shims();
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, openSync, closeSync } from "fs";
+import { join } from "path";
+import { randomBytes } from "crypto";
+var MAX_ENTRIES = 200;
+var MAX_FILE_SIZE = 16384;
+var MAX_COMMIT_FACT_ENTRIES = 300;
+var LOCK_RETRY_MAX_MS = 500;
+var LOCK_RETRY_INTERVAL_MS = 20;
+function acquireLock(lockPath) {
+  const start = Date.now();
+  while (true) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      writeFileSync(fd, String(process.pid), "utf-8");
+      closeSync(fd);
+      return () => {
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      };
+    } catch {
+      if (Date.now() - start > LOCK_RETRY_MAX_MS) {
+        return () => {
+        };
+      }
+      const waitUntil = Date.now() + LOCK_RETRY_INTERVAL_MS;
+      while (Date.now() < waitUntil) {
+      }
+    }
+  }
+}
+function atomicWrite(targetPath, content) {
+  const dir = join(targetPath, "..");
+  const tmpName = `.memory.${randomBytes(4).toString("hex")}.tmp`;
+  const tmpPath = join(dir, tmpName);
+  writeFileSync(tmpPath, content, "utf-8");
+  renameSync(tmpPath, targetPath);
+}
+function appendProjectMemory(cwd, claim) {
+  const entry = {
+    id: claim.id,
+    kind: claim.kind,
+    text: claim.text,
+    confidence: claim.confidence,
+    createdAt: claim.createdAt,
+    source: claim.evidence?.[0]?.summary ?? "unknown",
+    ...claim.tags && claim.tags.length > 0 ? { tags: claim.tags } : {}
+  };
+  if (entry.tags?.includes("commit_fact")) {
+    appendToJsonl(cwd, "commit-facts.jsonl", entry, MAX_COMMIT_FACT_ENTRIES);
+    return;
+  }
+  appendToJsonl(cwd, "memory.jsonl", entry);
+}
+function appendKnowledgeJsonl(cwd, filename, record, fifoCap) {
+  appendToJsonl(cwd, filename, record, fifoCap);
+}
+function appendToJsonl(cwd, filename, entry, fifoCap) {
+  const dir = join(cwd, ".rivet", "knowledge");
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, filename);
+  const lockPath = join(dir, `${filename}.lock`);
+  const release = acquireLock(lockPath);
+  try {
+    let existing = "";
+    if (existsSync(path)) {
+      try {
+        existing = readFileSync(path, "utf-8");
+      } catch {
+      }
+    }
+    let newContent = existing + JSON.stringify(entry) + "\n";
+    if (fifoCap !== void 0) {
+      const lines = newContent.split("\n").filter((l) => l.trim());
+      if (lines.length > fifoCap) {
+        newContent = lines.slice(lines.length - fifoCap).join("\n") + "\n";
+      }
+    }
+    atomicWrite(path, newContent);
+  } finally {
+    release();
+  }
+}
+function readCommitFacts(cwd) {
+  const path = join(cwd, ".rivet", "knowledge", "commit-facts.jsonl");
+  if (!existsSync(path)) return [];
+  const entries = [];
+  try {
+    for (const line of readFileSync(path, "utf-8").split("\n").filter((l) => l.trim())) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.id && parsed.text) entries.push(parsed);
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return entries;
+}
+function compactProjectMemory(cwd) {
+  const dir = join(cwd, ".rivet", "knowledge");
+  const path = join(dir, "memory.jsonl");
+  const lockPath = join(dir, "memory.jsonl.lock");
+  if (!existsSync(path)) return 0;
+  const release = acquireLock(lockPath);
+  try {
+    const entries = [];
+    let fileSize = 0;
+    try {
+      const raw = readFileSync(path, "utf-8");
+      fileSize = raw.length;
+      const lines = raw.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.id && parsed.text) entries.push(parsed);
+        } catch {
+        }
+      }
+    } catch {
+      return 0;
+    }
+    const seen = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      seen.set(entry.id, entry);
+    }
+    const kept = [...seen.values()].sort((a, b) => b.confidence - a.confidence || (b.createdAt ?? b.ts ?? 0) - (a.createdAt ?? a.ts ?? 0)).slice(0, MAX_ENTRIES);
+    if (kept.length < entries.length || fileSize > MAX_FILE_SIZE) {
+      atomicWrite(path, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
+      return entries.length - kept.length;
+    }
+    return 0;
+  } finally {
+    release();
+  }
+}
+
+// src/memory/query-terms.ts
+init_esm_shims();
+var HAN_RE = new RegExp("\\p{Script=Han}", "u");
+var WORD_RE = /[\p{L}\p{N}_]+/gu;
+var LATIN_OR_NUMBER_RE = /[a-z0-9_]+/gi;
+var MAX_TERMS = 32;
+function tokenizeRecallQuery(query) {
+  const terms = /* @__PURE__ */ new Set();
+  const normalized = query.toLocaleLowerCase();
+  for (const segment of normalized.match(WORD_RE) ?? []) {
+    for (const token of segment.match(LATIN_OR_NUMBER_RE) ?? []) {
+      if (token.length >= 3) terms.add(token);
+    }
+    const han = Array.from(segment).filter((char) => HAN_RE.test(char));
+    if (han.length === 1) {
+      terms.add(han[0]);
+    } else {
+      for (let index = 0; index < han.length - 1; index++) {
+        terms.add(`${han[index]}${han[index + 1]}`);
+      }
+    }
+  }
+  return [...terms].slice(0, MAX_TERMS);
+}
+
+// src/memory/unified-memory.ts
+function projectHash(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+function legacyMemoryPath(cwd) {
+  return join2(memoryDir(projectHash(cwd)), "memory.jsonl");
+}
+function memoryPath(cwd) {
+  return join2(cwd, ".rivet", "knowledge", "memory.jsonl");
+}
+function generateId() {
+  return `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function normalizeEntry(raw) {
+  if (!raw.id || !raw.text) return null;
+  return {
+    id: String(raw.id),
+    text: String(raw.text),
+    kind: raw.kind ?? "fact",
+    confidence: typeof raw.confidence === "number" ? raw.confidence : 0.5,
+    source: raw.source ?? "manual",
+    status: raw.status ?? "observed",
+    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
+    sessionId: typeof raw.sessionId === "string" ? raw.sessionId : void 0,
+    tags: Array.isArray(raw.tags) ? raw.tags.filter((t) => typeof t === "string") : [],
+    ts: typeof raw.ts === "number" ? raw.ts : typeof raw.createdAt === "number" ? raw.createdAt : 0,
+    repeatCount: typeof raw.repeatCount === "number" ? raw.repeatCount : 1,
+    promotedToRule: typeof raw.promotedToRule === "string" ? raw.promotedToRule : void 0,
+    claimId: typeof raw.claimId === "string" ? raw.claimId : void 0,
+    fileRefs: Array.isArray(raw.fileRefs) ? raw.fileRefs.filter((f) => typeof f === "string") : void 0,
+    validFrom: typeof raw.validFrom === "number" ? raw.validFrom : void 0,
+    validTo: typeof raw.validTo === "number" ? raw.validTo : void 0,
+    supersededBy: typeof raw.supersededBy === "string" ? raw.supersededBy : void 0,
+    transferableTo: Array.isArray(raw.transferableTo) ? raw.transferableTo.filter((t) => typeof t === "string") : void 0,
+    topic: typeof raw.topic === "string" ? raw.topic : void 0
+  };
+}
+function readJsonlEntries(path) {
+  if (!existsSync2(path)) return [];
+  const results = [];
+  try {
+    for (const line of readFileSync2(path, "utf-8").split("\n").filter(Boolean)) {
+      try {
+        const entry = normalizeEntry(JSON.parse(line));
+        if (entry) results.push(entry);
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results;
+}
+function isCurrentEntry(entry) {
+  if (entry.validTo !== void 0 && entry.validTo <= Date.now()) return false;
+  if (entry.supersededBy) return false;
+  if (entry.status === "expired" || entry.status === "rejected") return false;
+  return true;
+}
+function appendMemoryEntry(cwd, partial) {
+  const normalized = partial.text.trim().toLowerCase().slice(0, 200);
+  let repeatCount = 1;
+  const path = memoryPath(cwd);
+  if (existsSync2(path)) {
+    try {
+      for (const line of readFileSync2(path, "utf-8").split("\n")) {
+        if (!line.trim()) continue;
+        if (line.toLowerCase().includes(normalized.slice(0, 50))) {
+          repeatCount++;
+        }
+      }
+    } catch {
+    }
+  }
+  const entry = {
+    id: partial.id ?? generateId(),
+    text: partial.text.slice(0, 500),
+    kind: partial.kind,
+    confidence: partial.confidence,
+    source: partial.source,
+    status: partial.status,
+    evidence: partial.evidence,
+    sessionId: partial.sessionId,
+    tags: partial.tags,
+    ts: partial.ts ?? Date.now(),
+    repeatCount,
+    promotedToRule: partial.promotedToRule,
+    claimId: partial.claimId,
+    fileRefs: partial.fileRefs,
+    validFrom: partial.validFrom,
+    validTo: partial.validTo,
+    supersededBy: partial.supersededBy,
+    transferableTo: partial.transferableTo,
+    topic: partial.topic
+  };
+  appendKnowledgeJsonl(cwd, "memory.jsonl", compactUndefined(entry));
+  return entry;
+}
+function compactUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function supersedeMemoryEntry(cwd, oldId, newId) {
+  const path = memoryPath(cwd);
+  if (!existsSync2(path)) return false;
+  const lockPath = join2(cwd, ".rivet", "knowledge", "memory.jsonl.lock");
+  const release = acquireLock(lockPath);
+  try {
+    let found = false;
+    const lines = [];
+    try {
+      for (const line of readFileSync2(path, "utf-8").split("\n").filter(Boolean)) {
+        try {
+          const raw = JSON.parse(line);
+          if (raw.id === oldId && !raw.supersededBy) {
+            raw.validTo = Date.now();
+            raw.supersededBy = newId;
+            raw.status = "expired";
+            found = true;
+            lines.push(JSON.stringify(raw));
+            continue;
+          }
+        } catch {
+        }
+        lines.push(line);
+      }
+    } catch {
+      return false;
+    }
+    if (!found) return false;
+    writeFileAtomicSync(path, lines.join("\n") + "\n");
+    return true;
+  } finally {
+    release();
+  }
+}
+function pruneMemoryStore(cwd, options = {}) {
+  const path = memoryPath(cwd);
+  if (!existsSync2(path)) return 0;
+  const retentionMs = (options.retentionDays ?? 90) * 864e5;
+  const lockPath = join2(cwd, ".rivet", "knowledge", "memory.jsonl.lock");
+  const release = acquireLock(lockPath);
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const lines = raw.split("\n").filter(Boolean);
+    const now = Date.now();
+    const kept = [];
+    let pruned = 0;
+    for (const line of lines) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        kept.push(line);
+        continue;
+      }
+      if (!parsed?.id || !parsed.text && parsed.kind !== "tombstone") {
+        kept.push(line);
+        continue;
+      }
+      const validTo = typeof parsed.validTo === "number" ? parsed.validTo : void 0;
+      if (validTo !== void 0 && validTo <= now - retentionMs) {
+        pruned++;
+        continue;
+      }
+      kept.push(line);
+    }
+    if (pruned === 0 && raw.length <= (options.maxFileBytes ?? 16384)) return 0;
+    writeFileAtomicSync(path, (pruned > 0 ? kept : lines).join("\n") + "\n");
+    return pruned;
+  } catch {
+    return 0;
+  } finally {
+    release();
+  }
+}
+function readMemoryEntries(cwd) {
+  const primary = readJsonlEntries(memoryPath(cwd));
+  const legacy = readJsonlEntries(legacyMemoryPath(cwd)).filter((e) => e.source !== "auto");
+  if (legacy.length === 0) return primary;
+  const seen = new Set(primary.map((e) => e.id));
+  const merged = [...primary];
+  for (const entry of legacy) {
+    if (!seen.has(entry.id)) merged.push(entry);
+  }
+  return merged;
+}
+function recallMemoryEntries(cwd, query, limit = 5, kindFilter, options) {
+  const terms = tokenizeRecallQuery(query);
+  if (terms.length === 0) return [];
+  const kinds = kindFilter ? Array.isArray(kindFilter) ? kindFilter : [kindFilter] : void 0;
+  const excludedSessionIds = /* @__PURE__ */ new Set();
+  if (options?.excludeSessionId) excludedSessionIds.add(options.excludeSessionId);
+  for (const id of options?.excludeSessionIds ?? []) excludedSessionIds.add(id);
+  const candidates = readMemoryEntries(cwd).filter((e) => !kinds || kinds.includes(e.kind)).filter((e) => options?.includeHistory || isCurrentEntry(e)).filter((e) => !options?.topic || (e.topic ?? "").toLowerCase().includes(options.topic.toLowerCase())).filter((e) => !excludedSessionIds.has(e.sessionId ?? ""));
+  const scored = candidates.map((entry) => {
+    const text = entry.text.toLowerCase();
+    const tagText = entry.tags.join(" ").toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+      if (text.includes(term)) score += 2;
+      if (tagText.includes(term)) score += 1;
+    }
+    score *= entry.confidence;
+    return { entry, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score || b.entry.ts - a.entry.ts);
+  return scored.slice(0, limit).map((s) => s.entry);
+}
+function renderMemoryBlock(cwd, query, maxChars = 2e3, sourceFilter, options) {
+  const excludedSessionIds = /* @__PURE__ */ new Set();
+  if (options?.excludeSessionId) excludedSessionIds.add(options.excludeSessionId);
+  for (const id of options?.excludeSessionIds ?? []) excludedSessionIds.add(id);
+  const excluded = (e) => !excludedSessionIds.has(e.sessionId ?? "");
+  const excludeOptions = { excludeSessionIds: [...excludedSessionIds] };
+  const recalled = sourceFilter ? options?.queryGatedSource ? recallMemoryEntries(cwd, query, 100, void 0, excludeOptions).filter((e) => e.source === sourceFilter).sort((a, b) => b.ts - a.ts || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, 8) : readMemoryEntries(cwd).filter((e) => e.source === sourceFilter).filter(excluded).filter(isCurrentEntry).sort((a, b) => b.ts - a.ts || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).slice(0, 8) : recallMemoryEntries(cwd, query, 8, void 0, excludeOptions);
+  if (recalled.length === 0) return null;
+  const lines = ["<cross-session-memory>"];
+  let budget = maxChars;
+  for (const entry of recalled) {
+    const line = `  <m kind="${escapeXml(entry.kind)}" c="${entry.confidence.toFixed(2)}">${escapeXml(entry.text)}</m>`;
+    if (line.length > budget) break;
+    lines.push(line);
+    budget -= line.length;
+  }
+  lines.push("</cross-session-memory>");
+  return lines.join("\n");
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function countSimilarMemoryEntries(cwd, text) {
+  const normalized = text.trim().toLowerCase().slice(0, 200);
+  return readMemoryEntries(cwd).filter(
+    (e) => e.text.trim().toLowerCase().slice(0, 200) === normalized
+  ).length;
+}
+function validateKnowledgeChains(entries) {
+  const issues = [];
+  const byId = new Map(entries.map((e) => [e.id, e]));
+  const supersedeTargets = new Set(
+    entries.map((e) => e.supersededBy).filter((id) => !!id)
+  );
+  const reportedCycleMembers = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.supersededBy) continue;
+    if (!byId.has(entry.supersededBy)) {
+      issues.push({
+        kind: "dangling_reference",
+        entryIds: [entry.id],
+        detail: `${entry.id} \u7684 supersededBy \u6307\u5411\u4E0D\u5B58\u5728\u7684 ${entry.supersededBy}`
+      });
+      continue;
+    }
+    if (reportedCycleMembers.has(entry.id)) continue;
+    const visited = /* @__PURE__ */ new Set();
+    let current = entry;
+    let cycleStart = null;
+    while (current) {
+      if (visited.has(current.id)) {
+        cycleStart = current.id;
+        break;
+      }
+      visited.add(current.id);
+      if (!current.supersededBy) break;
+      current = byId.get(current.supersededBy);
+    }
+    if (cycleStart) {
+      for (const id of visited) reportedCycleMembers.add(id);
+      issues.push({
+        kind: "cycle",
+        entryIds: [...visited],
+        detail: `supersede \u94FE\u5728 ${cycleStart} \u5F62\u6210\u73AF\uFF08${visited.size} \u4E2A\u6761\u76EE\uFF09`
+      });
+      continue;
+    }
+    if (supersedeTargets.has(entry.id)) continue;
+    let leaf = entry;
+    while (leaf.supersededBy && byId.has(leaf.supersededBy)) {
+      leaf = byId.get(leaf.supersededBy);
+    }
+    if (!isCurrentEntry(leaf)) {
+      let cursor = entry;
+      let allDead = true;
+      while (cursor) {
+        if (isCurrentEntry(cursor)) {
+          allDead = false;
+          break;
+        }
+        if (!cursor.supersededBy) break;
+        cursor = byId.get(cursor.supersededBy);
+      }
+      if (allDead) {
+        issues.push({
+          kind: "dead_chain",
+          entryIds: [entry.id, ...leaf.id !== entry.id ? [leaf.id] : []],
+          detail: `\u4ECE ${entry.id} \u8D77\u7684 supersede \u94FE\u65E0 current \u53F6\u5B50\uFF08\u672B\u7AEF ${leaf.id} \u5DF2\u5C01\u53E3\uFF09`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/agent/post-commit-review-queue.ts
+init_esm_shims();
+var queue = [];
+function enqueuePostCommitReviewOutcome(entry) {
+  queue.push({ ...entry, enqueuedAt: Date.now() });
+}
+function consumePostCommitReviewOutcomes() {
+  return queue.splice(0);
+}
+
+// src/agent/probe-detector.ts
+init_esm_shims();
+import { isAbsolute, join as join3 } from "path";
+var CONSOLE_PROBE_RE = /(^|[^.])\bconsole\.(log|debug|dir|trace)\s*\(/gm;
+var DEBUGGER_RE = /\bdebugger\b/g;
+var ONLY_PROBE_RE = /\b(it|describe|test|xit|xdescribe|xit)\.only\s*\(/g;
+var ASSERT_PROBE_RE = /(^|[^.\w])assert\s*\(/gm;
+var PROBE_PATTERNS = [
+  { name: "console.log/debug/dir/trace", re: CONSOLE_PROBE_RE },
+  { name: "debugger", re: DEBUGGER_RE },
+  { name: ".only() test isolation", re: ONLY_PROBE_RE },
+  { name: "bare assert()", re: ASSERT_PROBE_RE }
+];
+var WHITELIST_PREFIXES = [
+  "scripts/",
+  "desktop/scripts/",
+  // CLI 脚本的用户可见输出（台账 F2 实例②）
+  "bin/",
+  "src/server/serve.ts"
+  // API server startup logs
+];
+var WHITELIST_SUFFIXES = [
+  ".test.ts",
+  ".test.tsx",
+  ".test.js",
+  ".spec.ts",
+  ".md"
+];
+var STRUCTURED_LOG_RE = /\b(?!console\b)\w+(?:\.\w+)*\.(info|warn|error|debug|trace|verbose|silly|fatal)\s*\(/;
+var CONDITIONAL_DEBUG_RE = /\bif\s*\([^)]*\)\s*\{?\s*console\.(debug|log|dir|trace)\s*\(/;
+function isWhitelistedPath(filePath) {
+  const normalized = filePath.replace(/^\.\//, "");
+  for (const suffix of WHITELIST_SUFFIXES) {
+    if (normalized.endsWith(suffix)) return true;
+  }
+  for (const prefix of WHITELIST_PREFIXES) {
+    if (normalized.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function detectProbes(content, filePath) {
+  if (isWhitelistedPath(filePath)) return [];
+  const lines = content.split("\n");
+  const hits = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length > 120) continue;
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    for (const { name, re } of PROBE_PATTERNS) {
+      re.lastIndex = 0;
+      if (re.test(line)) {
+        if (name === "console.log/debug/dir/trace" && STRUCTURED_LOG_RE.test(line)) {
+          continue;
+        }
+        if (name === "console.log/debug/dir/trace" && CONDITIONAL_DEBUG_RE.test(line)) {
+          continue;
+        }
+        hits.push({
+          filePath,
+          pattern: name,
+          line: line.length > 120 ? line.slice(0, 120) + "..." : line,
+          lineNumber: i + 1
+        });
+      }
+      re.lastIndex = 0;
+    }
+  }
+  return hits;
+}
+function scanFilesForProbes(filePaths, cwd, readFile) {
+  const allHits = [];
+  for (const filePath of filePaths) {
+    if (isWhitelistedPath(filePath)) continue;
+    const content = readFile(isAbsolute(filePath) ? filePath : join3(cwd, filePath));
+    if (content === null) continue;
+    const hits = detectProbes(content, filePath);
+    allHits.push(...hits);
+  }
+  return allHits;
+}
+function formatProbeHits(hits) {
+  if (hits.length === 0) return [];
+  const lines = [
+    "",
+    "\u26A0\uFE0F  \u63A2\u9488\u6B8B\u7559\u68C0\u6D4B \u2014 \u4EE5\u4E0B\u6587\u4EF6\u5305\u542B\u8C03\u8BD5\u63A2\u9488\uFF08console.log/debugger/.only \u7B49\uFF09\uFF0C\u4EA4\u4ED8\u524D\u5E94\u6E05\u7406\uFF1A"
+  ];
+  const byFile = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const existing = byFile.get(hit.filePath) ?? [];
+    existing.push(hit);
+    byFile.set(hit.filePath, existing);
+  }
+  for (const [filePath, fileHits] of byFile) {
+    lines.push(`  ${filePath}:`);
+    for (const h of fileHits.slice(0, 3)) {
+      lines.push(`    L${h.lineNumber} [${h.pattern}] ${h.line.trim()}`);
+    }
+    if (fileHits.length > 3) {
+      lines.push(`    ... +${fileHits.length - 3} more`);
+    }
+  }
+  lines.push("  \u6E05\u7406\u63A2\u9488\u540E\u91CD\u65B0\u4EA4\u4ED8\u3002\u5982\u679C\u662F\u6709\u610F\u6DFB\u52A0\u7684\u65E5\u5FD7\uFF0C\u8BF7\u4F7F\u7528\u7ED3\u6784\u5316\u65E5\u5FD7\uFF08logger.info \u7B49\uFF09\u3002");
+  return lines;
+}
+
+// src/agent/hooks/external-claim-tracking-hook.ts
+init_esm_shims();
+var DELEGATE_TOOLS = /* @__PURE__ */ new Set(["delegate_task", "delegate_batch"]);
+var VERIFY_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "grep",
+  "glob",
+  "semantic_search",
+  "lsp_goto_definition",
+  "lsp_find_references"
+]);
+var CLAIM_TTL_TURNS = 5;
+var FILE_LINE_RE = /(\b(?:src|test|tests|scripts|docs|config)\/[^\s:)]+\.(?:ts|tsx|js|jsx|json|md)):(\d+)/g;
+function canonicalizePath(pathRef) {
+  return pathRef.replace(/:\d+.*$/, "");
+}
+function extractClaimedPaths(content) {
+  const paths = /* @__PURE__ */ new Set();
+  FILE_LINE_RE.lastIndex = 0;
+  let match;
+  while ((match = FILE_LINE_RE.exec(content)) !== null) {
+    paths.add(canonicalizePath(match[1]));
+  }
+  return [...paths];
+}
+function verifyTargetOf(tool) {
+  const input = tool.input ?? {};
+  const parts = [];
+  for (const key of ["path", "file_path", "file", "pattern", "query", "command"]) {
+    const v = input[key];
+    if (typeof v === "string") parts.push(v);
+  }
+  if (tool.target) parts.push(tool.target);
+  return parts.join(" ");
+}
+function findUnverifiedClaimRefs(tracker, text) {
+  const scanText = text.split("\n").filter((l) => !l.includes("[\u5F85\u6838]")).join("\n");
+  const refs = extractClaimedPaths(scanText);
+  if (refs.length === 0) return [];
+  const unverified = new Set(
+    tracker.claims.filter((c) => c.verifiedAt === void 0).map((c) => c.filePath)
+  );
+  return refs.filter((r) => unverified.has(r));
+}
+function createExternalClaimTrackingHook(deps) {
+  const tracker = { claims: [] };
+  const hook = {
+    phase: "postTool",
+    name: "external-claim-tracking",
+    getClaimTracker() {
+      return tracker;
+    },
+    resetClaimTracker() {
+      tracker.claims = [];
+    },
+    run(ctx, tool) {
+      const { turn } = ctx.snapshot;
+      tracker.claims = tracker.claims.filter((c) => c.expiresAtTurn > turn);
+      if (DELEGATE_TOOLS.has(tool.name) && tool.success && tool.resultContent) {
+        const claimedPaths = extractClaimedPaths(tool.resultContent);
+        const inputPaths = /* @__PURE__ */ new Set();
+        const files = tool.input?.files;
+        if (Array.isArray(files)) {
+          for (const f of files) {
+            if (typeof f === "string") inputPaths.add(canonicalizePath(f));
+          }
+        }
+        const inputFiles = tool.input?.input_files;
+        if (Array.isArray(inputFiles)) {
+          for (const f of inputFiles) {
+            if (typeof f === "string") inputPaths.add(canonicalizePath(f));
+          }
+        }
+        for (const filePath of claimedPaths) {
+          if (inputPaths.has(filePath)) continue;
+          tracker.claims.push({
+            filePath,
+            turn,
+            expiresAtTurn: turn + CLAIM_TTL_TURNS
+          });
+        }
+        return;
+      }
+      const isVerifyShapedBash = tool.name === "bash" && /\b(grep|cat|rg|find|head|tail|sed)\b/.test(String(tool.input?.command ?? ""));
+      if ((VERIFY_TOOLS.has(tool.name) || isVerifyShapedBash) && tool.success) {
+        const hay = verifyTargetOf(tool);
+        if (hay) {
+          tracker.claims = tracker.claims.map(
+            (c) => c.verifiedAt === void 0 && hay.includes(c.filePath) ? { ...c, verifiedAt: turn } : c
+          );
+        }
+        return;
+      }
+      if (tool.name === "deliver_task" && tool.success) {
+        const input = tool.input ?? {};
+        const checklist = Array.isArray(input.checklist) ? input.checklist.map((e) => typeof e?.item === "string" ? e.item : "").join("\n") : "";
+        const text = `${typeof input.message === "string" ? input.message : ""}
+${checklist}`;
+        const refs = findUnverifiedClaimRefs(tracker, text);
+        if (refs.length > 0) {
+          deps.advisoryBus.submit({
+            key: "external-claim-in-delivery",
+            priority: 0.6,
+            category: "discipline",
+            content: `\u26A0 \u4EA4\u4ED8\u6587\u672C\u5F15\u7528\u4E86 delegate \u62A5\u544A\u7684 ${refs.join("\u3001")}\uFF0C\u4F46\u672C\u4F1A\u8BDD\u6CA1\u6709\u5BF9\u5176\u72EC\u7ACB\u6838\u9A8C\uFF08read_file/grep\uFF09\u3002worker \u7684 file:line \u662F\u5F85\u6838\u9A8C\u5047\u8BBE\u2014\u2014commit \u524D\u5148\u6838\u9A8C\uFF0C\u6216\u5C06\u8BE5\u6761\u6807\u6CE8 [\u5F85\u6838] \u964D\u7EA7\u4E3A\u7EBF\u7D22\u3002`,
+            ttl: 1,
+            expect: { kind: "tool_appears", tools: [...VERIFY_TOOLS, "bash"], targetIncludes: refs[0], withinTurns: 2 }
+          });
+        }
+        return;
+      }
+      if (!WRITE_TOOL_NAMES.has(tool.name)) return;
+      const writePaths = extractWriteFilePaths(tool.name, tool.input);
+      if (writePaths.length === 0) return;
+      const activeClaims = tracker.claims.filter((c) => c.expiresAtTurn > turn);
+      const matchedClaim = activeClaims.find(
+        (c) => writePaths.some((wp) => c.filePath === wp || wp.endsWith(c.filePath) || c.filePath.endsWith(wp))
+      );
+      if (!matchedClaim) return;
+      const history = ctx.snapshot.recentToolHistory;
+      const claimedPath = matchedClaim.filePath;
+      const hasIndependentVerify = history.some((h) => {
+        const target = h.target ?? "";
+        const pathMatches = target.includes(claimedPath) || claimedPath.includes(target);
+        if (!pathMatches) return false;
+        if (VERIFY_TOOLS.has(h.tool)) return true;
+        if (h.tool === "bash" && /\b(grep|cat|find|rg)\b/.test(target)) return true;
+        return false;
+      });
+      if (!hasIndependentVerify && matchedClaim.verifiedAt === void 0) {
+        deps.advisoryBus.submit({
+          key: "external-claim-unverified",
+          priority: 0.56,
+          category: "discipline",
+          content: `\u26A0 delegate \u62A5\u544A\u4E2D\u63D0\u5230\u4E86 ${claimedPath}\uFF0C\u4F60\u6B63\u5728\u7F16\u8F91\u5B83\uFF0C\u4F46\u4E2D\u95F4\u6CA1\u6709\u72EC\u7ACB\u6838\u9A8C\uFF08read_file/grep\uFF09\u3002worker \u62A5\u544A\u7684\u884C\u53F7\u53EF\u80FD\u504F\u79FB\u6216\u5F15\u7528\u4E86\u8FC7\u65F6\u6587\u4EF6\u72B6\u6001\u3002\u5148\u7528 read_file \u6216 grep \u72EC\u7ACB\u786E\u8BA4\u8BE5\u8DEF\u5F84\u7684\u5F53\u524D\u5185\u5BB9\uFF0C\u518D\u7F16\u8F91\u3002`,
+          ttl: 1,
+          // 谓词映射表（P1a）：external-claim → tool_appears(核验类, 目标=声称路径, 2 轮)
+          expect: {
+            kind: "tool_appears",
+            tools: [...VERIFY_TOOLS, "bash"],
+            targetIncludes: claimedPath,
+            withinTurns: 2
+          }
+        });
+      }
+    }
+  };
+  return hook;
+}
+
+export {
+  extractRegressionInventory,
+  findApprovedPlanInventory,
+  verifyRegressionInventory,
+  formatInventoryReport,
+  createRenderVerifyHook,
+  isUiFilePath,
+  isVisualVerifyTool,
+  appendProjectMemory,
+  readCommitFacts,
+  compactProjectMemory,
+  tokenizeRecallQuery,
+  isCurrentEntry,
+  appendMemoryEntry,
+  supersedeMemoryEntry,
+  pruneMemoryStore,
+  readMemoryEntries,
+  renderMemoryBlock,
+  countSimilarMemoryEntries,
+  validateKnowledgeChains,
+  enqueuePostCommitReviewOutcome,
+  consumePostCommitReviewOutcomes,
+  detectProbes,
+  scanFilesForProbes,
+  formatProbeHits,
+  findUnverifiedClaimRefs,
+  createExternalClaimTrackingHook
+};