tianshu-harness 3.23.0

package/dist/chunk-CGOADM2X.js

@@ -0,0 +1,337 @@
+#!/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 {
+  normalizeFrontmatterSource
+} from "./chunk-ADIVZ2D5.js";
+import {
+  STAR_DOMAINS
+} from "./chunk-WMUWEO2C.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/star-domain-registry.ts
+init_esm_shims();
+
+// src/agent/star-domain.ts
+init_esm_shims();
+function matchDomain(taskDescription, pool) {
+  return starDomainRegistry.matchDomain(taskDescription, pool);
+}
+var DELEGATION_FALLBACK_AUTHORITY = "tianliang";
+var MAX_AUTHORITY_KEYWORDS = 3;
+var MAX_AUTHORITY_REASON_LEN = 60;
+function deriveAuthority(objective) {
+  const detail = starDomainRegistry.matchDomainDetailed(objective);
+  if (detail.verdict === "hit" && detail.id) {
+    const kws = detail.matchedKeywords.slice(0, MAX_AUTHORITY_KEYWORDS);
+    const hit = kws.length > 0 ? `\u547D\u4E2D: ${kws.join("+")}` : `\u547D\u4E2D: ${detail.id}`;
+    return {
+      authority: detail.id,
+      reasons: [truncateReason(hit)],
+      detail
+    };
+  }
+  if (detail.verdict === "tie") {
+    const tied = (detail.tiedIds ?? []).map(labelDomain).join("/");
+    return {
+      authority: DELEGATION_FALLBACK_AUTHORITY,
+      reasons: [truncateReason(`\u5E73\u624B(${tied})\u2192\u5929\u6881\u515C\u5E95`)],
+      detail
+    };
+  }
+  return {
+    authority: DELEGATION_FALLBACK_AUTHORITY,
+    reasons: [truncateReason("\u65E0\u5173\u952E\u8BCD\u547D\u4E2D\u2192\u5929\u6881\u515C\u5E95")],
+    detail
+  };
+}
+function resolveAuthorityReason(objective, authority) {
+  if (!authority) return void 0;
+  const derived = deriveAuthority(objective);
+  if (authority === derived.authority && derived.detail.verdict === "hit") {
+    return derived.reasons[0];
+  }
+  return "\u663E\u5F0F\u6307\u5B9A";
+}
+function labelDomain(id) {
+  return starDomainRegistry.get(id)?.name ?? id;
+}
+function truncateReason(text) {
+  if (text.length <= MAX_AUTHORITY_REASON_LEN) return text;
+  return text.slice(0, MAX_AUTHORITY_REASON_LEN - 1) + "\u2026";
+}
+var DEFAULT_DOMAIN = "tianquan";
+var DOMAIN_AUTO_POOL = ["tianquan", "kaiyang", "yaoguang", "tianliang"];
+function resolveActiveDomain(taskDescription, opts) {
+  const keywordRouting = opts?.keywordRouting !== false;
+  const pool = [
+    ...DOMAIN_AUTO_POOL,
+    ...starDomainRegistry.list().filter((d) => d.isCustom).map((d) => d.id)
+  ];
+  const detail = keywordRouting ? starDomainRegistry.matchDomainDetailed(taskDescription, pool) : null;
+  let matchedId = null;
+  let matchedKeywords = [];
+  if (detail?.verdict === "hit" && typeof detail.id === "string") {
+    matchedId = detail.id;
+    matchedKeywords = detail.matchedKeywords.slice(0, 3);
+  }
+  const id = matchedId ?? DEFAULT_DOMAIN;
+  const definition = starDomainRegistry.get(id) ?? STAR_DOMAINS[DEFAULT_DOMAIN];
+  return {
+    domain: {
+      id,
+      name: definition.name,
+      volatileBlock: definition.volatileBlock,
+      motto: definition.motto,
+      courageThreshold: definition.courageThreshold
+    },
+    matchedKeywords,
+    reason: matchedId ? "keyword" : "fallback"
+  };
+}
+
+// src/agent/star-domain-registry.ts
+var MAX_STRING_FIELD_LENGTH = 2e3;
+var MAX_ARRAY_ITEMS = 50;
+var DOMAIN_ID_RE = /^[a-z][a-z0-9_-]{0,31}$/;
+var StarDomainRegistry = class {
+  domains = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor() {
+  }
+  /** Ensure built-in domains are loaded (lazy init breaks circular dep) */
+  ensureInit() {
+    if (this.initialized) return;
+    for (const domain of Object.values(STAR_DOMAINS)) {
+      this.domains.set(domain.id, domain);
+    }
+    this.initialized = true;
+  }
+  /** Load user domains from .rivet/domains/ directory.
+   *  Each subdirectory is a domain card: <id>/card.md */
+  async loadFromDirectory(dir) {
+    this.ensureInit();
+    const loaded = [];
+    const errors = [];
+    try {
+      const { readdirSync } = await import("fs");
+      const { join } = await import("path");
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        try {
+          const cardPath = join(dir, entry.name, "card.md");
+          const { readFileSync } = await import("fs");
+          const content = readFileSync(cardPath, "utf-8");
+          const def = parseDomainCard(content, entry.name);
+          if (this.domains.has(def.id) && this.domains.get(def.id).isCustom === false) {
+            errors.push(`${entry.name}: cannot override built-in domain "${def.id}"`);
+            continue;
+          }
+          if (this.domains.has(def.id) && this.domains.get(def.id).isCustom === true) {
+            errors.push(`${entry.name}: duplicate custom domain id "${def.id}"`);
+            continue;
+          }
+          this.domains.set(def.id, def);
+          loaded.push(def.id);
+        } catch (e) {
+          errors.push(`${entry.name}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+    } catch {
+    }
+    return { loaded, errors };
+  }
+  /** Get a domain definition by id */
+  get(id) {
+    this.ensureInit();
+    return this.domains.get(id);
+  }
+  /** Get all registered domain ids */
+  getDomainIds() {
+    this.ensureInit();
+    return [...this.domains.keys()];
+  }
+  /** Get all registered domains */
+  list() {
+    this.ensureInit();
+    return [...this.domains.values()];
+  }
+  /** Check if a domain id is registered */
+  has(id) {
+    this.ensureInit();
+    return this.domains.has(id);
+  }
+  /** Match a task description to the best domain by keyword scoring.
+   *  Returns null if no domain matches (all scores = 0 or tie).
+   *  `pool` 限定参与计分的域 id 集合（缺省 = 全集）——auto 路由收窄用。 */
+  matchDomain(taskDescription, pool) {
+    return this.matchDomainDetailed(taskDescription, pool).id;
+  }
+  /**
+   * Keyword-score match with audit detail: which keywords hit, hit/tie/no-match
+   * verdict, and optional runner-up. `matchDomain` is a thin `.id` projection —
+   * same inputs must keep returning the same id (or null).
+   */
+  matchDomainDetailed(taskDescription, pool) {
+    this.ensureInit();
+    const lower = taskDescription.slice(0, MAX_MATCH_CHARS).toLowerCase();
+    const scores = /* @__PURE__ */ new Map();
+    const keywordsByDomain = /* @__PURE__ */ new Map();
+    for (const domain of this.domains.values()) {
+      if (pool !== void 0 && !pool.includes(domain.id)) continue;
+      let score = 0;
+      const matched = [];
+      for (const keyword of domain.keywords) {
+        if (lower.includes(keyword.toLowerCase())) {
+          score++;
+          matched.push(keyword);
+        }
+      }
+      if (score > 0) {
+        scores.set(domain.id, score);
+        keywordsByDomain.set(domain.id, matched);
+      }
+    }
+    if (scores.size === 0) {
+      return { id: null, matchedKeywords: [], verdict: "no-match" };
+    }
+    let max = 0;
+    for (const s of scores.values()) {
+      if (s > max) max = s;
+    }
+    const winners = [...scores.entries()].filter(([, s]) => s === max);
+    if (winners.length > 1) {
+      const tiedIds = winners.map(([id]) => id).sort();
+      return {
+        id: null,
+        matchedKeywords: [],
+        verdict: "tie",
+        tiedIds,
+        runnerUp: tiedIds[1]
+      };
+    }
+    const winnerId = winners[0][0];
+    let runnerUp;
+    let runnerScore = 0;
+    for (const [id, s] of scores) {
+      if (id === winnerId) continue;
+      if (s > runnerScore) {
+        runnerScore = s;
+        runnerUp = id;
+      }
+    }
+    return {
+      id: winnerId,
+      matchedKeywords: keywordsByDomain.get(winnerId) ?? [],
+      verdict: "hit",
+      runnerUp
+    };
+  }
+};
+var MAX_MATCH_CHARS = 500;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function validateDomainId(id) {
+  if (!DOMAIN_ID_RE.test(id)) {
+    throw new Error(`Invalid domain id "${id}": must be 1-32 lowercase alphanumeric/underscore/hyphen chars, starting with a letter`);
+  }
+  return id;
+}
+function sanitizeString(value, _fieldName) {
+  if (typeof value !== "string") return "";
+  return value.slice(0, MAX_STRING_FIELD_LENGTH).trim();
+}
+function sanitizeStringArray(value, _fieldName) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string").slice(0, MAX_ARRAY_ITEMS).map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function parseDomainCard(content, fallbackId) {
+  content = normalizeFrontmatterSource(content);
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    throw new Error("Missing YAML frontmatter (--- delimiters)");
+  }
+  const raw = fmMatch[1];
+  const body = sanitizeString(fmMatch[2]?.trim(), "systemPromptSuffix");
+  const fm = {};
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^(\w+):\s*(.*)$/);
+    if (m) {
+      const key = m[1];
+      const val = m[2].trim();
+      if (val.startsWith("[")) {
+        try {
+          fm[key] = JSON.parse(val.replace(/'/g, '"'));
+        } catch {
+          throw new Error(`Failed to parse array for field "${key}": "${val}"`);
+        }
+      } else {
+        fm[key] = val;
+      }
+    }
+  }
+  if (typeof fm.name !== "string" || !fm.name.trim()) {
+    throw new Error("Missing required field: name");
+  }
+  const rawId = typeof fm.id === "string" && fm.id ? fm.id : fallbackId;
+  const id = validateDomainId(rawId);
+  const decisionStyle = fm.decisionStyle;
+  if (decisionStyle && !["bold", "cautious", "methodical"].includes(decisionStyle)) {
+    throw new Error(`Invalid decisionStyle "${decisionStyle}". Must be: bold, cautious, methodical`);
+  }
+  const accent = fm.accent;
+  const VALID_ACCENTS = ["primary", "secondary", "success", "warning", "error"];
+  if (accent && !VALID_ACCENTS.includes(accent)) {
+    throw new Error(`Invalid accent "${accent}". Must be: ${VALID_ACCENTS.join(", ")}`);
+  }
+  const separator = fm.separator;
+  const VALID_SEPARATORS = ["thin", "thick", "dots"];
+  if (separator && !VALID_SEPARATORS.includes(separator)) {
+    throw new Error(`Invalid separator "${separator}". Must be: ${VALID_SEPARATORS.join(", ")}`);
+  }
+  const keywords = sanitizeStringArray(fm.keywords, "keywords").filter(Boolean);
+  const toolWhitelist = sanitizeStringArray(fm.toolWhitelist, "toolWhitelist").filter(Boolean);
+  if (keywords.length === 0) {
+    throw new Error("keywords must contain at least one non-empty string value");
+  }
+  if (toolWhitelist.length === 0) {
+    throw new Error("toolWhitelist must contain at least one non-empty string value");
+  }
+  const name = sanitizeString(fm.name, "name");
+  const motto = sanitizeString(fm.motto, "motto");
+  const volatileBlock = sanitizeString(fm.volatileBlock, "volatileBlock");
+  return {
+    id,
+    name,
+    motto,
+    volatileBlock,
+    decisionStyle: decisionStyle ?? "methodical",
+    courageThreshold: clamp(
+      typeof fm.courageThreshold === "number" ? fm.courageThreshold : typeof fm.courageThreshold === "string" ? Number(fm.courageThreshold) || 0.5 : 0.5,
+      0,
+      1
+    ),
+    keywords,
+    isCustom: true,
+    toolWhitelist,
+    systemPromptSuffix: body,
+    uiPersona: {
+      separator: separator ?? "dots",
+      accent: accent ?? "secondary",
+      glyph: typeof fm.glyph === "string" ? fm.glyph.slice(0, 4) : "\u25C6"
+    }
+  };
+}
+var starDomainRegistry = new StarDomainRegistry();
+
+export {
+  starDomainRegistry,
+  matchDomain,
+  deriveAuthority,
+  resolveAuthorityReason,
+  DOMAIN_AUTO_POOL,
+  resolveActiveDomain
+};

package/dist/chunk-CI4R6P2B.js

@@ -0,0 +1,24 @@
+#!/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/utils/debug.ts
+init_esm_shims();
+var isDebugEnabled = () => {
+  const flag = process.env.RIVET_DEBUG?.toLowerCase();
+  return flag === "1" || flag === "true";
+};
+var debugLog = (...args) => {
+  if (isDebugEnabled()) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+    console.warn(`[${ts}]`, ...args);
+  }
+};
+var debugEnabled = () => isDebugEnabled();
+
+export {
+  debugLog,
+  debugEnabled
+};

package/dist/chunk-D2TCGRSX.js

@@ -0,0 +1,73 @@
+#!/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/worktree-baseline.ts
+init_esm_shims();
+import { createHash } from "crypto";
+function createWorktreeBaseline(snapshot) {
+  const externalSet = /* @__PURE__ */ new Set([
+    ...snapshot.preExistingDirty,
+    ...snapshot.preExistingUntracked
+  ]);
+  let _baselineHash = null;
+  function computeBaselineHash() {
+    const canonical = JSON.stringify({
+      branch: snapshot.branch,
+      head: snapshot.head,
+      preExistingDirty: [...snapshot.preExistingDirty].sort(),
+      preExistingUntracked: [...snapshot.preExistingUntracked].sort()
+    });
+    return createHash("sha256").update(canonical).digest("hex");
+  }
+  function getBaselineHash() {
+    if (!_baselineHash) {
+      _baselineHash = computeBaselineHash();
+    }
+    return _baselineHash;
+  }
+  function isExternal(filePath) {
+    if (!filePath) return false;
+    return externalSet.has(filePath);
+  }
+  function getExternalFiles() {
+    return [...externalSet].sort();
+  }
+  function getExternalDirtyCount() {
+    return snapshot.preExistingDirty.length;
+  }
+  function getExternalUntrackedCount() {
+    return snapshot.preExistingUntracked.length;
+  }
+  function getBranch() {
+    return snapshot.branch;
+  }
+  function getHead() {
+    return snapshot.head;
+  }
+  function toSnapshot() {
+    return {
+      branch: snapshot.branch,
+      head: snapshot.head,
+      preExistingDirty: [...snapshot.preExistingDirty],
+      preExistingUntracked: [...snapshot.preExistingUntracked],
+      capturedAt: snapshot.capturedAt
+    };
+  }
+  return {
+    getBranch,
+    getHead,
+    isExternal,
+    getExternalFiles,
+    getExternalDirtyCount,
+    getExternalUntrackedCount,
+    getBaselineHash,
+    toSnapshot
+  };
+}
+
+export {
+  createWorktreeBaseline
+};

package/dist/chunk-D4PTYFOG.js

@@ -0,0 +1,154 @@
+#!/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 {
+  profileRegistry
+} from "./chunk-6HSVXHCZ.js";
+import {
+  spawnGitSync
+} from "./chunk-THKDVSEC.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/budget-shape.ts
+init_esm_shims();
+var WRITE_DEFAULT_MAX_TURNS = 48;
+var SHAPE_MAX_TURNS_CEIL = 100;
+var SHAPE_TIMEOUT_CEIL_MS = 18e5;
+var TURNS_PER_EXTRA_FILE = 6;
+var MS_PER_EXTRA_FILE = 45e3;
+function shapeBudgetEnabled() {
+  return process.env.RIVET_WORKER_BUDGET_SHAPE !== "0";
+}
+function shapeWriteBudget(input) {
+  const baseTurns = input.baseMaxTurns ?? WRITE_DEFAULT_MAX_TURNS;
+  const extra = Math.max(0, (input.files?.length ?? 0) - 1);
+  return {
+    maxTurns: Math.min(SHAPE_MAX_TURNS_CEIL, baseTurns + TURNS_PER_EXTRA_FILE * extra),
+    timeoutMs: Math.min(SHAPE_TIMEOUT_CEIL_MS, input.baseTimeoutMs + MS_PER_EXTRA_FILE * extra)
+  };
+}
+function shapeWriteBudgetForProfile(files, profile) {
+  if (!shapeBudgetEnabled() || !profile) return void 0;
+  if ((files?.length ?? 0) <= 1) return void 0;
+  if (!profileRegistry.listWriteProfiles().includes(profile)) return void 0;
+  const baseTimeoutMs = profileRegistry.get(profile)?.defaultTimeoutMs ?? 48e4;
+  return shapeWriteBudget({ files, baseTimeoutMs });
+}
+function mergeBudgetOverride(explicit, shape) {
+  if (!shape) return explicit;
+  if (!explicit) return shape;
+  return {
+    ...explicit,
+    ...explicit.maxTurns === void 0 ? { maxTurns: shape.maxTurns } : {},
+    ...explicit.timeoutMs === void 0 ? { timeoutMs: shape.timeoutMs } : {}
+  };
+}
+function historyBudgetEnabled() {
+  return process.env.RIVET_WORKER_BUDGET_HISTORY !== "0";
+}
+var HISTORY_SAMPLE_LIMIT = 5;
+var NEAR_MISS_RATIO = 0.8;
+var TURNS_FROM_TOOL_USES = 1.15;
+var EXHAUSTION_HEADROOM = 1.3;
+var HISTORY_LIFT_CAP = 3;
+function historyBudgetFloor(samples, current) {
+  const valid = samples.filter((s) => Boolean(s) && ((s.toolUses ?? 0) > 0 || (s.durationMs ?? 0) > 0));
+  if (valid.length === 0) return void 0;
+  const triggered = valid.some((s) => s.exhausted === true || s.toolUses > 0 && s.toolUses >= NEAR_MISS_RATIO * (s.budget?.maxTurns ?? current.maxTurns));
+  if (!triggered) return void 0;
+  const maxToolUses = Math.max(...valid.map((s) => s.toolUses));
+  const maxDuration = Math.max(...valid.map((s) => s.durationMs));
+  const priorTurns = Math.ceil(maxToolUses * TURNS_FROM_TOOL_USES * EXHAUSTION_HEADROOM);
+  const priorTimeout = Math.ceil(maxDuration * EXHAUSTION_HEADROOM);
+  const lift = {
+    maxTurns: Math.min(
+      SHAPE_MAX_TURNS_CEIL,
+      Math.max(current.maxTurns, priorTurns),
+      current.maxTurns * HISTORY_LIFT_CAP
+    ),
+    timeoutMs: Math.min(
+      SHAPE_TIMEOUT_CEIL_MS,
+      Math.max(current.timeoutMs, priorTimeout),
+      current.timeoutMs * HISTORY_LIFT_CAP
+    )
+  };
+  if (lift.maxTurns <= current.maxTurns && lift.timeoutMs <= current.timeoutMs) return void 0;
+  return lift;
+}
+function parseWorkerActualRows(rows, objectiveHash) {
+  const prefix = `worker_actual:${objectiveHash}:`;
+  const samples = [];
+  for (const row of rows ?? []) {
+    if (!row?.kind?.startsWith(prefix)) continue;
+    try {
+      const parsed = JSON.parse(row.json);
+      if (typeof parsed.toolUses !== "number" && typeof parsed.durationMs !== "number") continue;
+      samples.push({
+        toolUses: typeof parsed.toolUses === "number" ? parsed.toolUses : 0,
+        durationMs: typeof parsed.durationMs === "number" ? parsed.durationMs : 0,
+        ...parsed.exhausted === true ? { exhausted: true } : {},
+        ...parsed.budget && typeof parsed.budget === "object" ? { budget: parsed.budget } : {}
+      });
+    } catch {
+    }
+  }
+  return samples.slice(0, HISTORY_SAMPLE_LIMIT);
+}
+
+// src/agent/diff-collector.ts
+init_esm_shims();
+function git(cwd, args) {
+  const result = spawnGitSync(["-c", "core.quotePath=false", ...args], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return {
+    ok: result.status === 0,
+    stdout: typeof result.stdout === "string" ? result.stdout : ""
+  };
+}
+function collectDiff(_baseCwd, workerCwd, baseBranch, excludePaths = []) {
+  const parts = [];
+  const pathspec = excludePaths.length > 0 ? ["--", ".", ...excludePaths.map((p) => `:(exclude)${p}`)] : [];
+  const committed = git(workerCwd, ["diff", `${baseBranch}...HEAD`, ...pathspec]);
+  if (committed.ok && committed.stdout.trim()) {
+    parts.push(committed.stdout);
+  }
+  git(workerCwd, ["add", "-A", ...pathspec]);
+  const staged = git(workerCwd, ["diff", "--cached", "HEAD", ...pathspec]);
+  if (staged.ok && staged.stdout.trim()) {
+    parts.push(staged.stdout);
+  }
+  return parts.join("");
+}
+function formatDiffArtifact(diff, _profile) {
+  const files = extractChangedFiles(diff);
+  return {
+    kind: "diff",
+    title: files.length > 0 ? `Patch: ${files.join(", ")}` : "Patch (empty)",
+    content: diff.length > 0 ? diff : "(empty diff)"
+  };
+}
+function extractChangedFiles(diff) {
+  const re = /^\+\+\+ b\/(.+)$/gm;
+  const files = [];
+  let m;
+  while ((m = re.exec(diff)) !== null) {
+    files.push(m[1]);
+  }
+  return files;
+}
+
+export {
+  WRITE_DEFAULT_MAX_TURNS,
+  shapeWriteBudgetForProfile,
+  mergeBudgetOverride,
+  historyBudgetEnabled,
+  historyBudgetFloor,
+  parseWorkerActualRows,
+  collectDiff,
+  formatDiffArtifact,
+  extractChangedFiles
+};