tianshu-harness 3.23.0

package/dist/chunk-ETHFACAB.js

@@ -0,0 +1,315 @@
+#!/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/platform.ts
+init_esm_shims();
+import { homedir } from "os";
+import { execFile, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { win32 as winPath } from "path";
+import { TextDecoder } from "util";
+var isWin = process.platform === "win32";
+function resolveTargetPlatform(platform) {
+  switch (platform) {
+    case "windows":
+      return "win32";
+    case "macos":
+      return "darwin";
+    case "linux":
+      return "linux";
+    case "auto":
+    default:
+      return process.platform;
+  }
+}
+var _targetPlatform = process.platform;
+var _targetEol = process.platform === "win32" ? "crlf" : "lf";
+function setTargetConventions(platform, eol) {
+  _targetPlatform = resolveTargetPlatform(platform);
+  _targetEol = eol === "auto" ? _targetPlatform === "win32" ? "crlf" : "lf" : eol;
+}
+function getTargetPlatform() {
+  return _targetPlatform;
+}
+function getTargetEol() {
+  return _targetEol;
+}
+var _cachedShell = null;
+var _cachedGitBash;
+function resolveGitBashPath(deps) {
+  if (!deps.isWindows) return null;
+  const override = deps.env["RIVET_GIT_BASH_PATH"];
+  if (override && deps.exists(override)) return override;
+  const gitPath = deps.whichGit();
+  if (gitPath) {
+    const gitRoot = winPath.dirname(winPath.dirname(gitPath));
+    const bashPath = winPath.join(gitRoot, "bin", "bash.exe");
+    if (deps.exists(bashPath)) return bashPath;
+  }
+  const bashOnPath = deps.whichBash?.();
+  if (bashOnPath && !/^[A-Za-z]:\\Windows\\(System32|SysWOW64)\\bash\.exe$/i.test(bashOnPath) && deps.exists(bashOnPath)) {
+    return bashOnPath;
+  }
+  const candidates = [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
+  ];
+  const localApp = deps.env["LOCALAPPDATA"];
+  if (localApp) candidates.push(winPath.join(localApp, "Programs", "Git", "bin", "bash.exe"));
+  const scoopRoot = deps.env["SCOOP"];
+  if (scoopRoot) candidates.push(winPath.join(scoopRoot, "apps", "git", "current", "bin", "bash.exe"));
+  const userProfile = deps.env["USERPROFILE"];
+  if (userProfile) candidates.push(winPath.join(userProfile, "scoop", "apps", "git", "current", "bin", "bash.exe"));
+  for (const c of candidates) {
+    if (deps.exists(c)) return c;
+  }
+  const bundledGitDir = deps.env["RIVET_BUNDLED_GIT_DIR"];
+  if (bundledGitDir) {
+    const bundledBash = winPath.join(bundledGitDir, "bin", "bash.exe");
+    if (deps.exists(bundledBash)) return bundledBash;
+  }
+  return null;
+}
+function whichGitWindows() {
+  try {
+    const result = spawnSync("where", ["git"], { stdio: ["ignore", "pipe", "ignore"], timeout: 3e3, windowsHide: true });
+    if (result.status === 0) {
+      const first = result.stdout.toString().split("\n")[0]?.trim();
+      return first && first.length > 0 ? first : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function whichBashWindows() {
+  try {
+    const result = spawnSync("where", ["bash"], { stdio: ["ignore", "pipe", "ignore"], timeout: 3e3, windowsHide: true });
+    if (result.status === 0) {
+      const first = result.stdout.toString().split("\n")[0]?.trim();
+      return first && first.length > 0 ? first : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function applyConfiguredGitBashPath(gitBashPath) {
+  const trimmed = gitBashPath?.trim();
+  if (!trimmed) return;
+  if (process.env["RIVET_GIT_BASH_PATH"]) return;
+  process.env["RIVET_GIT_BASH_PATH"] = trimmed;
+  _cachedGitBash = void 0;
+  _cachedShell = null;
+  _shellProbeGen++;
+}
+function whereAsync(cmd) {
+  return new Promise((resolve) => {
+    try {
+      execFile("where", [cmd], { timeout: 3e3, windowsHide: true, encoding: "utf8" }, (err, stdout) => {
+        if (err || typeof stdout !== "string") return resolve(void 0);
+        const first = stdout.split("\n")[0]?.trim();
+        resolve(first && first.length > 0 ? first : void 0);
+      });
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
+var _shellPrewarm = null;
+var _shellProbeGen = 0;
+function prewarmShellProbes() {
+  if (_cachedShell && _cachedGitBash !== void 0) return Promise.resolve();
+  if (_shellPrewarm) return _shellPrewarm;
+  _shellPrewarm = (async () => {
+    if (!isWin) {
+      if (_cachedGitBash === void 0) _cachedGitBash = null;
+      if (!_cachedShell) _cachedShell = resolveShellCommand({ isWindows: false, env: process.env, gitBashPath: null, hasPwsh: () => false });
+      return;
+    }
+    const gen = _shellProbeGen;
+    const [git, bash, pwsh, powershell] = await Promise.all([
+      whereAsync("git"),
+      whereAsync("bash"),
+      whereAsync("pwsh.exe"),
+      whereAsync("powershell.exe")
+    ]);
+    if (gen !== _shellProbeGen) return;
+    if (_cachedGitBash === void 0) {
+      _cachedGitBash = resolveGitBashPath({
+        isWindows: true,
+        env: process.env,
+        whichGit: () => git,
+        whichBash: () => bash,
+        exists: existsSync
+      });
+    }
+    if (!_cachedShell) {
+      const hits = { "pwsh.exe": !!pwsh, "powershell.exe": !!powershell };
+      _cachedShell = resolveShellCommand({
+        isWindows: true,
+        env: process.env,
+        gitBashPath: _cachedGitBash,
+        hasPwsh: (cmd) => hits[cmd] ?? false
+      });
+    }
+  })().catch(() => {
+  }).finally(() => {
+    _shellPrewarm = null;
+  });
+  return _shellPrewarm;
+}
+function findGitBashPath() {
+  if (_cachedGitBash !== void 0) return _cachedGitBash;
+  _cachedGitBash = resolveGitBashPath({
+    isWindows: isWin,
+    env: process.env,
+    whichGit: whichGitWindows,
+    whichBash: whichBashWindows,
+    exists: existsSync
+  });
+  return _cachedGitBash;
+}
+function resolveShellCommand(deps) {
+  if (deps.isWindows) {
+    const forcePwsh = /^(1|true|yes)$/i.test(deps.env["RIVET_USE_POWERSHELL"] ?? "");
+    if (!forcePwsh && deps.gitBashPath) {
+      return { cmd: deps.gitBashPath, args: ["-c"], kind: "bash" };
+    }
+    for (const cmd of ["pwsh.exe", "powershell.exe"]) {
+      if (deps.hasPwsh(cmd)) {
+        return { cmd, args: ["-NoProfile", "-NonInteractive", "-Command"], kind: "powershell" };
+      }
+    }
+    const comSpec = deps.env["ComSpec"] || "cmd.exe";
+    return { cmd: comSpec, args: ["/c"], kind: "cmd" };
+  }
+  return { cmd: "sh", args: ["-c"], kind: "sh" };
+}
+function hasPwshWindows(cmd) {
+  try {
+    const result = spawnSync("where", [cmd], { stdio: ["ignore", "pipe", "ignore"], timeout: 3e3, windowsHide: true });
+    return result.status === 0 && result.stdout.toString().trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function getShellCommand() {
+  if (_cachedShell) return _cachedShell;
+  _cachedShell = resolveShellCommand({
+    isWindows: isWin,
+    env: process.env,
+    gitBashPath: findGitBashPath(),
+    hasPwsh: hasPwshWindows
+  });
+  return _cachedShell;
+}
+function getShellDiagnostics() {
+  const shell = getShellCommand();
+  const gitBash = findGitBashPath();
+  const diag = { kind: shell.kind, cmd: shell.cmd, gitBashPath: gitBash };
+  if (isWin && shell.kind !== "bash") {
+    const bundledNote = process.env["RIVET_BUNDLED_GIT_DIR"] ? `, \u5185\u7F6E Git\uFF08${process.env["RIVET_BUNDLED_GIT_DIR"]}\u2014\u2014\u53EF\u80FD\u4ECD\u5728\u9996\u6B21\u89E3\u538B\u4E2D\uFF0C\u7A0D\u540E\u91CD\u8BD5\u6216\u91CD\u542F\uFF09` : "";
+    diag.fallbackReason = gitBash ? `Git Bash found at ${gitBash} but not selected (RIVET_USE_POWERSHELL set?)` : `Git Bash not found \u2014 probed RIVET_GIT_BASH_PATH, \`where git\` \u2192 \u2026\\Git\\bin\\bash.exe, C:\\Program Files\\Git, %LOCALAPPDATA%\\Programs\\Git${bundledNote}`;
+  }
+  return diag;
+}
+function rewriteWindowsNullRedirect(command) {
+  return command.replace(
+    /(^|\s)(\d?)>\s*nul(?=\s|$|;|&|\|)/gi,
+    (_m, pre, fd) => `${pre}${fd}>/dev/null`
+  );
+}
+function rewritePowershellNullRedirect(command) {
+  return command.replace(
+    /(^|\s)(\d?)>\s*(?:nul|\/dev\/null)(?=\s|$|;|&|\|)/gi,
+    (_m, pre, fd) => `${pre}${fd}>$null`
+  );
+}
+function gracefulKill(child) {
+  if (!child.pid) return;
+  try {
+    if (isWin) {
+      spawnSync("taskkill", ["/PID", String(child.pid)], {
+        stdio: ["ignore", "ignore", "ignore"],
+        timeout: 5e3,
+        windowsHide: true
+      });
+    } else {
+      child.kill("SIGTERM");
+    }
+  } catch {
+  }
+}
+function forceKill(child) {
+  if (!child.pid) return;
+  try {
+    if (isWin) {
+      spawnSync("taskkill", ["/F", "/PID", String(child.pid)], {
+        stdio: ["ignore", "ignore", "ignore"],
+        timeout: 5e3,
+        windowsHide: true
+      });
+    } else {
+      child.kill("SIGKILL");
+    }
+  } catch {
+  }
+}
+function expandHome(path) {
+  if (path.startsWith("~")) {
+    return homedir() + path.slice(1);
+  }
+  return path;
+}
+var isUtf8Buffer = typeof Buffer.isUtf8 === "function" ? Buffer.isUtf8 : (buf) => {
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(buf);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var WinStreamDecoder = class {
+  decoder = null;
+  isUtf8 = true;
+  first = true;
+  write(chunk) {
+    if (!isWin) {
+      return chunk.toString("utf8");
+    }
+    if (this.first) {
+      this.first = false;
+      this.isUtf8 = isUtf8Buffer(chunk);
+      const encoding = this.isUtf8 ? "utf-8" : "gbk";
+      this.decoder = new TextDecoder(encoding, { fatal: false });
+    }
+    if (this.decoder) {
+      return this.decoder.decode(chunk, { stream: true });
+    }
+    return chunk.toString("utf8");
+  }
+  end() {
+    if (this.decoder) {
+      return this.decoder.decode();
+    }
+    return "";
+  }
+};
+
+export {
+  setTargetConventions,
+  getTargetPlatform,
+  getTargetEol,
+  applyConfiguredGitBashPath,
+  prewarmShellProbes,
+  getShellCommand,
+  getShellDiagnostics,
+  rewriteWindowsNullRedirect,
+  rewritePowershellNullRedirect,
+  gracefulKill,
+  forceKill,
+  expandHome,
+  WinStreamDecoder
+};

package/dist/chunk-EXUE5W2F.js

@@ -0,0 +1,112 @@
+#!/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/prompt/volatile-git.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileP = promisify(execFile);
+function formatGitStatus(branch, status) {
+  if (!branch && !status) return void 0;
+  return `Current branch: ${branch}
+Status:
+${status || "(clean)"}`;
+}
+async function loadGitStatus(cwd) {
+  try {
+    const [branchResult, statusResult, logResult] = await Promise.all([
+      execFileP("git", ["branch", "--show-current"], { cwd, timeout: 5e3, windowsHide: true }),
+      execFileP("git", ["status", "--short"], { cwd, timeout: 5e3, windowsHide: true }),
+      execFileP("git", ["log", "--oneline", "-5"], { cwd, timeout: 5e3, windowsHide: true }).catch(() => ({ stdout: "" }))
+    ]);
+    const base = formatGitStatus(branchResult.stdout.trim(), statusResult.stdout.trim());
+    const log = logResult.stdout.trim();
+    if (!base && !log) return void 0;
+    return log ? `${base ?? ""}
+Recent commits:
+${log}` : base;
+  } catch {
+    return void 0;
+  }
+}
+var MAX_CACHED_CWDS = 50;
+function trimCache(map, ttlMs) {
+  if (map.size <= MAX_CACHED_CWDS) return;
+  const now = Date.now();
+  for (const [key, val] of map) {
+    if (now - val.timestamp > ttlMs) map.delete(key);
+  }
+  while (map.size > MAX_CACHED_CWDS) {
+    const [key] = map.keys();
+    map.delete(key);
+  }
+}
+function createGitStatusCache(options) {
+  const values = /* @__PURE__ */ new Map();
+  const refreshing = /* @__PURE__ */ new Map();
+  const isFresh = (cwd) => {
+    const entry = values.get(cwd);
+    return !!entry && options.now() - entry.timestamp < options.ttlMs;
+  };
+  return {
+    get(cwd) {
+      trimCache(values, options.ttlMs);
+      return values.get(cwd)?.value;
+    },
+    prime(cwd, nextValue) {
+      values.set(cwd, { value: nextValue, timestamp: options.now() });
+      trimCache(values, options.ttlMs);
+    },
+    async refresh(cwd) {
+      const existing = refreshing.get(cwd);
+      if (existing) return existing;
+      const work = options.load(cwd).then((nextValue) => {
+        values.set(cwd, { value: nextValue, timestamp: options.now() });
+        trimCache(values, options.ttlMs);
+      }).finally(() => {
+        refreshing.delete(cwd);
+      });
+      refreshing.set(cwd, work);
+      return work;
+    },
+    /**
+     * Awaitable variant: triggers refresh only if the cache is stale.
+     * Call this before building a prompt to eliminate the 30s staleness blind spot
+     * while keeping the synchronous get() path side-effect free.
+     */
+    async refreshIfStale(cwd) {
+      if (!isFresh(cwd)) {
+        await this.refresh(cwd);
+      }
+    }
+  };
+}
+var gitStatusCache = createGitStatusCache({
+  ttlMs: 3e4,
+  now: () => Date.now(),
+  load: loadGitStatus
+});
+async function getGitInjectedContext(cwd) {
+  try {
+    const [branchResult, headResult] = await Promise.all([
+      execFileP("git", ["branch", "--show-current"], { cwd, timeout: 5e3, windowsHide: true }),
+      execFileP("git", ["rev-parse", "HEAD"], { cwd, timeout: 5e3, windowsHide: true })
+    ]);
+    const branch = branchResult.stdout.trim() || void 0;
+    const head = headResult.stdout.trim() || void 0;
+    if (!branch && !head) return void 0;
+    return { branch, head };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  formatGitStatus,
+  createGitStatusCache,
+  gitStatusCache,
+  getGitInjectedContext
+};

package/dist/chunk-EXXICUIW.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/api/oai-types.ts
+init_esm_shims();
+function isToolMessage(msg) {
+  return msg.role === "tool";
+}
+function isAssistantWithTools(msg) {
+  return msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+}
+function normalizeOaiMessage(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length > 0) {
+    return message;
+  }
+  const { tool_calls: _, ...rest } = message;
+  return { ...rest, content: rest.content ?? "" };
+}
+function normalizeOaiMessages(messages) {
+  let normalized;
+  for (let i = 0; i < messages.length; i++) {
+    const message = normalizeOaiMessage(messages[i]);
+    if (message !== messages[i]) {
+      normalized ??= messages.slice();
+      normalized[i] = message;
+    }
+  }
+  return normalized ?? messages;
+}
+var STRIPPED_IMAGE_PLACEHOLDER = "[image removed to reduce payload size]";
+function oaiMessagesHaveImageParts(messages) {
+  return messages.some(
+    (m) => m.role === "user" && Array.isArray(m.content) && m.content.some((p) => p.type === "image_url")
+  );
+}
+function stripOaiImageParts(messages, placeholder = STRIPPED_IMAGE_PLACEHOLDER) {
+  let removedCount = 0;
+  let next;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+    const imageCount = msg.content.reduce(
+      (n, p) => p.type === "image_url" ? n + 1 : n,
+      0
+    );
+    if (imageCount === 0) continue;
+    removedCount += imageCount;
+    next ??= messages.slice();
+    const kept = msg.content.filter((p) => p.type !== "image_url");
+    const content = kept.length > 0 ? kept : [{ type: "text", text: placeholder }];
+    next[i] = { ...msg, content };
+  }
+  return { messages: next ?? messages, removedCount };
+}
+function oaiMessageText(msg) {
+  if (msg.role === "user" && Array.isArray(msg.content)) {
+    return msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+  }
+  return msg.content;
+}
+
+export {
+  isToolMessage,
+  isAssistantWithTools,
+  normalizeOaiMessage,
+  normalizeOaiMessages,
+  oaiMessagesHaveImageParts,
+  stripOaiImageParts,
+  oaiMessageText
+};

package/dist/chunk-FFQSZJOO.js

@@ -0,0 +1,169 @@
+#!/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 {
+  buildDeliveryGate,
+  emptyPhysarumShadowStats
+} from "./chunk-OTNHSAGN.js";
+import {
+  STAR_DOMAINS
+} from "./chunk-WMUWEO2C.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tui/cockpit/state.ts
+init_esm_shims();
+function describeStarDomain(domain) {
+  if (domain) return domain.name;
+  if (domain === null) return "\u5173\u95ED(\u73AF\u5883)";
+  const fallback = STAR_DOMAINS.tianshu?.name ?? "\u5929\u67A2";
+  return `Auto(${fallback})`;
+}
+function computePanelStatuses(snapshot) {
+  const safety = snapshot.safety.riskLevel === "high" || snapshot.safety.doomLoopLevel === "blocked" ? "error" : snapshot.safety.riskLevel === "medium" || snapshot.safety.doomLoopLevel === "warn" ? "warn" : "ok";
+  const verify = snapshot.verification.deliveryStatus === "failed" || snapshot.verification.deliveryStatus === "blocked" ? "error" : snapshot.verification.deliveryStatus === "unverified" && snapshot.verification.filesModified > 0 ? "warn" : "ok";
+  const context = snapshot.context ? snapshot.context.brokenRounds > 0 ? "error" : snapshot.context.compactionState === "critical" ? "error" : snapshot.context.compactionState === "warning" ? "warn" : "ok" : "idle";
+  const model = "ok";
+  const trace = snapshot.trace.events.some((e) => e.status === "failed") ? "error" : "ok";
+  const summary = safety === "error" || verify === "error" ? "error" : safety === "warn" || verify === "warn" ? "warn" : "ok";
+  const mcp = snapshot.mcp.servers.some((s) => s.status === "error") ? "error" : snapshot.mcp.servers.some((s) => s.status === "connecting") ? "warn" : "ok";
+  const advisory = snapshot.advisory.silenced.length > 0 ? "warn" : "ok";
+  return { summary, trace, verify, context, safety, model, mcp, advisory };
+}
+var ADVISORY_PANEL_MAX_KEYS = 8;
+function buildAdvisorySection(agent, statusNotices) {
+  const ga = agent.guardianActivity;
+  const readback = agent.advisoryReadback;
+  const bus = agent.advisoryBus;
+  const keys = readback ? [...readback.getStats()].filter(([, s]) => s.delivered > 0 || s.shadowHeld > 0).sort((a, b) => b[1].delivered - a[1].delivered).slice(0, ADVISORY_PANEL_MAX_KEYS).map(([key, s]) => ({
+    key,
+    delivered: s.delivered,
+    adopted: s.adopted,
+    ignored: s.ignored,
+    ignoredStreak: s.ignoredStreak,
+    adoptionRate: readback.getAdoptionRate(key),
+    lift: readback.getMatureLift(key)
+  })) : [];
+  return {
+    rendered: ga?.advisoriesRendered ?? 0,
+    dropped: ga?.advisoriesDropped ?? 0,
+    adopted: ga?.advisoriesAdopted ?? 0,
+    ignored: ga?.advisoriesIgnored ?? 0,
+    heldOut: ga?.advisoriesHeldOut ?? 0,
+    silenced: bus?.getSilencedKeys() ?? [],
+    pendingWatch: bus?.getPendingWatchCount() ?? 0,
+    keys,
+    statusNotices
+  };
+}
+function buildCockpitSnapshot(sources) {
+  const { agent, session, claimCounts, reasoningEffort } = sources;
+  const model = sources.model ?? "unknown";
+  const cacheHitRate = sources.cacheHitRate ?? session.getCacheHitRate();
+  const cost = sources.cost ?? 0;
+  const mcpManager = sources.mcpManager ?? null;
+  const agentWithCache = agent;
+  const prewarmStats = agentWithCache.getPrewarmStats?.() ?? { hits: 0, misses: 0, hitRate: 0 };
+  const physarumShadowStats = agentWithCache.getPhysarumShadowStats?.() ?? emptyPhysarumShadowStats();
+  const cacheDiagnostic = agentWithCache.getCacheDiagnostic?.() ?? null;
+  const speculationStats = agent.p3?.queue.statsBySource() ?? null;
+  const traceStore = agent.getTraceStore();
+  const evidence = agent.getEvidenceState();
+  const doomLevel = agent.getDoomLoopLevel();
+  const usage = session.getTotalUsage();
+  const risk = agent.getLatestRisk();
+  const contextReport = agent.getContextLayerReport();
+  const mcpStates = mcpManager?.getStates() ?? [];
+  const deliveryGate = buildDeliveryGate(evidence);
+  const snapshot = {
+    intent: null,
+    blockingReason: deliveryGate.blockingReason ?? null,
+    nextAction: deliveryGate.nextAction ?? null,
+    safety: {
+      doomLoopLevel: doomLevel,
+      riskLevel: risk.level,
+      riskReasons: risk.reasons,
+      suggestedAction: risk.suggestedAction,
+      recentFingerprints: new Set(traceStore.toolFingerprints).size
+    },
+    verification: {
+      filesRead: evidence.filesRead.size,
+      filesModified: evidence.filesModified.size,
+      runs: evidence.verifications.map((v) => ({
+        tool: v.command,
+        status: v.status,
+        summary: `${v.passed}\u2713 ${v.failed}\u2717 ${v.skipped}skip`
+      })),
+      deliveryStatus: evidence.deliveryStatus,
+      impactedFiles: evidence.impactedFiles.size,
+      impactedTests: evidence.impactedTests.size
+    },
+    trace: {
+      events: traceStore.events.map((e) => ({
+        id: e.id,
+        turn: e.turn,
+        kind: e.kind,
+        name: e.name,
+        status: e.status,
+        durationMs: e.durationMs,
+        summary: e.summary
+      })),
+      totalEvents: traceStore.events.length
+    },
+    context: session.getContextLedger() ? {
+      estimatedTokens: session.getContextLedger().tokenBudget.estimatedTokens,
+      maxTokens: session.getContextLedger().tokenBudget.maxTokens,
+      rounds: session.getContextLedger().rounds.length,
+      compactionState: session.getContextLedger().tokenBudget.compactionState,
+      brokenRounds: session.getContextLedger().apiInvariantStatus.brokenRounds,
+      layers: contextReport.layers.map((l) => ({
+        id: l.id,
+        label: l.label,
+        stability: l.stability,
+        channel: l.channel,
+        fingerprint: l.fingerprint,
+        digest: l.digest,
+        tokenEstimate: l.tokenEstimate
+      })),
+      claimCounts: claimCounts ?? { active: 0, stale: 0, conflicted: 0, durable: 0, durableCandidate: 0, quarantined: 0, recallBlocked: 0 }
+    } : null,
+    model: {
+      name: model,
+      cacheHitRate,
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      cacheReadTokens: usage.cache_read_input_tokens,
+      cacheWriteTokens: usage.cache_creation_input_tokens,
+      cost,
+      perTurnHitRate: session.getLatestTurnHitRate(),
+      recentTurnHitRate: session.getRecentTurnHitRate(3),
+      prewarmHits: prewarmStats.hits,
+      prewarmMisses: prewarmStats.misses,
+      prewarmHitRate: prewarmStats.hitRate,
+      physarumShadow: physarumShadowStats,
+      speculation: speculationStats,
+      cacheDiagnostic,
+      reasoningEffort: agent.getReasoningEffort() || reasoningEffort || "medium",
+      starDomain: describeStarDomain(agent.getSessionDomain())
+    },
+    mcp: {
+      servers: mcpStates.map((s) => ({
+        serverId: s.serverId,
+        status: s.status,
+        toolCount: s.toolCount,
+        lastErrorClass: s.lastErrorClass
+      })),
+      totalTools: mcpManager?.getAllTools().length ?? 0,
+      connectedServers: mcpStates.filter((s) => s.status === "connected").length
+    },
+    advisory: buildAdvisorySection(agent, sources.advisoryStatusNotices ?? [])
+  };
+  return {
+    ...snapshot,
+    panelStatuses: computePanelStatuses(snapshot)
+  };
+}
+
+export {
+  buildCockpitSnapshot
+};