tianshu-harness 3.23.0

package/dist/chunk-GHVMWF2I.js

@@ -0,0 +1,581 @@
+#!/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 {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/session-registry.ts
+init_esm_shims();
+import { join } from "path";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync } from "fs";
+
+// src/agent/retrospect-fingerprint.ts
+init_esm_shims();
+var SECTION_HEADINGS = {
+  rootCause: /^##\s+3\.\s+根因判定/,
+  recommendation: /^##\s+4\.\s+寻址建议/
+};
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "into",
+  "after",
+  "before",
+  "\u672C\u6B21",
+  "\u4F1A\u8BDD",
+  "\u5EFA\u8BAE",
+  "\u8003\u8651",
+  "\u7CFB\u7EDF",
+  "\u7528\u6237",
+  "\u53EF\u80FD",
+  "\u95EE\u9898"
+]);
+function extractSectionText(report, heading) {
+  const lines = report.split("\n");
+  const start = lines.findIndex((line) => heading.test(line.trim()));
+  if (start === -1) return "";
+  const section = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^##\s+/.test(line.trim())) break;
+    section.push(line);
+  }
+  return section.join("\n");
+}
+function isCJKChar(ch) {
+  const cp = ch.codePointAt(0);
+  return cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 12288 && cp <= 12351 || cp >= 65280 && cp <= 65519;
+}
+function extractKeywords(text, max = 12) {
+  if (!text) return [];
+  const rawTokens = text.split(/[^\p{L}\p{N}_./-]+/u).map((t) => t.trim()).filter((t) => t.length >= 2).filter((t) => !STOP_WORDS.has(t.toLowerCase()));
+  const expanded = [];
+  for (const token of rawTokens) {
+    const chars = [...token];
+    const allCJK = chars.every((ch) => isCJKChar(ch));
+    if (allCJK && chars.length > 2) {
+      for (let i = 0; i < chars.length - 1; i++) {
+        expanded.push(chars[i] + chars[i + 1]);
+      }
+    } else {
+      expanded.push(token.toLowerCase());
+    }
+  }
+  return [...new Set(expanded)].slice(0, max);
+}
+function buildRetrospectFingerprint(sessionId, report, bullets, options) {
+  const now = options?.now ?? Date.now();
+  const rootCauseText = extractSectionText(report, SECTION_HEADINGS.rootCause);
+  const recommendationText = extractSectionText(report, SECTION_HEADINGS.recommendation);
+  return {
+    sessionId,
+    createdAt: now,
+    rootCauseKeywords: extractKeywords(rootCauseText),
+    recommendationKeywords: extractKeywords(recommendationText),
+    stabilityTrend: options?.stabilityTrend ?? "stable",
+    confidenceTrend: options?.confidenceTrend ?? "stable",
+    maxPressure: options?.maxPressure ?? 0.5,
+    toolFailureRate: options?.toolFailureRate ?? 0,
+    bulletIds: bullets.map((b) => b.id)
+  };
+}
+function fingerprintSimilarity(a, b) {
+  const rootOverlap = keywordOverlap(a.rootCauseKeywords, b.rootCauseKeywords);
+  const recoOverlap = keywordOverlap(a.recommendationKeywords, b.recommendationKeywords);
+  let similarity = rootOverlap * 0.7 + recoOverlap * 0.3;
+  if (a.stabilityTrend !== b.stabilityTrend) similarity *= 0.9;
+  if (a.confidenceTrend !== b.confidenceTrend) similarity *= 0.9;
+  return similarity;
+}
+function keywordOverlap(a, b) {
+  const left = new Set(a);
+  const right = new Set(b);
+  if (left.size === 0 && right.size === 0) return 0;
+  const intersection = [...left].filter((k) => right.has(k)).length;
+  const denominator = Math.max(1, Math.min(left.size, right.size));
+  return intersection / denominator;
+}
+var VALID_TRENDS = /* @__PURE__ */ new Set(["stable", "falling", "rising"]);
+function validateTrend(value, fallback) {
+  if (VALID_TRENDS.has(value)) return value;
+  return fallback;
+}
+
+// src/agent/session-registry.ts
+function projectHash(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  pid INTEGER NOT NULL,
+  cwd TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL,
+  role TEXT NOT NULL CHECK(role IN ('coordinator','worker','standalone')),
+  task_description TEXT
+);
+
+CREATE TABLE IF NOT EXISTS claims (
+  session_id TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  claim_type TEXT NOT NULL CHECK(claim_type IN ('exclusive','shared_read')),
+  acquired_at TEXT NOT NULL,
+  confidence_trend TEXT,
+  detail TEXT,
+  priority INTEGER DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_claims_session ON claims(session_id);
+CREATE INDEX IF NOT EXISTS idx_claims_file ON claims(file_path);
+
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  file_path TEXT,
+  detail TEXT,
+  priority INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_created ON events(created_at);
+
+CREATE TABLE IF NOT EXISTS cycle_relay (
+  session_id TEXT PRIMARY KEY,
+  cycle_open TEXT NOT NULL,
+  cycle_close TEXT,
+  generation INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  closed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_cycle_relay_closed ON cycle_relay(closed_at);
+
+CREATE TABLE IF NOT EXISTS retrospect_fingerprints (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  root_cause_keywords TEXT NOT NULL,
+  recommendation_keywords TEXT NOT NULL,
+  stability_trend TEXT NOT NULL CHECK(stability_trend IN ('stable','falling','rising')),
+  confidence_trend TEXT NOT NULL CHECK(confidence_trend IN ('stable','falling','rising')),
+  max_pressure REAL NOT NULL,
+  tool_failure_rate REAL NOT NULL,
+  bullet_ids TEXT NOT NULL DEFAULT '[]',
+  project_hash TEXT,
+  UNIQUE(session_id)
+);
+CREATE INDEX IF NOT EXISTS idx_fingerprints_created ON retrospect_fingerprints(created_at);
+CREATE INDEX IF NOT EXISTS idx_fingerprints_project ON retrospect_fingerprints(project_hash);
+`;
+var _forceNullDbForTest = false;
+function _setBackendForTest(kind) {
+  _forceNullDbForTest = kind === "null";
+}
+function _resetBackendForTest() {
+  _forceNullDbForTest = false;
+}
+var SessionRegistry = class _SessionRegistry {
+  db;
+  static async create(stateDir) {
+    if (_forceNullDbForTest) return new _SessionRegistry(createNullDb());
+    if (!existsSync(stateDir)) mkdirSync(stateDir, { recursive: true });
+    let db;
+    try {
+      const { resolveBetterSqlite3 } = await import("./native-resolver-PN34UIVV.js");
+      const Database = resolveBetterSqlite3(import.meta.url);
+      if (!Database) throw new Error("better-sqlite3 not installed");
+      const dbPath = join(stateDir, "registry.db");
+      db = new Database(dbPath);
+      db.pragma("journal_mode = WAL");
+      db.pragma("busy_timeout = 3000");
+      db.pragma("foreign_keys = ON");
+      try {
+        db.exec("ALTER TABLE retrospect_fingerprints ADD COLUMN project_hash TEXT");
+      } catch {
+      }
+      db.exec(SCHEMA);
+    } catch (err) {
+      if (err?.code === "ESQLITE_BUNDLE_BROKEN") throw err;
+      if (err instanceof Error && err.message?.includes("better-sqlite3")) {
+        const hint = process.platform === "win32" ? 'Run: cd "$(npm root -g)\\tianshu-harness" && node scripts\\fetch-native-sqlite.js' : 'Run: cd "$(npm root -g)/tianshu-harness" && node scripts/fetch-native-sqlite.js';
+        console.warn(`\u26A0 better-sqlite3 not available. Session history & cross-session memory will NOT persist (in-memory only, lost on exit). Reason: ${err.message}
+  Fix: ${hint}`);
+      } else {
+        console.error("Session registry schema failed:", err);
+      }
+      db = createNullDb();
+    }
+    return new _SessionRegistry(db);
+  }
+  /**
+   * Create and immediately reap crashed sessions' rows/claims (pid-liveness
+   * sweep). A hard-killed process (kill -9 / power loss) leaves its exclusive
+   * claims behind in the shared db; without the sweep the R2 pre-write guard
+   * permanently rejects writes to those files, pointing at a dead session id.
+   * Single home for the TUI bootstrap and serve sidecar startup sweep — no
+   * auto-resume: crashed sessions stay recoverable via --continue / --resume.
+   */
+  static async createWithReap(stateDir, onReaped) {
+    const registry = await _SessionRegistry.create(stateDir);
+    const crashed = registry.detectCrashedSessions();
+    if (crashed.length > 0) onReaped?.(crashed);
+    return registry;
+  }
+  constructor(db) {
+    this.db = db;
+  }
+  // ── Safe DB helpers ──
+  safeRun(sql, ...params) {
+    try {
+      return this.db.prepare(sql).run(...params).changes ?? 0;
+    } catch (err) {
+      console.error("SessionRegistry write error:", err.message);
+      return 0;
+    }
+  }
+  safeGet(sql, ...params) {
+    try {
+      return this.db.prepare(sql).get(...params);
+    } catch (err) {
+      console.error("SessionRegistry read error:", err.message);
+      return void 0;
+    }
+  }
+  safeAll(sql, ...params) {
+    try {
+      return this.db.prepare(sql).all(...params);
+    } catch (err) {
+      console.error("SessionRegistry read error:", err.message);
+      return [];
+    }
+  }
+  register(sessionId, cwd, role = "standalone") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.safeRun(`
+      INSERT INTO sessions (id, pid, cwd, started_at, heartbeat_at, role)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        pid = excluded.pid,
+        cwd = excluded.cwd,
+        heartbeat_at = excluded.heartbeat_at,
+        role = excluded.role
+    `, sessionId, process.pid, cwd, now, now, role);
+  }
+  heartbeat(sessionId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.safeRun("UPDATE sessions SET heartbeat_at = ? WHERE id = ?", now, sessionId);
+  }
+  unregister(sessionId) {
+    this.releaseAllClaims(sessionId);
+    this.safeRun("DELETE FROM sessions WHERE id = ?", sessionId);
+  }
+  updatePid(sessionId, pid) {
+    this.safeRun("UPDATE sessions SET pid = ? WHERE id = ?", pid, sessionId);
+  }
+  listActive() {
+    return this.safeAll("SELECT id, pid, role, task_description AS taskDescription, heartbeat_at AS heartbeatAt FROM sessions");
+  }
+  /**
+   * Count other sessions running on the same cwd with a live pid and recent
+   * heartbeat. Used by VSW snapshot-policy to decide whether to isolate (C2).
+   *
+   * @param cwd           project root to match against
+   * @param mySessionId   exclude self
+   * @param maxHeartbeatAgeMs  sessions with heartbeat older than this are considered stale (default 120s)
+   */
+  countSameCwdActive(cwd, mySessionId, maxHeartbeatAgeMs = 12e4) {
+    const cutoff = new Date(Date.now() - maxHeartbeatAgeMs).toISOString();
+    const rows = this.safeAll(
+      `SELECT id, pid FROM sessions WHERE cwd = ? AND id != ? AND heartbeat_at > ?`,
+      cwd,
+      mySessionId,
+      cutoff
+    );
+    return rows.filter((r) => this.isProcessRunning(r.pid)).length;
+  }
+  detectCrashedSessions() {
+    const sessions = this.listActive();
+    const crashed = [];
+    for (const s of sessions) {
+      if (!this.isProcessRunning(s.pid)) {
+        crashed.push(s);
+      }
+    }
+    if (crashed.length > 0) {
+      const ids = crashed.map((s) => s.id);
+      const placeholders = ids.map(() => "?").join(",");
+      this.safeRun(`DELETE FROM claims WHERE session_id IN (${placeholders})`, ...ids);
+      this.safeRun(`DELETE FROM sessions WHERE id IN (${placeholders})`, ...ids);
+    }
+    return crashed;
+  }
+  acquireClaim(sessionId, filePath, claimType) {
+    const existing = this.safeAll(
+      "SELECT session_id, claim_type FROM claims WHERE file_path = ?",
+      filePath
+    );
+    for (const c of existing) {
+      if (c.session_id === sessionId) return true;
+      if (c.claim_type === "exclusive") return false;
+      if (claimType === "exclusive") return false;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const changes = this.safeRun(
+      "INSERT OR REPLACE INTO claims (session_id, file_path, claim_type, acquired_at) VALUES (?, ?, ?, ?)",
+      sessionId,
+      filePath,
+      claimType,
+      now
+    );
+    return changes > 0;
+  }
+  releaseClaim(sessionId, filePath) {
+    this.safeRun("DELETE FROM claims WHERE session_id = ? AND file_path = ?", sessionId, filePath);
+  }
+  releaseAllClaims(sessionId) {
+    this.safeRun("DELETE FROM claims WHERE session_id = ?", sessionId);
+  }
+  checkClaim(filePath) {
+    const row = this.safeGet(
+      "SELECT session_id AS sessionId, claim_type AS claimType, file_path AS filePath FROM claims WHERE file_path = ? LIMIT 1",
+      filePath
+    );
+    return row ?? null;
+  }
+  reapStaleClaims() {
+    const sessions = this.listActive();
+    const deadIds = [];
+    for (const s of sessions) {
+      if (!this.isProcessRunning(s.pid)) {
+        deadIds.push(s.id);
+      }
+    }
+    if (deadIds.length === 0) return [];
+    const placeholders = deadIds.map(() => "?").join(",");
+    const rows = this.safeAll(
+      `SELECT DISTINCT file_path FROM claims WHERE session_id IN (${placeholders})`,
+      ...deadIds
+    );
+    this.safeRun(`DELETE FROM claims WHERE session_id IN (${placeholders})`, ...deadIds);
+    this.safeRun(`DELETE FROM sessions WHERE id IN (${placeholders})`, ...deadIds);
+    return rows.map((r) => r.file_path);
+  }
+  close() {
+    this.db.close();
+  }
+  // ── Events (cross-session communication) ──────────────────
+  publishEvent(sessionId, input) {
+    this.safeRun(`
+      INSERT INTO events (session_id, event_type, file_path, detail, priority)
+      VALUES (?, ?, ?, ?, ?)
+    `, sessionId, input.eventType, input.filePath ?? null, input.detail ?? null, input.priority ?? 0);
+  }
+  consumeEvents(mySessionId, lastSeenId, limit = 50) {
+    return this.safeAll(`
+      SELECT id, session_id AS sessionId, event_type AS eventType,
+             file_path AS filePath, detail, priority, created_at AS createdAt
+      FROM events
+      WHERE id > ? AND session_id != ?
+      ORDER BY id ASC
+      LIMIT ?
+    `, lastSeenId, mySessionId, limit);
+  }
+  cleanupOldEvents(maxAgeMs) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    return this.safeRun("DELETE FROM events WHERE created_at < ?", cutoff);
+  }
+  // ── Cycle relay (Songline substrate) ─────────────────────
+  setCycleOpen(sessionId, cycleOpen, generation = 0) {
+    this.safeRun(`
+      INSERT INTO cycle_relay (session_id, cycle_open, generation)
+      VALUES (?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        cycle_open = excluded.cycle_open,
+        generation = excluded.generation
+    `, sessionId, cycleOpen, generation);
+  }
+  setCycleClose(sessionId, cycleClose) {
+    this.safeRun(`
+      INSERT INTO cycle_relay (session_id, cycle_open, cycle_close, generation, closed_at)
+      VALUES (?, ?, ?, 0, datetime('now'))
+      ON CONFLICT(session_id) DO UPDATE SET
+        cycle_close = excluded.cycle_close,
+        generation = cycle_relay.generation + 1,
+        closed_at = excluded.closed_at
+    `, sessionId, cycleClose, cycleClose);
+  }
+  getCycleOpen(sessionId) {
+    const row = this.safeGet(
+      "SELECT cycle_open AS cycleOpen FROM cycle_relay WHERE session_id = ?",
+      sessionId
+    );
+    return row?.cycleOpen ?? null;
+  }
+  getCycleClose(sessionId) {
+    const row = this.safeGet(
+      "SELECT cycle_close AS cycleClose FROM cycle_relay WHERE session_id = ?",
+      sessionId
+    );
+    return row?.cycleClose ?? null;
+  }
+  getLastCycleClose() {
+    const row = this.safeGet(`
+      SELECT cycle_close AS cycleClose
+      FROM cycle_relay
+      WHERE cycle_close IS NOT NULL
+      ORDER BY closed_at DESC, created_at DESC
+      LIMIT 1
+    `);
+    return row?.cycleClose ?? null;
+  }
+  getCycleRelay(sessionId) {
+    const row = this.safeGet(`
+      SELECT session_id AS sessionId,
+             cycle_open AS cycleOpen,
+             cycle_close AS cycleClose,
+             generation,
+             created_at AS createdAt,
+             closed_at AS closedAt
+      FROM cycle_relay
+      WHERE session_id = ?
+    `, sessionId);
+    return row ?? null;
+  }
+  // ── Cross-session claims snapshot for prompt injection ──
+  /**
+   * Return all active claims grouped by file, excluding claims held by `mySessionId`.
+   * Used for prompt injection so the LLM can see which files other sessions are working on.
+   */
+  getActiveClaims(excludeSessionId) {
+    return this.safeAll(`
+      SELECT c.session_id AS sessionId, c.file_path AS filePath, c.claim_type AS claimType
+      FROM claims c
+      JOIN sessions s ON s.id = c.session_id
+      WHERE c.session_id != ?
+    `, excludeSessionId);
+  }
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ── Retrospect Fingerprints (REM pattern detection) ──────
+  /**
+   * 存储 session 的 retrospect 指纹。
+   * 如果该 session 已有指纹，会被覆盖（UPSERT）。
+   */
+  storeFingerprint(fp) {
+    this.safeRun(
+      `
+      INSERT INTO retrospect_fingerprints
+        (session_id, created_at, root_cause_keywords, recommendation_keywords,
+         stability_trend, confidence_trend, max_pressure, tool_failure_rate, bullet_ids, project_hash)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        created_at = excluded.created_at,
+        root_cause_keywords = excluded.root_cause_keywords,
+        recommendation_keywords = excluded.recommendation_keywords,
+        stability_trend = excluded.stability_trend,
+        confidence_trend = excluded.confidence_trend,
+        max_pressure = excluded.max_pressure,
+        tool_failure_rate = excluded.tool_failure_rate,
+        bullet_ids = excluded.bullet_ids,
+        project_hash = excluded.project_hash
+    `,
+      fp.sessionId,
+      fp.createdAt,
+      JSON.stringify(fp.rootCauseKeywords),
+      JSON.stringify(fp.recommendationKeywords),
+      fp.stabilityTrend,
+      fp.confidenceTrend,
+      fp.maxPressure,
+      fp.toolFailureRate,
+      JSON.stringify(fp.bulletIds),
+      fp.projectHash ?? null
+    );
+  }
+  /**
+   * 加载历史指纹，按时间倒序。
+   * @param limit 最多返回的指纹数量（默认 10）
+   * @param excludeSessionId 排除的 session ID（通常是当前 session）
+   */
+  loadFingerprints(limit = 10, excludeSessionId, projectHash2) {
+    const conditions = [];
+    const params = [];
+    if (excludeSessionId) {
+      conditions.push("session_id != ?");
+      params.push(excludeSessionId);
+    }
+    if (projectHash2) {
+      conditions.push("project_hash = ?");
+      params.push(projectHash2);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    params.push(limit);
+    const query = `SELECT session_id, created_at, root_cause_keywords, recommendation_keywords,
+                stability_trend, confidence_trend, max_pressure, tool_failure_rate, bullet_ids
+         FROM retrospect_fingerprints
+         ${where}
+         ORDER BY created_at DESC
+         LIMIT ?`;
+    const rows = this.safeAll(query, ...params);
+    return rows.map((row) => ({
+      sessionId: row.session_id,
+      createdAt: row.created_at,
+      rootCauseKeywords: JSON.parse(row.root_cause_keywords),
+      recommendationKeywords: JSON.parse(row.recommendation_keywords),
+      stabilityTrend: validateTrend(row.stability_trend, "stable"),
+      confidenceTrend: validateTrend(row.confidence_trend, "stable"),
+      maxPressure: row.max_pressure,
+      toolFailureRate: row.tool_failure_rate,
+      bulletIds: JSON.parse(row.bullet_ids)
+    }));
+  }
+  /**
+   * 清理旧指纹。
+   * @param maxAgeMs 最大保留时间（毫秒）
+   * @returns 删除的指纹数量
+   */
+  cleanupOldFingerprints(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    return this.safeRun("DELETE FROM retrospect_fingerprints WHERE created_at < ?", cutoff);
+  }
+};
+function createNullDb() {
+  const noopStmt = {
+    run: () => ({ changes: 1, lastInsertRowid: 0 }),
+    all: () => [],
+    get: () => void 0
+  };
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get: (_target, prop) => {
+      if (prop === "prepare") return () => noopStmt;
+      if (prop === "exec") return () => {
+      };
+      if (prop === "pragma") return () => {
+      };
+      if (prop === "close") return () => {
+      };
+      return () => {
+      };
+    }
+  });
+}
+
+export {
+  buildRetrospectFingerprint,
+  fingerprintSimilarity,
+  projectHash,
+  _setBackendForTest,
+  _resetBackendForTest,
+  SessionRegistry
+};