@citeark/agent 0.3.20

package/src/dashboard/data.mjs

@@ -0,0 +1,898 @@
+import { open, readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+
+import { metricMeasurements, primaryComparison, primaryMetric } from "../records/views.mjs";
+import { estimateDeepSeekCost } from "../telemetry/pricing.mjs";
+import { mergeAgentUsage, readAgentUsage } from "../telemetry/usage.mjs";
+
+const STAGE_DEFINITIONS = [
+  ["research_compilation", "研究结构化", "从论文与仓库提取可执行的研究对象"],
+  ["research_plan", "研究计划快照", "固定并验证不可变 Research Plan CAP"],
+  ["contract_creation", "执行契约", "固定 Claim、实验、环境与验证边界"],
+  ["compute_scheduling", "计算调度", "根据实验需求、预算和资源目录选择执行规格"],
+  ["reproduction", "自主复现", "Agent 在隔离环境中执行与修复实验"],
+  ["evidence_parsing", "证据解析", "从原始输出中确定性解析指标"],
+  ["verification", "结果验证", "检查完整性并比较论文报告结果"],
+  ["research_card", "验证结论与卡片", "汇总论文级验证结论并生成展示快照"],
+  ["packaging", "产物封装", "生成 CAP 2.0 Records、Blobs 与签名证明"],
+  ["archive", "单文件封装", "生成可上传和可独立校验的 .cap 文件"],
+];
+
+const HEARTBEAT_HEALTHY_MS = 45_000;
+const HEARTBEAT_STALE_MS = 120_000;
+const OUTPUT_QUIET_MS = 5 * 60_000;
+const OUTPUT_ATTENTION_MS = 15 * 60_000;
+
+export async function listPipelineDashboard(pipelinesDirectory, { generatedAt = new Date().toISOString() } = {}) {
+  const root = path.resolve(pipelinesDirectory);
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return { generatedAt, pipelinesDirectory: root, pipelines: [], totals: emptyTotals() };
+  }
+
+  const pipelines = (
+    await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => readPipelineDashboard(root, entry.name, { generatedAt })),
+    )
+  )
+    .filter(Boolean)
+    .sort((left, right) => Date.parse(right.activity?.lastActivityAt ?? right.updatedAt) - Date.parse(left.activity?.lastActivityAt ?? left.updatedAt));
+
+  return {
+    generatedAt,
+    pipelinesDirectory: root,
+    pipelines,
+    totals: summarizePipelines(pipelines),
+  };
+}
+
+export async function readPipelineDashboard(pipelinesDirectory, directoryName, { generatedAt = new Date().toISOString() } = {}) {
+  const root = path.resolve(pipelinesDirectory, directoryName);
+  const pipeline = await safeJson(path.join(root, "pipeline.json"));
+  if (!pipeline?.pipelineId) return null;
+
+  const [compilationRecord, reproductionRecord, research, metrics, assessment, integrity, manifest, compileTask, runtimeTask, computeDecision, researchCard, verifiedConclusion] =
+    await Promise.all([
+      readNestedRunRecord(root, "compilations"),
+      readNestedRunRecord(root, "runs"),
+      firstJson([pipeline.researchPath]),
+      safeJson(path.join(root, "cap", "projections", "citeark", "metrics.json")),
+      safeJson(path.join(root, "cap", "projections", "citeark", "assessment.json")),
+      safeJson(path.join(root, "cap", "projections", "citeark", "integrity.json")),
+      safeJson(path.join(root, "cap", "cap-manifest.json")),
+      readNestedJson(root, "compilations", "input/submitted-compile-task.json"),
+      readNestedJson(root, "runs", "input/submitted-task.json"),
+      firstJson([
+        path.join(root, "cap", "protocol", "compute-decision.json"),
+        path.join(root, "protocol", "compute-decision.json"),
+      ]),
+      safeJson(path.join(root, "cap", "projections", "citeark", "research-card.json")),
+      safeJson(path.join(root, "cap", "projections", "citeark", "verified-conclusion.json")),
+    ]);
+  const compilationRun = compilationRecord?.run ?? null;
+  const reproductionRun = reproductionRecord?.run ?? null;
+
+  const [discoveredCompilationUsage, discoveredReproductionUsage] = await Promise.all([
+    usageForNestedRun(root, "compilations"),
+    usageForNestedRun(root, "runs"),
+  ]);
+  const measuredUsage = mergeAgentUsage(
+    preferMeasuredUsage(compilationRun?.usage, discoveredCompilationUsage),
+    preferMeasuredUsage(reproductionRun?.usage, discoveredReproductionUsage),
+  );
+  const usage = preferMeasuredUsage(pipeline.usage, measuredUsage);
+  const task = compileTask ?? runtimeTask ?? {};
+  const selectedAgent = pipeline.agent ?? task.agent ?? {};
+  const pricedUsage = {
+    ...usage,
+    pricing: pricingFor(usage, selectedAgent.model),
+    availability: usageAvailability(usage),
+  };
+  const stages = normalizeStages(pipeline, compilationRun, reproductionRun, generatedAt);
+  const activity = await readPipelineActivity({
+    root,
+    pipeline,
+    stages,
+    compilationRecord,
+    reproductionRecord,
+    generatedAt,
+  });
+  const start = pipeline.createdAt;
+  const end = pipeline.status === "running"
+    ? generatedAt
+    : pipeline.finishedAt ?? pipeline.updatedAt ?? generatedAt;
+  const completedStages = stages.filter((stage) => stage.status === "completed" || stage.status === "skipped").length;
+  const assessmentView = assessment?.citeark
+    ? { ...assessment.citeark, verdict: assessment.conclusion }
+    : assessment;
+  const comparison = primaryComparison(assessmentView);
+  const firstMeasurement = metricMeasurements(metrics)[0] ?? null;
+  const capFiles = [
+    ...(manifest?.records ?? []),
+    ...(manifest?.blobs ?? []),
+  ];
+
+  return {
+    id: pipeline.pipelineId,
+    directoryName,
+    title: research?.work?.title ?? compileTask?.paper?.title ?? task.name ?? pipeline.pipelineId,
+    workId: research?.work?.id ?? null,
+    claim: research?.claims?.find((claim) => claim.id === pipeline.claimId) ?? research?.claims?.[0] ?? null,
+    experiment: research?.experiments?.find((experiment) => experiment.id === pipeline.experimentId) ?? research?.experiments?.[0] ?? null,
+    status: pipeline.status,
+    phase: pipeline.phase,
+    verificationStatus: pipeline.verificationStatus ?? assessmentView?.verificationStatus ?? null,
+    integrityStatus: integrity?.status ?? null,
+    publicationStatus: manifest ? "publishable" : null,
+    createdAt: pipeline.createdAt,
+    updatedAt: latestTimestamp(pipeline.updatedAt, activity.lastActivityAt),
+    recordUpdatedAt: pipeline.updatedAt,
+    finishedAt: pipeline.finishedAt ?? null,
+    durationMs: validDuration(start, end),
+    progressPercent: Math.round((completedStages / stages.length) * 100),
+    stages,
+    activity,
+    usage: pricedUsage,
+    comparison,
+    metric: primaryMetric(metrics),
+    parser: firstMeasurement?.parser ?? null,
+    sourceEvidence: firstMeasurement?.sourceEvidence ?? null,
+    agent: {
+      runtime: selectedAgent.runtime ?? reproductionRun?.runtime ?? compilationRun?.runtime ?? null,
+      provider: selectedAgent.api?.protocol ?? null,
+      model: selectedAgent.model ?? firstModel(pricedUsage) ?? null,
+      subagentModel: selectedAgent.subagentModel ?? null,
+      effort: selectedAgent.effort ?? null,
+      turns: pricedUsage.turns ?? 0,
+    },
+    environment: {
+      sandbox: reproductionRun?.sandbox ?? compilationRun?.sandbox ?? null,
+      image: reproductionRun?.executionEnvironment?.image ?? computeDecision?.environment?.image ?? task.environment?.image ?? reproductionRun?.image ?? compilationRun?.image ?? null,
+      cpus: reproductionRun?.executionEnvironment?.cpus ?? computeDecision?.environment?.cpus ?? task.environment?.cpus ?? null,
+      memoryGb: reproductionRun?.executionEnvironment?.memoryGb ?? computeDecision?.environment?.memoryGb ?? task.environment?.memoryGb ?? null,
+      gpu: reproductionRun?.executionEnvironment?.gpu ?? computeDecision?.environment?.gpu ?? task.environment?.gpu ?? null,
+      networkAccess: reproductionRun?.executionEnvironment?.networkAccess ?? computeDecision?.environment?.networkAccess ?? task.environment?.networkAccess ?? null,
+      cloud: publicCloudView(reproductionRun?.cloudExecution),
+    },
+    compute: computeDecision ? {
+      decisionDigest: computeDecision.decisionDigest,
+      classification: computeDecision.requirement?.classification ?? null,
+      requirement: computeDecision.requirement ?? null,
+      selectedProfile: computeDecision.selectedProfile ?? null,
+      estimate: computeDecision.estimate ?? null,
+      rationale: computeDecision.rationale ?? null,
+      alternatives: computeDecision.alternatives ?? [],
+    } : pipeline.computeDecision ?? null,
+    researchCard: researchCard ? {
+      cardDigest: researchCard.cardDigest,
+      generatedAt: researchCard.generatedAt,
+      available: true,
+      readmePath: "preview/README.md",
+      jsonPath: "projections/citeark/research-card.json",
+    } : pipeline.researchCard ?? { available: false },
+    verifiedConclusion: verifiedConclusion ?? researchCard?.verifiedConclusion ?? null,
+    attempts: [
+      ...executionAttemptRows("研究结构化", compilationRun),
+      ...executionAttemptRows("自主复现", reproductionRun),
+    ],
+    resilience: cloudResilience(reproductionRun?.cloudExecution),
+    artifacts: {
+      artifactDigest: pipeline.artifactDigest ?? null,
+      fileCount: capFiles.length,
+      totalBytes: capFiles.reduce((total, file) => total + Number(file.size ?? 0), 0),
+      files: capFiles.map((file) => ({ path: file.path ?? null, size: file.size, digest: file.digest })),
+      attestation: Boolean(manifest),
+      researchCard: Boolean(researchCard),
+      verifiedConclusion: Boolean(verifiedConclusion),
+      readme: Boolean(researchCard),
+      archive: pipeline.citearkArchive ?? null,
+    },
+    checks: integrity?.checks ?? [],
+    error: pipeline.error ?? null,
+  };
+}
+
+function normalizeStages(pipeline, compilationRun, reproductionRun, generatedAt = new Date().toISOString()) {
+  if (Array.isArray(pipeline.stages)) {
+    return STAGE_DEFINITIONS.map(([id, label, description]) => {
+      const stored = pipeline.stages.find((stage) => stage.id === id) ?? {
+        status: "pending",
+        startedAt: null,
+        finishedAt: null,
+        durationMs: null,
+      };
+      const normalized = { id, label, description, timingSource: "recorded", ...stored };
+      if (normalized.status === "running" && normalized.startedAt) {
+        normalized.durationMs = validDuration(normalized.startedAt, generatedAt);
+      }
+      return normalized;
+    });
+  }
+
+  const rank = STAGE_DEFINITIONS.findIndex(([id]) => id === pipeline.phase);
+  return STAGE_DEFINITIONS.map(([id, label, description], index) => {
+    const exactRun = id === "research_compilation" ? compilationRun : id === "reproduction" ? reproductionRun : null;
+    let status = "pending";
+    if (exactRun) {
+      status = exactRun.status === "completed"
+        ? "completed"
+        : exactRun.status === "running"
+          ? "running"
+          : exactRun.status === "cancelled"
+            ? "cancelled"
+            : "failed";
+    }
+    else if (pipeline.status === "completed") status = "completed";
+    else if (pipeline.status === "failed" && index === rank) status = "failed";
+    else if (pipeline.status === "cancelled" && index === rank) status = "cancelled";
+    else if (index < rank) status = "completed";
+    else if (index === rank && pipeline.status === "running") status = "running";
+
+    const startedAt = exactRun?.startedAt ?? null;
+    const finishedAt = exactRun?.finishedAt ?? null;
+    return {
+      id,
+      label,
+      description,
+      status,
+      startedAt,
+      finishedAt,
+      durationMs: exactRun ? validDuration(startedAt, finishedAt ?? (status === "running" ? generatedAt : null)) : null,
+      timingSource: exactRun ? "recorded" : "derived",
+    };
+  });
+}
+
+async function readNestedRunRecord(root, group) {
+  let entries = [];
+  try {
+    entries = await readdir(path.join(root, group), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries.sort((left, right) => right.name.localeCompare(left.name))) {
+    if (!entry.isDirectory()) continue;
+    const directory = path.join(root, group, entry.name);
+    const run = await safeJson(path.join(directory, "run.json"));
+    if (run) return { run, directory };
+  }
+  return null;
+}
+
+async function readNestedJson(root, group, relativePath) {
+  let entries = [];
+  try {
+    entries = await readdir(path.join(root, group), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries.sort((left, right) => right.name.localeCompare(left.name))) {
+    if (!entry.isDirectory()) continue;
+    const value = await safeJson(path.join(root, group, entry.name, relativePath));
+    if (value) return value;
+  }
+  return null;
+}
+
+async function usageForNestedRun(root, group) {
+  let entries = [];
+  try {
+    entries = await readdir(path.join(root, group), { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const values = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const runDirectory = path.join(root, group, entry.name);
+    const run = await safeJson(path.join(runDirectory, "run.json"));
+    values.push(await readAgentUsage(path.join(runDirectory, "execution", "trace.jsonl"), {
+      runtimeHome: path.join(runDirectory, "runtime-home"),
+      model: run?.agent?.model ?? null,
+    }));
+  }
+  return mergeAgentUsage(...values);
+}
+
+function preferMeasuredUsage(...values) {
+  return values
+    .filter(Boolean)
+    .sort((left, right) =>
+      Number(right.totalTokens ?? 0) - Number(left.totalTokens ?? 0)
+      || Number(right.turns ?? 0) - Number(left.turns ?? 0)
+      || Number(right.costUsd ?? 0) - Number(left.costUsd ?? 0)
+    )[0] ?? mergeAgentUsage();
+}
+
+async function readPipelineActivity({
+  root,
+  pipeline,
+  stages,
+  compilationRecord,
+  reproductionRecord,
+  generatedAt,
+}) {
+  const [monitor, monitorEvents, compilationActivity, reproductionActivity] = await Promise.all([
+    safeJson(path.join(root, "observability", "progress.json")),
+    tailJsonRecords(path.join(root, "observability", "events.jsonl"), { maxBytes: 128 * 1024, maxLines: 40 }),
+    inspectRunActivity(compilationRecord?.directory),
+    inspectRunActivity(reproductionRecord?.directory),
+  ]);
+  const cloudActivity = inspectCloudActivity(reproductionRecord?.run);
+  const lastOutputAt = latestTimestamp(
+    monitor?.lastOutputAt,
+    compilationActivity.lastOutputAt,
+    reproductionActivity.lastOutputAt,
+    cloudActivity.lastOutputAt,
+  );
+  const lastActivityAt = latestTimestamp(
+    pipeline.updatedAt,
+    compilationRecord?.run?.updatedAt,
+    reproductionRecord?.run?.updatedAt,
+    monitor?.lastActivityAt,
+    lastOutputAt,
+  );
+  const lastHeartbeatAt = monitor?.lastHeartbeatAt ?? null;
+  const events = [
+    ...monitorEvents.records.map(publicMonitorEvent).filter(Boolean),
+    ...compilationActivity.events,
+    ...reproductionActivity.events,
+    ...cloudActivity.events,
+  ]
+    .filter(Boolean)
+    .sort((left, right) => eventSortTime(right) - eventSortTime(left) || Number(right.order ?? 0) - Number(left.order ?? 0))
+    .filter(uniqueEvent())
+    .slice(0, 16);
+  const health = classifyActivityHealth({
+    status: pipeline.status,
+    generatedAt,
+    lastHeartbeatAt,
+    lastActivityAt,
+    lastOutputAt,
+    hasMonitor: Boolean(monitor),
+  });
+  const activeStage = stages.find((stage) => stage.status === "running" || stage.status === "prepared")
+    ?? stages.find((stage) => stage.id === pipeline.phase)
+    ?? null;
+  return {
+    health: health.code,
+    healthLabel: health.label,
+    attentionRequired: health.attentionRequired,
+    controllerAlive: health.controllerAlive,
+    reason: health.reason,
+    currentAction: events.find((event) =>
+      event.source === "agent-trace"
+      && event.kind !== "checkpoint"
+      && event.kind !== "infrastructure"
+    )?.message ?? events[0]?.message ?? monitor?.currentAction ?? activeStage?.description ?? "等待新的执行记录",
+    currentStage: monitor?.currentStage ?? pipeline.phase ?? activeStage?.id ?? null,
+    currentStageStartedAt: activeStage?.startedAt ?? null,
+    lastHeartbeatAt,
+    lastActivityAt,
+    lastOutputAt,
+    heartbeatAgeMs: ageMs(generatedAt, lastHeartbeatAt),
+    activityAgeMs: ageMs(generatedAt, lastActivityAt),
+    outputAgeMs: ageMs(generatedAt, lastOutputAt),
+    source: monitor
+      ? "pipeline-heartbeat+execution-files+cloud-checkpoints"
+      : "execution-files+cloud-checkpoints",
+    refreshIntervalSeconds: 4,
+    events,
+  };
+}
+
+function inspectCloudActivity(run) {
+  const jobs = run?.cloudExecution?.jobs ?? [];
+  const activity = jobs.toReversed().find((job) => Array.isArray(job?.activity?.traceTail))?.activity ?? null;
+  if (!activity) return { lastOutputAt: null, events: [] };
+  const lastOutputAt = validTimestamp(activity.lastOutputAt);
+  const records = activity.traceTail.slice(-24).map((value, order) => ({ value, order }));
+  return {
+    lastOutputAt,
+    events: summarizeTraceEvents(records, lastOutputAt),
+  };
+}
+
+async function inspectRunActivity(directory) {
+  if (!directory) return { lastOutputAt: null, events: [] };
+  const tracePath = path.join(directory, "execution", "trace.jsonl");
+  const [trace, fixedFiles, logFiles, evidenceFiles] = await Promise.all([
+    tailJsonRecords(tracePath, { maxBytes: 256 * 1024, maxLines: 100 }),
+    newestFileTimestamp([
+      tracePath,
+      path.join(directory, "execution", "claude-stderr.log"),
+      path.join(directory, "output", "result.json"),
+    ]),
+    newestDirectoryFileTimestamp(path.join(directory, "output", "logs")),
+    newestDirectoryFileTimestamp(path.join(directory, "output", "evidence")),
+  ]);
+  return {
+    lastOutputAt: latestTimestamp(fixedFiles, logFiles, evidenceFiles, trace.modifiedAt),
+    events: summarizeTraceEvents(trace.records, trace.modifiedAt),
+  };
+}
+
+async function tailJsonRecords(target, { maxBytes, maxLines }) {
+  let handle;
+  try {
+    handle = await open(target, "r");
+    const info = await handle.stat();
+    const length = Math.min(info.size, maxBytes);
+    const start = Math.max(0, info.size - length);
+    const buffer = Buffer.alloc(length);
+    await handle.read(buffer, 0, length, start);
+    let lines = buffer.toString("utf8").split(/\r?\n/).filter(Boolean);
+    if (start > 0) lines = lines.slice(1);
+    const records = lines.slice(-maxLines).flatMap((line, index) => {
+      try {
+        return [{ value: JSON.parse(line), order: index }];
+      } catch {
+        return [];
+      }
+    });
+    return { records, modifiedAt: info.mtime.toISOString() };
+  } catch {
+    return { records: [], modifiedAt: null };
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+async function newestFileTimestamp(targets) {
+  const values = await Promise.all(targets.map(async (target) => {
+    try {
+      return (await stat(target)).mtime.toISOString();
+    } catch {
+      return null;
+    }
+  }));
+  return latestTimestamp(...values);
+}
+
+async function newestDirectoryFileTimestamp(directory) {
+  let entries = [];
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  return await newestFileTimestamp(entries.filter((entry) => entry.isFile()).map((entry) => path.join(directory, entry.name)));
+}
+
+function publicMonitorEvent(record) {
+  const event = record?.value;
+  if (!event || typeof event.message !== "string") return null;
+  return {
+    at: validTimestamp(event.at),
+    observedAt: validTimestamp(event.at),
+    kind: event.kind ?? "activity",
+    level: event.level ?? "info",
+    stage: event.stage ?? null,
+    message: cleanPublicText(event.message, 220),
+    order: event.sequence ?? record.order,
+    source: "pipeline-monitor",
+  };
+}
+
+function summarizeTraceEvents(records, observedAt) {
+  const events = [];
+  for (const record of records) {
+    const value = record.value;
+    const at = validTimestamp(value?.timestamp ?? value?.recorded_at ?? value?.created_at);
+    const base = {
+      at,
+      observedAt: at ?? observedAt,
+      stage: null,
+      order: record.order,
+      source: "agent-trace",
+    };
+    if (value?.type === "citeark.attempt_started") {
+      events.push({ ...base, kind: "attempt", level: "info", message: `Agent 开始第 ${value.attempt ?? "—"} 次执行` });
+      continue;
+    }
+    if (value?.type === "citeark.attempt_finished") {
+      const failed = Number(value.exit_code) !== 0 || value.timed_out === true;
+      events.push({
+        ...base,
+        kind: "attempt",
+        level: failed ? "error" : "success",
+        message: value.timed_out ? "Agent 执行超时" : failed ? `Agent 执行结束，退出码 ${value.exit_code}` : "Agent 执行成功结束",
+      });
+      continue;
+    }
+    if (value?.type === "citeark.checkpoint_saved") {
+      events.push({
+        ...base,
+        kind: "checkpoint",
+        level: "success",
+        message: `已保存${value.kind === "full" ? "完整" : "关键"}检查点${value.bytes ? `（${value.bytes} 字节）` : ""}`,
+      });
+      continue;
+    }
+    if (value?.type === "citeark.checkpoint_restored") {
+      events.push({ ...base, kind: "checkpoint", level: "warning", message: `基础设施重启，已从检查点恢复第 ${Number(value.infrastructureRetry ?? 0) + 1} 次执行` });
+      continue;
+    }
+    if (value?.type === "citeark.infrastructure_interruption") {
+      events.push({ ...base, kind: "infrastructure", level: "warning", message: "云端执行收到中断信号，正在紧急持久化关键状态" });
+      continue;
+    }
+    if (value?.type === "citeark.completed_result_reused") {
+      events.push({ ...base, kind: "checkpoint", level: "success", message: "恢复点已经包含完整结果，跳过重复实验并直接回传" });
+      continue;
+    }
+    if (value?.type === "citeark.result_ready_agent_stop_requested") {
+      events.push({ ...base, kind: "agent", level: "info", message: "结果已经稳定，正在自动结束 Agent 进程" });
+      continue;
+    }
+    if (value?.type === "citeark.result_ready_agent_force_stopped") {
+      events.push({ ...base, kind: "agent", level: "warning", message: "Agent 未在宽限期内退出，已由执行器强制结束" });
+      continue;
+    }
+    if (value?.type === "citeark.agent_stopped_after_result_ready") {
+      events.push({ ...base, kind: "agent", level: "success", message: "Agent 已在完整结果生成后自动收尾" });
+      continue;
+    }
+    if (value?.type === "thread.started") {
+      events.push({ ...base, kind: "agent", level: "info", message: "Agent 会话已经建立" });
+      continue;
+    }
+    if (value?.type === "turn.started") {
+      events.push({ ...base, kind: "agent", level: "info", message: "Agent 开始新的工作回合" });
+      continue;
+    }
+    if (value?.type === "turn.completed") {
+      events.push({ ...base, kind: "agent", level: "success", message: "Agent 工作回合完成" });
+      continue;
+    }
+    if (value?.type === "item.started" && value.item?.type === "command_execution") {
+      events.push({ ...base, kind: "command", level: "info", message: classifyCommand(value.item.command) });
+      continue;
+    }
+    if (value?.type === "item.completed" && value.item?.type === "command_execution" && Number(value.item.exit_code) !== 0) {
+      events.push({ ...base, kind: "command", level: "warning", message: `命令执行异常，退出码 ${value.item.exit_code}` });
+      continue;
+    }
+    if (value?.type === "item.completed" && value.item?.type === "agent_message" && value.item.text) {
+      events.push({ ...base, kind: "agent-message", level: "info", message: `Agent 更新：${cleanPublicText(value.item.text, 220)}` });
+      continue;
+    }
+    if (value?.type === "tool_progress") {
+      events.push({
+        ...base,
+        kind: "tool-heartbeat",
+        level: "info",
+        message: `${toolLabel(value.tool_name)} 已持续运行 ${Math.max(0, Number(value.elapsed_time_seconds) || 0)} 秒`,
+      });
+      continue;
+    }
+    if (value?.type === "assistant" && Array.isArray(value.message?.content)) {
+      for (const content of value.message.content) {
+        if (content?.type === "tool_use") {
+          events.push({ ...base, kind: "tool", level: "info", message: summarizeToolUse(content) });
+        } else if (content?.type === "text" && content.text) {
+          events.push({ ...base, kind: "agent-message", level: "info", message: `Agent 更新：${cleanPublicText(content.text, 220)}` });
+        }
+      }
+      continue;
+    }
+    if (value?.type === "result") {
+      events.push({
+        ...base,
+        kind: "agent",
+        level: value.is_error ? "error" : "success",
+        message: value.is_error ? "Agent 回合返回错误" : "Agent 已提交本轮结果",
+      });
+    }
+  }
+  return events.slice(-24);
+}
+
+function summarizeToolUse(content) {
+  const name = toolLabel(content.name);
+  if (content.name === "Bash") return classifyCommand(content.input?.command, content.input?.description);
+  if (content.name === "Read") return `正在读取文件：${cleanPublicText(content.input?.file_path ?? "仓库文件", 120)}`;
+  if (content.name === "Write" || content.name === "Edit") return `正在更新文件：${cleanPublicText(content.input?.file_path ?? "实验文件", 120)}`;
+  return `正在调用工具：${name}`;
+}
+
+function classifyCommand(command, description) {
+  if (description) return cleanPublicText(description, 180);
+  const raw = cleanPublicText(command ?? "", 180);
+  const lower = raw.toLowerCase();
+  if (/\b(pip|npm|apt-get|conda|uv)\b.*\binstall\b/.test(lower)) return "正在安装实验依赖";
+  if (/\b(curl|wget|download|huggingface|git lfs)\b/.test(lower)) return "正在下载数据、模型或实验资源";
+  if (/\b(train\.py|python[^;]*(train|finetune)|torchrun)\b/.test(lower)) return "正在运行模型训练";
+  if (/\b(evaluation\.py|evaluate|pytest|unittest|benchmark)\b/.test(lower)) return "正在运行论文评测或测试";
+  if (/\bgit\b/.test(lower)) return "正在检查代码仓库与变更";
+  if (/\b(ps|tail|top|nvidia-smi)\b/.test(lower)) return "正在检查进程、资源或运行日志";
+  return raw ? `正在执行命令：${raw}` : "正在执行实验命令";
+}
+
+function classifyActivityHealth({ status, generatedAt, lastHeartbeatAt, lastActivityAt, lastOutputAt, hasMonitor }) {
+  if (status !== "running") {
+    return {
+      code: status === "failed" ? "failed" : status === "prepared" ? "waiting" : "finished",
+      label: status === "failed" ? "运行失败" : status === "prepared" ? "等待执行" : status === "cancelled" ? "已取消" : "已结束",
+      attentionRequired: false,
+      controllerAlive: false,
+      reason: status === "failed"
+        ? "流水线已经记录失败原因"
+        : status === "prepared"
+          ? "运行包已经准备，但尚未真实执行"
+          : status === "cancelled"
+            ? "流水线已按用户请求停止"
+            : "流水线已经进入终态",
+    };
+  }
+  const heartbeatAge = ageMs(generatedAt, lastHeartbeatAt);
+  const outputAge = ageMs(generatedAt, lastOutputAt);
+  const activityAge = ageMs(generatedAt, lastActivityAt);
+  if (hasMonitor) {
+    if (heartbeatAge === null || heartbeatAge > HEARTBEAT_STALE_MS) {
+      return { code: "stalled", label: "疑似中断", attentionRequired: true, controllerAlive: false, reason: "控制器心跳已超过 2 分钟没有更新" };
+    }
+    if (heartbeatAge > HEARTBEAT_HEALTHY_MS) {
+      return { code: "delayed", label: "心跳延迟", attentionRequired: false, controllerAlive: true, reason: "控制器仍可能在线，但心跳刷新出现延迟" };
+    }
+    if (outputAge !== null && outputAge > OUTPUT_ATTENTION_MS) {
+      return { code: "quiet", label: "长时间无输出", attentionRequired: true, controllerAlive: true, reason: "控制器心跳正常，但超过 15 分钟没有新的 Agent 输出或日志" };
+    }
+    if (outputAge !== null && outputAge > OUTPUT_QUIET_MS) {
+      return { code: "quiet", label: "计算中", attentionRequired: false, controllerAlive: true, reason: "控制器心跳正常，当前步骤暂时没有新输出" };
+    }
+    return { code: "active", label: "持续运行", attentionRequired: false, controllerAlive: true, reason: "控制器心跳和执行活动均正常" };
+  }
+  return { code: "stalled", label: "缺少控制器心跳", attentionRequired: true, controllerAlive: false, reason: "CAP 2.0 流水线缺少必需的控制器心跳记录" };
+}
+
+function latestTimestamp(...values) {
+  return values
+    .map(validTimestamp)
+    .filter(Boolean)
+    .sort((left, right) => Date.parse(right) - Date.parse(left))[0] ?? null;
+}
+
+function validTimestamp(value) {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function ageMs(now, then) {
+  if (!then) return null;
+  const value = Date.parse(now) - Date.parse(then);
+  return Number.isFinite(value) ? Math.max(0, value) : null;
+}
+
+function eventSortTime(event) {
+  return Date.parse(event?.at ?? event?.observedAt ?? 0) || 0;
+}
+
+function uniqueEvent() {
+  const seen = new Set();
+  return (event) => {
+    const key = `${event.source}|${event.at ?? event.observedAt}|${event.kind}|${event.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  };
+}
+
+function toolLabel(value) {
+  return ({ Bash: "命令", Read: "文件读取", Write: "文件写入", Edit: "文件编辑", TaskOutput: "后台任务" })[value] ?? value ?? "Agent 工具";
+}
+
+function cleanPublicText(value, maximumLength) {
+  const normalized = String(value ?? "")
+    .replaceAll(/sk-[A-Za-z0-9_-]{12,}/g, "<已隐藏密钥>")
+    .replaceAll(/((?:api[_-]?key|token|password|secret)\s*[=:]\s*)[^\s,;]+/gi, "$1<已隐藏>")
+    .replaceAll(/\s+/g, " ")
+    .trim();
+  return normalized.length > maximumLength ? `${normalized.slice(0, maximumLength - 1)}…` : normalized;
+}
+
+async function safeJson(target) {
+  if (!target || typeof target !== "string") return null;
+  try {
+    return JSON.parse(await readFile(target, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function firstJson(targets) {
+  for (const target of targets) {
+    const value = await safeJson(target);
+    if (value) return value;
+  }
+  return null;
+}
+
+function executionAttemptRows(stage, run) {
+  const completed = (run?.attempts ?? []).map((attempt) => ({
+    stage,
+    attempt: attempt.attempt,
+    startedAt: attempt.startedAt,
+    finishedAt: attempt.finishedAt,
+    durationMs: validDuration(attempt.startedAt, attempt.finishedAt),
+    exitCode: attempt.exitCode,
+    timedOut: attempt.timedOut,
+    executor: attempt.executor ?? null,
+    batchJob: attempt.batchJob ?? null,
+    batchState: attempt.batchState ?? null,
+    infrastructureAttempt: attempt.infrastructureAttempt ?? null,
+    infrastructureAttemptLimit: attempt.infrastructureAttemptLimit ?? null,
+    resumeCount: attempt.resumeCount ?? 0,
+    checkpoint: publicCheckpoint(attempt.checkpoint),
+  }));
+  const recordedJobs = new Set(completed.map((attempt) => attempt.batchJob).filter(Boolean));
+  const live = (run?.cloudExecution?.jobs ?? [])
+    .filter((job) => !recordedJobs.has(job.name))
+    .map((job) => ({
+      stage,
+      attempt: job.attempt,
+      startedAt: job.startedAt,
+      finishedAt: job.finishedAt ?? null,
+      durationMs: validDuration(job.startedAt, job.finishedAt ?? new Date().toISOString()),
+      exitCode: null,
+      timedOut: job.state === "TIMED_OUT",
+      executor: "gcp-batch",
+      batchJob: job.name,
+      batchState: job.state,
+      infrastructureAttempt: job.infrastructureAttempt ?? 1,
+      infrastructureAttemptLimit: job.infrastructureAttemptLimit ?? null,
+      resumeCount: job.resumeCount ?? 0,
+      checkpoint: publicCheckpoint(job.checkpoint),
+    }));
+  return [...completed, ...live];
+}
+
+function cloudResilience(cloud) {
+  if (!cloud) return null;
+  const jobs = cloud.jobs ?? [];
+  const current = jobs[jobs.length - 1] ?? null;
+  const currentCounters = infrastructureCounters(current);
+  return {
+    enabled: cloud.checkpointing?.enabled === true,
+    criticalIntervalSeconds: cloud.checkpointing?.criticalIntervalSeconds ?? null,
+    fullIntervalSeconds: cloud.checkpointing?.fullIntervalSeconds ?? null,
+    infrastructureAttempt: currentCounters.infrastructureAttempt,
+    infrastructureAttemptLimit: current?.infrastructureAttemptLimit ?? null,
+    resumeCount: jobs.reduce((total, job) => total + infrastructureCounters(job).resumeCount, 0),
+    interruptionCount: jobs.reduce((total, job) => total + infrastructureCounters(job).interruptionCount, 0),
+    latestCheckpoint: publicCheckpoint(current?.checkpoint),
+    currentJobState: current?.state ?? null,
+  };
+}
+
+function publicCloudView(cloud) {
+  if (!cloud) return null;
+  return {
+    ...structuredClone(cloud),
+    jobs: (cloud.jobs ?? []).map((job) => {
+      const counters = infrastructureCounters(job);
+      return {
+        ...structuredClone(job),
+        ...counters,
+        checkpoint: publicCheckpoint(job.checkpoint),
+        activity: job.activity ? {
+          traceDigest: job.activity.traceDigest ?? null,
+          lastOutputAt: validTimestamp(job.activity.lastOutputAt),
+          eventCount: Array.isArray(job.activity.traceTail) ? job.activity.traceTail.length : 0,
+        } : null,
+      };
+    }),
+  };
+}
+
+function publicCheckpoint(checkpoint) {
+  if (!checkpoint) return null;
+  const { activity: _privateActivity, ...safe } = structuredClone(checkpoint);
+  return safe;
+}
+
+function infrastructureCounters(job) {
+  if (!job) return { infrastructureAttempt: null, resumeCount: 0, interruptionCount: 0 };
+  const checkpointRetry = Number(job.checkpoint?.infrastructureRetry);
+  const resumeCount = Number.isInteger(checkpointRetry) && checkpointRetry >= 0
+    ? checkpointRetry
+    : Math.max(0, Number(job.resumeCount ?? 0));
+  return {
+    infrastructureAttempt: resumeCount + 1,
+    resumeCount,
+    interruptionCount: resumeCount,
+  };
+}
+
+function firstModel(usage) {
+  return Object.keys(usage?.models ?? {})[0] ?? null;
+}
+
+function validDuration(start, end) {
+  const value = Date.parse(end) - Date.parse(start);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function summarizePipelines(pipelines) {
+  const totals = emptyTotals();
+  totals.runs = pipelines.length;
+  totals.running = pipelines.filter((item) => item.status === "running").length;
+  totals.runningActive = pipelines.filter((item) => item.status === "running" && item.activity?.health === "active").length;
+  totals.attentionRequired = pipelines.filter((item) => item.activity?.attentionRequired).length;
+  totals.stalled = pipelines.filter((item) => item.status === "running" && item.activity?.health === "stalled").length;
+  totals.completed = pipelines.filter((item) => item.status === "completed").length;
+  totals.failed = pipelines.filter((item) => item.status === "failed").length;
+  totals.reproduced = pipelines.filter((item) => item.verificationStatus === "reproduced").length;
+  totals.approximatelyReproduced = pipelines.filter((item) => item.verificationStatus === "approximately_reproduced").length;
+  totals.notReproduced = pipelines.filter((item) => item.verificationStatus === "not_reproduced").length;
+  totals.inconclusive = pipelines.filter((item) => item.verificationStatus === "inconclusive").length;
+  totals.assessed = totals.reproduced + totals.approximatelyReproduced + totals.notReproduced + totals.inconclusive;
+  totals.decisive = totals.reproduced + totals.approximatelyReproduced + totals.notReproduced;
+  totals.decisiveRate = totals.assessed
+    ? Math.round((totals.decisive / totals.assessed) * 100)
+    : 0;
+  totals.durationMs = pipelines.reduce((sum, item) => sum + Number(item.durationMs ?? 0), 0);
+  totals.usage = mergeAgentUsage(...pipelines.map((item) => item.usage));
+  const availableUsageCount = pipelines.filter((item) => item.usage?.availability?.status === "reported").length;
+  totals.usage.availability = {
+    status: availableUsageCount === 0 ? "unavailable" : availableUsageCount === pipelines.length ? "reported" : "partial",
+    reportedRuns: availableUsageCount,
+    totalRuns: pipelines.length,
+  };
+  totals.usage.pricing = pipelines.every((item) =>
+    String(item.agent?.model ?? "").toLowerCase().includes("deepseek"),
+  )
+    ? estimateDeepSeekCost(totals.usage)
+    : pricingFor(totals.usage, null);
+  return totals;
+}
+
+function pricingFor(usage, model) {
+  if (String(model ?? "").toLowerCase().includes("deepseek")) {
+    return estimateDeepSeekCost(usage, { defaultModel: model });
+  }
+  if (usage?.costStatus === "reported" || usage?.costStatus === "partial") {
+    return {
+      currency: "USD",
+      source: usage.costStatus === "reported" ? "agent-reported" : "agent-reported-partial",
+      costUsd: Number(usage.costUsd),
+    };
+  }
+  return { currency: null, source: "unavailable" };
+}
+
+function usageAvailability(usage) {
+  const reported = Number(usage?.totalTokens ?? 0) > 0
+    || Number(usage?.turns ?? 0) > 0
+    || Number(usage?.costUsd ?? 0) > 0
+    || Object.keys(usage?.models ?? {}).length > 0;
+  return reported
+    ? { status: "reported", reason: null }
+    : { status: "unavailable", reason: "当前 Agent CLI trace 未提供 Token 用量字段" };
+}
+
+function emptyTotals() {
+  return {
+    runs: 0,
+    running: 0,
+    runningActive: 0,
+    attentionRequired: 0,
+    stalled: 0,
+    completed: 0,
+    failed: 0,
+    reproduced: 0,
+    approximatelyReproduced: 0,
+    notReproduced: 0,
+    inconclusive: 0,
+    assessed: 0,
+    decisive: 0,
+    decisiveRate: 0,
+    durationMs: 0,
+    usage: mergeAgentUsage(),
+  };
+}