@citeark/agent 0.3.20

package/src/research-card/renderer.mjs

@@ -0,0 +1,277 @@
+import { writeFile } from "node:fs/promises";
+
+import { sha256Value, writeJson } from "../util.mjs";
+import { buildVerifiedConclusion } from "./verified-conclusion.mjs";
+import { primaryComparison, primaryMetric } from "../records/views.mjs";
+
+export async function renderResearchCard({
+  research,
+  contract,
+  run,
+  result,
+  metrics,
+  outputs = null,
+  integrity,
+  assessment,
+  runnerAudit,
+  verifiedConclusion,
+  computeDecision = run?.computeDecision ?? null,
+  generatedAt = assessment?.assessedAt ?? run?.finishedAt ?? new Date().toISOString(),
+  jsonPath,
+  markdownPath,
+}) {
+  const selectedClaim = research.claims.find((item) => item.versionId === contract.research.claimVersionId)
+    ?? research.claims.find((item) => item.id === contract.research.claimId);
+  const selectedExperiment = research.experiments.find((item) => item.versionId === contract.research.experimentVersionId)
+    ?? research.experiments.find((item) => item.id === contract.research.experimentId);
+  const conclusion = verifiedConclusion ?? buildVerifiedConclusion({
+    research,
+    verifications: [{ contract, assessment, metrics, integrity }],
+    generatedAt,
+  });
+  const body = {
+    schemaVersion: "1.0",
+    kind: "citeark.research-card",
+    generatedAt,
+    work: research.work,
+    sources: research.sources,
+    claims: research.claims.map((claim) => ({
+      id: claim.id,
+      versionId: claim.versionId,
+      statement: claim.statement,
+      type: claim.type,
+      sourceLocator: claim.sourceLocator,
+      reportedMeasurements: claim.reportedMeasurements,
+      reproduction: claim.reproduction,
+      selected: claim.id === selectedClaim?.id,
+    })),
+    experiments: research.experiments.map((experiment) => ({
+      id: experiment.id,
+      versionId: experiment.versionId,
+      title: experiment.title,
+      claimIds: experiment.claimIds,
+      reproductionLevel: experiment.reproductionLevel,
+      reconstructionFidelity: experiment.reconstructionFidelity
+        ?? (experiment.implementationOrigin === "citeark_reconstruction" ? "approximate" : "faithful"),
+      implementationOrigin: experiment.implementationOrigin ?? experiment.repository?.implementationOrigin ?? "official",
+      repository: experiment.repository,
+      selected: experiment.id === selectedExperiment?.id,
+    })),
+    latestExecution: {
+      runId: run.runId,
+      status: run.status,
+      outcome: {
+        status: result.execution?.status ?? "unknown",
+        summary: result.execution?.summary ?? null,
+        failure: result.execution?.failure ?? null,
+      },
+      selectedClaimId: selectedClaim?.id ?? contract.research.claimId,
+      selectedExperimentId: selectedExperiment?.id ?? contract.research.experimentId,
+      agent: run.agent ?? { runtime: run.runtime ?? null },
+      computeDecision,
+      metric: primaryMetric(metrics),
+      measurements: metrics.measurements ?? null,
+      outputs: outputs?.outputs ?? [],
+      integrityStatus: integrity.status,
+      verificationStatus: assessment.verificationStatus,
+      verdict: assessment.verdict,
+      comparison: primaryComparison(assessment),
+      measurementAssessments: assessment.measurementAssessments ?? null,
+      limitations: result.limitations ?? [],
+      executionAudit: runnerAudit?.audit ? {
+        status: runnerAudit.audit.status,
+        auditDigest: runnerAudit.audit.auditDigest,
+        captureBoundary: runnerAudit.audit.captureBoundary,
+        commandRecordCount: runnerAudit.audit.commandRecordCount,
+      } : null,
+      finishedAt: run.finishedAt ?? null,
+    },
+    verifiedConclusion: conclusion,
+    license: research.license,
+    provenance: research.provenance,
+    canonicalRecords: {
+      sourceWork: "https://citeark.com/cap/record-types/entity/2.0",
+      claim: "https://citeark.com/cap/record-types/assertion/2.0",
+      experiment: "https://citeark.com/cap/record-types/entity/2.0",
+      execution: "https://citeark.com/cap/record-types/activity/2.0",
+      evidence: "https://citeark.com/cap/record-types/entity/2.0",
+      assessment: "https://citeark.com/cap/record-types/assertion/2.0",
+      traceBlobRole: "execution-trace",
+    },
+    renderingPolicy: {
+      canonical: false,
+      verificationAuthority: "primaryAssessment CAP Record",
+      metricExtraction: "deterministic-external-parser",
+      commandProvenance: "runner-captured-runtime-json-stream",
+      description: "This card is derived from structured research, runner-captured runtime command records, and deterministic verification records. Private reasoning is excluded; command and output records are retained verbatim unless likely credentials require redaction, with hashes preserving the original byte identity.",
+    },
+  };
+  const card = { ...body, cardDigest: `sha256:${sha256Value(body)}` };
+  const markdown = renderResearchCardMarkdown(card);
+  if (jsonPath) await writeJson(jsonPath, card);
+  if (markdownPath) await writeFile(markdownPath, markdown, "utf8");
+  return { card, markdown };
+}
+
+export function renderResearchCardMarkdown(card) {
+  const execution = card.latestExecution;
+  const selectedClaim = card.claims.find((item) => item.selected);
+  const selectedExperiment = card.experiments.find((item) => item.selected);
+  const comparison = execution.comparison;
+  const compute = execution.computeDecision;
+  const lines = [
+    `# ${markdownText(card.work.title)}`,
+    "",
+    "> This is a research card snapshot automatically generated from CiteArk structured research, real execution records, and the verification engine. The machine-readable files are the source of truth; this page does not replace the verification conclusion.",
+    "",
+    markdownText(card.work.abstract),
+    "",
+    "## Paper-Level Verification Conclusion",
+    "",
+    markdownText(card.verifiedConclusion.text),
+    "",
+    `- Conclusion coverage: ${card.verifiedConclusion.coverage.evaluatedClaims}/${card.verifiedConclusion.coverage.structuredClaims} structured claims verified`,
+    `- Evidence digest: ${markdownCode(card.verifiedConclusion.conclusionDigest)}`,
+    "",
+    "## Current Reproduction Conclusion",
+    "",
+    `- Verification status: ${verificationLabel(execution.verificationStatus)}`,
+    `- Integrity status: ${execution.integrityStatus === "passed" ? "passed" : "failed"}`,
+    `- Run: \`${markdownCode(execution.runId)}\``,
+    `- Execution outcome: ${markdownText(execution.outcome?.status ?? "unknown")}`,
+    `- Runner audit: ${markdownText(execution.executionAudit?.status ?? "unavailable")}; ${execution.executionAudit?.commandRecordCount ?? 0} command records`,
+    `- Claim: ${markdownText(selectedClaim?.statement ?? execution.selectedClaimId)}`,
+    `- Experiment: ${markdownText(selectedExperiment?.title ?? execution.selectedExperimentId)}`,
+    `- Implementation origin: ${markdownText(selectedExperiment?.implementationOrigin ?? "unknown")}`,
+    `- Reconstruction fidelity: ${markdownText(selectedExperiment?.reconstructionFidelity ?? "not recorded")}`,
+  ];
+  if (execution.outcome?.summary) {
+    lines.push(`- Execution summary: ${markdownText(execution.outcome.summary)}`);
+  }
+  if (execution.outcome?.failure) {
+    const failure = execution.outcome.failure;
+    lines.push(
+      `- Failure: ${markdownText(failure.category)} during ${markdownText(failure.stage)}; ${failure.retryable ? "potentially retryable" : "not retryable without changed inputs or conditions"}`,
+      `- Failure reason: ${markdownText(failure.reason)}`,
+    );
+  }
+  if (comparison && typeof comparison.observedValue === "number" && Number.isFinite(comparison.observedValue)) {
+    lines.push(
+      `- Metric: ${markdownText(comparison.metric)}, reported ${formatMetric(comparison.reportedValue, comparison.unit)}, observed ${formatMetric(comparison.observedValue, comparison.unit)}`,
+      `- Absolute difference: ${formatMetric(comparison.absoluteDifference, comparison.unit)}; declared tolerance: ±${formatMetric(comparison.tolerance, comparison.unit)}`,
+    );
+  } else if (comparison) {
+    lines.push(`- Comparable metric: unavailable; claim assessment remains ${verificationLabel(execution.verificationStatus)}`);
+  }
+  if (Array.isArray(execution.measurementAssessments) && execution.measurementAssessments.length > 1) {
+    lines.push("- Measurement coverage:");
+    for (const item of execution.measurementAssessments) {
+      const detail = item.comparison;
+      lines.push(
+        `  - ${markdownCode(item.measurementId)}: ${verificationLabel(item.verificationStatus)}${
+          detail && typeof detail.observedValue === "number"
+            ? `; reported ${formatMetric(detail.reportedValue, detail.unit)}, observed ${formatMetric(detail.observedValue, detail.unit)}`
+            : ""
+        }`,
+      );
+    }
+  }
+  if (Array.isArray(execution.outputs) && execution.outputs.length) {
+    lines.push("- Scientific outputs:");
+    for (const output of execution.outputs) {
+      lines.push(
+        `  - ${markdownCode(output.id)}: ${markdownText(output.kind)} · ${markdownText(output.role)} · ${markdownText(output.mediaType)} · ${markdownText(output.description)} · ${markdownCode(output.digest)}`,
+      );
+    }
+  }
+  lines.push("", "## Research Claims", "");
+  if (card.claims.length) {
+    lines.push("| Claim | Type | Reported Metrics | Source |", "| --- | --- | --- | --- |");
+    for (const claim of card.claims) {
+      const measurements = claim.reportedMeasurements.map((item) => `${item.metric}=${formatMetric(item.value, item.unit)}`).join("; ") || "—";
+      lines.push(`| ${tableCell(claim.statement)} | ${tableCell(claim.type)} | ${tableCell(measurements)} | ${tableCell(`${claim.sourceLocator.sourceId}:${claim.sourceLocator.locator}`)} |`);
+    }
+  } else {
+    lines.push("No structured claims yet.");
+  }
+  lines.push("", "## Experiments", "", "| Experiment | Implementation Origin | Fidelity | Reproduction Level | Pinned Base |", "| --- | --- | --- | --- | --- |");
+  for (const experiment of card.experiments) {
+    lines.push(`| ${tableCell(experiment.title)} | ${tableCell(experiment.implementationOrigin)} | ${tableCell(experiment.reconstructionFidelity)} | ${tableCell(experiment.reproductionLevel)} | ${tableCell(shortDigest(experiment.repository.commit))} |`);
+  }
+  lines.push("", "## Compute Scheduling and Execution Origin", "");
+  if (compute) {
+    lines.push(
+      `- Resource classification: ${computeClassLabel(compute.requirement?.classification)}`,
+      `- Selected profile: ${markdownText(compute.selectedProfile?.label ?? compute.selectedProfile?.id ?? "unknown")}`,
+      `- Executor: ${markdownText(compute.selectedProfile?.executor ?? "unknown")}`,
+      `- Resources: ${resourceLabel(compute.environment)}`,
+      `- Estimated cost: ${compute.estimate?.costUsd === null || compute.estimate?.costUsd === undefined ? "unknown" : `${compute.estimate.costUsd} USD`}`,
+      `- Scheduling rationale: ${markdownText(compute.rationale)}`,
+    );
+  } else {
+    lines.push("- No compute scheduling record is available; this run cannot be presented as a complete CAP 2.0 workflow.");
+  }
+  lines.push(
+    `- Agent: ${markdownText(execution.agent?.runtime ?? "unknown")} / ${markdownText(execution.agent?.model ?? "not recorded")}`,
+    `- Execution finished: ${markdownText(execution.finishedAt ?? "not recorded")}`,
+    "",
+    "## Sources and Licenses",
+    "",
+  );
+  for (const source of card.sources) lines.push(`- ${markdownText(source.kind)}: ${markdownText(source.uri)}${source.version ? ` (${markdownText(source.version)})` : ""}`);
+  lines.push(
+    `- Paper license: ${markdownText(card.license.paper)}`,
+    `- Code license: ${markdownText(card.license.code)}`,
+    `- Execution allowed: ${card.license.executionAllowed ? "yes" : "no"}`,
+    "",
+    "## Limitations",
+    "",
+  );
+  if (execution.limitations.length) lines.push(...execution.limitations.map((item) => `- ${markdownText(item)}`));
+  else lines.push("- This execution reported no additional limitations; review together with the original paper, protocol, and underlying evidence.");
+  lines.push(
+    "",
+    "## Verifiable Records",
+    "",
+    ...Object.entries(card.canonicalRecords).map(([name, target]) => `- ${name}: \`${target}\``),
+    `- Evidence boundary: metrics are parsed outside the execution Agent; typed scientific outputs are independently hashed by the runner; command requests and runtime output come from the runner-captured stream and are bound to the signed CAP.`,
+    "",
+    `Card digest: \`${card.cardDigest}\``,
+    "",
+  );
+  return lines.join("\n");
+}
+
+function verificationLabel(value) {
+  return { reproduced: "reproduced", approximately_reproduced: "approximately reproduced", not_reproduced: "not reproduced", inconclusive: "inconclusive" }[value] ?? value ?? "unknown";
+}
+
+function computeClassLabel(value) {
+  return { "cpu-only": "CPU only", "gpu-optional": "GPU optional", "gpu-required": "GPU required" }[value] ?? value ?? "unknown";
+}
+
+function resourceLabel(environment = {}) {
+  return `${environment.cpus ?? "?"} CPU · ${environment.memoryGb ?? "?"} GB memory · ${environment.gpu === "all" ? "GPU" : "no GPU"}`;
+}
+
+function formatMetric(value, unit) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "—";
+  const formatted = new Intl.NumberFormat("en-US", { maximumFractionDigits: 6 }).format(value);
+  return unit === "percentage_points" ? `${formatted}%` : `${formatted} ${unit ?? ""}`.trim();
+}
+
+function shortDigest(value) {
+  return value?.length > 16 ? `${value.slice(0, 12)}…` : value ?? "—";
+}
+
+function tableCell(value) {
+  return markdownText(value).replaceAll("|", "\\|").replaceAll(/\r?\n/g, " ");
+}
+
+function markdownText(value) {
+  return String(value ?? "").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+function markdownCode(value) {
+  return String(value ?? "").replaceAll("`", "ˋ");
+}

package/src/research-card/verified-conclusion.mjs

@@ -0,0 +1,143 @@
+import { sha256Value } from "../util.mjs";
+import { primaryComparison, primaryMetric } from "../records/views.mjs";
+
+const MAX_STATEMENT_CHARACTERS = 72;
+
+export function buildVerifiedConclusion({
+  research,
+  verifications = [],
+  generatedAt = new Date().toISOString(),
+}) {
+  const claimsById = new Map(research.claims.map((claim) => [claim.id, claim]));
+  const claimsByVersion = new Map(
+    research.claims
+      .filter((claim) => claim.versionId)
+      .map((claim) => [claim.versionId, claim]),
+  );
+  const records = verifications
+    .map((verification) => normalizeVerification(verification, claimsById, claimsByVersion))
+    .filter(Boolean);
+  const evaluatedClaimIds = new Set(records.map((record) => record.claimId));
+  const counts = {
+    structuredClaims: research.claims.length,
+    evaluatedClaims: evaluatedClaimIds.size,
+    verificationRecords: records.length,
+    reproduced: records.filter((record) => record.verificationStatus === "reproduced").length,
+    approximatelyReproduced: records.filter((record) => record.verificationStatus === "approximately_reproduced").length,
+    notReproduced: records.filter((record) => record.verificationStatus === "not_reproduced").length,
+    inconclusive: records.filter((record) => record.verificationStatus === "inconclusive").length,
+  };
+  counts.unevaluatedClaims = Math.max(0, counts.structuredClaims - counts.evaluatedClaims);
+  const overallStatus = conclusionStatus(counts);
+  const body = {
+    schemaVersion: "0.1",
+    kind: "citeark.verified-conclusion",
+    workId: research.work.id,
+    generatedAt,
+    overallStatus,
+    text: conclusionParagraph({ title: research.work.title, counts, records, overallStatus }),
+    coverage: counts,
+    basis: records.map(({ statement, ...record }) => record),
+    policy: {
+      evidenceGrounded: true,
+      claimUniverse: "compiler-structured",
+      paperWideCoverageEstablished: false,
+      maximumDisplayedClaimsPerStatus: 1,
+      description: "This paragraph summarizes only compiler-structured claims and signed scientific assessment records. It is never a paper-wide validity judgment, and claims without executions are not counted as supported.",
+    },
+  };
+  return { ...body, conclusionDigest: `sha256:${sha256Value(body)}` };
+}
+
+function normalizeVerification(verification, claimsById, claimsByVersion) {
+  const assessment = verification?.assessment ?? verification;
+  if (!assessment || typeof assessment !== "object") return null;
+  const contract = verification?.contract ?? {};
+  const claim = claimsByVersion.get(assessment.claimVersionId ?? contract.research?.claimVersionId)
+    ?? claimsById.get(verification?.claimId ?? contract.research?.claimId);
+  if (!claim) return null;
+  const comparison = primaryComparison(assessment) ?? primaryMetric(verification?.metrics);
+  return {
+    claimId: claim.id,
+    claimVersionId: claim.versionId ?? assessment.claimVersionId ?? null,
+    statement: claim.statement,
+    verificationStatus: normalizedStatus(assessment.verificationStatus),
+    assessmentDigest: assessment.assessmentDigest ?? null,
+    integrityStatus: assessment.integrityStatus ?? verification?.integrity?.status ?? null,
+    comparison: comparison ? {
+      metric: comparison.metric ?? null,
+      unit: comparison.unit ?? null,
+      reportedValue: finiteOrNull(comparison.reportedValue),
+      observedValue: finiteOrNull(comparison.observedValue ?? comparison.value),
+      tolerance: finiteOrNull(comparison.tolerance),
+      absoluteDifference: finiteOrNull(comparison.absoluteDifference),
+    } : null,
+  };
+}
+
+function conclusionStatus(counts) {
+  const supported = counts.reproduced + counts.approximatelyReproduced;
+  if (supported > 0 && counts.notReproduced === 0 && counts.inconclusive === 0 && counts.unevaluatedClaims === 0) {
+    return "tested_claims_supported";
+  }
+  if (supported > 0) return "partially_supported";
+  if (counts.notReproduced > 0) return "not_supported";
+  return "inconclusive";
+}
+
+function conclusionParagraph({ title, counts, records, overallStatus }) {
+  if (!records.length) {
+    return `"${clean(title)}" has no verifiable claim execution records yet, so the paper's conclusions can neither be confirmed nor refuted at this stage.`;
+  }
+  const coverage = `CiteArk evaluated ${counts.evaluatedClaims} of ${counts.structuredClaims} structured claims`;
+  const tally = `with ${counts.reproduced} reproduced, ${counts.approximatelyReproduced} approximately reproduced, ${counts.notReproduced} not reproduced, and ${counts.inconclusive} inconclusive`;
+  const evidence = [
+    evidenceSentence(records, "reproduced", "was reproduced"),
+    evidenceSentence(records, "approximately_reproduced", "was approximately reproduced"),
+    evidenceSentence(records, "not_reproduced", "was not reproduced"),
+    evidenceSentence(records, "inconclusive", "lacks sufficient evidence for a conclusion"),
+  ].filter(Boolean).join("; ");
+  const ending = {
+    tested_claims_supported: "Therefore, within the pinned code, data, and execution environment, all claims structured and evaluated in this artifact were reproduced. This supports only those tested claims and does not establish that every material claim in the paper was covered.",
+    partially_supported: "Therefore, the execution evidence supports some tested structured claims, while untested, inconclusive, or inconsistent claims remain unsupported by this artifact. This is not a paper-wide validity judgment.",
+    not_supported: "Therefore, this execution did not support at least one tested structured claim. This finding applies to the recorded protocol and conditions, rather than serving as a paper-wide verdict.",
+    inconclusive: "Therefore, the available execution evidence is insufficient to confirm or refute the tested structured claims, and no paper-wide conclusion is warranted.",
+  }[overallStatus];
+  return `"${clean(title)}": ${coverage}, ${tally}: ${evidence}. ${ending}`;
+}
+
+function evidenceSentence(records, status, suffix) {
+  const selected = records.filter((record) => record.verificationStatus === status).slice(0, 1);
+  if (!selected.length) return null;
+  return selected.map((record) => {
+    const metric = metricComparison(record.comparison);
+    return `"${shortStatement(record.statement)}"${metric} ${suffix}`;
+  }).join("; ");
+}
+
+function metricComparison(comparison) {
+  if (!comparison || comparison.reportedValue === null || comparison.observedValue === null) return "";
+  return ` (reported ${formatMetric(comparison.reportedValue, comparison.unit)}, observed ${formatMetric(comparison.observedValue, comparison.unit)})`;
+}
+
+function formatMetric(value, unit) {
+  const formatted = new Intl.NumberFormat("en-US", { maximumFractionDigits: 6 }).format(value);
+  return unit === "percentage_points" ? `${formatted}%` : `${formatted}${unit ? ` ${unit}` : ""}`;
+}
+
+function shortStatement(value) {
+  const text = clean(value).replace(/[。.!！]+$/u, "");
+  return text.length > MAX_STATEMENT_CHARACTERS ? `${text.slice(0, MAX_STATEMENT_CHARACTERS - 1)}…` : text;
+}
+
+function clean(value) {
+  return String(value ?? "").replaceAll(/\s+/g, " ").trim();
+}
+
+function normalizedStatus(value) {
+  return new Set(["reproduced", "approximately_reproduced", "not_reproduced", "inconclusive"]).has(value) ? value : "inconclusive";
+}
+
+function finiteOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/src/results/output-registry.mjs

@@ -0,0 +1,183 @@
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  CiteArkError,
+  pathExists,
+  safeRelativePath,
+  sha256File,
+} from "../util.mjs";
+
+export const INLINE_OUTPUT_MAX_BYTES = 64 * 1024 * 1024;
+
+const OUTPUT_KINDS = new Set([
+  "table",
+  "figure",
+  "dataset",
+  "model",
+  "checkpoint",
+  "text",
+  "archive",
+  "audio",
+  "video",
+  "other",
+]);
+const OUTPUT_ROLES = new Set(["primary", "supporting"]);
+const WITHHELD_OUTPUT_KINDS = new Set(["model", "checkpoint", "dataset"]);
+
+export async function buildOutputRegistry({
+  result,
+  outputDirectory,
+  runId,
+  contractDigest,
+  capturedAt,
+  inlineMaximumBytes = INLINE_OUTPUT_MAX_BYTES,
+}) {
+  const declaredOutputs = Array.isArray(result?.outputs) ? result.outputs : [];
+  const evidencePaths = new Set(
+    (Array.isArray(result?.evidence) ? result.evidence : [])
+      .map((item) => item?.path)
+      .filter((value) => typeof value === "string"),
+  );
+  const outputs = await Promise.all(declaredOutputs.map(async (item) => {
+    const sourcePath = item.path;
+    const source = resolveOutputPath(outputDirectory, sourcePath);
+    const [stat, sha256] = await Promise.all([lstat(source), sha256File(source)]);
+    if (!stat.isFile()) throw new CiteArkError(`科学输出不是常规文件：${sourcePath}`);
+    const withheld = WITHHELD_OUTPUT_KINDS.has(item.kind);
+    const external = !withheld && stat.size > inlineMaximumBytes;
+    return {
+      id: item.id,
+      ...(item.scientificObjectId ? { scientificObjectId: item.scientificObjectId } : {}),
+      kind: item.kind,
+      role: item.role,
+      sourcePath,
+      artifactPath: withheld || external
+        ? null
+        : evidencePaths.has(sourcePath)
+          ? `evidence/${sourcePath}`
+          : `outputs/${sourcePath}`,
+      description: item.description,
+      digest: `sha256:${sha256}`,
+      byteSize: stat.size,
+      mediaType: mediaTypeForPath(sourcePath),
+      storage: withheld ? "withheld" : external ? "external" : "embedded",
+      ...(Array.isArray(item.relatedEvidencePaths) && item.relatedEvidencePaths.length
+        ? { relatedEvidencePaths: [...item.relatedEvidencePaths] }
+        : {}),
+    };
+  }));
+  return {
+    schemaVersion: "0.1",
+    kind: "citeark.output-registry",
+    runId,
+    contractDigest,
+    outputs,
+    checks: outputs.map((output) => ({
+      outputId: output.id,
+      type: "content-identity",
+      status: "passed",
+      description: "The runner resolved a regular file and recorded its exact byte size and SHA-256 digest",
+    })),
+    capturedAt: capturedAt ?? new Date().toISOString(),
+  };
+}
+
+export async function validateDeclaredOutputs(result, outputDirectory) {
+  if (result?.outputs === undefined) return [];
+  if (!Array.isArray(result.outputs)) return ["outputs 必须是数组"];
+  const issues = [];
+  const ids = new Set();
+  const paths = new Set();
+  const evidencePaths = new Set(
+    (Array.isArray(result?.evidence) ? result.evidence : [])
+      .map((item) => item?.path)
+      .filter((value) => typeof value === "string"),
+  );
+  for (const [index, item] of result.outputs.entries()) {
+    const label = `outputs[${index}]`;
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      issues.push(`${label} 必须是对象`);
+      continue;
+    }
+    if (typeof item.id !== "string" || !item.id.trim()) issues.push(`${label}.id 必须是非空字符串`);
+    else if (ids.has(item.id)) issues.push(`output id 重复：${item.id}`);
+    else ids.add(item.id);
+    if (item.scientificObjectId !== undefined && (typeof item.scientificObjectId !== "string" || !item.scientificObjectId.trim())) issues.push(`${label}.scientificObjectId must be a nonempty research object identity`);
+    if (!OUTPUT_KINDS.has(item.kind)) issues.push(`${label}.kind 无效`);
+    if (!OUTPUT_ROLES.has(item.role)) issues.push(`${label}.role 无效`);
+    if (typeof item.description !== "string" || !item.description.trim()) {
+      issues.push(`${label}.description 必须是非空字符串`);
+    }
+    if (!safeRelativePath(item.path)) {
+      issues.push(`${label}.path 必须是 output 内的安全相对路径`);
+      continue;
+    }
+    if (paths.has(item.path)) issues.push(`output path 重复：${item.path}`);
+    else paths.add(item.path);
+    const target = path.resolve(outputDirectory, item.path);
+    if (!(await pathExists(target))) {
+      issues.push(`科学输出文件不存在：${item.path}`);
+    } else if (!(await lstat(target)).isFile()) {
+      issues.push(`科学输出必须是常规文件：${item.path}`);
+    }
+    if (item.relatedEvidencePaths !== undefined) {
+      if (!Array.isArray(item.relatedEvidencePaths)) {
+        issues.push(`${label}.relatedEvidencePaths 必须是数组`);
+      } else {
+        const related = new Set();
+        for (const [relatedIndex, relatedPath] of item.relatedEvidencePaths.entries()) {
+          if (!safeRelativePath(relatedPath)) {
+            issues.push(`${label}.relatedEvidencePaths[${relatedIndex}] 必须是安全相对路径`);
+          } else if (!evidencePaths.has(relatedPath)) {
+            issues.push(`${label}.relatedEvidencePaths[${relatedIndex}] 没有对应的 evidence：${relatedPath}`);
+          } else if (related.has(relatedPath)) {
+            issues.push(`${label}.relatedEvidencePaths 包含重复路径：${relatedPath}`);
+          }
+          related.add(relatedPath);
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+function resolveOutputPath(outputDirectory, relativePath) {
+  if (!safeRelativePath(relativePath)) throw new CiteArkError(`科学输出路径无效：${String(relativePath)}`);
+  const root = path.resolve(outputDirectory);
+  const target = path.resolve(root, relativePath);
+  if (!target.startsWith(`${root}${path.sep}`)) throw new CiteArkError(`科学输出路径逃逸：${relativePath}`);
+  return target;
+}
+
+export function mediaTypeForPath(value) {
+  const extension = path.extname(value).toLowerCase();
+  return ({
+    ".json": "application/json",
+    ".jsonl": "application/x-ndjson",
+    ".csv": "text/csv; charset=utf-8",
+    ".tsv": "text/tab-separated-values; charset=utf-8",
+    ".parquet": "application/vnd.apache.parquet",
+    ".arrow": "application/vnd.apache.arrow.file",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".log": "text/plain; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".safetensors": "application/octet-stream",
+    ".pt": "application/octet-stream",
+    ".pth": "application/octet-stream",
+    ".ckpt": "application/octet-stream",
+    ".zip": "application/zip",
+    ".tar": "application/x-tar",
+    ".gz": "application/gzip",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".flac": "audio/flac",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+  })[extension] ?? "application/octet-stream";
+}

package/src/runtime/claude-code.mjs

@@ -0,0 +1,52 @@
+import { hasSessionEvents } from '../terminal/events.mjs';
+import { CLI_COMMUNICATION } from './prompt.mjs';
+
+export async function buildClaudeCodeInvocation({
+  bundle,
+  attempt,
+  prompt,
+  instructions,
+}) {
+  const agent = bundle.runtimeAgent;
+  const attemptBudget = agent.maxBudgetUsd / (1 + agent.validationRetries);
+  const common = [
+    "--print",
+    "--bare",
+    "--safe-mode",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    ...(hasSessionEvents() ? ["--include-partial-messages"] : []),
+    "--model",
+    agent.model,
+    "--effort",
+    agent.effort,
+    "--max-turns",
+    String(agent.maxTurns),
+    "--max-budget-usd",
+    String(attemptBudget),
+    "--dangerously-skip-permissions",
+    "--append-system-prompt",
+    hasSessionEvents() ? `${instructions}\n\n${CLI_COMMUNICATION}` : instructions,
+  ];
+
+  if (attempt === 1) {
+    return {
+      command: "claude",
+      args: [
+        ...common,
+        "--session-id",
+        bundle.sessionId,
+        prompt,
+      ],
+      prompt,
+      promptArgument: prompt,
+    };
+  }
+  return {
+    command: "claude",
+    args: [...common, "--resume", bundle.sessionId, prompt],
+    prompt,
+    promptArgument: prompt,
+  };
+}