@citeark/agent 0.3.20

package/src/pipeline/orchestrator.mjs

@@ -0,0 +1,1281 @@
+import { controlledExecutors, researchBoundary } from '../workspace/control.mjs';
+import { mkdir, rm } from "node:fs/promises";
+import { createSourceReviewCompletion } from '../research/source-review-model.mjs';
+import { runtimeProviderConfiguration } from '../provider/runtime-auth.mjs';
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  createAssetPreparationComputeDecision,
+  selectAssetPreparationProfile,
+} from "../assets/compute.mjs";
+import { executeGcpAssetPreparation } from "../assets/executor.mjs";
+import { executeGcpBatchReproduction } from "../compute/gcp-batch-executor.mjs";
+import { createCpuResearchPreparationWorkload } from "../workloads/cpu-research-preparation.mjs";
+import {
+  assetPreparationPlanFailures,
+  createAssetPreparationPlan,
+} from "../assets/plan.mjs";
+import { createAssetReadiness } from "../assets/readiness.mjs";
+import {
+  assetPreparationFallback,
+  decideOpportunisticAssetPreparation,
+  mustAbortAfterAssetPreparationFailure,
+} from "../assets/opportunistic-preparation.mjs";
+import {
+  ASSET_QUALIFICATION_BOUNDARY,
+  assertAssetQualificationAdmission,
+  probeAssetQualification,
+} from "../assets/qualification.mjs";
+import { packCap, capDirectoryContentDigest } from "../cap/v2/archive.mjs";
+import { loadResearchCompilationCap } from "../cap/v2/compilation-artifact.mjs";
+import { assembleResearchPlanCap } from "../cap/v2/research-artifact.mjs";
+import { loadComputeCatalog, loadComputePolicy } from "../compute/catalog.mjs";
+import {
+  executeScheduledCompilation,
+  listCompilerExecutors,
+} from "../compute/compiler-router.mjs";
+import { executeScheduledReproduction } from "../compute/executor-router.mjs";
+import { scheduleCompute } from "../compute/scheduler.mjs";
+import {
+  createExecutionContract,
+  loadExecutionContract,
+  loadVerificationPolicy,
+} from "../contracts/execution-contract.mjs";
+import { prepareInventoryForExecution, writePreparationTaskFromInventory } from "../research/inventory-handoff.mjs";
+import { runResearchCompiler } from "../research/compiler.mjs";
+import { loadResearchStructure } from "../research/structure.mjs";
+import { mergeAgentUsage } from "../telemetry/usage.mjs";
+import {
+  CiteArkError,
+  createRunId,
+  pathExists,
+  readJson,
+  sha256File,
+  writeJson,
+} from "../util.mjs";
+import { createPipelineMonitor } from "../observability/pipeline-monitor.mjs";
+import { createStageCheckpoint } from "./stage-checkpoint.mjs";
+import { replayRunToCap } from "./replay.mjs";
+import { isCiteArkReconstructionRepository } from "../repository-origin.mjs";
+import { createPipelineRecoveryEnvelope } from "./stage-recovery.mjs";
+import { createScientificAssessor } from "../verification/ai-assessor.mjs";
+import { usesWorkspaceSummary } from "../reproduction/workspace-mode.mjs";
+import { createCampaignContract, campaignTargetDirectory } from "../contracts/campaign-contract.mjs";
+import { reproductionCampaign } from "../compute/campaign.mjs";
+
+export const PIPELINE_STAGES = Object.freeze(
+  [
+    ["research_compilation", "研究结构化"],
+    ["research_plan", "研究计划快照"],
+    ["contract_creation", "执行契约"],
+    ["compute_scheduling", "计算调度"],
+    ["asset_preparation", "资产与依赖准备"],
+    ["reproduction", "自主复现"],
+    ["evidence_parsing", "证据解析"],
+    ["verification", "完整性检查与 AI 科学评估"],
+    ["research_card", "验证结论与卡片"],
+    ["execution_handoff", "整理再次执行的交付说明"],
+    ["packaging", "产物封装"],
+    ["archive", "单文件封装"],
+  ].map((stage) => Object.freeze(stage)),
+);
+
+const PACKAGE_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../..",
+);
+
+export async function executeFullPipeline({
+  compileTaskPath,
+  researchPath,
+  compilationArtifactPath,
+  sourceArtifactDigests = [],
+  sourceCompilationDigests: inheritedCompilationDigests = [],
+  referenceMaterialsPath,
+  paperPath,
+  paperReading,
+  claimId,
+  experimentId,
+  executionClaimIds,
+  executionTargets,
+  tolerance,
+  workDirectory,
+  signingKeyPath,
+  agentRuntime,
+  computeCatalogPath,
+  computePolicyPath,
+  resourceLimits,
+  computeProfile,
+  computeSelection,
+  datasetRegistryPath,
+  executorOptions,
+  processingBinding,
+  researchArtifactDigest,
+  repositoryPath,
+  upstreamCompilation,
+  upstreamAssetAdmission,
+  scientificAssessor,
+  stopAfter,
+  dryRun = false,
+  progress = () => {},
+  observe = () => {},
+  onPhaseChange = async () => {},
+  onCheckpoint = async () => {},
+  resume = false,
+  retryScientificExecution = false,
+  postProcessingOnly = false,
+}) {
+  executorOptions = controlledExecutors(executorOptions);
+  const inputs = [compileTaskPath, researchPath, compilationArtifactPath].filter(Boolean);
+  if (inputs.length !== 1) {
+    throw new CiteArkError(
+      "pipeline execute 必须且只能提供 --compile-task、--research 或 --compilation 之一",
+    );
+  }
+  if (stopAfter !== undefined && !new Set([ASSET_QUALIFICATION_BOUNDARY, "research_plan"]).has(stopAfter)) {
+    throw new CiteArkError(`不支持的流水线停止边界：${stopAfter}`);
+  }
+  const root = path.resolve(workDirectory);
+  const existing = await pathExists(path.join(root, "pipeline.json"));
+  if (existing && !resume)
+    throw new CiteArkError(`流水线目录已经被使用：${root}`);
+  const restoredState = existing
+    ? await readJson(path.join(root, "pipeline.json"))
+    : null;
+  if (postProcessingOnly && !(await pathExists(path.join(root, "stage-results", "reproduction.json")))) {
+    throw new CiteArkError("后处理恢复缺少已保存的实验结果；保留现场，不启动新的实验", {
+      retryable: false, failureCategory: "publication", failureCode: "recovery.completed_result_missing",
+    });
+  }
+  const pipelineId =
+    restoredState?.pipelineId ?? createRunId().replace(/^car_/, "pipeline_");
+  if (
+    restoredState && retryScientificExecution &&
+    (await pathExists(path.join(root, "stage-results", "reproduction.json")))
+  ) {
+    const cached = await readJson(
+      path.join(root, "stage-results", "reproduction.json"),
+    );
+    // Re-running scientific work requires an explicit execution-retry decision.
+    // A partial/failed result is still a completed input to assessment/publication.
+    if (cached.value?.validation?.result?.execution?.status !== "succeeded"
+      && restoredState.phase === "completed") {
+      for (const [id] of PIPELINE_STAGES.slice(5)) {
+        await rm(path.join(root, "stage-results", `${id}.json`), {
+          force: true,
+        });
+        const stage = restoredState.stages.find((item) => item.id === id);
+        if (stage) stage.status = "pending";
+      }
+      const oldRunId = cached.value?.bundle?.runId;
+      if (oldRunId) {
+        const runPath = path.join(root, "runs", oldRunId, "run.json");
+        const run = await readJson(runPath);
+        delete run.recoveryRemoteResult;
+        run.recoveryContinueAgent = true;
+        await writeJson(runPath, run);
+      }
+      await rm(path.join(root, "cap"), { recursive: true, force: true });
+    }
+  }
+  if (restoredState && computeSelection)
+    await rm(path.join(root, "stage-results", "compute_scheduling.json"), {
+      force: true,
+    });
+
+  const directories = {
+    root,
+    compilations: path.join(root, "compilations"),
+    protocol: path.join(root, "protocol"),
+    private: path.join(root, "private"),
+    runs: path.join(root, "runs"),
+    researchPlanCap: path.join(root, "research-plan-cap"),
+    cap: path.join(root, "cap"),
+  };
+  const researchPlanArchivePath = path.join(
+    root,
+    `${pipelineId}-research-plan.cap`,
+  );
+
+  await Promise.all(
+    Object.values(directories).map((directory) =>
+      mkdir(directory, { recursive: true }),
+    ),
+  );
+  const createdAt = new Date().toISOString();
+  const state = restoredState ?? {
+    schemaVersion: "1.0",
+    pipelineId,
+    status: "running",
+    phase: compileTaskPath ? "research_compilation" : "research_plan",
+    createdAt,
+    updatedAt: createdAt,
+    stages: PIPELINE_STAGES.map(([id, label]) => {
+      const importedCompilation = id === "research_compilation"
+        && Boolean(upstreamCompilation || compilationArtifactPath);
+      const startedAt = importedCompilation
+        ? (upstreamCompilation?.startedAt ?? null)
+        : null;
+      const finishedAt = importedCompilation
+        ? (upstreamCompilation?.finishedAt ?? null)
+        : null;
+      return {
+        id,
+        label,
+        status: importedCompilation
+          ? "completed"
+          : !compileTaskPath && id === "research_compilation"
+            ? "skipped"
+            : "pending",
+        startedAt,
+        finishedAt,
+        durationMs:
+          startedAt && finishedAt
+            ? Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt))
+            : null,
+      };
+    }),
+  };
+  const stageCheckpoint = createStageCheckpoint({
+    directory: root,
+    enabled: !dryRun,
+    identity: {
+      sourceDigest: processingBinding?.sourceDigest ?? null,
+      inputDigest: processingBinding
+        ? null
+        : await sha256File(compileTaskPath ?? researchPath ?? compilationArtifactPath),
+      tolerance: tolerance ?? null,
+      researchArtifactDigest: researchArtifactDigest ?? null,
+      claimId: claimId ?? null,
+      experimentId: experimentId ?? null,
+      executionClaimIds: Array.isArray(executionClaimIds)
+        ? [...executionClaimIds].sort()
+        : null,
+      executionTargets: executionTargets ?? null,
+      sourceArtifactDigests,
+      referenceMaterialsDigest: referenceMaterialsPath ? await sha256File(referenceMaterialsPath) : null,
+    },
+    persist: dryRun ? async () => {} : onCheckpoint,
+    progress,
+  });
+  const monitor = createPipelineMonitor({
+    directory: root,
+    pipelineId,
+    correlation: {
+      jobId: processingBinding?.jobId,
+      repositoryId: processingBinding?.repositoryId,
+      sourceDigest: processingBinding?.sourceDigest,
+      claimId,
+      experimentId,
+    },
+    onEvent: observe,
+  });
+  await monitor.start({ stage: state.phase });
+  const reportProgress = (message, details) => {
+    progress(message, details);
+    monitor.record(message, { stage: state.phase });
+  };
+  const save = async (patch) => {
+    Object.assign(state, patch, { updatedAt: new Date().toISOString() });
+    await writeJson(path.join(root, "pipeline.json"), state);
+  };
+  const updateStage = async (id, status, details = {}) => {
+    if (status === "running") await researchBoundary(id);
+    const stage = state.stages.find((item) => item.id === id);
+    if (!stage) throw new CiteArkError(`未知流水线阶段：${id}`);
+    const now = new Date().toISOString();
+    if (status === "running") {
+      stage.startedAt ??= now;
+      stage.finishedAt = null;
+      stage.durationMs = null;
+    } else if (
+      status === "completed" ||
+      status === "failed" ||
+      status === "deferred" ||
+      status === "skipped"
+    ) {
+      stage.startedAt ??= now;
+      stage.finishedAt = now;
+      stage.durationMs = Math.max(
+        0,
+        Date.parse(now) - Date.parse(stage.startedAt),
+      );
+    } else if (status === "prepared") {
+      stage.startedAt ??= now;
+    }
+    stage.status = status;
+    await save({ phase: id });
+    if (status === "running" && !dryRun)
+      await onCheckpoint({ stage: id, status });
+    await onPhaseChange({
+      id,
+      status,
+      stage: structuredClone(stage),
+      ...details,
+    });
+    monitor.stage(id, status, `${stage.label}：${stageStatusLabel(status)}`, {
+      startedAt: stage.startedAt,
+      finishedAt: stage.finishedAt,
+      durationMs: stage.durationMs,
+    });
+  };
+  await save({});
+  for (const stage of state.stages.filter(
+    (item) => item.status === "skipped",
+  )) {
+    monitor.stage(
+      stage.id,
+      "skipped",
+      `${stage.label}：${stageStatusLabel("skipped")}`,
+    );
+  }
+
+  let currentAssetReadiness = null;
+  let assetAdmission = upstreamAssetAdmission ?? null;
+  let reproduction = null;
+  try {
+    let loadedComputeCatalog = null;
+    let normalizedResearchPath = researchPath
+      ? path.resolve(researchPath)
+      : null;
+    let compilation = null;
+    let compilationArtifact = null;
+    const sourceCompilationDigests = [...inheritedCompilationDigests];
+    if (compilationArtifactPath) {
+      reportProgress("读取并验证 Research Compilation CAP");
+      compilationArtifact = await loadResearchCompilationCap(compilationArtifactPath);
+      normalizedResearchPath = path.join(root, "research-compilation-input.json");
+      await writeJson(normalizedResearchPath, compilationArtifact.inventory);
+      sourceCompilationDigests.push(compilationArtifact.artifactDigest);
+      await save({
+        compilationArtifact: {
+          source: path.resolve(compilationArtifactPath),
+          artifactDigest: compilationArtifact.artifactDigest,
+        },
+      });
+    }
+    if (compileTaskPath) {
+      reportProgress("阶段 1/12：Research Compiler 正在结构化论文与仓库");
+      await updateStage("research_compilation", "running");
+      if (computeCatalogPath) {
+        loadedComputeCatalog = await loadComputeCatalog(computeCatalogPath);
+      }
+      const compilerProfile = loadedComputeCatalog
+        ? (loadedComputeCatalog.profiles.find(
+            (profile) => profile.id === computeProfile,
+          ) ?? loadedComputeCatalog.profiles.find(profile => profile.available !== false && profile.accelerator === "cpu")
+            ?? loadedComputeCatalog.profiles.find(profile => profile.available !== false))
+        : null;
+      compilation = await stageCheckpoint("research_compilation", async () =>
+        compilerProfile &&
+        listCompilerExecutors().includes(compilerProfile.executor)
+          ? await executeScheduledCompilation({
+              taskPath: compileTaskPath,
+              runsDirectory: directories.compilations,
+              runId: `${pipelineId}-compile`,
+              agentRuntime,
+              computeProfile: compilerProfile,
+              executorOptions,
+              dryRun,
+              progress: reportProgress,
+            })
+          : await runResearchCompiler({
+              taskPath: compileTaskPath,
+              runsDirectory: directories.compilations,
+              runId: `${pipelineId}-compile`,
+              agentRuntime,
+              dryRun,
+            }),
+      );
+      if (dryRun) {
+        await updateStage("research_compilation", "prepared");
+        await save({
+          status: "prepared",
+          phase: "research_compilation",
+          compilationRunId: compilation.bundle.runId,
+        });
+        return { dryRun: true, state, directories, compilation, compilationArtifact };
+      }
+      await updateStage("research_compilation", "completed");
+      compilation = await stageCheckpoint("reproduction_preparation", () => prepareInventoryForExecution({
+        compilation, sourceTaskPath: compileTaskPath, outputDirectory: path.join(directories.compilations, "preparation-input"),
+        progress: reportProgress,
+        execute: (overrides) => compilerProfile && listCompilerExecutors().includes(compilerProfile.executor)
+          ? executeScheduledCompilation({ ...overrides, runsDirectory: directories.compilations, agentRuntime,
+              computeProfile: compilerProfile, executorOptions, dryRun })
+          : runResearchCompiler({ ...overrides, runsDirectory: directories.compilations, agentRuntime, dryRun }),
+      }));
+      normalizedResearchPath = path.join(
+        compilation.bundle.directories.output,
+        "research.normalized.json",
+      );
+    }
+
+    let research = await loadResearchStructure(normalizedResearchPath);
+    if (research.compilationStage === "inventory") {
+      if (computeCatalogPath && !loadedComputeCatalog) loadedComputeCatalog = await loadComputeCatalog(computeCatalogPath);
+      const preparationProfile = loadedComputeCatalog
+        ? (loadedComputeCatalog.profiles.find((profile) => profile.id === computeProfile) ?? loadedComputeCatalog.profiles.find(profile => profile.available !== false && profile.accelerator === "cpu")
+            ?? loadedComputeCatalog.profiles.find(profile => profile.available !== false)) : null;
+      const taskPath = await writePreparationTaskFromInventory({ inventoryPath: normalizedResearchPath, paperPath,
+        repositoryPath, outputPath: path.join(directories.compilations, "preparation-input", "task.json") });
+      compilation = await stageCheckpoint("reproduction_preparation", async () => {
+        reportProgress("根据已审核研究清单与固定来源进行复现准备");
+        const options = { taskPath, runsDirectory: directories.compilations, runId: `${pipelineId}-prepare`, agentRuntime, dryRun };
+        return preparationProfile && listCompilerExecutors().includes(preparationProfile.executor)
+          ? executeScheduledCompilation({ ...options, computeProfile: preparationProfile, executorOptions })
+          : runResearchCompiler(options);
+      });
+      if (dryRun) {
+        await updateStage("research_plan", "prepared");
+        await save({ status: "prepared", phase: "research_plan", compilationRunId: compilation.bundle.runId });
+        return { dryRun: true, state, directories, compilation, compilationArtifact };
+      }
+      research = compilation.research;
+    }
+    normalizedResearchPath = path.join(root, "research.normalized.json");
+    await writeJson(normalizedResearchPath, research);
+
+    const {
+      effectiveResearchArtifactDigest,
+      researchPlan,
+      researchPlanArchive,
+    } = await stageCheckpoint("research_plan", async () => {
+      reportProgress("阶段 2/12：固定并验证不可变 Research Plan CAP");
+      await updateStage("research_plan", "running");
+      let effectiveResearchArtifactDigest;
+      let researchPlan;
+      let researchPlanArchive = null;
+      if (researchArtifactDigest !== undefined) {
+        if (!processingBinding || !validSha256Digest(researchArtifactDigest)) {
+          throw new CiteArkError(
+            "外部 Research Plan 摘要只接受平台已验证并绑定处理任务的 CAP",
+          );
+        }
+        effectiveResearchArtifactDigest = researchArtifactDigest;
+        researchPlan = {
+          source: "platform-verified",
+          artifactDigest: researchArtifactDigest,
+        };
+      } else {
+        const assembled = await assembleResearchPlanCap({
+          directory: directories.researchPlanCap,
+          research,
+          compilerRunId:
+            compilation?.bundle?.runId ?? `${pipelineId}-research-plan`,
+          ...(sourceCompilationDigests.length
+            ? {
+                planner: {
+                  id: "citeark/planner",
+                  name: "CiteArk Research Planner",
+                  version: "reproduction-preparation-v1",
+                },
+                plannerRunId: compilation?.bundle?.runId ?? `${pipelineId}-planner`,
+                sourceCompilationDigests,
+              }
+            : {}),
+          sourceArtifactDigests,
+          signingKeyPath,
+          processingBinding,
+        });
+        researchPlanArchive = await packCap({
+          directory: directories.researchPlanCap,
+          outputPath: researchPlanArchivePath,
+        });
+        effectiveResearchArtifactDigest = assembled.artifactDigest;
+        researchPlan = {
+          source: "locally-assembled",
+          artifactDigest: assembled.artifactDigest,
+          ...(sourceCompilationDigests.length ? { sourceCompilationDigests } : {}),
+          capDirectory: directories.researchPlanCap,
+          archive: researchPlanArchive,
+        };
+      }
+      await save({ researchPlan });
+      await updateStage("research_plan", "completed");
+      return {
+        effectiveResearchArtifactDigest,
+        researchPlan,
+        researchPlanArchive,
+      };
+    });
+    if (stopAfter === 'research_plan') {
+      await save({ status: 'prepared', phase: 'research_plan', researchPath: normalizedResearchPath });
+      return { state, directories, research, researchPlan, researchPlanArchive, compilation, compilationArtifact };
+    }
+    const selectedClaim = claimId
+      ? research.claims.find((item) => item.id === claimId)
+      : research.claims.find((item) =>
+          research.experiments.some((experiment) =>
+            experiment.claimIds.includes(item.id),
+          ),
+        );
+    if (!selectedClaim)
+      throw new CiteArkError("Research Compiler 没有产出可执行 claim");
+    const originalSelectedExperiment = experimentId
+      ? research.experiments.find((item) => item.id === experimentId)
+      : research.experiments.find((item) =>
+          item.claimIds.includes(selectedClaim.id),
+        );
+    if (!originalSelectedExperiment)
+      throw new CiteArkError(`claim ${selectedClaim.id} 没有可执行 experiment`);
+    const campaign = executionTargets?.length ? reproductionCampaign(research, executionTargets) : null;
+    const selectedExperiment = campaign?.experiment ?? originalSelectedExperiment;
+    const datasetRegistry = await readJson(
+      datasetRegistryPath ??
+        path.join(PACKAGE_ROOT, "data", "dataset-source-registry.v1.json"),
+    );
+
+    const contractPath = path.join(
+      directories.protocol,
+      "execution-contract.json",
+    );
+    const policyPath = campaign ? path.join(campaignTargetDirectory(directories.protocol, campaign.targets[0]), "policy.json") : path.join(
+      directories.private,
+      "verification-policy.json",
+    );
+    await stageCheckpoint("contract_creation", async () => {
+      reportProgress("阶段 3/12：生成盲化 Execution Contract 与私有验证策略");
+      await updateStage("contract_creation", "running");
+      await save({
+        researchPath: normalizedResearchPath,
+        claimId: selectedClaim.id,
+        experimentId: selectedExperiment.id,
+      });
+      if (campaign) {
+        const { contract } = await createCampaignContract({ research, researchPath: normalizedResearchPath,
+          targets: campaign.targets, directory: directories.protocol, outputPath: contractPath, tolerance });
+        await updateStage("contract_creation", "completed");
+        return { contractDigest: contract.contractDigest, campaignId: campaign.id };
+      }
+      const { contract, policy } = await createExecutionContract({
+        researchPath: normalizedResearchPath,
+        claimId: selectedClaim.id,
+        experimentId: selectedExperiment.id,
+        executionClaimIds,
+        outputPath: contractPath,
+        policyPath,
+        tolerance,
+      });
+      await updateStage("contract_creation", "completed");
+
+      return {
+        contractDigest: contract.contractDigest,
+        policyDigest: policy.policyDigest,
+      };
+    });
+    const contract = await loadExecutionContract(contractPath);
+    const assessmentContractPath = campaign
+      ? path.join(campaignTargetDirectory(directories.protocol, campaign.targets[0]), "contract.json") : contractPath;
+    const policy = await loadVerificationPolicy(policyPath, campaign ? await loadExecutionContract(assessmentContractPath) : contract);
+    const computeCatalog =
+      loadedComputeCatalog ?? (await loadComputeCatalog(computeCatalogPath));
+    const { assetPlan, computeDecision } = await stageCheckpoint(
+      "compute_scheduling",
+      async () => {
+        reportProgress(
+          stopAfter === ASSET_QUALIFICATION_BOUNDARY
+            ? "阶段 4/12：为资产验收选择独立的低成本 CPU，不调度科研算力"
+            : "阶段 4/12：按实验需求、资源目录与预算生成可审计计算决策",
+        );
+        await updateStage("compute_scheduling", "running");
+        const assetPlan = createAssetPreparationPlan({
+          experiment: selectedExperiment,
+          datasetRegistry,
+        });
+        currentAssetReadiness = createAssetReadiness(assetPlan, {
+          state: "planned",
+          admission: assetAdmission,
+        });
+        await writeJson(
+          path.join(directories.protocol, "asset-preparation-plan.json"),
+          assetPlan,
+        );
+        await writeJson(
+          path.join(directories.protocol, "asset-readiness.json"),
+          currentAssetReadiness,
+        );
+        await save({ assetReadiness: currentAssetReadiness });
+        const assetPlanFailures = assetPreparationPlanFailures(assetPlan);
+        if (assetPlanFailures.length) {
+          currentAssetReadiness = createAssetReadiness(assetPlan, {
+            state: "planned",
+            admission: assetAdmission,
+            message: `${assetPlanFailures.map((failure) => failure.message).join("；")}这些问题只影响预下载缓存，不会阻止最终复现 Agent。`,
+          });
+          await writeJson(
+            path.join(directories.protocol, "asset-readiness.json"),
+            currentAssetReadiness,
+          );
+          await save({ assetReadiness: currentAssetReadiness });
+        }
+        let computeDecision;
+        if (stopAfter === ASSET_QUALIFICATION_BOUNDARY) {
+          const assetProfile = selectAssetPreparationProfile(
+            computeCatalog,
+            null,
+            {
+              profileOverride: computeProfile,
+            },
+          );
+          computeDecision = createAssetPreparationComputeDecision({
+            profile: assetProfile,
+            contract,
+            experiment: selectedExperiment,
+            plan: assetPlan,
+            catalog: computeCatalog,
+          });
+          await writeJson(
+            path.join(
+              directories.protocol,
+              "asset-preparation-compute-decision.json",
+            ),
+            computeDecision,
+          );
+        } else {
+          const computePolicy = await loadComputePolicy(computePolicyPath);
+          computeDecision = await scheduleCompute({
+            experiment: selectedExperiment,
+            contract,
+            catalog: computeCatalog,
+            policy: computePolicy,
+            resourceLimits,
+            profileOverride: computeProfile,
+            selectionConstraints: computeSelection,
+            outputPath: path.join(
+              directories.protocol,
+              "compute-decision.json",
+            ),
+          });
+        }
+        await save({
+          computeDecision: {
+            decisionDigest: computeDecision.decisionDigest,
+            classification: computeDecision.requirement.classification,
+            profileId: computeDecision.selectedProfile.id,
+            executor: computeDecision.selectedProfile.executor,
+            accelerator: computeDecision.selectedProfile.accelerator,
+            estimatedCostUsd: computeDecision.estimate.costUsd,
+            workload: computeDecision.workload ?? "reproduction",
+          },
+        });
+        await updateStage("compute_scheduling", "completed");
+
+        return { assetPlan, computeDecision };
+      },
+    );
+    const repositoryOverride = resolvePipelineRepositoryOverride({
+      compilation,
+      repositoryPath,
+      experiment: selectedExperiment,
+    });
+    if (!paperReading && compilation?.bundle?.runtimeTask?.paper?.reading?.status === "ready") {
+      const bundle = compilation.bundle;
+      paperReading = { ...bundle.runtimeTask.paper.reading, directory: path.join(bundle.directories.input, "paper-reading") };
+      paperPath ??= path.join(bundle.directories.input, bundle.runtimeTask.paper.path.slice("/job/input/".length));
+    }
+    const paperOverride = paperPath
+      ? { path: paperPath, digest: processingBinding?.sourceDigest, ...(paperReading ? { preparedReading: paperReading } : {}) }
+      : undefined;
+    const { assetPreparation, effectivePreparationDecision } =
+      await stageCheckpoint("asset_preparation", async () => {
+        const preparationDecision = resolvePipelineAssetPreparationDecision({
+          decision: decideOpportunisticAssetPreparation({
+            plan: assetPlan,
+            admission: assetAdmission,
+            executor: computeDecision.selectedProfile.executor,
+          }),
+          reuseCompletedResultOnRestore:
+            executorOptions?.gcpBatch?.reuseCompletedResultOnRestore === true,
+          singleWorkspace: usesWorkspaceSummary(contract) && stopAfter !== ASSET_QUALIFICATION_BOUNDARY,
+          cpuPreparation: usesWorkspaceSummary(contract) && computeDecision.selectedProfile.executor === "gcp-batch" && computeDecision.environment.gpu === "all",
+        });
+        currentAssetReadiness = createAssetReadiness(assetPlan, {
+          state:
+            preparationDecision.action === "attempt" ? "preparing" : "deferred",
+          admission: assetAdmission,
+          preparationMode:
+            preparationDecision.action === "attempt"
+              ? null
+              : "reproduction-agent-fallback",
+          message: preparationDecision.message,
+        });
+        await writeJson(
+          path.join(directories.protocol, "asset-readiness.json"),
+          currentAssetReadiness,
+        );
+        await save({
+          assetReadiness: currentAssetReadiness,
+          preparationDecision,
+        });
+        if (stopAfter === ASSET_QUALIFICATION_BOUNDARY) {
+          reportProgress(
+            "资料检查：只观察公开链接能否下载；该结果不判断实验能否复现",
+          );
+          assetAdmission = await probeAssetQualification({
+            research,
+            claim: selectedClaim,
+            experiment: selectedExperiment,
+            datasetRegistry,
+            outputPath: path.join(directories.protocol, "asset-admission.json"),
+            observe,
+          });
+          currentAssetReadiness = createAssetReadiness(assetPlan, {
+            state: "planned",
+            admission: assetAdmission,
+          });
+          await writeJson(
+            path.join(directories.protocol, "asset-readiness.json"),
+            currentAssetReadiness,
+          );
+          await save({
+            assetAdmission: assetAdmission.summary,
+            assetReadiness: currentAssetReadiness,
+          });
+          assertAssetQualificationAdmission(assetAdmission);
+        }
+        let assetPreparation = null;
+        let effectivePreparationDecision =
+          resolvePipelineAssetPreparationDecision({
+            decision: decideOpportunisticAssetPreparation({
+              plan: assetPlan,
+              admission: assetAdmission,
+              executor: computeDecision.selectedProfile.executor,
+            }),
+            reuseCompletedResultOnRestore:
+              executorOptions?.gcpBatch?.reuseCompletedResultOnRestore === true,
+            singleWorkspace: usesWorkspaceSummary(contract) && stopAfter !== ASSET_QUALIFICATION_BOUNDARY,
+            cpuPreparation: usesWorkspaceSummary(contract) && computeDecision.selectedProfile.executor === "gcp-batch" && computeDecision.environment.gpu === "all",
+          });
+        if (effectivePreparationDecision.action === "attempt") {
+          currentAssetReadiness = createAssetReadiness(assetPlan, {
+            state: "preparing",
+            admission: assetAdmission,
+            message: effectivePreparationDecision.message,
+          });
+          await writeJson(
+            path.join(directories.protocol, "asset-readiness.json"),
+            currentAssetReadiness,
+          );
+          await save({
+            assetReadiness: currentAssetReadiness,
+            preparationDecision: effectivePreparationDecision,
+          });
+          reportProgress(
+            "阶段 5/12：尝试在低成本 CPU 上预先准备可复用资料缓存",
+            { assetReadiness: currentAssetReadiness },
+          );
+          await updateStage("asset_preparation", "running", {
+            assetReadiness: currentAssetReadiness,
+          });
+          const researchPreparation = usesWorkspaceSummary(contract) && stopAfter !== ASSET_QUALIFICATION_BOUNDARY;
+          const assetComputeDecision =
+            computeDecision.workload === "asset-preparation"
+              ? computeDecision
+              : createAssetPreparationComputeDecision({
+                  profile: selectAssetPreparationProfile(
+                    computeCatalog,
+                    computeDecision,
+                  ),
+                  contract,
+                  experiment: selectedExperiment,
+                  plan: assetPlan,
+                  catalog: computeCatalog,
+                  ...(researchPreparation ? { researchRuntimeMinutes: computeDecision.environment.timeoutMinutes } : {}),
+                });
+          if (computeDecision.workload !== "asset-preparation") {
+            await writeJson(
+              path.join(
+                directories.protocol,
+                "asset-preparation-compute-decision.json",
+              ),
+              assetComputeDecision,
+            );
+          }
+          try {
+            const prepare = researchPreparation ? executeGcpBatchReproduction : executeGcpAssetPreparation;
+            assetPreparation = await prepare({
+              taskPath: contractPath,
+              runsDirectory: directories.runs,
+              runId: `${pipelineId}-assets`,
+              repositoryOverride,
+              paperOverride,
+              computeDecision: assetComputeDecision,
+              assetPlan,
+              agentRuntime,
+              executorOptions: researchPreparation ? { ...executorOptions, gcpBatch: {
+                ...executorOptions?.gcpBatch,
+                restoreCheckpointPrefix: executorOptions?.gcpBatch?.assetPreparationRestoreCheckpointPrefix,
+                restoreCheckpointBucket: executorOptions?.gcpBatch?.assetPreparationRestoreCheckpointBucket,
+                clients: executorOptions?.gcpBatch?.assetPreparationClients ?? executorOptions?.gcpBatch?.clients,
+                keepStaging: true,
+              } } : executorOptions,
+              ...(researchPreparation ? { workloadAdapter: createCpuResearchPreparationWorkload({ runtimeBudgetMinutes: computeDecision.environment.timeoutMinutes }) } : {}),
+              dryRun,
+              progress: reportProgress,
+            });
+          } catch (error) {
+            // A failed CPU handoff is not permission to rent the GPU and repeat preparation.
+            if (usesWorkspaceSummary(contract) && stopAfter !== ASSET_QUALIFICATION_BOUNDARY) throw error;
+            if (mustAbortAfterAssetPreparationFailure(error)) throw error;
+            const fallback = assetPreparationFallback(error);
+            effectivePreparationDecision = {
+              action: "defer",
+              reasonCode: fallback.reasonCode,
+              message: fallback.message,
+              constraints: [],
+            };
+            currentAssetReadiness = createAssetReadiness(assetPlan, {
+              state: fallback.state,
+              admission: assetAdmission,
+              preparationMode: fallback.preparationMode,
+              message: fallback.message,
+            });
+            await writeJson(
+              path.join(directories.protocol, "asset-readiness.json"),
+              currentAssetReadiness,
+            );
+            await save({
+              assetPreparation: {
+                planDigest: assetPlan.planDigest,
+                mode: fallback.preparationMode,
+                reasonCode: fallback.reasonCode,
+                reason: fallback.message,
+              },
+              assetReadiness: currentAssetReadiness,
+              preparationDecision: effectivePreparationDecision,
+            });
+            reportProgress(fallback.message, {
+              assetReadiness: currentAssetReadiness,
+            });
+            await updateStage("asset_preparation", "deferred", {
+              assetReadiness: currentAssetReadiness,
+            });
+          }
+          if (assetPreparation) {
+            if (assetPreparation.preparation?.status === "blocked") throw new CiteArkError(
+              `CPU 准备确认当前实验无法继续：${assetPreparation.preparation.summary}`,
+              { failureCode: "research_preparation.no_viable_execution", retryable: false });
+            await save({
+              assetPreparation: {
+                planDigest: assetPlan.planDigest,
+                manifestDigest:
+                  assetPreparation.manifest?.manifestDigest ?? null,
+                cacheHit: assetPreparation.cacheHit ?? false,
+                checkpointPrefix:
+                  assetPreparation.checkpoint?.checkpointPrefix ?? null,
+              },
+            });
+            currentAssetReadiness = createAssetReadiness(assetPlan, {
+              state: dryRun ? "preparing" : "prepared",
+              manifest: assetPreparation.manifest,
+              admission: assetAdmission,
+              preparationMode: assetPreparation.preparationMode,
+              cacheHit: assetPreparation.cacheHit ?? false,
+            });
+            await writeJson(
+              path.join(directories.protocol, "asset-readiness.json"),
+              currentAssetReadiness,
+            );
+            await save({ assetReadiness: currentAssetReadiness });
+            await updateStage(
+              "asset_preparation",
+              dryRun ? "prepared" : "completed",
+              {
+                assetReadiness: currentAssetReadiness,
+              },
+            );
+          }
+        } else {
+          currentAssetReadiness = createAssetReadiness(assetPlan, {
+            state: "deferred",
+            admission: assetAdmission,
+            preparationMode: "reproduction-agent-fallback",
+            message: effectivePreparationDecision.message,
+          });
+          await writeJson(
+            path.join(directories.protocol, "asset-readiness.json"),
+            currentAssetReadiness,
+          );
+          await save({
+            assetPreparation: {
+              planDigest: assetPlan.planDigest,
+              mode: "reproduction-agent-fallback",
+              reasonCode: effectivePreparationDecision.reasonCode,
+              reason: effectivePreparationDecision.message,
+            },
+            assetReadiness: currentAssetReadiness,
+          });
+          reportProgress(effectivePreparationDecision.message, {
+            assetReadiness: currentAssetReadiness,
+          });
+          await updateStage("asset_preparation", "deferred", {
+            assetReadiness: currentAssetReadiness,
+          });
+        }
+
+        return { assetPreparation, effectivePreparationDecision };
+      });
+    if (stopAfter === ASSET_QUALIFICATION_BOUNDARY) {
+      for (const [id] of PIPELINE_STAGES.slice(
+        PIPELINE_STAGES.findIndex(
+          ([id]) => id === ASSET_QUALIFICATION_BOUNDARY,
+        ) + 1,
+      )) {
+        await updateStage(id, "skipped");
+      }
+      const qualification = {
+        schemaVersion: "0.1",
+        kind: "citeark.asset-qualification",
+        status: dryRun
+          ? "prepared"
+          : assetPreparation
+            ? "qualified"
+            : "deferred",
+        boundary: ASSET_QUALIFICATION_BOUNDARY,
+        reproductionStarted: false,
+        claimId: selectedClaim.id,
+        experimentId: selectedExperiment.id,
+        planDigest: assetPlan.planDigest,
+        manifestDigest: assetPreparation?.manifest?.manifestDigest ?? null,
+        checkpointPrefix:
+          assetPreparation?.checkpoint?.checkpointPrefix ?? null,
+        cacheHit: assetPreparation?.cacheHit ?? false,
+        ...(assetPreparation
+          ? {}
+          : {
+              reasonCode: effectivePreparationDecision.reasonCode,
+              message: effectivePreparationDecision.message,
+            }),
+        finishedAt: new Date().toISOString(),
+      };
+      await writeJson(
+        path.join(directories.protocol, "asset-qualification.json"),
+        qualification,
+      );
+      await save({
+        status: dryRun ? "prepared" : "completed",
+        phase: ASSET_QUALIFICATION_BOUNDARY,
+        executionBoundary: ASSET_QUALIFICATION_BOUNDARY,
+        contractDigest: contract.contractDigest,
+        policyDigest: policy.policyDigest,
+        usage: mergeAgentUsage(
+          compilation?.totalUsage ?? compilation?.bundle?.state?.usage,
+          assetPreparation?.bundle?.state?.usage,
+          assetPreparation?.usage,
+        ),
+        qualification,
+        finishedAt: qualification.finishedAt,
+      });
+      return {
+        dryRun,
+        state,
+        directories,
+        researchPlan,
+        researchPlanArchive,
+        compilation,
+        research,
+        contract,
+        policy,
+        computeDecision,
+        assetAdmission,
+        assetPlan,
+        assetPreparation,
+        qualification,
+      };
+    }
+
+    const existingReproductionCheckpoint =
+      executorOptions?.gcpBatch?.restoreCheckpointPrefix;
+    const reproductionExecutorOptions = assetPreparation?.checkpoint
+      ?.checkpointPrefix
+      ? {
+          ...executorOptions,
+          gcpBatch: {
+            ...(executorOptions?.gcpBatch ?? {}),
+            ...(assetPreparation.preparationMode === "research-workspace" ? {
+              cpuResearchComputeDecision: assetPreparation.bundle.computeDecision,
+            } : {}),
+            restoreCheckpointPrefix:
+              existingReproductionCheckpoint ??
+              assetPreparation.checkpoint.checkpointPrefix,
+            restoreCheckpointBucket: existingReproductionCheckpoint
+              ? executorOptions?.gcpBatch?.restoreCheckpointBucket
+              : assetPreparation.checkpoint.bucket,
+          },
+        }
+      : executorOptions;
+
+    reproduction = await stageCheckpoint("reproduction", async () => {
+      reportProgress("阶段 6/12：Agent 在隔离工作区中自主复现");
+      await updateStage("reproduction", "running");
+      await save({
+        contractDigest: contract.contractDigest,
+        policyDigest: policy.policyDigest,
+      });
+      const executed = await executeScheduledReproduction({
+        referenceMaterialsPath,
+        taskPath: contractPath,
+        runsDirectory: directories.runs,
+        runId: `${pipelineId}-run`,
+        repositoryOverride,
+        paperOverride,
+        agentRuntime,
+        computeDecision,
+        executorOptions: reproductionExecutorOptions,
+        dryRun,
+        progress: reportProgress,
+      });
+      await save({
+        reproductionRunId: executed.bundle.runId,
+        agent: executed.bundle.state.agent,
+      });
+      if (!dryRun) await updateStage("reproduction", "completed");
+      return executed;
+    });
+    if (dryRun) {
+      await updateStage("reproduction", "prepared");
+      await save({
+        status: "prepared",
+        phase: "reproduction",
+        reproductionRunId: reproduction.bundle.runId,
+      });
+      return {
+        dryRun: true,
+        state,
+        directories,
+        researchPlan,
+        researchPlanArchive,
+        research,
+        contract,
+        policy,
+        computeDecision,
+        assetPlan,
+        assetPreparation,
+        reproduction,
+      };
+    }
+    await save({
+      reproductionRunId: reproduction.bundle.runId,
+      agent: reproduction.bundle.state.agent,
+      usage: mergeAgentUsage(
+        compilation?.totalUsage ?? compilation?.bundle.state.usage,
+        // The full research session continues on GPU, so its trace already
+        // includes CPU preparation. Dedicated legacy cache jobs remain separate.
+        assetPreparation?.preparationMode === "research-workspace" ? null : assetPreparation?.bundle?.state?.usage,
+        reproduction.bundle.state.usage,
+      ),
+    });
+    const effectiveScientificAssessor =
+      typeof scientificAssessor === "function"
+        ? scientificAssessor
+        : createScientificAssessor({
+            runtimeAgent: agentRuntime,
+            providerSecret: executorOptions?.gcpBatch?.providerSecret,
+            paperBudget: executorOptions?.gcpBatch?.paperBudget,
+          });
+    const replay = await replayRunToCap({
+      researchPath: normalizedResearchPath,
+      contractPath: assessmentContractPath,
+      ...(campaign ? { executionContractPath: contractPath } : {}),
+      policyPath,
+      runDirectory: reproduction.bundle.directories.run,
+      capDirectory: directories.cap,
+      signingKeyPath,
+      processingBinding,
+      researchArtifactDigest: effectiveResearchArtifactDigest,
+      scientificAssessor: effectiveScientificAssessor,
+      handoffCompletion: Boolean(agentRuntime.codexAccountId || runtimeProviderConfiguration(agentRuntime).baseUrl)
+        ? createSourceReviewCompletion({ runtimeAgent: agentRuntime,
+            providerSecret: executorOptions?.gcpBatch?.providerSecret,
+            paperBudget: executorOptions?.gcpBatch?.paperBudget, maxRequests: 80, maxToolCalls: 300 }) : undefined,
+      stageCheckpoint,
+      onAssessment: async (assessment) => {
+        if (assessment?.usage) {
+          await save({ usage: mergeAgentUsage(state.usage, assessment.usage) });
+        }
+      },
+      getPipelineSummary: async () => ({
+        schemaVersion: "1.0",
+        kind: "citeark.pipeline-summary",
+        pipelineId: state.pipelineId,
+        status: state.status,
+        phase: state.phase,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        stages: structuredClone(state.stages),
+        usage: structuredClone(state.usage ?? mergeAgentUsage()),
+        usageScope: upstreamCompilation ? "target" : "pipeline",
+        agent: structuredClone(
+          state.agent ?? reproduction.bundle.state.agent ?? {},
+        ),
+        computeDecision: structuredClone(state.computeDecision ?? {}),
+      }),
+      onStageChange: async ({ stage, status }) => {
+        if (status === "started") {
+          const messages = {
+            evidence_parsing: "阶段 7/12：从原始证据独立解析指标",
+            verification:
+              "阶段 8/12：检查执行完整性，并由独立 AI 评估数值差异是否合理",
+            research_card:
+              "阶段 9/12：汇总论文级验证结论并生成研究卡片与 README 快照",
+            execution_handoff: "阶段 10/12：整理已执行路线和再次运行说明",
+            packaging: "阶段 11/12：生成 CAP 2.0 Records、Blobs 与签名证明",
+          };
+          reportProgress(messages[stage]);
+          await updateStage(stage, "running");
+        } else {
+          await updateStage(stage, status === "skipped" ? "skipped" : "completed");
+        }
+      },
+    });
+    reportProgress("阶段 12/12：生成可上传的 .cap 单文件包并复核哈希");
+    const archiveContentDigest = await capDirectoryContentDigest(directories.cap);
+    const archive = await stageCheckpoint("archive", async () => {
+      await updateStage("archive", "running");
+      const packed = await packCap({
+        directory: directories.cap,
+        outputPath: path.join(root, `${pipelineId}-${archiveContentDigest.slice(7)}.cap`),
+        reuseExisting: true,
+      });
+      await updateStage("archive", "completed");
+      return packed;
+    }, archiveContentDigest);
+    await save({
+      status: "completed",
+      phase: "completed",
+      verificationStatus: replay.assessment.verificationStatus,
+      artifactDigest: replay.cap.artifactDigest,
+      capDirectory: directories.cap,
+      researchCard: {
+        cardDigest: replay.researchCard.card.cardDigest,
+        path: "cap/preview/README.md",
+      },
+      citearkArchive: archive,
+      finishedAt: new Date().toISOString(),
+    });
+    if (!dryRun) await onCheckpoint({ stage: "publishing", status: "ready" });
+    return {
+      dryRun: false,
+      state,
+      directories,
+      archive,
+      researchPlan,
+      researchPlanArchive,
+      compilation,
+      compilationArtifact,
+      research,
+      contract,
+      policy,
+      computeDecision,
+      assetPlan,
+      assetPreparation,
+      reproduction,
+      replay,
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && currentAssetReadiness) {
+      error.assetReadiness ??= currentAssetReadiness;
+    }
+    const activeStage = state.stages.find(
+      (stage) => stage.status === "running",
+    );
+    if (activeStage) await updateStage(activeStage.id, "failed");
+    await save({
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error),
+      finishedAt: new Date().toISOString(),
+    });
+    if (error && typeof error === "object") {
+      error.pipelineRecovery = createPipelineRecoveryEnvelope({
+        state,
+        reproduction,
+        checkpoint: error.recoveryCheckpoint,
+      });
+      error.failureStage ??= error.pipelineRecovery?.resumeStage;
+    }
+    try {
+      if (!dryRun) await onCheckpoint({ stage: state.phase, status: "failed" });
+    } catch (checkpointError) {
+      error.recoveryPersistenceError = checkpointError.message;
+    }
+    throw error;
+  } finally {
+    await monitor.close({
+      status: state.status,
+      stage: state.phase,
+      message:
+        state.status === "completed"
+          ? state.executionBoundary === ASSET_QUALIFICATION_BOUNDARY
+            ? "资产验收已完成，未启动复现 Agent"
+            : "流水线已完成"
+          : state.status === "prepared"
+            ? "流水线已准备，尚未真实执行"
+            : state.status === "failed"
+              ? "流水线执行失败"
+              : "流水线监控已结束",
+    });
+  }
+}
+
+function validSha256Digest(value) {
+  return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+
+export function resolvePipelineRepositoryOverride({
+  compilation,
+  repositoryPath,
+  experiment,
+}) {
+  // 独立重建必须从 CiteArk 的确定性空白基座开始，不能误把编译阶段的
+  // “无作者仓库”目录或调用方传入的代码当成官方实现。
+  if (isCiteArkReconstructionRepository(experiment?.repository))
+    return undefined;
+  if (compilation) {
+    return {
+      path: compilation.bundle.directories.repositorySnapshot,
+      digest: compilation.bundle.repositoryIdentity.snapshotDigest,
+    };
+  }
+  return repositoryPath ? { path: path.resolve(repositoryPath) } : undefined;
+}
+
+export function resolvePipelineAssetPreparationDecision({
+  decision,
+  reuseCompletedResultOnRestore,
+  singleWorkspace = false,
+  cpuPreparation = false,
+}) {
+  if (singleWorkspace && cpuPreparation && !reuseCompletedResultOnRestore) return {
+    action: "attempt", reasonCode: "cpu_research_preparation",
+    message: "同一研究工作区先在 CPU 阅读、修订、下载与准备，再携带完整检查点进入 GPU。",
+    constraints: [],
+  };
+  if (singleWorkspace && !reuseCompletedResultOnRestore) return {
+    action: "defer", reasonCode: "single_research_workspace",
+    message: "资料与依赖由当前实验工作区准备；已有缓存经核验后复用。",
+    constraints: [],
+  };
+  if (!reuseCompletedResultOnRestore) return decision;
+  return {
+    action: "defer",
+    reasonCode: "completed_result_reuse",
+    message: "已恢复完整实验结果，不再重复准备模型与数据缓存。",
+    constraints: [],
+  };
+}
+
+function stageStatusLabel(status) {
+  return (
+    {
+      running: "正在执行",
+      completed: "已完成",
+      failed: "失败",
+      prepared: "已准备",
+      deferred: "交由复现 Agent",
+      skipped: "已跳过",
+      pending: "等待中",
+    }[status] ?? status
+  );
+}