@citeark/agent 0.3.20

package/src/research/structure.mjs

@@ -0,0 +1,3163 @@
+import { validateResearchMap } from './research-map.mjs';
+import { validateResearchObjects } from './research-objects.mjs';
+import { normalizeExperimentImportance } from "./experiment-importance.mjs";
+import { REPRODUCTION_ROUTES, reproductionScopeIssues } from "./reproduction-scope.mjs";
+import { revisedInventoryClaims, sourceClaim } from "./inventory-revisions.mjs";
+import { measurementRequiresHardwareProtocol, measurementHardwareIssues } from "../compute/measurement-hardware.mjs";
+import { publicContractPolicyIssues, researchPublicContract } from "../contracts/public-contract.mjs";
+import { continuationRepairTargets } from "./continuation-selection.mjs";
+import { executionWorkloadIssues } from "../contracts/execution-workload.mjs";
+import { automaticClaimCoverage } from "./automatic-admission.mjs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import { CiteArkError, isRecord, readJson, safeRelativePath, sha256Value, writeJson } from "../util.mjs";
+import { validateEvidenceParserDescriptor } from "../evidence/parser-registry.mjs";
+import { validateDeclaredComputeRequirement } from "../compute/requirements.mjs";
+import { EXECUTION_MODES } from "../contracts/execution-mode.mjs";
+import { executionTimeoutCapMinutes } from "../contracts/execution-timeouts.mjs";
+import {
+  CURRENT_PREFLIGHT_SCHEMA_VERSION,
+  describeSupportedPreflightSchemaVersions,
+  MAX_PREFLIGHT_MINUTES,
+  MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES,
+  PREFLIGHT_CHECK_KINDS,
+  supportsPreflightSchemaVersion,
+} from "../contracts/preflight-schema.mjs";
+import {
+  IMPLEMENTATION_ORIGINS,
+  RECONSTRUCTION_REPOSITORY,
+} from "../repository-origin.mjs";
+import {
+  ASSET_ACQUISITION_MODES,
+  ASSET_SCIENTIFIC_ROLES,
+  assetLocalPath,
+} from "../assets/plan.mjs";
+import {
+  ASSET_REQUIREMENT_KINDS,
+  evaluateAssetRequirementCoverage,
+  normalizeAssetRequirements,
+} from "../assets/requirements.mjs";
+import {
+  commandVerifiesDependencies,
+  explicitlyUnderspecifiedHardwareProtocol,
+  hardwareSensitiveMetric,
+  isSimpleScriptEntrypoint,
+  parserPreflightTargetLeaks,
+  sanitizeParserPreflightCommand,
+} from "./compiler-normalization-guards.mjs";
+
+export const RESEARCH_SCHEMA_VERSION = "1.0";
+export {
+  MAX_PREFLIGHT_MINUTES,
+  MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES,
+  PREFLIGHT_CHECK_KINDS,
+};
+const CLAIM_TYPES = new Set(["finding", "method", "measurement", "limitation"]);
+const SOURCE_KINDS = new Set(["paper", "repository", "dataset", "supplement", "checkpoint"]);
+const REPRODUCTION_LEVELS = new Set(REPRODUCTION_ROUTES);
+const REPRODUCTION_DISPOSITIONS = new Set(["planned", "deferred", "blocked", "not_applicable"]);
+export const RECONSTRUCTION_FIDELITIES = new Set(["exact", "faithful", "approximate", "proxy"]);
+const PREFLIGHT_ASSET_KINDS = new Set([
+  "dataset",
+  "checkpoint",
+  "model",
+  "repository",
+  "other",
+]);
+const PREFLIGHT_ASSET_AVAILABILITY = new Set([
+  "bundled",
+  "public_verified",
+  "public_unverified",
+  "private",
+  "unknown",
+]);
+const COVERAGE_STATUSES = new Set(["represented", "deferred", "blocked", "not_applicable"]);
+import { SUBJECT_TAGS } from '../contracts/subject-tags.mjs';
+export { SUBJECT_TAGS };
+
+export async function loadResearchStructure(target) {
+  return normalizeResearchStructure(await readJson(target));
+}
+
+export async function normalizeResearchFile(inputPath, outputPath) {
+  const research = await loadResearchStructure(inputPath);
+  await writeJson(outputPath, research);
+  return research;
+}
+
+/**
+ * Accept a best-effort Research Compiler draft and deterministically turn local
+ * structural mistakes into warnings, conservative claim dispositions, or
+ * dropped non-executable experiments. The returned research object still
+ * passes the strict Artifact validator; this tolerance is only for the
+ * compiler boundary, never for third-party Artifact verification.
+ */
+export function normalizeCompilerResearchDraft(input, context = {}, { collectIssues = false } = {}) {
+  if (!isRecord(input)) throw new CiteArkError("research.json 的根节点必须是对象");
+  const warnings = [];
+  const draft = structuredClone(input);
+  draft.schemaVersion = RESEARCH_SCHEMA_VERSION;
+  if (context.reproductionScope !== undefined) draft.reproductionScope = context.reproductionScope;
+  else delete draft.reproductionScope;
+  draft.work = compilerWork(draft.work, context, warnings);
+  draft.sources = compilerSources(draft.sources, context, warnings);
+  const sourceIds = new Set(draft.sources.map((source) => source.id));
+  const paperSourceId = draft.sources.find((source) => source.kind === "paper")?.id
+    ?? draft.sources[0]?.id;
+  draft.claims = compilerClaims(draft.claims, {
+    sourceIds,
+    paperSourceId,
+    warnings,
+  });
+  const inventoryOnly = context.compilationStage === "inventory";
+  if (inventoryOnly) draft.compilationStage = "inventory";
+  else delete draft.compilationStage;
+  draft.experiments = inventoryOnly ? [] : compilerExperiments(draft.experiments, {
+    claims: draft.claims,
+    researchObjects: draft.researchObjects,
+    repositoryIdentity: context.repositoryIdentity,
+    executionAllowed: context.licensePolicy?.executable !== false,
+    reproductionScope: context.reproductionScope,
+    continuation: context.continuation,
+    warnings,
+  });
+  if (context.licensePolicy?.executable === false) {
+    for (const claim of draft.claims) if (claim.reportedMeasurements.length) {
+      claim.reproduction = { status: "blocked", reason: "The recorded license policy does not allow execution.",
+        blocker: { kind: "access", evidence: "Runner-owned licensePolicy.executable=false" } };
+    }
+  }
+  if (inventoryOnly) {
+    for (const claim of draft.claims) claim.reproduction = { status: "deferred", reason: "Source inventory recorded; verification route and feasibility belong to reproduction preparation." };
+  } else reconcileCompilerDispositions(draft.claims, draft.experiments, warnings, context.computeContext);
+  draft.experiments = draft.experiments.filter((experiment) => experiment.claimIds.length > 0);
+  draft.coverage = compilerCoverage(draft.coverage, {
+    claims: draft.claims,
+    sourceIds,
+    paperSourceId,
+    warnings,
+  });
+  draft.lineage = compilerLineage(draft.lineage, {
+    sources: draft.sources,
+    claims: draft.claims,
+    experiments: draft.experiments,
+    warnings,
+  });
+  draft.license = compilerLicense(draft.license, context.licensePolicy, warnings);
+  draft.provenance = compilerProvenance(draft.provenance, context, warnings);
+  const allWarnings = [...new Set(warnings)];
+  const uniqueWarnings = allWarnings.length > 100
+    ? [
+        ...allWarnings.slice(0, 99),
+        `${allWarnings.length - 99} additional normalization warnings were omitted from this record.`,
+      ]
+    : allWarnings;
+  if (uniqueWarnings.length) draft.provenance.normalizationWarnings = uniqueWarnings;
+  else delete draft.provenance.normalizationWarnings;
+  try {
+    return {
+      research: normalizeResearchStructure(draft, { requireAuthors: true }),
+      warnings: uniqueWarnings,
+      structureIssues: [],
+    };
+  } catch (error) {
+    if (!collectIssues) throw error;
+    // Keep structure failures blocking while also collecting feasibility errors.
+    return { research: draft, warnings: uniqueWarnings, structureIssues: [error.message] };
+  }
+}
+
+/**
+ * Inspect a compiler draft for trust-boundary and execution-agent diagnostics.
+ * The caller retries only identity, scope and evidence-integrity violations.
+ * Operational findings remain useful audit guidance, but an agent-planned
+ * contract carries them forward instead of demanding another broad rewrite.
+ */
+export function compilerReconstructionRetryIssues(research, context = {}) {
+  const issues = [];
+  const allExperiments = Array.isArray(research?.experiments) ? research.experiments : [];
+  const experiments = continuationFailedTargetExperiments(
+    allExperiments,
+    context.continuation,
+  );
+  const missingContinuationTargets = continuationTargetCoverageFailures(
+    allExperiments,
+    context.continuation,
+  );
+  if (missingContinuationTargets.length) {
+    const details = missingContinuationTargets.slice(0, 8)
+      .map(({ claimId, experimentId, disposition }) =>
+        `${disposition}:${[claimId, experimentId].filter(Boolean).join("/") || "unknown target"}`)
+      .join(", ");
+    issues.push(
+      `Continuation-target coverage retry: ${details} were recorded by the parent campaign but are absent from this repaired plan. A continuation may change resources, preflight, orchestration, or evidence generation for failed targets, but it must preserve every completed or failed experiment id and its claim binding. Completed targets must remain addressable under their original identity so the worker imports their evidence instead of rerunning a renamed duplicate; failed targets remain mandatory until fresh execution succeeds. Do not delete a difficult target, replace it with an already completed supporting experiment, rename a completed target, or mark a required target blocked merely to pass validation.`,
+    );
+  }
+  const hasOfficialRepository = Boolean(
+    context.repositoryIdentity?.available !== false
+    && textValue(context.repositoryIdentity?.url)
+    && textValue(context.repositoryIdentity?.commit),
+  );
+  const missingOfficialEntrypoints = officialEntrypointIdentityFailures(experiments, context);
+  if (missingOfficialEntrypoints.length) {
+    const details = missingOfficialEntrypoints.slice(0, 8)
+      .map(({ experimentId, references }) => `${experimentId}: ${references.join(", ")}`)
+      .join("; ");
+    issues.push(
+      `Official-entrypoint identity retry: ${details} are declared as official scientific entrypoints but are absent from the runner-owned snapshot of the fixed repository commit. An official plan may invoke only source files that actually exist in that snapshot. Inspect the repository inventory and replace invented adapters with the real checked-in command(s); capture and transform their raw stdout or source artifacts into /job/output evidence without changing the scientific command. If a report-defining implementation truly is absent, use a separately declared CiteArk reconstruction from the clean scaffold or leave that measurement blocked. Audit matching preflight commands and requiredCommandFragments at the same time; never describe a generated wrapper as checked in or official.`,
+    );
+  }
+  const reconstructionOriginLeaks = reconstructionOriginIsolationFailures(experiments, context);
+  if (reconstructionOriginLeaks.length) {
+    const details = reconstructionOriginLeaks.slice(0, 8)
+      .map(({ experimentId, references }) => `${experimentId}: ${references.join(", ")}`)
+      .join("; ");
+    issues.push(
+      `Reconstruction-origin isolation retry: ${details} are fixed-author-snapshot files referenced by experiments declared as citeark_reconstruction. An independent reconstruction runs from CiteArk's clean scaffold and must not copy, import, patch, or invoke the author snapshot. If a generated loop, evaluator driver, or evidence adapter calls a checked-in author implementation, keep that helper operational and declare the scientific experiment official with the real checked-in command visible in protocol.entrypoint and requiredCommandFragments. Otherwise implement the paper-described method independently under /job/workspace/repository without any author-source dependency, lower fidelity for material deviations, and keep missing conditions blocked when independence cannot be established. Audit protocol instructions, preflight checks, and command fragments together; changing only the repository label does not repair provenance.`,
+    );
+  }
+  const incompletePreflights = experiments
+    .filter((experiment) =>
+      experiment?.reconstructionFidelity !== "proxy"
+      && experiment?.protocol?.preflight?.source !== "declared",
+    );
+  if (incompletePreflights.length) {
+    issues.push(
+      `Execution preflight retry: ${incompletePreflights.slice(0, 8).map((experiment) => experiment.id).join(", ")} do not have a compiler-declared structured preflight. For every automatically runnable experiment, declare protocol.preflight with a bounded maxMinutes, runtime/dependency/entrypoint/parser/smoke-test checks, a real dataset_loader check for each required dataset, every required dataset/checkpoint/model asset and its current availability, and exact pass criteria. Do not defer known Python, dependency, checkpoint, dataset-loader, or parser requirements to the expensive execution phase.`,
+    );
+  }
+  const missingDurationEstimates = experiments.flatMap((experiment) =>
+    missingRunnableDurationEstimate(experiment),
+  );
+  if (missingDurationEstimates.length) {
+    const details = missingDurationEstimates.slice(0, 8)
+      .map(({ experimentId, missing }) => `${experimentId}: ${missing.join(" and ")}`)
+      .join("; ");
+    issues.push(
+      `Compute-estimate retry: ${details} do not have a finite positive duration estimate for every scheduler-eligible accelerator. Estimate the complete workload, including setup and evidence publication, from its declared units and a measured, documented, or explicitly assumed conservative rate. Explain the arithmetic, hardware, basis and uncertainty in compute.rationale. A rough transparent estimate is required; null, omission, the runtime ceiling, or a cap-aware placeholder is not an estimate. Retain a separate finite execution timeout and a bounded real-device probe that can recalibrate the estimate before expensive work.`,
+    );
+  }
+  const invalidExecutionTimeouts = experiments.flatMap((experiment) =>
+    runnableExecutionTimeoutIssues(experiment),
+  );
+  if (invalidExecutionTimeouts.length) {
+    const details = invalidExecutionTimeouts.slice(0, 8)
+      .map(({ experimentId, reason }) => `${experimentId}: ${reason}`)
+      .join("; ");
+    issues.push(
+      `Execution-timeout retry: ${details}. Every automatically runnable experiment must declare environment.timeoutMinutes explicitly. Treat it as a generous anomaly circuit breaker rather than the expected duration: keep it above the longest scheduler-eligible estimate plus a conservative reserve, but within the platform fidelity cap. Do not shorten the scientific workload merely to fit a timeout.`,
+    );
+  }
+  const mixedVariantExperiments = experiments.flatMap((experiment) => {
+    if (experiment?.reconstructionFidelity === "proxy") return [];
+    const variants = experimentReportedModelVariants(research, experiment);
+    return variants.length > 1 ? [{ experiment, variants }] : [];
+  });
+  if (mixedVariantExperiments.length) {
+    const details = mixedVariantExperiments.slice(0, 8)
+      .map(({ experiment, variants }) => `${experiment.id} binds ${variants.join(" / ")}`)
+      .join("; ");
+    issues.push(
+      `Model-variant isolation retry: ${details}. Split distinct paper-reported model variants into separately bound experiments with distinct entrypoint commands and evidence paths, then verify that every variant has a real official or explicitly reconstructed implementation path. A selector, boolean, loop label, or second evidence filename is not a model variant when it does not change the scientific computation. If the fixed official repository omits one variant, do not relabel the available implementation or duplicate its output; either ground a CiteArk reconstruction in the paper's algorithm and lower fidelity as needed, or leave that measurement blocked with the concrete missing condition.`,
+    );
+  }
+  const selfDisqualifiedExperiments = experiments.filter((experiment) =>
+    experiment?.reconstructionFidelity !== "proxy"
+    && Array.isArray(experiment?.measurements)
+    && experiment.measurements.length > 0
+    && explicitlyDisclaimsReportedScope(experiment),
+  );
+  if (selfDisqualifiedExperiments.length) {
+    issues.push(
+      `Scope-equivalence retry: ${selfDisqualifiedExperiments.slice(0, 8).map((experiment) => experiment.id).join(", ")} bind paper-reported measurements while their own title or protocol instructions describe the run as a smoke/plumbing check, not equivalent to the paper evaluation, or outside the reported scope. A non-proxy experiment cannot bind a reported measurement after explicitly disavowing its dataset, sample count, split, repetition, aggregation, or evaluation scope. Keep valid structural checks as separate supporting experiments, but either execute the report-defining scope for the measurement or mark the reduced run proxy and leave the paper measurement unsatisfied. Never compare a one-sample or synthetic-input agreement rate with a paper's full-dataset aggregate merely because both can equal 100%.`,
+    );
+  }
+  const reportedMeasurements = new Map(
+    (Array.isArray(research?.claims) ? research.claims : []).flatMap((claim) =>
+      (Array.isArray(claim?.reportedMeasurements) ? claim.reportedMeasurements : [])
+        .map((measurement) => [measurement.id, measurement]),
+    ),
+  );
+  const embeddedReportedValues = experiments.flatMap((experiment) =>
+    (Array.isArray(experiment?.measurements) ? experiment.measurements : []).flatMap((measurement) => {
+      const reported = reportedMeasurements.get(measurement?.reportedMeasurementId);
+      return entrypointEmbedsReportedValue(experiment?.protocol?.entrypoint, measurement, reported)
+        ? [{ experiment, measurement }]
+        : [];
+    }),
+  );
+  if (embeddedReportedValues.length) {
+    const details = embeddedReportedValues.slice(0, 8)
+      .map(({ experiment, measurement }) => `${experiment.id}/${measurement.reportedMeasurementId}`)
+      .join(", ");
+    issues.push(
+      `Evidence-integrity retry: ${details} embed the paper-reported measurement value directly in protocol.entrypoint under the parsed metric key. An entrypoint must derive raw evidence from executed model, dataset, evaluator, or source artifacts; it cannot print, assign, or serialize the target value as a literal. Parser fixtures may demonstrate a JSON shape in preflight, but the measurement evidence path must be produced from independently executed outputs. Remove the literal result and implement a real aggregation over raw per-sample or per-run artifacts, or leave the measurement unsatisfied.`,
+    );
+  }
+  const placeholderEntrypoints = experiments.filter((experiment) =>
+    experiment?.reconstructionFidelity !== "proxy"
+    && entrypointIsProsePlaceholder(experiment?.protocol?.entrypoint),
+  );
+  if (placeholderEntrypoints.length) {
+    issues.push(
+      `Entrypoint-executability retry: ${placeholderEntrypoints.slice(0, 8).map((experiment) => experiment.id).join(", ")} use a prose-printing placeholder as the immutable scientific command. Importing function names without calling them, then printing instructions such as “execute/evaluate/write ...”, performs no model, dataset, cycle, aggregation, or evidence work. Replace it with a command that actually invokes the fixed implementation, enumerates the declared scope, computes the bound measurement, and writes the parser evidence unchanged at execution time. An execution Agent must never be asked to invent the missing scientific driver.`,
+    );
+  }
+  const alreadyInvalidEntrypointIds = new Set([
+    ...placeholderEntrypoints.map((experiment) => experiment.id),
+    ...embeddedReportedValues.map(({ experiment }) => experiment.id),
+  ]);
+  const inconsistentEntrypointFragments = experiments.flatMap((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    if (
+      !entrypoint
+      || simpleEntrypointReference(entrypoint)
+      || alreadyInvalidEntrypointIds.has(experiment.id)
+    ) return [];
+    const fragments = Array.isArray(experiment?.protocol?.requiredCommandFragments)
+      ? experiment.protocol.requiredCommandFragments.map(textValue).filter(Boolean)
+      : [];
+    const missing = fragments.filter((fragment) => !entrypoint.includes(fragment));
+    return missing.length ? [{ experimentId: experiment.id, missing }] : [];
+  });
+  if (inconsistentEntrypointFragments.length) {
+    const details = inconsistentEntrypointFragments.slice(0, 8)
+      .map(({ experimentId, missing }) => `${experimentId}: ${missing.slice(0, 8).join(", ")}`)
+      .join("; ");
+    issues.push(
+      `Entrypoint-executability retry: ${details} are declared in requiredCommandFragments but are absent from the complete immutable protocol.entrypoint. For a full command, every required scientific fragment must be present in that command; a token used only by parser, smoke, duration, or another preflight fixture is not a scientific entrypoint fragment. Remove preflight-only fragments, or repair the immutable entrypoint when the missing operation is genuinely part of the paper measurement. Keep legacy path-only entrypoints separate because their recorded invocation may supply fixed arguments.`,
+    );
+  }
+  const invalidInlinePythonEntrypoints = inlinePythonSyntaxFailures(experiments);
+  if (invalidInlinePythonEntrypoints.length) {
+    issues.push(
+      `Entrypoint-syntax retry: ${invalidInlinePythonEntrypoints.slice(0, 8).map((experiment) => experiment.id).join(", ")} contain inline Python that does not parse before any scientific work begins. Validate the exact code passed to python -c with ast.parse or compile during compilation, then keep that same immutable command in the plan. In particular, do not mix a one-line for-suite with a subsequently indented nested loop; use a syntactically valid multiline block or a checked-in/generated repository script with a compile-only preflight. Never defer a deterministic syntax error to the expensive execution Agent.`,
+    );
+  }
+  const nonRepresentativeSmokeTests = smokePreflightFailures(experiments);
+  if (nonRepresentativeSmokeTests.length) {
+    issues.push(
+      `Execution preflight retry: ${nonRepresentativeSmokeTests.slice(0, 8).map((experiment) => experiment.id).join(", ")} declare corpus-scale neural work but use a constant, always-true, or non-scientific smoke command. The smoke test must execute a bounded representative path through the fixed implementation on one real or identity-verified fixture input, including model/evaluator loading, the decisive encode/decode/infer/evaluate operation, and evidence-shape generation. Assertions such as \`assert 2620 > 0\`, \`... or True\`, or parser-only fixtures do not prove end-to-end plumbing and must not defer the first real invocation to the full experiment.`,
+    );
+  }
+  const unverifiedOfficialCliInterfaces = officialCliInterfaceFailures(experiments);
+  if (unverifiedOfficialCliInterfaces.length) {
+    const details = unverifiedOfficialCliInterfaces.slice(0, 8)
+      .map(({ experimentId, script, options }) => `${experimentId}: ${script} ${options.join(" ")}`)
+      .join("; ");
+    issues.push(
+      `Entrypoint-executability retry: ${details} pass long options to an official repository script without an entrypoint preflight that invokes that exact script's --help interface and verifies every declared option. File existence does not prove a CLI accepts invented flags. Inspect the fixed script; if it exposes those options, add a non-scientific --help/interface check. If it does not, replace the command with a real inline driver that calls the checked-in functions and performs the complete declared scope, or leave the measurement blocked. Never defer an unsupported immutable command to the execution Agent.`,
+    );
+  }
+  const nonPortableAssetPaths = experiments.filter((experiment) =>
+    experimentUsesUnavailableDataRoot(experiment),
+  );
+  if (nonPortableAssetPaths.length) {
+    issues.push(
+      `Asset-path portability retry: ${nonPortableAssetPaths.slice(0, 8).map((experiment) => experiment.id).join(", ")} reference /data in immutable entrypoint or preflight commands, but CiteArk execution grants the unprivileged Agent a writable /job/assets root and does not promise a writable or mounted /data directory. Bind every acquired dataset, checkpoint, and model beneath /job/assets, use those exact paths in the immutable command and checks, and keep caches under /job/runtime-cache. Do not rely on root-created compatibility symlinks.`,
+    );
+  }
+  const mismatchedAssetPaths = experiments.flatMap(assetPathBindingFailures);
+  if (mismatchedAssetPaths.length) {
+    const details = mismatchedAssetPaths.slice(0, 8)
+      .map(({ experimentId, path: assetPath }) => `${experimentId}: ${assetPath}`)
+      .join("; ");
+    issues.push(
+      `Asset-path binding retry: ${details} reference an asset path that is not the immutable localPath derived from the declared asset kind and id. Use /job/assets/<kind>/<asset-id> consistently in the scientific entrypoint and every preflight command. Do not rely on the execution Agent to create compatibility symlinks for a mismatched compiler path.`,
+    );
+  }
+  const invalidParserFixtures = parserPreflightFixtureFailures(
+    experiments,
+    reportedMeasurements,
+  );
+  if (invalidParserFixtures.length) {
+    const details = invalidParserFixtures.slice(0, 8)
+      .map(({ experimentId, reasons }) => `${experimentId}: ${reasons.join(" and ")}`)
+      .join("; ");
+    issues.push(
+      `Parser-evidence generation retry: ${details}. A parser preflight must create its own tiny synthetic sentinel fixture in the same command before reading it, and the sentinel must not contain or compare against the paper-reported target value. Keep fixtures outside the measurement evidence path, validate only shape/unit/parser plumbing, and require the scientific entrypoint to derive final evidence from executed outputs.`,
+    );
+  }
+  const prematureFastTextPartitions = experiments.filter((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    const usesFastTextParser = (Array.isArray(experiment?.measurements)
+      ? experiment.measurements
+      : []).some((measurement) => measurement?.parser?.id === "fasttext.classification.test");
+    return usesFastTextParser
+      && /\^N\[\[:space:\]\][\s\S]{0,80}\{[^}]*\bexit\b[^}]*\}/i.test(entrypoint);
+  });
+  if (prematureFastTextPartitions.length) {
+    issues.push(
+      `Parser-evidence generation retry: ${prematureFastTextPartitions.slice(0, 8).map((experiment) => experiment.id).join(", ")} partition fastText native output by exiting on the N sample-count line before P@1 and R@1 are preserved. The registered fasttext.classification.test parser requires the complete native metric block at every parser.evidencePath. Change the deterministic partitioner to stop only after the required metric lines, and make declared preflight run the exact splitter on a representative N/P@1/R@1 fixture followed by the registered parser. Testing the parser alone on a hand-written file does not validate evidence generation.`,
+    );
+  }
+  const outputEntrypoints = experiments.filter((experiment) =>
+    experiment?.implementationOrigin === "citeark_reconstruction"
+    && /(?:^|[\s"'])\/job\/output\/[A-Za-z0-9._/-]+\.(?:py|sh|js|mjs|cjs|rb|pl|jl|r)(?=$|[\s"'])/i
+      .test(textValue(experiment?.protocol?.entrypoint) ?? ""),
+  );
+  if (outputEntrypoints.length) {
+    issues.push(
+      `Entrypoint-location retry: ${outputEntrypoints.slice(0, 8).map((experiment) => experiment.id).join(", ")} place generated scientific code under /job/output. Reconstruction entrypoints must live under /job/workspace/repository so source changes, checkpoints, and integrity policy share one auditable path; reserve /job/output for evidence, manifests, results, and other run products. Rewrite the immutable command to execute the repository-relative reconstruction script and keep parser evidence under /job/output.`,
+    );
+  }
+  const nonPortableRecursiveGlobs = experiments.filter((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    return /(?:^|[;&|]\s*|\b)(?:\/bin\/)?sh\s+-c\b/i.test(entrypoint)
+      && /(?:^|[\s"'])[^\s"']*\*\*\//.test(entrypoint);
+  });
+  if (nonPortableRecursiveGlobs.length) {
+    issues.push(
+      `Shell-portability retry: ${nonPortableRecursiveGlobs.slice(0, 8).map((experiment) => experiment.id).join(", ")} use recursive ** globs under sh -c. POSIX sh does not enable recursive globbing, so the immutable command can pass a literal nonexistent path or silently cover the wrong corpus. Replace it with deterministic null-safe find -print0 or pathlib.Path.rglob enumeration, sort identities, and make preflight verify the exact declared sample count before expensive execution.`,
+    );
+  }
+  const repeatedInterpreterCorpusLoops = experiments.filter((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    if (!/\bfor\s+[A-Za-z_][A-Za-z0-9_]*\s+in\b[\s\S]*\bpython(?:3)?\b/i.test(entrypoint)) {
+      return false;
+    }
+    const durations = Object.values(experiment?.compute?.estimatedDurationMinutes ?? {})
+      .map(Number)
+      .filter(Number.isFinite);
+    return durations.some((duration) => duration >= 30);
+  });
+  if (repeatedInterpreterCorpusLoops.length) {
+    issues.push(
+      `Corpus-execution retry: ${repeatedInterpreterCorpusLoops.slice(0, 8).map((experiment) => experiment.id).join(", ")} launch a fresh Python interpreter inside a long corpus loop. This commonly reloads the model or evaluator once per sample and makes the declared full-scope duration unreliable. Use one persistent official model/evaluator process with deterministic enumeration and auditable per-sample outputs, or provide a bounded startup/throughput benchmark proving the complete immutable loop fits its declared duration and budget. Prefer compatible accelerator execution when the fixed implementation supports it and CPU is materially slower.`,
+    );
+  }
+  const unbenchmarkedLargeWorkloads = experiments.filter((experiment) =>
+    requiresDurationFeasibilityBenchmark(experiment)
+    && !hasDurationFeasibilityCheck(experiment),
+  );
+  const missingWorkloads = experiments.filter((experiment) => requiresDurationFeasibilityBenchmark(experiment) && !experiment.protocol?.workload);
+  if (missingWorkloads.length) issues.push(`Workload-boundary retry: ${missingWorkloads.map((experiment) => experiment.id).join(", ")} must declare protocol.workload with full execution unit counts and groups covering different methods and material cost strata. Preserve every dataset, seed, epoch and aggregation requirement. A probe must execute a whole representative unit; the execution Agent measures it and forecasts all remaining units before committing to the full run.`);
+  if (unbenchmarkedLargeWorkloads.length) {
+    issues.push(
+      `Duration-feasibility retry: ${unbenchmarkedLargeWorkloads.slice(0, 8).map((experiment) => experiment.id).join(", ")} multiply corpus items, cycles, repetitions, epochs, steps, or trials into a large execution workload without a runnable duration preflight. Add a bounded representative benchmark that uses the fixed implementation and allocated device, records measured setup and per-unit throughput, extrapolates the complete immutable workload, and requires it to fit the contract timeout after reserving at least five minutes for evidence and result publication. If the forecast does not fit, redesign only the operational execution plan—such as safe batching, durable per-item progress, a compatible faster profile, or an honestly longer Research Plan budget—without reducing the scientific sample count, cycles, repetitions, aggregation, or other reported scope.`,
+    );
+  }
+  const computeEntrypointMismatches = experiments.filter((experiment) =>
+    experiment?.reconstructionFidelity !== "proxy"
+    && entrypointForcesCpuWhileDeclaringGpu(experiment),
+  );
+  if (computeEntrypointMismatches.length) {
+    issues.push(
+      `Compute-boundary retry: ${computeEntrypointMismatches.slice(0, 8).map((experiment) => experiment.id).join(", ")} declare GPU resources or GPU duration estimates while the immutable entrypoint hard-codes CPU execution. The scheduler can only honor the executable contract it receives. Either make the command select the allocated CUDA device and declare the accelerator required when the complete workload depends on it, or remove the GPU declaration and prove with a real CPU duration benchmark that the complete immutable run fits. Do not describe GPU as preferred while silently forcing the scientific command onto CPU.`,
+    );
+  }
+  const underconstrainedAccelerators = experiments.filter((experiment) =>
+    experiment?.reconstructionFidelity !== "proxy"
+    && largeWorkloadNeedsDeclaredAccelerator(experiment),
+  );
+  if (underconstrainedAccelerators.length) {
+    issues.push(
+      `Compute-boundary retry: ${underconstrainedAccelerators.slice(0, 8).map((experiment) => experiment.id).join(", ")} describe a large workload whose own estimates make GPU materially faster, but leave the accelerator optional with CPU fallback enabled. That contract is eligible for Standard CPU scheduling. If the promised duration relies on GPU throughput, set accelerator to required, disable CPU fallback, request a compatible GPU, and make the entrypoint use the allocated device. Keep accelerator optional only when a runnable CPU benchmark independently proves the complete workload fits the CPU timeout and budget.`,
+    );
+  }
+  const cycleCountMismatches = repeatedCycleCountFailures(experiments);
+  if (cycleCountMismatches.length) {
+    const details = cycleCountMismatches.slice(0, 8)
+      .map(({ experimentId, declaredCycles, loopCycles }) =>
+        `${experimentId}: declares ${declaredCycles} cycles but executes ${loopCycles}`)
+      .join("; ");
+    issues.push(
+      `Scope-equivalence retry: ${details}. The initial encoding establishes the baseline and is not a decode-re-encode cycle. Execute exactly the declared number of decode-re-encode transitions before comparing with the baseline; do not subtract one from the paper's cycle count or label a shorter loop as the reported scope.`,
+    );
+  }
+  const invalidFinalCycleComparisons = repeatedCycleFinalComparisonFailures(
+    experiments,
+    reportedMeasurements,
+  );
+  if (invalidFinalCycleComparisons.length) {
+    const details = invalidFinalCycleComparisons.slice(0, 8)
+      .map(({ experimentId, cycles }) => `${experimentId}: final comparison after ${cycles} cycles`)
+      .join("; ");
+    issues.push(
+      `Scope-equivalence retry: ${details} establish the baseline inside the repeated cycle loop or average agreement across intermediate cycles. A paper measurement defined as agreement between the first encoding and cycle N requires one baseline encoding before the loop, exactly N decode-re-encode transitions, and one final token-stream comparison per sample after the loop. Do not include the tautological baseline comparison or cycles 1..N-1 in the reported aggregate.`,
+    );
+  }
+  const selectionMismatches = reportedSelectionFailures(experiments, reportedMeasurements);
+  if (selectionMismatches.length) {
+    const details = selectionMismatches.slice(0, 8)
+      .map(({ experimentId, selection }) => `${experimentId}: ${selection}`)
+      .join("; ");
+    issues.push(
+      `Scope-equivalence retry: ${details}. The immutable entrypoint does not implement or consume evidence for the paper-declared sample selection. Sorting a corpus and taking the first N items is not a seeded random, reader/speaker-balanced, or stratified panel. Implement the exact deterministic seed and grouping algorithm in the command, or consume a digest-bound selection manifest whose construction and identities are declared and verified; otherwise lower the claim to the actually executed selection and leave the paper measurement unsatisfied.`,
+    );
+  }
+  const collapsedCorpusScopes = experiments.filter((experiment) =>
+    corpusScopeCollapsedToSingleExplicitInput(experiment, reportedMeasurements),
+  );
+  if (collapsedCorpusScopes.length) {
+    issues.push(
+      `Scope-equivalence retry: ${collapsedCorpusScopes.slice(0, 8).map((experiment) => experiment.id).join(", ")} declare a multi-sample corpus measurement but their immutable entrypoint processes only one explicit input file and contains no corpus or manifest enumeration. A declared sampleCount, dataset split, or aggregate cannot be satisfied by repeatedly invoking one fixture. Deterministically enumerate and verify the complete declared identities, process each distinct sample, and aggregate per-sample evidence; otherwise lower the experiment to the actually executed one-sample scope and leave the paper measurement unsatisfied.`,
+    );
+  }
+  const invalidSiSnrFormulas = siSnrFormulaFailures(experiments);
+  if (invalidSiSnrFormulas.length) {
+    issues.push(
+      `Evidence-integrity retry: ${invalidSiSnrFormulas.slice(0, 8).map((experiment) => experiment.id).join(", ")} implement SI-SNR without projecting the reconstructed estimate onto the clean reference. Computing the projection from reference-minus-estimate noise, or subtracting that projection from the reference, is a different quantity. Use a fixed trusted evaluator or compute target = <estimate, reference> / ||reference||^2 * reference, residual = estimate - target, then 10*log10(||target||^2 / ||residual||^2); add an analytical scale-invariance sanity check that exercises the same evaluator before corpus execution.`,
+    );
+  }
+  const missingSiSnrInvariantChecks = siSnrInvariantPreflightFailures(experiments);
+  if (missingSiSnrInvariantChecks.length) {
+    issues.push(
+      `Execution preflight retry: ${missingSiSnrInvariantChecks.slice(0, 8).map((experiment) => experiment.id).join(", ")} compute SI-SNR but their smoke preflight does not verify scale invariance with the same evaluator used by the corpus path. The smoke preflight and corpus entrypoint are separate command strings: each must define or import and call the same named evaluator. Repeating the arithmetic inline in the corpus path while naming the evaluator only in the smoke command does not satisfy this requirement. Use a non-colinear analytical reference/estimate pair, call the same named evaluator once on that pair and once on a clearly named non-unit scaled estimate such as scaled_estimate or analytic_scaled_estimate while keeping the reference fixed, then assert the two finite SI-SNR values agree within a small numerical tolerance. Scaling both reference and estimate together, using estimate = scalar * reference, or checking only finiteness is degenerate and cannot distinguish SI-SNR from an incorrectly oriented projection.`,
+    );
+  }
+  const leakedSiSnrInvariantFixtures = siSnrEntrypointInvariantFixtureFailures(experiments);
+  if (leakedSiSnrInvariantFixtures.length) {
+    issues.push(
+      `Execution preflight retry: ${leakedSiSnrInvariantFixtures.slice(0, 8).map((experiment) => experiment.id).join(", ")} copy the analytical SI-SNR scale-invariance fixture into the immutable scientific entrypoint or requiredCommandFragments. The named scaled estimate and tolerance assertion are smoke-only plumbing checks, not part of the corpus measurement or its command provenance. Keep the invariant in protocol.preflight smoke_test, remove its fixture variables and assertions from protocol.entrypoint, and remove preflight-only tokens such as scaled_estimate from requiredCommandFragments; do not satisfy fragment consistency by moving a smoke fixture into the scientific command.`,
+    );
+  }
+  const activeClaimIds = new Set(experiments.flatMap((experiment) =>
+    Array.isArray(experiment?.claimIds) ? experiment.claimIds : []));
+  const blockedClaims = (Array.isArray(research?.claims) ? research.claims : []).filter((claim) =>
+    ["blocked", "deferred"].includes(claim?.reproduction?.status)
+    && (!context.continuation || activeClaimIds.has(claim?.id)),
+  );
+  const compilerResourceBlocks = blockedClaims.filter((claim) => {
+    const reason = textValue(claim?.reproduction?.reason) ?? "";
+    return /(?:\b(?:compiler|compilation|current|available)\b[\s\S]{0,120}\b(?:cpu|host|job|budget|resources?)\b|\b(?:cpu|host|job|budget|resources?)\b[\s\S]{0,120}\b(?:compiler|compilation)\b)/i
+      .test(reason);
+  });
+  if (compilerResourceBlocks.length) {
+    issues.push(
+      `Compute-boundary retry: ${compilerResourceBlocks.slice(0, 8).map((claim) => claim.id).join(", ")} use the Research Compiler's CPU host, compilation budget, or inability to run the experiment during compilation as a scientific resource blocker. Compilation and experiment execution are separate allocations. Declare the complete experiment's CPU/GPU requirements and duration so the scheduler can choose GCP Standard or AutoDL; block only after identifying a concrete execution-profile, lifetime, storage, or experiment-budget limit.`,
+    );
+  }
+  const preverifiedPublicAssetBlocks = hasOfficialRepository
+    ? blockedClaims.filter((claim) => {
+        const reason = textValue(claim?.reproduction?.reason) ?? "";
+        return /(?:\b(?:checkpoint|model|dataset|evaluator|training (?:code|script))\b[\s\S]{0,180}\b(?:not bundled|no (?:checkpoint )?bytes|unverified at compil|pre-known digest|not (?:publicly )?(?:available|released|published)|unavailable|missing)|\bpublic\b[\s\S]{0,180}\b(?:unverified at compil|not bundled|missing digest|unavailable)|\b(?:not released|not published|no public)\b[\s\S]{0,120}\b(?:checkpoint|model|dataset|evaluator|code|script))/i
+          .test(reason);
+      })
+    : [];
+  if (preverifiedPublicAssetBlocks.length) {
+    issues.push(
+      `Public-asset preflight retry: ${preverifiedPublicAssetBlocks.slice(0, 8).map((claim) => claim.id).join(", ")} treat missing bundled bytes, a missing pre-known digest, an unavailable author script, or public assets being unverified during compilation as a blocker. Inspect the fixed paper and repository for the exact condition first. For grounded public checkpoints, datasets, and evaluators, declare public_unverified assets and make execution preflight resolve the transport, reject error/authentication content, and record byte size, SHA-256, format, and scientific identity. If author code is absent but the paper specifies a reconstructable protocol, create an isolated citeark_reconstruction experiment instead. Block only when the required scientific input or decision rule itself cannot be recovered, and name that exact blocker.`,
+    );
+  }
+  const incompleteCoverage = context.continuation
+    ? []
+    : (Array.isArray(research?.claims) ? research.claims : []).flatMap((claim) => {
+    if (
+      claim?.reproduction?.status === "not_applicable"
+      || !Array.isArray(claim?.reportedMeasurements)
+      || claim.reportedMeasurements.length === 0
+    ) return [];
+    const coverage = claimCatalogCoverage(
+      claim,
+      Array.isArray(research?.experiments) ? research.experiments : [],
+    );
+    return (coverage.bound.length > 0 || claim.reproduction?.status === "deferred") && coverage.missingIds.length > 0
+      ? [{ claim, coverage }]
+      : [];
+  });
+  if (incompleteCoverage.length) {
+    const details = incompleteCoverage.slice(0, 8).map(({ claim, coverage }) =>
+      `${claim.id} is missing ${coverage.missingIds.join(", ")}`,
+    ).join("; ");
+    const remainder = incompleteCoverage.length > 8
+      ? `; and ${incompleteCoverage.length - 8} more claims`
+      : "";
+    issues.push(
+      `Scientific coverage retry: the draft leaves empirical claim measurements unscheduled (${details}${remainder}). First check each measurement against the exact claim statement and cited source: an unrelated table column is not automatically a separate claim or a required condition of this one; bind its evidence to the scientifically meaningful proposition it tests, using a source-grounded inventory revision when necessary. Then schedule a scientifically coherent experiment for every feasible missing measurement, including claims with zero experiments. Separate experiments when their scientific questions, methods, decision rules or independently selectable routes differ. Preserve dataset, split and seed axes inside coherent method batches; a loop coordinate alone does not require another experiment, step or output object. Do not merge distinct questions merely to satisfy the schema. If a remaining measurement is genuinely impossible to execute, state the concrete hard blocker and leave the partial experiments intact instead of deleting valid work.`,
+    );
+  }
+  if (context.licensePolicy?.executable === false) return issues;
+  // A continuation is a bounded repair campaign over a prior immutable plan.
+  // Preserve honest blocked coverage instead of expanding the campaign into
+  // unrelated claims while repairing the diagnosed failed targets.
+  if (context.continuation) return issues;
+  const partiallyCoveredClaimIds = new Set(incompleteCoverage.filter(({ coverage }) => coverage.bound.length > 0).map(({ claim }) => claim.id));
+  const unresolved = (Array.isArray(research?.claims) ? research.claims : []).filter((claim) =>
+    claim?.type !== "limitation"
+    && (
+      claim?.type === "finding"
+      || claim?.type === "measurement"
+      || (Array.isArray(claim?.reportedMeasurements) && claim.reportedMeasurements.length > 0)
+    )
+    && !(Array.isArray(claim.reproduction?.derivedFromClaimIds)
+      && claim.reproduction.derivedFromClaimIds.length > 0)
+    && claim.reproduction?.status !== "planned"
+    && !partiallyCoveredClaimIds.has(claim.id),
+  );
+  if (!unresolved.length) return issues;
+  const ids = unresolved.slice(0, 8).map((claim) => claim.id).join(", ");
+  const remainder = unresolved.length > 8 ? ` and ${unresolved.length - 8} more` : "";
+  const officialAssetGuidance = hasOfficialRepository
+    ? " The fixed official repository is available. An official public checkpoint, dataset, or evaluator must not be treated as unavailable merely because its bytes were not bundled or its digest was not known at compile time: declare it public_unverified, make preflight fetch it from the paper- or repository-grounded URL, record the resolved URL, byte size, SHA-256, archive/member identity, and format checks in the acquisition manifest, and stop before the expensive phase only if that verification actually fails. Prioritize a direct experiment on the paper's central empirical claim; a static configuration, parameter-count, or formula check is useful secondary evidence but is not a substitute for the headline result when the official public assets appear reachable. If the fixed official snapshot demonstrably omits or breaks the implementation for a report-defining condition, keep runnable official conditions as official experiments and independently reconstruct only the missing condition from the clean CiteArk scaffold with implementationOrigin citeark_reconstruction. Never copy, relabel, or silently repair author code as an independent reconstruction, and disclose every reconstruction assumption and material deviation."
+    : "";
+  issues.push(
+    `Direct-evidence retry: paper-grounded empirical claims remain unscheduled (${ids}${remainder}). Make one more attempt to design an exact, faithful, or honest approximate experiment that directly measures the paper-bound outcome.${officialAssetGuidance} Pin every recoverable material condition and disclose every substitution. Missing author code or an incompletely specified implementation is not by itself a blocker: independently reconstruct the method when the paper gives enough information to define a meaningful test. Proxy experiments remain researcher-selected because they test a substitute rather than the paper-bound measurement. Keep a claim blocked only when a concrete required scientific input, safe decision rule, access right, or feasible execution profile is unavailable; state that exact blocker.`,
+  );
+  return issues;
+}
+
+function assetPathBindingFailures(experiment) {
+  const assets = Array.isArray(experiment?.protocol?.preflight?.assets)
+    ? experiment.protocol.preflight.assets
+    : [];
+  if (!assets.length) return [];
+  const allowed = assets.map((asset) => assetLocalPath(asset?.kind ?? "other", asset?.id ?? "asset"));
+  const texts = [
+    experiment?.protocol?.entrypoint,
+    ...(Array.isArray(experiment?.protocol?.preflight?.checks)
+      ? experiment.protocol.preflight.checks.map((check) => check?.command)
+      : []),
+  ].filter((value) => typeof value === "string");
+  const paths = [...new Set(texts.flatMap((value) =>
+    [...value.matchAll(/\/job\/assets\/[A-Za-z0-9._/-]+/g)].map((match) =>
+      match[0].replace(/[),;'"\]}]+$/, ""),
+    )))];
+  return paths
+    .filter((candidate) => !allowed.some((root) => candidate === root || candidate.startsWith(`${root}/`)))
+    .map((candidate) => ({ experimentId: experiment?.id ?? "unknown", path: candidate }));
+}
+
+export function blockingCompilerReconstructionIssues(issues, {
+  agentPlanned = true,
+} = {}) {
+  const candidates = Array.isArray(issues) ? issues : [];
+  const trustBoundary = /^(?:Continuation-repair boundary|Continuation-target coverage|Reconstruction-origin isolation) retry:/;
+  const quoteBoundary = /^Compute-estimate retry:/;
+  if (agentPlanned) return candidates.filter((issue) =>
+    trustBoundary.test(issue) || quoteBoundary.test(issue));
+
+  // Textual scope, model-label and result-literal heuristics are advisories in
+  // both modes: they cannot establish scientific violations.
+  // Legacy fixed-entrypoint plans cannot repair operational defects while
+  // running. Keep the old compile-time gate only for that compatibility mode.
+  const fixedEntrypointBoundary = /^(?:Official-entrypoint identity|Execution preflight|Entrypoint-executability|Entrypoint-syntax|Asset-path portability|Asset-path binding|Parser-evidence generation|Shell-portability|Corpus-execution|Duration-feasibility|Compute-boundary|Public-asset preflight) retry:/;
+  return candidates.filter((issue) =>
+    trustBoundary.test(issue) || quoteBoundary.test(issue) || fixedEntrypointBoundary.test(issue),
+  );
+}
+
+function inlinePythonSyntaxFailures(experiments) {
+  return experiments.filter((experiment) => {
+    if (experiment?.reconstructionFidelity === "proxy") return false;
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    const match = /^\s*python(?:3(?:\.\d+)?)?\s+-c\s+(["'])([\s\S]*)\1\s*$/i.exec(entrypoint);
+    if (!match) return false;
+    const quote = match[1];
+    const source = quote === '"'
+      ? match[2].replace(/\\(["\\$`\n])/g, "$1")
+      : match[2];
+    const parsed = spawnSync(
+      "python3",
+      [
+        "-c",
+        [
+          "import ast,sys",
+          "pending=[sys.stdin.read()]",
+          "seen=set()",
+          "while pending:",
+          " source=pending.pop()",
+          " if source in seen: continue",
+          " seen.add(source)",
+          " tree=ast.parse(source)",
+          " for node in ast.walk(tree):",
+          "  if isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id=='exec' and node.args and isinstance(node.args[0],ast.Constant) and isinstance(node.args[0].value,str): pending.append(node.args[0].value)",
+        ].join("\n"),
+      ],
+      {
+        input: source,
+        encoding: "utf8",
+        timeout: 5_000,
+        maxBuffer: 64 * 1024,
+      },
+    );
+    return parsed.error || parsed.status !== 0;
+  });
+}
+
+function inlinePythonExecutableSources(entrypoint) {
+  const value = textValue(entrypoint) ?? "";
+  const match = /^\s*python(?:3(?:\.\d+)?)?\s+-c\s+(["'])([\s\S]*)\1\s*$/i.exec(value);
+  if (!match) return [value];
+  const quote = match[1];
+  const source = quote === '"'
+    ? match[2].replace(/\\(["\\$`\n])/g, "$1")
+    : match[2];
+  const parsed = spawnSync(
+    "python3",
+    [
+      "-c",
+      [
+        "import ast,json,sys",
+        "pending=[sys.stdin.read()]",
+        "seen=set()",
+        "sources=[]",
+        "while pending:",
+        " source=pending.pop()",
+        " if source in seen: continue",
+        " seen.add(source)",
+        " sources.append(source)",
+        " try: tree=ast.parse(source)",
+        " except SyntaxError: continue",
+        " for node in ast.walk(tree):",
+        "  if isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id=='exec' and node.args and isinstance(node.args[0],ast.Constant) and isinstance(node.args[0].value,str): pending.append(node.args[0].value)",
+        "print(json.dumps(sources))",
+      ].join("\n"),
+    ],
+    {
+      input: source,
+      encoding: "utf8",
+      timeout: 5_000,
+      maxBuffer: 256 * 1024,
+    },
+  );
+  if (parsed.error || parsed.status !== 0) return [value, source];
+  try {
+    const sources = JSON.parse(parsed.stdout);
+    return [value, ...(Array.isArray(sources) ? sources : [source])];
+  } catch {
+    return [value, source];
+  }
+}
+
+function smokePreflightFailures(experiments) {
+  return experiments.filter((experiment) => {
+    if (!requiresDurationFeasibilityBenchmark(experiment)) return false;
+    const checks = Array.isArray(experiment?.protocol?.preflight?.checks)
+      ? experiment.protocol.preflight.checks
+      : [];
+    const smoke = checks.find((check) => check?.kind === "smoke_test");
+    const command = textValue(smoke?.command) ?? "";
+    if (!command) return true;
+    if (/\bor\s+True\b|\bassert\s+True\b/i.test(command)) return true;
+    return !/(?:\b(?:load_model|encode|decode|infer|evaluate|predict|fit|train|run)\s*\(|\bpython(?:3)?\s+\/job\/workspace\/repository\/[A-Za-z0-9._/-]+\.py\b)/i.test(command);
+  });
+}
+
+function reportedSelectionFailures(experiments, reportedMeasurements) {
+  return experiments.flatMap((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    return (Array.isArray(experiment?.measurements) ? experiment.measurements : []).flatMap((measurement) => {
+      const reported = reportedMeasurements.get(measurement?.reportedMeasurementId);
+      const selection = textValue(reported?.dimensions?.selection);
+      if (!selection) return [];
+      const needsRandom = /(?:random|seed)/i.test(selection);
+      const needsGrouping = /(?:reader|speaker|balanced|stratif)/i.test(selection);
+      if (!needsRandom && !needsGrouping) return [];
+      const usesManifest = /(?:selection|sample|reader|speaker)[-_]?(?:manifest|ids?|list)|manifest[-_]?(?:path|file)/i.test(entrypoint);
+      const implementsRandom = /(?:\brandom\b|manual_seed|default_rng|RandomState|Generator\s*\(|randperm|shuffle|\bseed\s*[=(])/i.test(entrypoint);
+      const implementsGrouping = /(?:reader|speaker|stratif|balance|groupby|group_by|defaultdict)/i.test(entrypoint);
+      if ((needsRandom && !implementsRandom && !usesManifest)
+        || (needsGrouping && !implementsGrouping && !usesManifest)) {
+        return [{
+          experimentId: experiment?.id ?? "unnamed-experiment",
+          selection,
+        }];
+      }
+      return [];
+    });
+  });
+}
+
+function continuationTargetCoverageFailures(experiments, continuation) {
+  const completedTargets = Array.isArray(continuation?.completedTargets)
+    ? continuation.completedTargets
+    : [];
+  const failedTargets = Array.isArray(continuation?.failedTargets)
+    ? continuation.failedTargets
+    : [];
+  return [
+    ...completedTargets.map((target) => ({ target, disposition: "completed" })),
+    ...failedTargets.map((target) => ({ target, disposition: "failed" })),
+    ...(continuation?.requestedTargets ?? []).map((target) => ({ target, disposition: "requested" })),
+  ].filter(({ target }) => {
+    if (!isRecord(target)) return false;
+    const experimentId = textValue(target.experimentId);
+    const claimId = textValue(target.claimId);
+    if (!experimentId && !claimId) return false;
+    if (experimentId) {
+      const experiment = experiments.find((candidate) => candidate?.id === experimentId);
+      return !experiment
+        || (claimId && !experiment.claimIds?.includes(claimId));
+    }
+    return !experiments.some((experiment) =>
+      experiment?.reconstructionFidelity !== "proxy"
+      && experiment?.claimIds?.includes(claimId));
+  }).map(({ target, disposition }) => ({ ...target, disposition }));
+}
+
+function continuationFailedTargetExperiments(experiments, continuation) {
+  const failedIds = new Set(
+    continuationRepairTargets(continuation)
+      .filter(isRecord)
+      .map((target) => textValue(target.experimentId))
+      .filter(Boolean),
+  );
+  return failedIds.size
+    ? experiments.filter((experiment) => failedIds.has(experiment?.id))
+    : experiments;
+}
+
+function corpusScopeCollapsedToSingleExplicitInput(experiment, reportedMeasurements) {
+  if (experiment?.reconstructionFidelity === "proxy") return false;
+  const workloadKeys = /^(?:sample(?:_?count)?|samples|items|clips|utterances|files)$/i;
+  const declaredCounts = (Array.isArray(experiment?.measurements) ? experiment.measurements : [])
+    .flatMap((measurement) => {
+      const reported = reportedMeasurements?.get(measurement?.reportedMeasurementId);
+      return Object.entries(isRecord(reported?.dimensions) ? reported.dimensions : {});
+    })
+    .filter(([key, value]) => workloadKeys.test(key) && Number.isFinite(Number(value)))
+    .map(([, value]) => Number(value));
+  if (Math.max(0, ...declaredCounts) <= 1) return false;
+
+  const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+  const enumeratesInputs = /(?:\brglob\s*\(|\bglob\s*\(|glob\.iglob|os\.walk|listdir\s*\(|scandir\s*\(|\bfind\s+[^\n;&|]*-(?:type|name)|manifest|sample[_-]?(?:ids?|list)|reader[_-]?(?:ids?|list)|speaker[_-]?(?:ids?|list))/i
+    .test(entrypoint);
+  if (enumeratesInputs) return false;
+  const explicitInputs = new Set(
+    [...entrypoint.matchAll(/(?:^|[\s='"(])([^\s'"()]+\.(?:wav|flac|mp3|ogg|m4a))(?:$|[\s'"),;])/gi)]
+      .map((match) => match[1])
+      .filter((inputPath) => !inputPath.startsWith("/job/output/")),
+  );
+  return explicitInputs.size === 1
+    && /(?:--input\b|input[_-]?(?:path|file)?\s*=|load_(?:wav|audio)\s*\(|read\s*\([^)]*\.(?:wav|flac)|soundfile\.read|torchaudio\.load)/i
+      .test(entrypoint);
+}
+
+function requiresDurationFeasibilityBenchmark(experiment) {
+  if (experiment?.reconstructionFidelity === "proxy") return false;
+  const workloadKeys = /^(?:sample(?:_?count)?|samples|items|clips|cycles?|repetitions?|repeats?|runs?|seeds?|epochs?|steps?|iterations?|trials?)$/i;
+  const declaredByDimensions = (Array.isArray(experiment?.measurements) ? experiment.measurements : []).some((measurement) => {
+    const dimensions = isRecord(measurement?.dimensions) ? measurement.dimensions : {};
+    const factors = Object.entries(dimensions)
+      .filter(([key, value]) => workloadKeys.test(key) && Number.isFinite(Number(value)) && Number(value) > 1)
+      .map(([, value]) => Number(value));
+    if (!factors.length) return false;
+    return factors.reduce((product, value) => product * value, 1) >= 1_000;
+  });
+  if (declaredByDimensions) return true;
+
+  const protocol = experiment?.protocol ?? {};
+  const workloadText = [
+    experiment?.title,
+    protocol.entrypoint,
+    protocol.instructions,
+    ...(Array.isArray(experiment?.measurements)
+      ? experiment.measurements.flatMap((measurement) => [measurement?.aggregation])
+      : []),
+  ].map((value) => textValue(value) ?? "").join("\n");
+  const corpusCounts = [
+    ...[...workloadText.matchAll(/\blen\s*\([^)]*\)\s*==\s*([0-9][0-9,_]*)/gi)],
+    ...[...workloadText.matchAll(/\b([0-9][0-9,_]*)\s+(?:distinct\s+|unique\s+|total\s+)?(?:samples?|clips?|items?|utterances?|files?)(?:\b|_)/gi)],
+  ].map((match) => Number(match[1].replaceAll(/[,_]/g, ""))).filter(Number.isFinite);
+  const loopCounts = [
+    ...[...workloadText.matchAll(/\brange\s*\(\s*([0-9][0-9,_]*)\s*\)/gi)],
+    ...[...workloadText.matchAll(/\b([0-9][0-9,_]*)\s+(?:total\s+)?(?:cycles?|repetitions?|repeats?|epochs?|steps?|iterations?|trials?)(?:\b|_)/gi)],
+  ].map((match) => Number(match[1].replaceAll(/[,_]/g, ""))).filter(Number.isFinite);
+  const largestCorpus = Math.max(0, ...corpusCounts);
+  const largestLoop = Math.max(1, ...loopCounts);
+  return largestCorpus >= 1_000 || largestCorpus * largestLoop >= 1_000;
+}
+
+function hasDurationFeasibilityCheck(experiment) {
+  const checks = Array.isArray(experiment?.protocol?.preflight?.checks)
+    ? experiment.protocol.preflight.checks
+    : [];
+  const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+  return checks.some((check) => {
+    if (check?.kind !== "duration") return false;
+    const command = textValue(check.command) ?? "";
+    const criterion = textValue(check.successCriterion) ?? "";
+    if (experiment?.protocol?.executionMode === "agent_planned") {
+      return /(?:representative|throughput|workload|slice|sample|代表性|吞吐|工作量|切片|样本)/i.test(criterion)
+        && /(?:extrapolat|complete|full|total|budget|timeout|reserve|完整|总时限|预算|预留)/i.test(criterion);
+    }
+    const measuresElapsedTime = /(?:perf_counter|monotonic|process_time|date\s+\+%s|\/usr\/bin\/time|\btime\s+-p\b)/i.test(command);
+    const executesRepresentativeWork = /(?:\bbenchmark\s*\(|\b(?:encode|decode|infer|evaluate|predict|fit|train|run)\s*\()/i.test(command);
+    const enforcesForecast = /(?:\bassert\b|sys\.exit\s*\(|\braise\b|\bexit\s+[1-9]\b|\btest\b[^\n;&|]*(?:-lt|-le)\b)/i.test(command);
+    const usesSameModelLoader = !/\bload_model\s*\(/i.test(entrypoint)
+      || /\bload_model\s*\(/i.test(command);
+    const usesSameInputLoader = !/\bload_wav\s*\(/i.test(entrypoint)
+      || /\bload_wav\s*\(/i.test(command);
+    const usesRepresentativeCorpusInput = !/(?:\brglob\s*\(|\/job\/assets\/)/i.test(entrypoint)
+      || (/(?:\brglob\s*\(|\/job\/assets\/)/i.test(command)
+        && !(/\btorch\.(?:randn|rand|zeros|ones)\s*\(/i.test(command)
+          && !/\bload_wav\s*\(/i.test(command)));
+    return measuresElapsedTime
+      && executesRepresentativeWork
+      && enforcesForecast
+      && usesSameModelLoader
+      && usesSameInputLoader
+      && usesRepresentativeCorpusInput
+      && /(?:extrapolat|complete|full|total|budget|timeout|reserve|完整|总时限|预算|预留)/i.test(criterion);
+  });
+}
+
+function missingRunnableDurationEstimate(experiment) {
+  if (experiment?.reconstructionFidelity === "proxy") return [];
+  const experimentId = experiment?.id ?? "unnamed-experiment";
+  const compute = experiment?.compute;
+  if (!isRecord(compute)) {
+    return [{
+      experimentId,
+      missing: ["declared compute requirement and duration estimate"],
+    }];
+  }
+  const eligible = compute.accelerator === "none"
+    ? ["cpu"]
+    : compute.accelerator === "required"
+      ? ["gpu"]
+      : compute.accelerator === "optional"
+        ? compute.cpuFallbackAllowed === false
+          ? ["gpu"]
+          : ["cpu", "gpu"]
+        : ["cpu", "gpu"];
+  const missing = eligible.filter((accelerator) => {
+    const minutes = compute?.estimatedDurationMinutes?.[accelerator];
+    return typeof minutes !== "number" || !Number.isFinite(minutes) || minutes <= 0;
+  });
+  return missing.length
+    ? [{
+        experimentId,
+        missing: missing.map((accelerator) => `compute.estimatedDurationMinutes.${accelerator}`),
+      }]
+    : [];
+}
+
+function compilerExecutionEnvironment(value, {
+  compute,
+  experimentId,
+  reconstructionFidelity,
+  warnings,
+}) {
+  const environment = isRecord(value) ? { ...value } : {};
+  const proposed = Number(environment.timeoutMinutes);
+  const capMinutes = executionTimeoutCapMinutes(reconstructionFidelity);
+  const estimates = schedulerEligibleDurationEstimates({ compute });
+  const longestEstimate = estimates.length ? Math.max(...estimates) : null;
+  const reserveMinutes = longestEstimate === null
+    ? null
+    : Math.max(30, Math.min(360, Math.ceil(longestEstimate * 0.25)));
+  const requiredTimeout = longestEstimate === null ? 60 : longestEstimate + reserveMinutes;
+  const fallback = Math.min(capMinutes, requiredTimeout);
+  const normalized = Number.isFinite(proposed) && proposed > 0
+    ? Math.min(capMinutes, Math.max(fallback, proposed))
+    : fallback;
+  if (normalized !== proposed) {
+    const reason = !Number.isFinite(proposed) || proposed <= 0
+      ? "was missing or invalid"
+      : proposed > capMinutes
+        ? `exceeded the ${capMinutes}-minute fidelity cap`
+        : `did not include the ${reserveMinutes}-minute anomaly reserve`;
+    warnings.push(`Experiment ${experimentId} environment.timeoutMinutes ${reason} and was normalized to ${normalized}.`);
+  }
+  return { ...environment, timeoutMinutes: normalized };
+}
+
+function runnableExecutionTimeoutIssues(experiment) {
+  if (experiment?.reconstructionFidelity === "proxy") return [];
+  const experimentId = textValue(experiment?.id) ?? "unknown-experiment";
+  const timeoutMinutes = Number(experiment?.environment?.timeoutMinutes);
+  const fidelity = experiment?.reconstructionFidelity
+    ?? (experiment?.implementationOrigin === "citeark_reconstruction" ? "approximate" : "faithful");
+  const capMinutes = executionTimeoutCapMinutes(fidelity);
+  if (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0) {
+    return [{ experimentId, reason: "environment.timeoutMinutes is missing or invalid" }];
+  }
+  if (timeoutMinutes > capMinutes) {
+    return [{
+      experimentId,
+      reason: `environment.timeoutMinutes ${timeoutMinutes} exceeds the ${capMinutes}-minute ${fidelity} circuit-breaker cap`,
+    }];
+  }
+  const estimates = schedulerEligibleDurationEstimates(experiment);
+  if (!estimates.length) return [];
+  const longestEstimate = Math.max(...estimates);
+  const reserveMinutes = Math.max(30, Math.min(360, Math.ceil(longestEstimate * 0.25)));
+  const requiredTimeout = longestEstimate + reserveMinutes;
+  if (timeoutMinutes < requiredTimeout) {
+    return [{
+      experimentId,
+      reason: `environment.timeoutMinutes ${timeoutMinutes} must be at least ${requiredTimeout} for the ${longestEstimate}-minute estimate and ${reserveMinutes}-minute reserve`,
+    }];
+  }
+  return [];
+}
+
+function schedulerEligibleDurationEstimates(experiment) {
+  const compute = experiment?.compute;
+  if (!isRecord(compute)) return [];
+  const eligible = compute.accelerator === "none"
+    ? ["cpu"]
+    : compute.accelerator === "required"
+      ? ["gpu"]
+      : compute.accelerator === "optional"
+        ? compute.cpuFallbackAllowed === false
+          ? ["gpu"]
+          : ["cpu", "gpu"]
+        : ["cpu", "gpu"];
+  return eligible
+    .map((accelerator) => Number(compute?.estimatedDurationMinutes?.[accelerator]))
+    .filter((minutes) => Number.isFinite(minutes) && minutes > 0);
+}
+
+function entrypointForcesCpuWhileDeclaringGpu(experiment) {
+  const compute = experiment?.compute ?? {};
+  const declaresGpu = Number(compute.gpuCount ?? 0) > 0
+    || compute.accelerator === "required"
+    || (Array.isArray(compute.preferredGpuTypes) && compute.preferredGpuTypes.length > 0)
+    || Number.isFinite(Number(compute?.estimatedDurationMinutes?.gpu));
+  if (!declaresGpu) return false;
+  const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+  return /(?:torch\.device\s*\(\s*["']cpu["']\s*\)|device\s*=\s*["']cpu["']|--device(?:=|\s+)cpu\b|\.to\s*\(\s*["']cpu["']\s*\))/i.test(entrypoint);
+}
+
+function largeWorkloadNeedsDeclaredAccelerator(experiment) {
+  if (!requiresDurationFeasibilityBenchmark(experiment)) return false;
+  const compute = experiment?.compute ?? {};
+  if (compute.accelerator === "required" || compute.cpuFallbackAllowed === false) return false;
+  if (Number(compute.gpuCount ?? 0) < 1) return false;
+  const cpuMinutes = Number(compute?.estimatedDurationMinutes?.cpu);
+  const gpuMinutes = Number(compute?.estimatedDurationMinutes?.gpu);
+  return Number.isFinite(cpuMinutes)
+    && Number.isFinite(gpuMinutes)
+    && gpuMinutes > 0
+    && cpuMinutes / gpuMinutes >= 1.5;
+}
+
+function repeatedCycleCountFailures(experiments) {
+  return experiments.flatMap((experiment) => {
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    if (!/(?:encode\s*\([^;\n]{0,160}decode\s*\(|decode\s*\([^;\n]{0,160}encode\s*\()/i.test(entrypoint)) return [];
+    const scopeText = [
+      experiment?.title,
+      experiment?.protocol?.instructions,
+      ...(Array.isArray(experiment?.measurements)
+        ? experiment.measurements.flatMap((measurement) => [measurement?.aggregation])
+        : []),
+    ].map((value) => textValue(value) ?? "").join("\n");
+    const declaredCycles = [...scopeText.matchAll(/(?:after\s+(?:cycle\s*)?|\b)([0-9][0-9,_]*)\s*(?:total\s+)?cycles?\b/gi)]
+      .map((match) => Number(match[1].replaceAll(/[,_]/g, "")))
+      .filter(Number.isFinite);
+    if (!declaredCycles.length) return [];
+    const expected = Math.max(...declaredCycles);
+    const loopCycles = [...entrypoint.matchAll(/\brange\s*\(\s*([0-9][0-9,_]*)\s*\)/gi)]
+      .map((match) => Number(match[1].replaceAll(/[,_]/g, "")))
+      .filter(Number.isFinite);
+    const offByOne = loopCycles.find((value) => value === expected - 1);
+    return Number.isFinite(offByOne)
+      ? [{
+          experimentId: experiment?.id ?? "unnamed-experiment",
+          declaredCycles: expected,
+          loopCycles: offByOne,
+        }]
+      : [];
+  });
+}
+
+function repeatedCycleFinalComparisonFailures(experiments, reportedMeasurements) {
+  return experiments.flatMap((experiment) => {
+    const bindings = Array.isArray(experiment?.measurements) ? experiment.measurements : [];
+    const finalCycleMeasurements = bindings.flatMap((measurement) => {
+      const reported = reportedMeasurements.get(measurement?.reportedMeasurementId);
+      const cycles = Number(reported?.dimensions?.cycles);
+      const comparison = textValue(reported?.dimensions?.comparison) ?? "";
+      return Number.isInteger(cycles) && cycles > 1 && /(?:first encoding|initial|baseline)/i.test(comparison)
+        ? [{ cycles }]
+        : [];
+    });
+    if (!finalCycleMeasurements.length) return [];
+    const sources = inlinePythonExecutableSources(experiment?.protocol?.entrypoint);
+    return finalCycleMeasurements.flatMap(({ cycles }) => {
+      const cycleLoop = new RegExp(`\\bfor\\s+[A-Za-z_][A-Za-z0-9_]*\\s+in\\s+range\\s*\\(\\s*${cycles}\\s*\\)\\s*:[\\s\\S]+`, "i");
+      const invalid = sources.some((source) => {
+        const loop = source.match(cycleLoop)?.[0] ?? "";
+        if (!loop) return false;
+        const baselineInsideLoop = /\bif\s+[A-Za-z_][A-Za-z0-9_]*\s+is\s+None\s*:[^\n;]*\b[A-Za-z_][A-Za-z0-9_]*\s*=/i.test(loop);
+        const aggregatesIntermediateComparisons = /\b(?:matched|matches|agreement|equal_count|total)\s*\+=/i.test(loop)
+          && /\b(?:matched|matches|agreement|equal_count)\s*\/\s*(?:total|cycles|count)\b/i.test(source);
+        return baselineInsideLoop || aggregatesIntermediateComparisons;
+      });
+      return invalid
+        ? [{ experimentId: experiment?.id ?? "unnamed-experiment", cycles }]
+        : [];
+    });
+  });
+}
+
+function siSnrFormulaFailures(experiments) {
+  return experiments.filter((experiment) => {
+    const usesSiSnr = (Array.isArray(experiment?.measurements)
+      ? experiment.measurements
+      : []).some((measurement) => /^(?:si[_ -]?snr|scale[_ -]?invariant[_ -]?(?:snr|signal[_ -]?noise[_ -]?ratio))$/i
+        .test(textValue(measurement?.metric) ?? ""));
+    if (!usesSiSnr) return false;
+    const sources = inlinePythonExecutableSources(experiment?.protocol?.entrypoint);
+    if (sources.some((source) =>
+      /\b(?:[A-Za-z_][A-Za-z0-9_]*_)?(?:si_snr|sisnr|scale_invariant_signal_noise_ratio)\s*\(/i.test(source))) return false;
+    const decodedSources = sources.flatMap((source) => {
+      const decoded = source.match(/\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*[^;\n]{0,200}?\.decode\s*\(\s*[^;\n]*?\.encode\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/i);
+      return decoded ? [{ source, decoded }] : [];
+    });
+    if (!decodedSources.length) return false;
+    return !decodedSources.some(({ source, decoded }) => {
+      const [, estimate, reference] = decoded;
+      const crossProduct = new RegExp(`(?:\\b${escapeRegExp(estimate)}\\s*\\*\\s*${escapeRegExp(reference)}\\b|\\b${escapeRegExp(reference)}\\s*\\*\\s*${escapeRegExp(estimate)}\\b)`);
+      return crossProduct.test(source);
+    });
+  });
+}
+
+function siSnrInvariantPreflightFailures(experiments) {
+  return experiments.filter((experiment) => {
+    const usesSiSnr = (Array.isArray(experiment?.measurements)
+      ? experiment.measurements
+      : []).some((measurement) => /^(?:si[_ -]?snr|scale[_ -]?invariant[_ -]?(?:snr|signal[_ -]?noise[_ -]?ratio))$/i
+        .test(textValue(measurement?.metric) ?? ""));
+    if (!usesSiSnr) return false;
+    const checks = Array.isArray(experiment?.protocol?.preflight?.checks)
+      ? experiment.protocol.preflight.checks
+      : [];
+    const smoke = checks.find((check) => check?.kind === "smoke_test");
+    const sources = inlinePythonExecutableSources(smoke?.command);
+    const entrypointSources = inlinePythonExecutableSources(experiment?.protocol?.entrypoint);
+    const hasNonUnitScale = sources.some((source) => {
+      const scaledAssignments = [...source.matchAll(
+        /\b(?:[A-Za-z_][A-Za-z0-9_]*_)?(?:scaled_(?:estimate|est)|(?:estimate|est)_scaled)\s*=\s*([^;\n]+)/gi,
+      )];
+      return scaledAssignments.some(([, expression]) => {
+        const factors = [
+          ...expression.matchAll(/(?:^|[^A-Za-z0-9_.])([+-]?(?:\d+(?:\.\d*)?|\.\d+))\s*\*\s*(?:[A-Za-z_]|\()/g),
+          ...expression.matchAll(/(?:[A-Za-z_][A-Za-z0-9_]*|\))\s*\*\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))(?![A-Za-z0-9_.])/g),
+        ].map((match) => Number(match[1]));
+        return factors.some((factor) =>
+          Number.isFinite(factor)
+          && Math.abs(factor) > 1e-12
+          && Math.abs(Math.abs(factor) - 1) > 1e-12);
+      });
+    });
+    const hasToleranceAssertion = sources.some((source) =>
+      /\b(?:allclose|isclose)\s*\(|\bassert\b[^\n;]*(?:abs\s*\(|<\s*1e-|<=\s*1e-)/i.test(source));
+    const evaluatorNames = new Set(entrypointSources.flatMap((source) =>
+      [...source.matchAll(/\b((?:[A-Za-z_][A-Za-z0-9_]*_)?(?:si_snr|sisnr|scale_invariant_signal_noise_ratio))\s*\(/gi)]
+        .map((match) => match[1].toLowerCase())));
+    const reusesEvaluatorTwice = [...evaluatorNames].some((name) => {
+      const calls = sources.reduce((total, source) =>
+        total + [...source.matchAll(new RegExp(`\\b${escapeRegExp(name)}\\s*\\(`, "gi"))].length
+        - [...source.matchAll(new RegExp(`\\bdef\\s+${escapeRegExp(name)}\\s*\\(`, "gi"))].length,
+      0);
+      return calls >= 2;
+    });
+    const namesScaledEstimate = sources.some((source) =>
+      /\b(?:[A-Za-z_][A-Za-z0-9_]*_)?(?:scaled_(?:estimate|est)|(?:estimate|est)_scaled)\s*=/i.test(source));
+    const obviousDegeneratePair = sources.some((source) =>
+      /\b(?:estimate|est)\s*=\s*(?:reference|ref)\s*\*\s*[0-9.]+\b/i.test(source)
+      && !/(?:\bnoise\b|\bperturb|torch\.tensor\s*\()/i.test(source));
+    return !hasNonUnitScale
+      || !hasToleranceAssertion
+      || !reusesEvaluatorTwice
+      || !namesScaledEstimate
+      || obviousDegeneratePair;
+  });
+}
+
+function siSnrEntrypointInvariantFixtureFailures(experiments) {
+  return experiments.filter((experiment) => {
+    const usesSiSnr = (Array.isArray(experiment?.measurements)
+      ? experiment.measurements
+      : []).some((measurement) => /^(?:si[_ -]?snr|scale[_ -]?invariant[_ -]?(?:snr|signal[_ -]?noise[_ -]?ratio))$/i
+        .test(textValue(measurement?.metric) ?? ""));
+    if (!usesSiSnr) return false;
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    const fragments = Array.isArray(experiment?.protocol?.requiredCommandFragments)
+      ? experiment.protocol.requiredCommandFragments.map((fragment) => textValue(fragment) ?? "")
+      : [];
+    const namesScaledEstimate = /\b(?:[A-Za-z_][A-Za-z0-9_]*_)?(?:scaled_(?:estimate|est)|(?:estimate|est)_scaled)\b/i;
+    const embedsAnalyticalAssertion = namesScaledEstimate.test(entrypoint)
+      && /\b(?:allclose|isclose)\s*\(|\bassert\b[^\n;]*(?:abs\s*\(|<\s*1e-|<=\s*1e-)/i.test(entrypoint);
+    return embedsAnalyticalAssertion || fragments.some((fragment) => namesScaledEstimate.test(fragment));
+  });
+}
+
+export function compilerReconstructionIssueFamily(issue) {
+  const value = typeof issue === "string" ? issue.trim() : "";
+  const separator = value.indexOf(":");
+  return separator >= 0 ? value.slice(0, separator) : value;
+}
+
+export function novelCompilerReconstructionIssues(issues, seenFamilies = new Set()) {
+  return (Array.isArray(issues) ? issues : []).filter((issue) =>
+    !seenFamilies.has(compilerReconstructionIssueFamily(issue)),
+  );
+}
+
+function officialEntrypointIdentityFailures(experiments, context) {
+  if (!Array.isArray(context?.repositoryFiles)) return [];
+  const repositoryFiles = new Set(
+    context.repositoryFiles
+      .map(normalizeRepositoryPath)
+      .filter(Boolean),
+  );
+  if (!repositoryFiles.size) return [];
+  const filesByBasename = new Map();
+  for (const file of repositoryFiles) {
+    const basename = path.posix.basename(file);
+    const matches = filesByBasename.get(basename) ?? [];
+    matches.push(file);
+    filesByBasename.set(basename, matches);
+  }
+  return experiments.flatMap((experiment) => {
+    if (experiment?.implementationOrigin !== "official") return [];
+    const references = officialContractScriptReferences(experiment);
+    if (!references.length) return [];
+    const missing = references.filter((reference) => {
+      const logical = normalizeRepositoryPath(reference);
+      if (!logical) return true;
+      if (repositoryFiles.has(logical)) return false;
+      if (logical.includes("/")) return true;
+      return (filesByBasename.get(logical) ?? []).length !== 1;
+    });
+    return missing.length
+      ? [{ experimentId: experiment.id ?? "unnamed-experiment", references: missing }]
+      : [];
+  });
+}
+
+function officialContractScriptReferences(experiment) {
+  const protocol = experiment?.protocol ?? {};
+  const commandSources = [
+    protocol.entrypoint,
+    ...(Array.isArray(protocol.requiredCommandFragments)
+      ? protocol.requiredCommandFragments
+      : []),
+    ...(Array.isArray(protocol.preflight?.checks)
+      ? protocol.preflight.checks.map((check) => check?.command)
+      : []),
+  ];
+  return [...new Set(commandSources.flatMap(entrypointScriptReferences))];
+}
+
+function officialCliInterfaceFailures(experiments) {
+  return experiments.flatMap((experiment) => {
+    if (experiment?.implementationOrigin !== "official") return [];
+    const entrypoint = textValue(experiment?.protocol?.entrypoint) ?? "";
+    const invocations = pythonRepositoryScriptInvocations(entrypoint);
+    if (!invocations.length) return [];
+    const entrypointChecks = (Array.isArray(experiment?.protocol?.preflight?.checks)
+      ? experiment.protocol.preflight.checks
+      : []).filter((check) => check?.kind === "entrypoint");
+    return invocations.flatMap(({ script, options }) => {
+      if (!options.length) return [];
+      const verified = entrypointChecks.some((check) => {
+        const command = textValue(check?.command) ?? "";
+        return command.includes(script)
+          && /(?:^|\s)--help(?:\s|$)/.test(command)
+          && options.every((option) => command.includes(option));
+      });
+      return verified
+        ? []
+        : [{ experimentId: experiment.id ?? "unnamed-experiment", script, options }];
+    });
+  });
+}
+
+function pythonRepositoryScriptInvocations(command) {
+  const value = textValue(command);
+  if (!value) return [];
+  const pattern = /(?:^|[;&|]\s*)python(?:3(?:\.\d+)?)?\s+(\/job\/workspace\/repository\/[A-Za-z0-9._/-]+\.py)\b([^;&|]*)/gi;
+  return [...value.matchAll(pattern)].map((match) => ({
+    script: match[1],
+    options: [...new Set([...match[2].matchAll(/(?:^|\s)(--[A-Za-z0-9][A-Za-z0-9_-]*)\b/g)]
+      .map((option) => option[1]))],
+  }));
+}
+
+function experimentUsesUnavailableDataRoot(experiment) {
+  const protocol = experiment?.protocol ?? {};
+  const commands = [
+    protocol.entrypoint,
+    ...(Array.isArray(protocol.preflight?.checks)
+      ? protocol.preflight.checks.map((check) => check?.command)
+      : []),
+  ];
+  return commands.some((command) => /(?:^|[\s"'=:(])\/data(?:\/|\b)/.test(textValue(command) ?? ""));
+}
+
+function parserPreflightFixtureFailures(experiments, reportedMeasurements) {
+  return experiments.flatMap((experiment) => {
+    const checks = (Array.isArray(experiment?.protocol?.preflight?.checks)
+      ? experiment.protocol.preflight.checks
+      : []).filter((check) => check?.kind === "parser" && textValue(check?.command));
+    if (!checks.length) return [];
+    const reasons = new Set();
+    for (const check of checks) {
+      const command = textValue(check.command) ?? "";
+      const mentionsFixture = /(?:fixture|parser[-_]?sample)/i.test(command);
+      const createsFixture = /(?:write_text|write_bytes|json\.dump\s*\(|open\s*\([^)]*,\s*["']w|(?:printf|echo)\b[^;&|]*(?:>|tee\b))/i
+        .test(command);
+      if (mentionsFixture && !createsFixture) reasons.add("reads a fixture it never creates");
+      const bindings = (Array.isArray(experiment?.measurements)
+        ? experiment.measurements
+        : []).map((measurement) => ({
+          measurement,
+          reported: reportedMeasurements.get(measurement?.reportedMeasurementId),
+        }));
+      if (parserPreflightTargetLeaks(command, bindings).length) {
+        reasons.add("embeds the paper-reported target in a blind parser check");
+      }
+    }
+    return reasons.size
+      ? [{ experimentId: experiment.id ?? "unnamed-experiment", reasons: [...reasons] }]
+      : [];
+  });
+}
+
+function reconstructionOriginIsolationFailures(experiments, context) {
+  if (!Array.isArray(context?.repositoryFiles)) return [];
+  const repositoryFiles = new Set(
+    context.repositoryFiles
+      .map(normalizeRepositoryPath)
+      .filter(Boolean),
+  );
+  if (!repositoryFiles.size) return [];
+  const filesByBasename = new Map();
+  for (const file of repositoryFiles) {
+    const basename = path.posix.basename(file);
+    const matches = filesByBasename.get(basename) ?? [];
+    matches.push(file);
+    filesByBasename.set(basename, matches);
+  }
+  return experiments.flatMap((experiment) => {
+    if (experiment?.implementationOrigin !== "citeark_reconstruction") return [];
+    const protocol = experiment?.protocol ?? {};
+    const references = [...new Set([
+      protocol.entrypoint,
+      protocol.instructions,
+      ...(Array.isArray(protocol.requiredCommandFragments)
+        ? protocol.requiredCommandFragments
+        : []),
+      ...(Array.isArray(protocol.preflight?.checks)
+        ? protocol.preflight.checks.flatMap((check) => [check?.command, check?.successCriterion])
+        : []),
+    ].flatMap(entrypointScriptReferences))];
+    const leaked = references.filter((reference) => {
+      const logical = normalizeRepositoryPath(reference);
+      if (logical && repositoryFiles.has(logical)) return true;
+      const basename = path.posix.basename(reference.replaceAll("\\", "/"));
+      return (filesByBasename.get(basename) ?? []).length === 1;
+    });
+    return leaked.length
+      ? [{ experimentId: experiment.id ?? "unnamed-experiment", references: leaked }]
+      : [];
+  });
+}
+
+function entrypointScriptReferences(value) {
+  const command = textValue(value);
+  if (!command) return [];
+  const scriptPattern = /\/job\/workspace\/repository\/[A-Za-z0-9._/-]+\.(?:py|sh|js|mjs|cjs|rb|pl|jl|r)\b|(?:\.{1,2}\/)?[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*\.(?:py|sh|js|mjs|cjs|rb|pl|jl|r)\b/gi;
+  return [...new Set([...command.matchAll(scriptPattern)].map((match) => match[0]))];
+}
+
+function normalizeRepositoryPath(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  let normalized = value.trim().replaceAll("\\", "/");
+  const repositoryPrefix = "/job/workspace/repository/";
+  if (normalized.startsWith(repositoryPrefix)) normalized = normalized.slice(repositoryPrefix.length);
+  else if (normalized.startsWith("/")) return null;
+  normalized = path.posix.normalize(normalized);
+  if (normalized.startsWith("./")) normalized = normalized.slice(2);
+  if (
+    normalized === "."
+    || normalized === ".."
+    || normalized.startsWith("../")
+    || normalized.includes("\0")
+  ) return null;
+  return normalized;
+}
+
+function experimentReportedModelVariants(research, experiment) {
+  const boundMeasurementIds = new Set(
+    (Array.isArray(experiment?.measurements) ? experiment.measurements : [])
+      .map((measurement) => measurement?.reportedMeasurementId)
+      .filter(Boolean),
+  );
+  const variants = new Set();
+  for (const claim of (Array.isArray(research?.claims) ? research.claims : [])) {
+    for (const measurement of (Array.isArray(claim?.reportedMeasurements) ? claim.reportedMeasurements : [])) {
+      if (!boundMeasurementIds.has(measurement?.id)) continue;
+      const variant = textValue(measurement?.dimensions?.model_variant);
+      if (variant) variants.add(variant);
+    }
+  }
+  return [...variants];
+}
+
+function explicitlyDisclaimsReportedScope(experiment) {
+  const description = [experiment?.title, experiment?.protocol?.instructions]
+    .map(textValue)
+    .filter(Boolean)
+    .join(" ");
+  const statements = description.replace(
+    /\bnot\s+(?:(?:a|the)\s+)?(?:(?:reduced|mere|only)\s+)?(?:smoke|plumbing)(?:[- ]shaped)?\s+(?:evaluation|experiment|input|check|orchestration|command)\b/gi,
+    "",
+  );
+  return /\b(?:smoke|plumbing)(?:[- ]shaped)? (?:evaluation|experiment|input|check|orchestration|command)\b/i.test(statements)
+    || /\bnot equivalent to (?:the )?paper(?:'s)?\b/i.test(description)
+    || /\bnot (?:the )?paper(?:'s)?(?: (?:full|reported|report-defining))? (?:evaluation|experiment|protocol|scope)\b/i.test(description)
+    || /\bdo not promote .{0,120}\b(?:scope|measurement|metric)\b/i.test(description)
+    || /\b(?:entrypoint|command).{0,120}\b(?:example|placeholder)\b/i.test(description)
+    || /\bmust be replaced by (?:the )?execution agent\b/i.test(description);
+}
+
+function entrypointEmbedsReportedValue(entrypointValue, measurement, reported) {
+  const entrypoint = textValue(entrypointValue);
+  const metric = textValue(measurement?.metric) ?? textValue(reported?.metric);
+  if (!entrypoint || !metric || typeof reported?.value !== "number" || !Number.isFinite(reported.value)) {
+    return false;
+  }
+  const candidates = [reported.value];
+  const scale = Number(measurement?.parser?.config?.scale ?? 1);
+  const offset = Number(measurement?.parser?.config?.offset ?? 0);
+  if (Number.isFinite(scale) && scale !== 0 && Number.isFinite(offset)) {
+    candidates.push((reported.value - offset) / scale);
+  }
+  const key = escapeRegExp(metric);
+  return [...new Set(candidates.filter(Number.isFinite))].some((value) => {
+    const literal = numericLiteralPattern(value);
+    const match = new RegExp(
+      `["']?${key}["']?\\s*[:=]\\s*${literal}(?![0-9.])`,
+      "i",
+    ).exec(entrypoint);
+    if (!match) return false;
+    const suffix = entrypoint.slice(match.index + match[0].length);
+    if (/^[ \t]*[*/+%-]/.test(suffix)) return false;
+    if (runtimeConditionalLiteral(suffix, value)) return false;
+    return true;
+  });
+}
+
+function entrypointIsProsePlaceholder(entrypointValue) {
+  const entrypoint = textValue(entrypointValue);
+  if (!entrypoint) return false;
+  const explicitPlaceholder = /\b(?:todo|placeholder|replace (?:this|me)|execution agent (?:must|should|will) (?:implement|replace|write))\b/i
+    .test(entrypoint);
+  if (explicitPlaceholder) return true;
+
+  const pythonInline = /\bpython(?:3)?\s+-c\s+(["'])([\s\S]*)\1\s*$/i.exec(entrypoint);
+  if (pythonInline) {
+    const code = pythonInline[2];
+    const calls = [...code.matchAll(/(?:^|[^.A-Za-z0-9_])([A-Za-z_][A-Za-z0-9_]*)\s*\(/g)]
+      .map((match) => match[1].toLowerCase());
+    const meaningfulCalls = calls.filter((name) => !new Set(["print"]).has(name));
+    return meaningfulCalls.length === 0
+      && /\b(?:execute|evaluate|run|write|create|generate|compute)\b[\s\S]{0,240}\b(?:driver|model|dataset|corpus|files?|clips?|cycles?|evidence|output|json|metric|aggregate|evaluation)\b/i
+        .test(code);
+  }
+
+  return /^\s*(?:echo|printf)\b[\s\S]*\b(?:execute|evaluate|run|write|create|generate|compute)\b[\s\S]{0,240}\b(?:driver|model|dataset|corpus|files?|clips?|cycles?|evidence|output|json|metric|aggregate|evaluation)\b/i
+    .test(entrypoint);
+}
+
+function simpleEntrypointReference(entrypoint) {
+  return isSimpleScriptEntrypoint(entrypoint);
+}
+
+function runtimeConditionalLiteral(suffix, reportedValue) {
+  const conditional = /^[ \t]+if[ \t]+(?!true\b|false\b|none\b)([^\n;]{1,160}?)[ \t]+else[ \t]+([+-]?(?:\d+(?:\.\d*)?|\.\d+))/i
+    .exec(suffix);
+  if (!conditional) return false;
+  const condition = conditional[1].trim();
+  const alternative = Number(conditional[2]);
+  return /[A-Za-z_]/.test(condition)
+    && Number.isFinite(alternative)
+    && alternative !== reportedValue;
+}
+
+function numericLiteralPattern(value) {
+  if (Number.isInteger(value)) return `${escapeRegExp(String(value))}(?:\\.0+)?`;
+  return escapeRegExp(String(value));
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function compilerWork(value, context, warnings) {
+  const work = isRecord(value) ? { ...value } : {};
+  if (!isRecord(value)) warnings.push("Missing work object was reconstructed from compiler inputs.");
+  const fallbackTitle = textValue(context.paperTitle) ?? textValue(context.taskName) ?? "Untitled research work";
+  const title = textValue(work.title) ?? fallbackTitle;
+  if (!textValue(work.title)) warnings.push("Missing work.title was filled from compiler inputs.");
+  const id = textValue(work.id) ?? `work-${sha256Value({ title }).slice(0, 16)}`;
+  if (!textValue(work.id)) warnings.push("Missing work.id was deterministically derived from the title.");
+  const abstract = textValue(work.abstract)
+    ?? "The compiler did not provide an abstract; consult the fixed paper source for the canonical abstract.";
+  if (!textValue(work.abstract)) warnings.push("Missing work.abstract was replaced by an explicit source-reference placeholder.");
+  const significance = textValue(work.significance);
+  if (!significance) {
+    throw new CiteArkError("work.significance 必须解释论文意味着什么、谁可能受益以及价值边界");
+  }
+  const authors = Array.isArray(work.authors)
+    ? work.authors.map(textValue).filter(Boolean).slice(0, 500)
+    : [];
+  if (!Array.isArray(work.authors)) warnings.push("Missing or invalid work.authors was normalized to an empty array.");
+  const subjects = Array.isArray(work.subjects)
+    ? [...new Set(work.subjects.filter((subject) => SUBJECT_TAGS.has(subject)))]
+    : [];
+  if (Array.isArray(work.subjects) && subjects.length !== work.subjects.length) {
+    warnings.push("Unknown subject tags were omitted instead of failing compilation.");
+  }
+  return { ...work, id, title, abstract, significance, authors, subjects };
+}
+
+function compilerSources(value, context, warnings) {
+  const sources = [];
+  const usedIds = new Set();
+  for (const [index, candidate] of (Array.isArray(value) ? value : []).entries()) {
+    if (!isRecord(candidate) || !SOURCE_KINDS.has(candidate.kind) || !textValue(candidate.uri)) {
+      warnings.push(`Invalid sources[${index}] was omitted.`);
+      continue;
+    }
+    if (candidate.kind === "repository") {
+      warnings.push(`sources[${index}] repository identity was replaced by the platform trust boundary.`);
+      continue;
+    }
+    const baseId = textValue(candidate.id) ?? `source-${candidate.kind}-${index + 1}`;
+    const id = uniqueCompilerId(baseId, usedIds);
+    if (id !== candidate.id) warnings.push(`sources[${index}].id was missing or duplicated and was normalized to ${id}.`);
+    usedIds.add(id);
+    sources.push({ ...candidate, id, uri: candidate.uri.trim() });
+  }
+  if (!sources.some((source) => source.kind === "paper")) {
+    const uri = textValue(context.paperUri)
+      ?? (textValue(context.paperDigest) ? `citeark://paper/${context.paperDigest}` : "citeark://paper/fixed-input");
+    const id = uniqueCompilerId("paper", usedIds);
+    usedIds.add(id);
+    sources.unshift({ id, kind: "paper", uri, ...(context.paperDigest ? { digest: context.paperDigest } : {}) });
+    warnings.push("Missing paper source was reconstructed from the fixed compiler input.");
+  }
+  const repositoryUrl = textValue(context.repositoryIdentity?.url);
+  const repositoryCommit = textValue(context.repositoryIdentity?.commit);
+  if (repositoryUrl && repositoryCommit) {
+    const id = uniqueCompilerId("repository", usedIds);
+    sources.push({
+      id,
+      kind: "repository",
+      uri: repositoryUrl,
+      version: repositoryCommit,
+      ...(context.repositoryIdentity.snapshotDigest ? { digest: context.repositoryIdentity.snapshotDigest } : {}),
+    });
+    warnings.push("Repository source was reconstructed from the fixed platform-verified identity.");
+  }
+  return sources;
+}
+
+function compilerClaims(value, { sourceIds, paperSourceId, warnings }) {
+  const claims = [];
+  const usedClaimIds = new Set();
+  const usedMeasurementIds = new Set();
+  for (const [index, candidate] of (Array.isArray(value) ? value : []).entries()) {
+    if (!isRecord(candidate) || !textValue(candidate.statement)) {
+      warnings.push(`Invalid claims[${index}] without a statement was omitted.`);
+      continue;
+    }
+    const baseId = textValue(candidate.id) ?? `claim-${index + 1}`;
+    const id = uniqueCompilerId(baseId, usedClaimIds);
+    usedClaimIds.add(id);
+    if (id !== candidate.id) warnings.push(`claims[${index}].id was missing or duplicated and was normalized to ${id}.`);
+    const type = CLAIM_TYPES.has(candidate.type) ? candidate.type : "finding";
+    if (type !== candidate.type) warnings.push(`claims[${index}].type was normalized to finding.`);
+    const sourceLocator = compilerLocator(candidate.sourceLocator, {
+      sourceIds,
+      fallbackSourceId: paperSourceId,
+      fallbackLocator: "Location not specified by the compiler",
+      warning: `claims[${index}].sourceLocator was repaired against the fixed paper source.`,
+      warnings,
+    });
+    const measurements = [];
+    for (const [measurementIndex, measurement] of (
+      Array.isArray(candidate.reportedMeasurements) ? candidate.reportedMeasurements : []
+    ).entries()) {
+      if (
+        !isRecord(measurement)
+        || !textValue(measurement.metric)
+        || !textValue(measurement.unit)
+        || typeof measurement.value !== "number"
+        || !Number.isFinite(measurement.value)
+      ) {
+        warnings.push(`Invalid reported measurement at claims[${index}].reportedMeasurements[${measurementIndex}] was omitted.`);
+        continue;
+      }
+      const measurementBaseId = textValue(measurement.id) ?? `${id}-measurement-${measurementIndex + 1}`;
+      const measurementId = uniqueCompilerId(measurementBaseId, usedMeasurementIds);
+      usedMeasurementIds.add(measurementId);
+      if (measurementId !== measurement.id) {
+        warnings.push(`A missing or duplicated reported measurement id was normalized to ${measurementId}.`);
+      }
+      measurements.push({
+        ...measurement,
+        id: measurementId,
+        metric: measurement.metric.trim(),
+        unit: measurement.unit.trim(),
+        sourceLocator: compilerLocator(measurement.sourceLocator, {
+          sourceIds,
+          fallbackSourceId: sourceLocator.sourceId,
+          fallbackLocator: sourceLocator.locator,
+          warning: `Measurement ${measurementId} inherited its claim source locator.`,
+          warnings,
+        }),
+      });
+    }
+    claims.push({
+      ...candidate,
+      id,
+      statement: candidate.statement.trim(),
+      type,
+      sourceLocator,
+      reportedMeasurements: measurements,
+      reproduction: isRecord(candidate.reproduction) ? { ...candidate.reproduction } : {},
+    });
+  }
+  return claims;
+}
+
+function compilerExperiments(value, {
+  claims,
+  researchObjects,
+  repositoryIdentity,
+  executionAllowed,
+  reproductionScope,
+  continuation,
+  warnings,
+}) {
+  const repositoryUrl = textValue(repositoryIdentity?.url);
+  const repositoryCommit = textValue(repositoryIdentity?.commit);
+  const hasOfficialRepository = Boolean(repositoryUrl && repositoryCommit);
+  if (!executionAllowed && Array.isArray(value) && value.length) {
+    warnings.push("Executable experiments were omitted because the recorded license policy does not allow execution.");
+    return [];
+  }
+  const experiments = [];
+  const claimIds = new Set(claims.map((claim) => claim.id));
+  const measurementOwners = new Map();
+  const observationIds = new Set((researchObjects ?? []).filter(object => object.role === "observation").map(object => object.id));
+  for (const claim of claims) {
+    for (const measurement of claim.reportedMeasurements) measurementOwners.set(measurement.id, { claim, measurement });
+  }
+  const usedIds = new Set();
+  const completedExperimentIds = new Set(
+    (Array.isArray(continuation?.completedTargets) ? continuation.completedTargets : [])
+      .map((target) => target?.experimentId)
+      .filter(Boolean),
+  );
+  for (const [index, candidate] of (Array.isArray(value) ? value : []).entries()) {
+    if (!isRecord(candidate)) {
+      warnings.push(`Invalid experiments[${index}] was omitted.`);
+      continue;
+    }
+    if (Array.isArray(candidate.protocol?.measurements)) {
+      if (candidate.measurements !== undefined
+        && sha256Value(candidate.measurements) !== sha256Value(candidate.protocol.measurements)) {
+        throw new CiteArkError(`Conflicting measurement bindings at experiments[${index}]: experiment and protocol disagree`);
+      }
+      candidate.measurements = candidate.protocol.measurements;
+      delete candidate.protocol.measurements;
+      warnings.push(`Experiment ${candidate.id ?? index} measurement bindings were relocated from protocol.measurements without changing their content.`);
+    }
+    const requestedReconstruction = candidate.implementationOrigin === "citeark_reconstruction";
+    const implementationOrigin = requestedReconstruction
+      ? "citeark_reconstruction"
+      : hasOfficialRepository
+        ? "official"
+        : null;
+    if (!implementationOrigin) {
+      warnings.push(`experiments[${index}] was omitted because no official repository exists and it was not declared as a CiteArk independent reconstruction.`);
+      continue;
+    }
+    const executionMode = EXECUTION_MODES.has(candidate.protocol?.executionMode)
+      ? candidate.protocol.executionMode : "agent_planned";
+    // This is a declarative marker, never an invented repository script. The
+    // autonomous workspace chooses and records the actual command at runtime.
+    const entrypoint = textValue(candidate.protocol?.entrypoint)
+      ?? (executionMode === "agent_planned" && textValue(candidate.protocol?.objective) ? "agent_planned" : null);
+    if (!entrypoint) {
+      warnings.push(`experiments[${index}] without a real entrypoint was omitted.`);
+      continue;
+    }
+    const id = uniqueCompilerId(textValue(candidate.id) ?? `experiment-${index + 1}`, usedIds);
+    usedIds.add(id);
+    const boundClaims = new Set(
+      (Array.isArray(candidate.claimIds) ? candidate.claimIds : []).filter((claimId) => claimIds.has(claimId)),
+    );
+    const measurements = [];
+    const measurementBindings = [];
+    for (const [measurementIndex, measurement] of (
+      Array.isArray(candidate.measurements) ? candidate.measurements : []
+    ).entries()) {
+      const owner = isRecord(measurement)
+        ? measurementOwners.get(measurement.reportedMeasurementId)
+        : null;
+      if (!owner && observationIds.has(measurement?.reportedMeasurementId)) {
+        throw new CiteArkError(`Experiment ${id} uses observation ${measurement.reportedMeasurementId} as a scalar reportedMeasurementId. Preserve its method with observationTargets and an unresolved decision_rule limitation; bind measurements only to actual reported numeric IDs.`);
+      }
+      if (!owner || (!isRecord(measurement.parser) && executionMode !== "agent_planned")) {
+        warnings.push(`Invalid measurement binding at experiments[${index}].measurements[${measurementIndex}] was omitted.`);
+        continue;
+      }
+      const provisionalParser = {
+        id: "json.scalar", version: "1",
+        evidencePath: `measurements/${sha256Value(measurement.reportedMeasurementId).slice(0, 16)}.json`,
+        config: { pointer: "/value", metric: owner.measurement.metric, unit: owner.measurement.unit },
+      };
+      const parser = compilerEvidenceParser(measurement.parser ?? provisionalParser, {
+        experimentId: id,
+        measurementId: measurement.reportedMeasurementId,
+        warnings,
+      });
+      const normalized = {
+        ...measurement,
+        metric: textValue(measurement.metric) ?? owner.measurement.metric,
+        unit: textValue(measurement.unit) ?? owner.measurement.unit,
+        parser,
+      };
+      let parserIssues = validateEvidenceParserDescriptor(normalized.parser, normalized);
+      if (parserIssues.length > 0 && executionMode === "agent_planned") {
+        // A partial runtime suggestion must not erase the scientific target.
+        // Use the same provisional destination as an omitted parser; the
+        // execution workspace must establish the real evidence binding.
+        normalized.parser = provisionalParser;
+        warnings.push(`Experiment ${id} measurement ${measurement.reportedMeasurementId} parser suggestion is provisional: ${parserIssues.join("; ")}. The execution workspace must resolve its real evidence source and parser.`);
+        parserIssues = validateEvidenceParserDescriptor(normalized.parser, normalized);
+      }
+      if (
+        normalized.metric !== owner.measurement.metric
+        || normalized.unit !== owner.measurement.unit
+        || parserIssues.length > 0
+      ) {
+        warnings.push(`Non-verifiable measurement binding ${measurement.reportedMeasurementId} in experiment ${id} was omitted.`);
+        continue;
+      }
+      boundClaims.add(owner.claim.id);
+      measurements.push(normalized);
+      measurementBindings.push({
+        claim: owner.claim,
+        measurement: normalized,
+        reported: owner.measurement,
+      });
+    }
+    // Observation comparisons are planning targets, not scalar measurements.
+    // Preserve their methods in the catalog; strict validation below checks
+    // source identity and claim ownership instead of inventing numeric IDs.
+    const observationTargets = Array.isArray(candidate.observationTargets) ? candidate.observationTargets : [];
+    for (const target of observationTargets) {
+      if (claimIds.has(target?.claimId)) boundClaims.add(target.claimId);
+    }
+    if ((!measurements.length && !observationTargets.length) || !boundClaims.size) {
+      warnings.push(`Experiment ${id} had no verifiable measurement binding and was omitted.`);
+      continue;
+    }
+    const hardwareProtocolUnderspecified = (
+      measurementBindings.length > 0 && measurementBindings.every(({ measurement, reported }) =>
+        hardwareSensitiveMetric(measurement?.metric ?? reported?.metric))
+      && explicitlyUnderspecifiedHardwareProtocol(candidate, measurementBindings)
+    );
+    if (hardwareProtocolUnderspecified && executionMode !== "agent_planned") {
+      for (const { claim } of measurementBindings) {
+        claim.reproduction = {
+          status: "blocked",
+          implementationOrigin: "insufficient",
+          blocker: { kind: "scientific_input", evidence: "The fixed-entrypoint protocol explicitly declares the original benchmark conditions unspecified in the fixed sources." },
+          reason: "The original hardware-sensitive benchmark conditions are underspecified by the fixed paper and repository, so a strict comparable verdict is not available.",
+        };
+      }
+      warnings.push(`Hardware-sensitive fixed-entrypoint experiment ${id} was omitted because its own protocol states that the paper does not specify the original benchmark conditions.`);
+      continue;
+    }
+    const repository = implementationOrigin === "official"
+      ? { implementationOrigin, url: repositoryUrl, commit: repositoryCommit }
+      : { ...RECONSTRUCTION_REPOSITORY };
+    const fragments = Array.isArray(candidate.protocol?.requiredCommandFragments)
+      ? candidate.protocol.requiredCommandFragments.map(textValue).filter(Boolean)
+      : [];
+    const objective = textValue(candidate.protocol?.objective)
+      ?? textValue(candidate.protocol?.instructions)
+      ?? textValue(candidate.title)
+      ?? `Reproduce the protocol-bound measurements for ${id}.`;
+    const computeIssues = candidate.compute === undefined
+      ? []
+      : validateDeclaredComputeRequirement(candidate.compute, `experiment ${id}.compute`);
+    if (computeIssues.length) warnings.push(`Invalid compute proposal for experiment ${id} was discarded so the scheduler can infer resources.`);
+    let reconstructionFidelity = RECONSTRUCTION_FIDELITIES.has(candidate.reconstructionFidelity)
+      ? candidate.reconstructionFidelity
+      : implementationOrigin === "official"
+        ? "faithful"
+        : "approximate";
+    if (hardwareProtocolUnderspecified && reconstructionFidelity !== "proxy") {
+      reconstructionFidelity = "approximate";
+      warnings.push(`Hardware-sensitive agent-planned experiment ${id} was retained as an approximate independent benchmark because the paper does not fully specify the original hardware protocol.`);
+    }
+    const preflight = compilerPreflight(candidate.protocol?.preflight, {
+      experimentId: id,
+      entrypoint,
+      executionMode,
+      measurements,
+      measurementBindings,
+      warnings,
+      implementationOrigin,
+      legacyCompleted: completedExperimentIds.has(id),
+    });
+    const environment = compilerExecutionEnvironment(candidate.environment, {
+      compute: computeIssues.length ? undefined : candidate.compute,
+      experimentId: id,
+      reconstructionFidelity,
+      warnings,
+    });
+    experiments.push({
+      ...candidate,
+      id,
+      title: textValue(candidate.title) ?? `Execute ${entrypoint}`,
+      claimIds: [...boundClaims],
+      ...(reproductionScope ? { reproductionScope } : {}),
+      reproductionLevel: REPRODUCTION_LEVELS.has(candidate.reproductionLevel)
+        ? candidate.reproductionLevel
+        : "directional",
+      reconstructionFidelity,
+      implementationOrigin,
+      repository,
+      protocol: {
+        ...candidate.protocol,
+        executionMode,
+        objective,
+        entrypoint,
+        requiredCommandFragments: fragments.length
+          ? fragments
+          : executionMode === "fixed_entrypoint"
+            ? [entrypoint]
+            : [],
+        preflight,
+      },
+      measurements,
+      environment,
+      ...(computeIssues.length ? { compute: undefined } : {}),
+    });
+    if (computeIssues.length) delete experiments.at(-1).compute;
+  }
+  return experiments;
+}
+
+function compilerPreflight(value, {
+  experimentId,
+  entrypoint,
+  executionMode,
+  measurements,
+  measurementBindings,
+  warnings,
+  implementationOrigin,
+  legacyCompleted,
+}) {
+  const provided = isRecord(value);
+  const schemaVersion = legacyCompleted && !provided
+    ? "0.1"
+    : new Set(["0.1", "0.2"]).has(value?.schemaVersion)
+    ? value.schemaVersion
+    : CURRENT_PREFLIGHT_SCHEMA_VERSION;
+  const maxMinutes = Number(value?.maxMinutes);
+  const checks = [];
+  const usedIds = new Set();
+  for (const [index, candidate] of (Array.isArray(value?.checks) ? value.checks : []).entries()) {
+    if (!isRecord(candidate) || !PREFLIGHT_CHECK_KINDS.has(candidate.kind)) continue;
+    const id = uniqueCompilerId(textValue(candidate.id) ?? `preflight-${candidate.kind}-${index + 1}`, usedIds);
+    usedIds.add(id);
+    const proposedCommand = textValue(candidate.command);
+    let command = executionMode === "agent_planned" && candidate.kind === "duration"
+      ? undefined
+      : normalizedPreflightCommand(proposedCommand);
+    if (candidate.kind === "parser" && command) {
+      const sanitized = sanitizeParserPreflightCommand(command, measurementBindings);
+      command = sanitized.command;
+      if (sanitized.replacements.length) {
+        warnings.push(`Experiment ${experimentId} parser preflight ${id} replaced ${sanitized.replacements.length} paper-target literal(s) with a neutral synthetic sentinel.`);
+      }
+    }
+    if (proposedCommand && executionMode === "agent_planned" && candidate.kind === "duration") {
+      warnings.push(`Experiment ${experimentId} duration check kept its success criterion but dropped the compiler-generated timing command; the execution Agent owns the real-device probe and batching strategy.`);
+    }
+    if (
+      proposedCommand
+      && !command
+      && !(executionMode === "agent_planned" && candidate.kind === "duration")
+    ) {
+      warnings.push(`Experiment ${experimentId} preflight check ${id} had a non-executable generated probe; the command was removed while preserving its success criterion for execution-time repair.`);
+    }
+    checks.push({
+      id,
+      kind: candidate.kind,
+      ...(command ? { command } : {}),
+      successCriterion: textValue(candidate.successCriterion)
+        ?? `Resolve the actual ${candidate.kind} requirement against the paper and working implementation before expensive execution.`,
+    });
+  }
+  if (!checks.some((check) => check.kind === "dependencies")) {
+    const dependencyCoverage = checks.find((check) =>
+      new Set(["runtime", "entrypoint", "smoke_test"]).has(check.kind)
+      && commandVerifiesDependencies(check.command),
+    );
+    if (dependencyCoverage) {
+      const id = uniqueCompilerId("preflight-dependencies", usedIds);
+      usedIds.add(id);
+      checks.push({
+        id,
+        kind: "dependencies",
+        command: dependencyCoverage.command,
+        successCriterion: `The dependency imports or package checks already exercised by ${dependencyCoverage.id} succeed in the execution environment.`,
+      });
+      warnings.push(`Experiment ${experimentId} dependency coverage from ${dependencyCoverage.id} was normalized into an explicit dependencies check.`);
+    }
+  }
+  const requiredKinds = ["runtime", "dependencies", "entrypoint", "parser", "smoke_test"];
+  const assets = [];
+  const assetIds = new Set();
+  for (const [index, candidate] of (Array.isArray(value?.assets) ? value.assets : []).entries()) {
+    if (!isRecord(candidate)) continue;
+    if (isCompilerControlAsset(candidate)) {
+      warnings.push(`Experiment ${experimentId} preflight omitted compiler-only control asset ${textValue(candidate.identity) ?? textValue(candidate.id) ?? index + 1}; repository identity is already fixed by the contract and runner audit.`);
+      continue;
+    }
+    const id = uniqueCompilerId(textValue(candidate.id) ?? `asset-${index + 1}`, assetIds);
+    assetIds.add(id);
+    const sourceUrls = [...new Set(
+      (Array.isArray(candidate.sourceUrls) ? candidate.sourceUrls : [])
+        .map(textValue)
+        .filter((sourceUrl) => sourceUrl && validPublicAssetSourceUrl(sourceUrl)),
+    )];
+    const registryDatasetId = textValue(candidate.registryDatasetId);
+    assets.push({
+      id,
+      kind: PREFLIGHT_ASSET_KINDS.has(candidate.kind) ? candidate.kind : "other",
+      identity: textValue(candidate.identity) ?? id,
+      availability: PREFLIGHT_ASSET_AVAILABILITY.has(candidate.availability)
+        ? candidate.availability
+        : "unknown",
+      required: candidate.required !== false,
+      verification: textValue(candidate.verification)
+        ?? "Verify the asset identity and record a digest-bound acquisition manifest before execution.",
+      scientificRole: ASSET_SCIENTIFIC_ROLES.has(candidate.scientificRole)
+        ? candidate.scientificRole
+        : candidate.required === false
+          ? "optional"
+          : "execution_required",
+      acquisition: compilerAssetAcquisition(candidate.acquisition),
+      sourceEvidence: compilerAssetSourceEvidence(candidate.sourceEvidence),
+      ...(sourceUrls.length ? { sourceUrls } : {}),
+      ...(registryDatasetId ? { registryDatasetId } : {}),
+    });
+  }
+  if (assets.length && !checks.some((check) => check.kind === "assets")) {
+    checks.push({
+      id: uniqueCompilerId("preflight-assets", usedIds),
+      kind: "assets",
+      successCriterion: "Every required asset is reachable and its identity can be verified before the full experiment begins.",
+    });
+  }
+  if (assets.some((asset) => asset.required && asset.kind === "dataset")) {
+    requiredKinds.push("dataset_loader");
+  }
+  const requirements = normalizeAssetRequirements(value?.requirements, {
+    fillMissing: schemaVersion === "0.3" && executionMode !== "agent_planned",
+  });
+  const requirementCoverage = evaluateAssetRequirementCoverage({
+    requirements: value?.requirements,
+    assets,
+    checks,
+  });
+  if (schemaVersion === "0.3" && requirementCoverage.status !== "complete") {
+    warnings.push(
+      executionMode === "agent_planned"
+        ? `Experiment ${experimentId} material requirements are ${requirementCoverage.status}; unspecified categories are unknown, not automatically required. Resolve the materials the real implementation needs in the workspace.`
+        : `Experiment ${experimentId} scientific material inventory is ${requirementCoverage.status}; every author-code, model, tokenizer, train/eval data, evaluator, configuration, and dependency row must be explicitly decided and bound before execution.`,
+    );
+  }
+  const declaredKinds = new Set(checks.map((check) => check.kind));
+  const declared = provided
+    && Array.isArray(value.assets)
+    && requiredKinds.every((kind) => declaredKinds.has(kind))
+    && (schemaVersion !== "0.3" || requirementCoverage.status === "complete");
+  const source = declared ? "declared" : "defaulted";
+  if (!declared) {
+    warnings.push(`Experiment ${experimentId} uses default preparation guidance; the execution workspace must verify the actual loader, implementation and scientific scope before expensive work.`);
+  }
+  for (const kind of requiredKinds) {
+    if (checks.some((check) => check.kind === kind)) continue;
+    const id = uniqueCompilerId(`preflight-${kind}`, usedIds);
+    usedIds.add(id);
+    checks.push({
+      id,
+      kind,
+      successCriterion: kind === "entrypoint"
+        ? executionMode === "agent_planned"
+          ? "Inspect the real implementation and choose a working entrypoint for the scientific objective; the initial command is a revisable suggestion."
+          : `The fixed entrypoint ${entrypoint} exists and can be invoked without beginning the full experiment.`
+        : kind === "parser"
+          ? executionMode === "agent_planned"
+            ? "Use representative real output to connect each paper-defined quantity to its parser field, unit conversion and aggregation; a parseable fixture alone does not establish metric meaning."
+            : `Every declared parser can read a tiny format-valid fixture at ${measurements.map((measurement) => measurement.parser.evidencePath).join(", ")}.`
+          : kind === "dataset_loader"
+            ? "The real evaluation loader resolves every required dataset configuration and split, reads representative rows, and verifies the declared schema and identity before any checkpoint download or full evaluation."
+            : `Resolve the actual ${kind} requirement against the paper and working implementation before expensive execution.`,
+    });
+  }
+  const proposedMaxMinutes = Number.isFinite(maxMinutes)
+    ? Math.max(1, Math.min(MAX_PREFLIGHT_MINUTES, maxMinutes))
+    : 10;
+  const requiredPublicAssets = assets.filter((asset) =>
+    asset.required && asset.availability === "public_unverified",
+  );
+  const normalizedMaxMinutes = requiredPublicAssets.length
+    ? Math.max(MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES, proposedMaxMinutes)
+    : proposedMaxMinutes;
+  if (normalizedMaxMinutes !== proposedMaxMinutes) {
+    warnings.push(
+      `Experiment ${experimentId} preflight budget was raised to ${MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES} minutes because required public assets must be acquired and identity-verified before scientific execution.`,
+    );
+  }
+  return {
+    // Keep already-published 0.1/0.2 plans semantically stable. New compiler
+    // output defaults to 0.3 and must close the complete material inventory.
+    schemaVersion,
+    source,
+    maxMinutes: normalizedMaxMinutes,
+    evidencePath: safeRelativePath(value?.evidencePath) ? value.evidencePath : "preflight.json",
+    checks,
+    assets,
+    ...(schemaVersion === "0.3" || value?.requirements !== undefined ? { requirements } : {}),
+  };
+}
+
+function validPublicAssetSourceUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return new Set(["http:", "https:"]).has(parsed.protocol)
+      && !parsed.username
+      && !parsed.password;
+  } catch {
+    return false;
+  }
+}
+
+function compilerAssetAcquisition(value) {
+  const candidate = isRecord(value) ? value : {};
+  const mode = ASSET_ACQUISITION_MODES.has(candidate.mode) ? candidate.mode : "auto";
+  const normalized = { mode };
+  const revision = textValue(candidate.revision);
+  if (revision) normalized.revision = revision;
+  for (const field of ["requiredPaths", "excludedPaths"]) {
+    const patterns = [...new Set((Array.isArray(candidate[field]) ? candidate[field] : [])
+      .map(textValue)
+      .filter((pattern) => pattern && safeAssetPattern(pattern)))];
+    if (patterns.length) normalized[field] = patterns;
+  }
+  for (const field of [
+    "expectedDownloadBytes",
+    "expectedExpandedBytes",
+    "maximumDownloadBytes",
+    "maximumExpandedBytes",
+  ]) {
+    const number = Number(candidate[field]);
+    if (
+      Number.isSafeInteger(number)
+      && number >= (field.startsWith("maximum") ? 1 : 0)
+    ) {
+      normalized[field] = number;
+    }
+  }
+  if (typeof candidate.supportsStreaming === "boolean") {
+    normalized.supportsStreaming = candidate.supportsStreaming;
+  }
+  return normalized;
+}
+
+function compilerAssetSourceEvidence(value) {
+  return (Array.isArray(value) ? value : []).flatMap((candidate) => {
+    if (!isRecord(candidate)) return [];
+    const source = textValue(candidate.source);
+    const locator = textValue(candidate.locator);
+    if (!new Set(["paper", "repository", "dataset_registry"]).has(source) || !locator) return [];
+    const result = { source, locator };
+    const sourcePath = textValue(candidate.path);
+    if (sourcePath && safeRelativePath(sourcePath)) result.path = sourcePath;
+    const commit = textValue(candidate.commit);
+    if (commit) result.commit = commit;
+    const resolver = textValue(candidate.resolver);
+    if (new Set(["exact_url", "append_path", "huggingface_model", "huggingface_dataset"]).has(resolver)) {
+      result.resolver = resolver;
+    }
+    const suffix = textValue(candidate.suffix);
+    if (suffix && safeAssetPattern(suffix)) result.suffix = suffix;
+    return [result];
+  });
+}
+
+function safeAssetPattern(value) {
+  const normalized = String(value).replaceAll("\\", "/");
+  return !path.posix.isAbsolute(normalized)
+    && !normalized.split("/").includes("..")
+    && !/[\u0000-\u001f]/.test(normalized);
+}
+
+function normalizedPreflightCommand(value) {
+  const command = textValue(value);
+  if (!command || command.includes("\0")) return null;
+  if (
+    /(?:^|\s)python(?:3(?:\.\d+)?)?\s+-c(?:\s|$)/i.test(command)
+    && /\b(?:true|false|null)\b/.test(command)
+  ) return null;
+  return command.trim();
+}
+
+function isCompilerControlAsset(candidate) {
+  const description = [candidate.id, candidate.identity, candidate.verification]
+    .map(textValue)
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return description.includes("repository-identity.json")
+    || description.includes("/job/input/repository-identity")
+    || description.includes("compiler-only repository identity");
+}
+
+function compilerEvidenceParser(value, { experimentId, measurementId, warnings }) {
+  const parser = { ...value };
+  const original = textValue(parser.evidencePath);
+  if (!original) return parser;
+  const portable = original.replaceAll("\\", "/");
+  const withoutOutputRoot = portable.startsWith("/job/output/")
+    ? portable.slice("/job/output/".length)
+    : portable.replace(/^\/+/, "");
+  if (!safeRelativePath(withoutOutputRoot)) return parser;
+  if (withoutOutputRoot !== original) {
+    warnings.push(`Parser evidence path for ${measurementId} in experiment ${experimentId} was normalized to ${withoutOutputRoot}.`);
+  }
+  parser.evidencePath = withoutOutputRoot;
+  return parser;
+}
+
+function reconcileCompilerDispositions(claims, experiments, warnings, computeContext) {
+  for (const claim of claims) {
+    const requiredIds = new Set(claim.reportedMeasurements.map((measurement) => measurement.id));
+    if (requiredIds.size > 0) {
+      for (const experiment of experiments) {
+        if (!experiment.claimIds.includes(claim.id)) continue;
+        const bindsClaimMeasurement = experiment.measurements.some((measurement) =>
+          requiredIds.has(measurement.reportedMeasurementId),
+        );
+        const hasObservationTarget = (experiment.observationTargets ?? []).some(target => target.claimId === claim.id);
+        if (!bindsClaimMeasurement && !hasObservationTarget) {
+          experiment.claimIds = experiment.claimIds.filter((claimId) => claimId !== claim.id);
+          warnings.push(`Experiment ${experiment.id} was detached from claim ${claim.id} because it binds none of that claim's reported measurements.`);
+        }
+      }
+    }
+    const coverage = automaticClaimCoverage(claim, experiments);
+    const requested = REPRODUCTION_DISPOSITIONS.has(claim.reproduction?.status)
+      ? claim.reproduction.status
+      : null;
+    const contextualWithoutMeasurement = claim.type === "method"
+      || claim.type === "limitation"
+      || (Array.isArray(claim.reproduction?.derivedFromClaimIds)
+        && claim.reproduction.derivedFromClaimIds.length > 0);
+    if (requiredIds.size === 0 && contextualWithoutMeasurement) {
+      if (requested === "planned") {
+        warnings.push(`Claim ${claim.id} had no paper-reported measurement and was reclassified as contextual.`);
+      }
+      claim.reproduction = {
+        ...claim.reproduction,
+        status: "not_applicable",
+        reason: textValue(claim.reproduction?.reason)
+          ?? "This contextual claim has no paper-reported measurement and is not scheduled as an independent reproduction target.",
+      };
+      delete claim.reproduction.implementationOrigin;
+    } else if (requiredIds.size === 0) {
+      const comparisons = experiments.flatMap(experiment => experiment.observationTargets ?? [])
+        .filter(target => target.claimId === claim.id);
+      claim.reproduction = {
+        ...claim.reproduction,
+        status: "blocked",
+        implementationOrigin: "insufficient",
+        ...(comparisons.length ? {
+          blocker: { kind: "decision_rule", evidence: comparisons.map(target => target.limitation?.evidence).filter(Boolean).join("; ") },
+        } : {}),
+        reason: (comparisons.length ? "The proposed observation comparison is retained, but a deterministic decision rule is unresolved." : null) ?? textValue(claim.reproduction?.reason)
+          ?? "This empirical claim has no safely extractable paper-reported measurement or direct decision rule for an automatic experiment.",
+      };
+      warnings.push(`Empirical claim ${claim.id} was kept as blocked instead of being reclassified as contextual.`);
+    } else if (coverage.bound.length > 0 && coverage.coveredIds.size > 0) {
+      const partial = coverage.missingIds.length > 0;
+      const coveredByOfficial = new Set(
+        coverage.bound
+          .filter((experiment) => experiment.implementationOrigin === "official")
+          .flatMap((experiment) => experiment.measurements ?? [])
+          .map((measurement) => measurement?.reportedMeasurementId)
+          .filter((measurementId) => coverage.coveredIds.has(measurementId)),
+      );
+      claim.reproduction = {
+        ...claim.reproduction,
+        status: "planned",
+        implementationOrigin: [...coverage.coveredIds].every((measurementId) => coveredByOfficial.has(measurementId))
+          ? "official"
+          : "citeark_reconstruction",
+        ...(partial ? {
+          reason: `Partially planned: runnable experiments cover ${coverage.coveredIds.size} of ${requiredIds.size} paper-reported measurements; these measurements remain unscheduled: ${coverage.missingIds.join(", ")}.`,
+        } : {}),
+      };
+      if (!partial) delete claim.reproduction.reason;
+      if (partial) {
+        warnings.push(`Claim ${claim.id} retained ${coverage.bound.length} runnable partial experiment(s); ${coverage.missingIds.join(", ")} remain explicitly unscheduled.`);
+      }
+    } else {
+      // Absence of a binding is a planning gap, not evidence of infeasibility.
+      const blocker = claim.reproduction?.blocker;
+      const substantiatedBlocker = requested === "blocked" && isRecord(blocker)
+        && ["scientific_input", "access", "resources", "budget", "decision_rule"].includes(blocker.kind)
+        && Boolean(textValue(blocker.evidence))
+        && !(blocker.kind === "budget" && (computeContext?.limits?.maximumCost === null));
+      claim.reproduction = {
+        ...claim.reproduction,
+        status: substantiatedBlocker ? "blocked" : "deferred",
+        reason: blocker?.kind === "budget" && computeContext?.limits?.maximumCost === null
+          ? "The prior monetary blocker does not apply to this uncapped job; this empirical claim still needs a runnable experiment."
+          : textValue(claim.reproduction?.reason)
+            ?? "No experiment has been scheduled for this empirical claim; feasibility remains to be established.",
+      };
+      if (substantiatedBlocker) claim.reproduction.implementationOrigin = "insufficient";
+      else {
+        delete claim.reproduction.implementationOrigin;
+        delete claim.reproduction.blocker;
+        warnings.push(`Claim ${claim.id} remains unscheduled; missing experiment bindings do not establish a blocker.`);
+      }
+    }
+  }
+}
+
+function claimCatalogCoverage(claim, experiments) {
+  const requiredIds = new Set(
+    (Array.isArray(claim?.reportedMeasurements) ? claim.reportedMeasurements : [])
+      .map((measurement) => measurement?.id)
+      .filter(Boolean),
+  );
+  const bound = (Array.isArray(experiments) ? experiments : []).filter((experiment) =>
+    Array.isArray(experiment?.claimIds) && experiment.claimIds.includes(claim?.id),
+  );
+  const coveredIds = new Set(bound.flatMap((experiment) =>
+    (experiment.measurements ?? [])
+      .map((measurement) => measurement?.reportedMeasurementId)
+      .filter((measurementId) => requiredIds.has(measurementId)),
+  ));
+  return {
+    bound,
+    coveredIds,
+    missingIds: [...requiredIds].filter((measurementId) => !coveredIds.has(measurementId)),
+  };
+}
+
+function compilerCoverage(value, { claims, sourceIds, paperSourceId, warnings }) {
+  const claimIds = new Set(claims.map((claim) => claim.id));
+  const items = [];
+  const usedIds = new Set();
+  for (const [index, candidate] of (Array.isArray(value?.items) ? value.items : []).entries()) {
+    if (!isRecord(candidate)) {
+      warnings.push(`Invalid coverage.items[${index}] was omitted.`);
+      continue;
+    }
+    const id = uniqueCompilerId(textValue(candidate.id) ?? `coverage-${index + 1}`, usedIds);
+    usedIds.add(id);
+    const covered = [...new Set(
+      (Array.isArray(candidate.claimIds) ? candidate.claimIds : []).filter((claimId) => claimIds.has(claimId)),
+    )];
+    let status = COVERAGE_STATUSES.has(candidate.status) ? candidate.status : (covered.length ? "represented" : "not_applicable");
+    if (status === "represented" && !covered.length) status = "not_applicable";
+    if (covered.length) {
+      const dispositions = claims.filter((claim) => covered.includes(claim.id)).map((claim) => claim.reproduction.status);
+      if (dispositions.includes("planned")) status = "represented";
+      else if (dispositions.includes("deferred")) status = "deferred";
+    }
+    items.push({
+      ...candidate,
+      id,
+      description: textValue(candidate.description) ?? `Research coverage item ${index + 1}`,
+      sourceLocator: compilerLocator(candidate.sourceLocator, {
+        sourceIds,
+        fallbackSourceId: paperSourceId,
+        fallbackLocator: "Location not specified by the compiler",
+        warning: `coverage.items[${index}].sourceLocator was repaired against the fixed paper source.`,
+        warnings,
+      }),
+      status,
+      claimIds: covered,
+      ...(status === "represented" ? {} : {
+        reason: textValue(candidate.reason) ?? "This item has no independently verifiable structured claim binding.",
+      }),
+    });
+  }
+  if (!items.length) {
+    warnings.push("Missing coverage inventory was derived from normalized claims.");
+    for (const claim of claims) {
+      const status = claim.reproduction.status === "planned"
+        ? "represented"
+        : claim.reproduction.status === "blocked"
+          ? "blocked"
+          : claim.reproduction.status === "deferred" ? "deferred" : "not_applicable";
+      items.push({
+        id: uniqueCompilerId(`coverage-${claim.id}`, usedIds),
+        description: claim.statement,
+        sourceLocator: claim.sourceLocator,
+        status,
+        claimIds: [claim.id],
+        ...(status === "represented" ? {} : { reason: claim.reproduction.reason }),
+      });
+    }
+  }
+  if (!items.length) {
+    items.push({
+      id: "coverage-unstructured",
+      description: "The compiler did not produce a grounded empirical claim inventory.",
+      sourceLocator: { sourceId: paperSourceId, locator: "Fixed paper input" },
+      status: "not_applicable",
+      claimIds: [],
+      reason: "No grounded structured claim was available for execution scheduling.",
+    });
+  }
+  return { items };
+}
+
+function compilerLineage(value, { sources, claims, experiments, warnings }) {
+  const nodeIds = new Set([
+    ...sources.map((source) => source.id),
+    ...claims.map((claim) => claim.id),
+    ...claims.flatMap((claim) => claim.reportedMeasurements.map((measurement) => measurement.id)),
+    ...experiments.map((experiment) => experiment.id),
+  ]);
+  const lineage = [];
+  const keys = new Set();
+  for (const edge of (Array.isArray(value) ? value : [])) {
+    if (!isRecord(edge) || !nodeIds.has(edge.from) || !nodeIds.has(edge.to) || !textValue(edge.relation)) {
+      warnings.push("An invalid lineage edge was omitted.");
+      continue;
+    }
+    const key = `${edge.from}\u0000${edge.to}\u0000${edge.relation}`;
+    if (keys.has(key)) continue;
+    keys.add(key);
+    lineage.push(edge);
+  }
+  const paperId = sources.find((source) => source.kind === "paper")?.id;
+  for (const claim of claims) {
+    addCompilerEdge(lineage, keys, paperId, claim.id, "reports");
+    for (const measurement of claim.reportedMeasurements) {
+      addCompilerEdge(lineage, keys, claim.id, measurement.id, "reports_measurement");
+    }
+  }
+  for (const experiment of experiments) {
+    for (const claimId of experiment.claimIds) addCompilerEdge(lineage, keys, claimId, experiment.id, "tested_by");
+  }
+  return lineage;
+}
+
+function compilerLicense(value, policy, warnings) {
+  const license = isRecord(value) ? { ...value } : {};
+  if (!isRecord(value)) warnings.push("Missing license record was reconstructed from platform policy.");
+  return {
+    ...license,
+    paper: textValue(license.paper) ?? textValue(policy?.paperLicense) ?? "unknown",
+    code: textValue(license.code) ?? textValue(policy?.codeLicense) ?? "unknown",
+    executionAllowed: policy?.executable !== false,
+  };
+}
+
+function compilerProvenance(value, context, warnings) {
+  const provenance = isRecord(value) ? { ...value } : {};
+  if (!isRecord(value)) warnings.push("Missing provenance was reconstructed by the platform compiler boundary.");
+  return {
+    ...provenance,
+    compiler: textValue(provenance.compiler) ?? textValue(context.compiler) ?? "citeark-research-compiler/0.2",
+    compiledAt: textValue(provenance.compiledAt) ?? new Date().toISOString(),
+    reviewStatus: new Set(["agent-draft", "human-reviewed"]).has(provenance.reviewStatus)
+      ? provenance.reviewStatus
+      : "agent-draft",
+  };
+}
+
+function compilerLocator(value, { sourceIds, fallbackSourceId, fallbackLocator, warning, warnings }) {
+  const sourceId = textValue(value?.sourceId);
+  const locator = textValue(value?.locator);
+  if (sourceId && sourceIds.has(sourceId) && locator) return { ...value, sourceId, locator };
+  warnings.push(warning);
+  return {
+    ...(isRecord(value) ? value : {}),
+    sourceId: sourceId && sourceIds.has(sourceId) ? sourceId : fallbackSourceId,
+    locator: locator ?? fallbackLocator,
+  };
+}
+
+function addCompilerEdge(lineage, keys, from, to, relation) {
+  if (!from || !to) return;
+  const key = `${from}\u0000${to}\u0000${relation}`;
+  if (keys.has(key)) return;
+  keys.add(key);
+  lineage.push({ from, to, relation });
+}
+
+function uniqueCompilerId(base, used) {
+  const normalized = base.trim().replaceAll(/[^a-zA-Z0-9._:-]+/g, "-") || "item";
+  if (!used.has(normalized)) return normalized;
+  let suffix = 2;
+  while (used.has(`${normalized}-${suffix}`)) suffix += 1;
+  return `${normalized}-${suffix}`;
+}
+
+function textValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+export function normalizeResearchStructure(input, options = {}) {
+  const issues = [];
+  if (!isRecord(input)) throw new CiteArkError("research.json 的根节点必须是对象");
+  const inventoryOnly = input.compilationStage === "inventory";
+  if (input.compilationStage !== undefined && !inventoryOnly) issues.push("Unknown compilationStage");
+  if (inventoryOnly && (input.experiments?.length || input.claims?.some((claim) => claim.reproduction?.status !== "deferred"))) issues.push("Inventory must contain pending claims and no executable experiments");
+  if (input.schemaVersion !== RESEARCH_SCHEMA_VERSION) {
+    issues.push(`schemaVersion 必须是 ${RESEARCH_SCHEMA_VERSION}`);
+  }
+  if (!isRecord(input.work)) issues.push("work 必须是对象");
+  const rawWork = isRecord(input.work) ? input.work : {};
+  const work = options.requireAuthors === true && rawWork.authors === undefined
+    ? { ...rawWork, authors: [] }
+    : rawWork;
+  required(work.id, "work.id", issues);
+  required(work.title, "work.title", issues);
+  required(work.abstract, "work.abstract", issues);
+  if (textValue(work.abstract) && textValue(work.abstract).length > 1200) {
+    issues.push("work.abstract 最多 1200 字符：编译器必须用自己的话重写为 80–120 词的客观陈述，不得照抄论文原摘要");
+  }
+  if (work.authors !== undefined) {
+    const authors = array(work.authors, "work.authors", issues);
+    if (authors.length > 500) issues.push("work.authors 最多包含 500 位作者");
+    authors.forEach((author, index) => required(author, `work.authors[${index}]`, issues));
+  }
+  if (work.subjects !== undefined) {
+    array(work.subjects, "work.subjects", issues).forEach((tag, index) => {
+      if (!SUBJECT_TAGS.has(tag)) issues.push(`work.subjects[${index}] 无效：${tag}`);
+    });
+  }
+
+  const sources = array(input.sources, "sources", issues);
+  const sourceIds = new Set();
+  for (const [index, source] of sources.entries()) {
+    if (!isRecord(source)) {
+      issues.push(`sources[${index}] 必须是对象`);
+      continue;
+    }
+    required(source.id, `sources[${index}].id`, issues);
+    if (sourceIds.has(source.id)) issues.push(`source id 重复：${source.id}`);
+    sourceIds.add(source.id);
+    if (!SOURCE_KINDS.has(source.kind)) issues.push(`sources[${index}].kind 无效`);
+    required(source.uri, `sources[${index}].uri`, issues);
+  }
+
+  const claims = array(input.claims, "claims", issues);
+  const claimIds = new Set();
+  const reportedMeasurementIds = new Set();
+  const normalizedClaims = claims.map((claim, index) => {
+    if (!isRecord(claim)) {
+      issues.push(`claims[${index}] 必须是对象`);
+      return claim;
+    }
+    required(claim.id, `claims[${index}].id`, issues);
+    if (claimIds.has(claim.id)) issues.push(`claim id 重复：${claim.id}`);
+    claimIds.add(claim.id);
+    required(claim.statement, `claims[${index}].statement`, issues);
+    if (!CLAIM_TYPES.has(claim.type)) issues.push(`claims[${index}].type 无效`);
+    validateLocator(claim.sourceLocator, `claims[${index}].sourceLocator`, sourceIds, issues);
+    const measurements = array(claim.reportedMeasurements, `claims[${index}].reportedMeasurements`, issues);
+    measurements.forEach((measurement, measurementIndex) => {
+      validateMeasurement(measurement, `claims[${index}].reportedMeasurements[${measurementIndex}]`, issues);
+      if (isRecord(measurement)) {
+        if (measurement.value === undefined) issues.push(`claims[${index}].reportedMeasurements[${measurementIndex}].value 缺少报告数值；无可靠数值的经验结论应保留为空测量数组及明确判据阻塞`);
+        required(measurement.id, `claims[${index}].reportedMeasurements[${measurementIndex}].id`, issues);
+        if (reportedMeasurementIds.has(measurement.id)) issues.push(`reported measurement id 重复：${measurement.id}`);
+        reportedMeasurementIds.add(measurement.id);
+        validateLocator(measurement.sourceLocator, `claims[${index}].reportedMeasurements[${measurementIndex}].sourceLocator`, sourceIds, issues);
+      }
+    });
+    const reproduction = normalizeClaimReproduction(claim, index, measurements, issues, inventoryOnly);
+    const body = { ...claim };
+    body.reproduction = reproduction;
+    delete body.versionId;
+    return { ...body, versionId: `sha256:${sha256Value(body)}` };
+  });
+
+  const experiments = array(input.experiments, "experiments", issues);
+  const experimentIds = new Set();
+  const normalizedExperiments = experiments.map((experiment, index) => {
+    if (!isRecord(experiment)) {
+      issues.push(`experiments[${index}] 必须是对象`);
+      return experiment;
+    }
+    required(experiment.id, `experiments[${index}].id`, issues);
+    if (experimentIds.has(experiment.id)) issues.push(`experiment id 重复：${experiment.id}`);
+    experimentIds.add(experiment.id);
+    required(experiment.title, `experiments[${index}].title`, issues);
+    if (!REPRODUCTION_LEVELS.has(experiment.reproductionLevel)) {
+      issues.push(`experiments[${index}].reproductionLevel 无效`);
+    }
+    if (
+      experiment.reconstructionFidelity !== undefined
+      && !RECONSTRUCTION_FIDELITIES.has(experiment.reconstructionFidelity)
+    ) {
+      issues.push(`experiments[${index}].reconstructionFidelity 无效`);
+    }
+    if (experiment.implementationOrigin !== undefined && !IMPLEMENTATION_ORIGINS.has(experiment.implementationOrigin)) {
+      issues.push(`experiments[${index}].implementationOrigin 无效`);
+    }
+    const boundClaims = array(experiment.claimIds, `experiments[${index}].claimIds`, issues);
+    boundClaims.forEach((claimId) => {
+      if (!claimIds.has(claimId)) issues.push(`experiment 引用了不存在的 claim：${claimId}`);
+    });
+    if (!isRecord(experiment.repository)) issues.push(`experiments[${index}].repository 必须是对象`);
+    else {
+      required(experiment.repository.url, `experiments[${index}].repository.url`, issues);
+      required(experiment.repository.commit, `experiments[${index}].repository.commit`, issues);
+      if (experiment.repository.implementationOrigin !== undefined && !IMPLEMENTATION_ORIGINS.has(experiment.repository.implementationOrigin)) {
+        issues.push(`experiments[${index}].repository.implementationOrigin 无效`);
+      }
+    }
+    if (!isRecord(experiment.protocol)) issues.push(`experiments[${index}].protocol 必须是对象`);
+    else {
+      if (
+        experiment.protocol.executionMode !== undefined
+        && !EXECUTION_MODES.has(experiment.protocol.executionMode)
+      ) {
+        issues.push(`experiments[${index}].protocol.executionMode 无效`);
+      }
+      if (experiment.protocol.executionMode === "agent_planned") {
+        required(experiment.protocol.objective, `experiments[${index}].protocol.objective`, issues);
+      }
+      required(experiment.protocol.entrypoint, `experiments[${index}].protocol.entrypoint`, issues);
+      const fragments = array(experiment.protocol.requiredCommandFragments, `experiments[${index}].protocol.requiredCommandFragments`, issues);
+      fragments.forEach((fragment, fragmentIndex) => required(fragment, `experiments[${index}].protocol.requiredCommandFragments[${fragmentIndex}]`, issues));
+      validateProtocolPreflight(experiment.protocol.preflight, `experiments[${index}].protocol.preflight`, issues, experiment.protocol.executionMode === "agent_planned");
+    }
+    const measurements = array(experiment.measurements, `experiments[${index}].measurements`, issues);
+    measurements.forEach((measurement, measurementIndex) => {
+      const label = `experiments[${index}].measurements[${measurementIndex}]`;
+      validateMeasurement(measurement, label, issues);
+      if (isRecord(measurement)) {
+        required(measurement.reportedMeasurementId, `${label}.reportedMeasurementId`, issues);
+        if (measurement.reportedMeasurementId && !reportedMeasurementIds.has(measurement.reportedMeasurementId)) {
+          issues.push(`${label}.reportedMeasurementId 不存在：${measurement.reportedMeasurementId}`);
+        }
+        const owners = claims.filter((claim) =>
+          Array.isArray(claim?.reportedMeasurements)
+          && claim.reportedMeasurements.some((reported) => reported?.id === measurement.reportedMeasurementId),
+        );
+        if (owners.length && !owners.some((claim) => boundClaims.includes(claim.id))) {
+          issues.push(`${label} 引用的 reported measurement 不属于 experiment.claimIds`);
+        }
+        const reported = owners.flatMap((claim) => claim.reportedMeasurements).find(
+          (candidate) => candidate?.id === measurement.reportedMeasurementId,
+        );
+        if (reported && (reported.metric !== measurement.metric || reported.unit !== measurement.unit)) {
+          issues.push(`${label} 与 ${measurement.reportedMeasurementId} 的 metric/unit 不一致`);
+        }
+      }
+      if (!isRecord(measurement?.parser)) issues.push(`${label}.parser 必须是对象`);
+      else {
+        required(measurement.parser.id, `${label}.parser.id`, issues);
+        required(measurement.parser.version, `${label}.parser.version`, issues);
+        required(measurement.parser.evidencePath, `${label}.parser.evidencePath`, issues);
+        for (const parserIssue of validateEvidenceParserDescriptor(
+          measurement.parser,
+          measurement,
+        )) {
+          issues.push(`${label}.parser：${parserIssue}`);
+        }
+      }
+    });
+    if (experiment.protocol?.benchmark || measurements.some(measurementRequiresHardwareProtocol)) {
+      validateHardwareBenchmarkProtocol(
+        experiment.protocol?.benchmark,
+        `experiments[${index}].protocol.benchmark`,
+        issues,
+        {
+          requiresComparator: measurements.some((measurement) =>
+            typeof measurement?.metric === "string"
+            && /(?:speedup|relative[_ -]?speed|ratio)/i.test(measurement.metric)),
+        },
+      );
+    }
+    issues.push(...measurementHardwareIssues(experiment).map((issue) => `${experiment.id}: ${issue}`));
+    issues.push(...executionWorkloadIssues(experiment.protocol?.workload).map((issue) => `${experiment.id}: ${issue}`));
+    if (experiment.compute !== undefined) {
+      issues.push(...validateDeclaredComputeRequirement(experiment.compute, `experiments[${index}].compute`));
+    }
+    issues.push(...publicContractPolicyIssues(researchPublicContract(experiment))
+      .map((issue) => `experiments[${index}].publicContract: ${issue}`));
+    const body = { ...experiment };
+    delete body.versionId;
+    return { ...body, versionId: `sha256:${sha256Value(body)}` };
+  });
+
+  for (const [index, claim] of normalizedClaims.entries()) {
+      if (!isRecord(claim) || claim.type === "limitation") continue;
+      const disposition = claim.reproduction?.status;
+      const measurements = Array.isArray(claim.reportedMeasurements) ? claim.reportedMeasurements : [];
+      const claimExperiments = experiments.filter((experiment) =>
+        Array.isArray(experiment?.claimIds) && experiment.claimIds.includes(claim.id),
+      );
+      if (disposition === "planned") {
+        if (!claimExperiments.length) issues.push(`claims[${index}] 标记为 planned，但没有绑定 experiment`);
+        const requiredMeasurementIds = new Set(measurements.map((measurement) => measurement?.id).filter(Boolean));
+        const collectivelyCovered = new Set(
+          claimExperiments.flatMap((experiment) =>
+            (experiment.measurements ?? [])
+              .map((measurement) => measurement?.reportedMeasurementId)
+              .filter((measurementId) => requiredMeasurementIds.has(measurementId)),
+          ),
+        );
+        for (const experiment of claimExperiments) {
+          const bindsClaimMeasurement = (experiment.measurements ?? []).some((measurement) =>
+            requiredMeasurementIds.has(measurement?.reportedMeasurementId),
+          );
+          const hasObservationTarget = (experiment.observationTargets ?? []).some(target => target.claimId === claim.id);
+          if (!bindsClaimMeasurement && !hasObservationTarget) {
+            issues.push(`experiment ${experiment.id} 没有绑定 claim ${claim.id} 的任何 reported measurement`);
+          }
+        }
+        if (requiredMeasurementIds.size > 0 && collectivelyCovered.size === 0) {
+          issues.push(`claims[${index}] 标记为 planned，但没有任何 reported measurement 被实验测量绑定`);
+        }
+      }
+  }
+
+  const lineage = array(input.lineage, "lineage", issues);
+  const nodeIds = new Set([...sourceIds, ...claimIds, ...reportedMeasurementIds, ...experimentIds]);
+  lineage.forEach((edge, index) => {
+    if (!isRecord(edge)) {
+      issues.push(`lineage[${index}] 必须是对象`);
+      return;
+    }
+    if (!nodeIds.has(edge.from)) issues.push(`lineage[${index}].from 不存在：${edge.from}`);
+    if (!nodeIds.has(edge.to)) issues.push(`lineage[${index}].to 不存在：${edge.to}`);
+    required(edge.relation, `lineage[${index}].relation`, issues);
+  });
+
+  if (!isRecord(input.license)) issues.push("license 必须是对象");
+  else {
+    required(input.license.paper, "license.paper", issues);
+    required(input.license.code, "license.code", issues);
+    if (typeof input.license.executionAllowed !== "boolean") issues.push("license.executionAllowed 必须是布尔值");
+  }
+  if (!isRecord(input.provenance)) issues.push("provenance 必须是对象");
+  else {
+    required(input.provenance.compiler, "provenance.compiler", issues);
+    required(input.provenance.compiledAt, "provenance.compiledAt", issues);
+    if (!new Set(["agent-draft", "human-reviewed"]).has(input.provenance.reviewStatus)) {
+      issues.push("provenance.reviewStatus 必须是 agent-draft 或 human-reviewed");
+    }
+  }
+  if (input.sourceInventory !== undefined) {
+    const source = input.sourceInventory;
+    if (inventoryOnly || source?.research?.compilationStage !== "inventory" || source.research.sourceInventory !== undefined) {
+      issues.push("sourceInventory must reference a standalone inventory");
+    } else {
+      try {
+        const inventory = normalizeResearchStructure(source.research);
+        if (source.digest !== `sha256:${sha256Value(inventory)}`) issues.push("sourceInventory digest mismatch");
+        const revisedClaims = normalizeResearchStructure({ ...inventory,
+          claims: revisedInventoryClaims(inventory, source.revisions).map((claim) => ({ ...claim, reproduction: { status: "deferred", reason: "Provisional source interpretation awaiting preparation." } })),
+        }).claims.map(sourceClaim);
+        if (sha256Value(normalizedClaims.map(sourceClaim)) !== sha256Value(revisedClaims)) issues.push("Preparation cannot rewrite source inventory claims or reported measurements without a recorded source-grounded revision");
+        if (sha256Value(input.hypotheses ?? []) !== sha256Value(inventory.hypotheses ?? [])) issues.push("Preparation cannot rewrite source hypotheses");
+        for (const field of ["reading", "researchRelations"]) if (sha256Value(input[field] ?? null) !== sha256Value(inventory[field] ?? null)) issues.push(`Preparation cannot rewrite source ${field}`);
+        const preparedObjects = new Map((input.researchObjects ?? []).map(object => [object.id, object]));
+        for (const object of inventory.researchObjects ?? []) if (!preparedObjects.has(object.id)
+          || sha256Value(preparedObjects.get(object.id)) !== sha256Value(object)) issues.push(`Preparation cannot rewrite source research object ${object.id}`);
+      } catch (error) { issues.push(`Invalid sourceInventory: ${error.message}`); }
+    }
+  }
+  validateResearchMap(input, issues);
+  const researchObjects = validateResearchObjects({ ...input, claims: normalizedClaims, experiments: normalizedExperiments }, issues);
+  const coverage = validateCoverageInventory(input.coverage, claimIds, sourceIds, issues);
+  issues.push(...reproductionScopeIssues(input));
+  const experimentSelection = normalizeExperimentSelection(
+    input.experimentSelection,
+    experimentIds,
+  );
+
+  if (issues.length) throw new CiteArkError(`研究结构校验失败：\n- ${issues.join("\n- ")}`);
+  return {
+    schemaVersion: RESEARCH_SCHEMA_VERSION,
+    ...(inventoryOnly ? { compilationStage: "inventory" } : {}),
+    ...(input.sourceInventory ? { sourceInventory: structuredClone(input.sourceInventory) } : {}),
+    ...(input.reproductionScope !== undefined ? { reproductionScope: input.reproductionScope } : {}),
+    ...(experimentSelection ? { experimentSelection } : {}),
+    work,
+    sources,
+    claims: normalizedClaims,
+    ...(input.reading !== undefined ? { reading: structuredClone(input.reading) } : {}),
+    ...(input.researchRelations !== undefined ? { researchRelations: structuredClone(input.researchRelations) } : {}),
+    ...(input.hypotheses !== undefined ? { hypotheses: structuredClone(input.hypotheses) } : {}),
+    experiments: normalizedExperiments,
+    ...(input.researchObjects !== undefined ? { researchObjects } : {}),
+    lineage,
+    coverage,
+    license: input.license,
+    provenance: input.provenance,
+  };
+}
+
+function normalizeExperimentSelection(value, experimentIds) {
+  if (!isRecord(value)) return null;
+  const groups = [];
+  const assigned = new Set();
+  for (const candidate of Array.isArray(value.groups) ? value.groups.slice(0, 5) : []) {
+    if (!isRecord(candidate)) continue;
+    const id = textValue(candidate.id);
+    const title = textValue(candidate.title);
+    const description = textValue(candidate.description);
+    const ids = [...new Set(
+      (Array.isArray(candidate.experimentIds) ? candidate.experimentIds : [])
+        .filter((experimentId) => typeof experimentId === "string"
+          && experimentIds.has(experimentId)
+          && !assigned.has(experimentId)),
+    )];
+    if (!id || !title || !description || !ids.length) continue;
+    ids.forEach((experimentId) => assigned.add(experimentId));
+    groups.push({ id, title, description, experimentIds: ids });
+  }
+  const presets = {};
+  for (const preset of ["low", "medium", "high"]) {
+    const candidate = value.presets?.[preset];
+    if (!isRecord(candidate)) continue;
+    const ids = [...new Set(
+      (Array.isArray(candidate.experimentIds) ? candidate.experimentIds : [])
+        .filter((id) => typeof id === "string" && experimentIds.has(id)),
+    )];
+    const rationale = textValue(candidate.rationale);
+    if (rationale) presets[preset] = { experimentIds: ids, rationale };
+  }
+  const importance = normalizeExperimentImportance(value.importance, experimentIds);
+  return Object.keys(presets).length || groups.length || importance.length ? {
+    ...(importance.length ? { importance } : {}),
+    ...(groups.length ? { groups } : {}),
+    presets,
+  } : null;
+}
+
+function validateProtocolPreflight(value, label, issues, agentPlanned = false) {
+  // Research Plan 1.0 records created before structured preflight remain valid.
+  if (value === undefined) return;
+  if (!isRecord(value)) {
+    issues.push(`${label} 必须是对象`);
+    return;
+  }
+  if (!supportsPreflightSchemaVersion(value.schemaVersion)) {
+    issues.push(`${label}.schemaVersion 必须是 ${describeSupportedPreflightSchemaVersions()}`);
+  }
+  if (!new Set(["declared", "defaulted"]).has(value.source)) issues.push(`${label}.source 无效`);
+  if (!Number.isFinite(value.maxMinutes) || value.maxMinutes < 1 || value.maxMinutes > MAX_PREFLIGHT_MINUTES) {
+    issues.push(`${label}.maxMinutes 必须在 1 到 ${MAX_PREFLIGHT_MINUTES} 之间`);
+  }
+  if (!safeRelativePath(value.evidencePath)) issues.push(`${label}.evidencePath 必须是安全相对路径`);
+  const checks = array(value.checks, `${label}.checks`, issues);
+  const checkIds = new Set();
+  for (const [index, check] of checks.entries()) {
+    if (!isRecord(check)) {
+      issues.push(`${label}.checks[${index}] 必须是对象`);
+      continue;
+    }
+    required(check.id, `${label}.checks[${index}].id`, issues);
+    if (checkIds.has(check.id)) issues.push(`${label}.checks[${index}].id 重复`);
+    checkIds.add(check.id);
+    if (!PREFLIGHT_CHECK_KINDS.has(check.kind)) issues.push(`${label}.checks[${index}].kind 无效`);
+    if (check.command !== undefined) required(check.command, `${label}.checks[${index}].command`, issues);
+    required(check.successCriterion, `${label}.checks[${index}].successCriterion`, issues);
+  }
+  const assets = array(value.assets, `${label}.assets`, issues);
+  const assetIds = new Set();
+  for (const [index, asset] of assets.entries()) {
+    if (!isRecord(asset)) {
+      issues.push(`${label}.assets[${index}] 必须是对象`);
+      continue;
+    }
+    required(asset.id, `${label}.assets[${index}].id`, issues);
+    if (assetIds.has(asset.id)) issues.push(`${label}.assets[${index}].id 重复`);
+    assetIds.add(asset.id);
+    if (!PREFLIGHT_ASSET_KINDS.has(asset.kind)) issues.push(`${label}.assets[${index}].kind 无效`);
+    if (!PREFLIGHT_ASSET_AVAILABILITY.has(asset.availability)) issues.push(`${label}.assets[${index}].availability 无效`);
+    if (typeof asset.required !== "boolean") issues.push(`${label}.assets[${index}].required 必须是布尔值`);
+    required(asset.identity, `${label}.assets[${index}].identity`, issues);
+    required(asset.verification, `${label}.assets[${index}].verification`, issues);
+    if (asset.scientificRole !== undefined && !ASSET_SCIENTIFIC_ROLES.has(asset.scientificRole)) {
+      issues.push(`${label}.assets[${index}].scientificRole 无效`);
+    }
+    validateAssetAcquisition(asset.acquisition, `${label}.assets[${index}].acquisition`, issues);
+    validateAssetSourceEvidence(asset.sourceEvidence, `${label}.assets[${index}].sourceEvidence`, issues);
+    const sourceUrls = asset.sourceUrls === undefined
+      ? []
+      : array(asset.sourceUrls, `${label}.assets[${index}].sourceUrls`, issues);
+    for (const [sourceIndex, sourceUrl] of sourceUrls.entries()) {
+      if (!validPublicAssetSourceUrl(sourceUrl)) {
+        issues.push(`${label}.assets[${index}].sourceUrls[${sourceIndex}] 必须是无凭据的 HTTP(S) URL`);
+      }
+    }
+    if (asset.registryDatasetId !== undefined) {
+      required(asset.registryDatasetId, `${label}.assets[${index}].registryDatasetId`, issues);
+      if (asset.kind !== "dataset") {
+        issues.push(`${label}.assets[${index}].registryDatasetId 只适用于 dataset`);
+      }
+    }
+    if (
+      asset.required === true
+      && asset.availability === "public_unverified"
+      && sourceUrls.length === 0
+      && !textValue(asset.registryDatasetId)
+    ) {
+      issues.push(`${label}.assets[${index}] 是必需的 public_unverified 资产，必须声明 sourceUrls 或 registryDatasetId`);
+    }
+  }
+  if (
+    assets.some((asset) => isRecord(asset) && asset.required === true && asset.kind === "dataset")
+    && !checks.some((check) => isRecord(check) && check.kind === "dataset_loader")
+  ) {
+    issues.push(`${label}.checks 对每个必需 dataset 资产必须包含 dataset_loader，并实际加载配置、split 和代表性行`);
+  }
+  if (
+    assets.some((asset) =>
+      isRecord(asset) && asset.required === true && asset.availability === "public_unverified",
+    )
+    && value.maxMinutes < MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES
+  ) {
+    issues.push(`${label}.maxMinutes 对必需的 public_unverified 资产不得低于 ${MIN_PUBLIC_ASSET_PREFLIGHT_MINUTES}`);
+  }
+  if (value.schemaVersion === "0.3") {
+    validateAssetRequirements(value.requirements, assets, checks, label, issues, agentPlanned && value.source === "defaulted");
+  }
+}
+
+function validateAssetRequirements(value, assets, checks, label, issues, deferredBindings = false) {
+  const requirements = array(value, `${label}.requirements`, issues);
+  const kinds = new Set();
+  for (const [index, requirement] of requirements.entries()) {
+    const itemLabel = `${label}.requirements[${index}]`;
+    if (!isRecord(requirement)) {
+      issues.push(`${itemLabel} 必须是对象`);
+      continue;
+    }
+    if (!ASSET_REQUIREMENT_KINDS.includes(requirement.kind)) {
+      issues.push(`${itemLabel}.kind 无效`);
+    }
+    if (kinds.has(requirement.kind)) issues.push(`${itemLabel}.kind 重复`);
+    kinds.add(requirement.kind);
+    if (typeof requirement.required !== "boolean") issues.push(`${itemLabel}.required 必须是布尔值`);
+    required(requirement.reason, `${itemLabel}.reason`, issues);
+    array(requirement.assetIds, `${itemLabel}.assetIds`, issues);
+    array(requirement.checkIds, `${itemLabel}.checkIds`, issues);
+    if (typeof requirement.repository !== "boolean") issues.push(`${itemLabel}.repository 必须是布尔值`);
+  }
+  for (const kind of deferredBindings ? [] : ASSET_REQUIREMENT_KINDS) {
+    if (!kinds.has(kind)) issues.push(`${label}.requirements 缺少 ${kind}`);
+  }
+  const coverage = evaluateAssetRequirementCoverage({ requirements, assets, checks });
+  for (const kind of deferredBindings ? [] : coverage.missingRequirements) {
+    issues.push(`${label}.requirements 的必需项 ${kind} 没有绑定仓库、资产或检查`);
+  }
+  for (const binding of coverage.invalidBindings) {
+    issues.push(`${label}.requirements 引用了不存在或非必需的绑定 ${binding}`);
+  }
+}
+
+function validateAssetAcquisition(value, label, issues) {
+  if (value === undefined) return;
+  if (!isRecord(value)) {
+    issues.push(`${label} 必须是对象`);
+    return;
+  }
+  if (!ASSET_ACQUISITION_MODES.has(value.mode)) issues.push(`${label}.mode 无效`);
+  if (value.revision !== undefined) required(value.revision, `${label}.revision`, issues);
+  for (const field of ["requiredPaths", "excludedPaths"]) {
+    if (value[field] === undefined) continue;
+    const patterns = array(value[field], `${label}.${field}`, issues);
+    for (const [index, pattern] of patterns.entries()) {
+      if (typeof pattern !== "string" || !safeAssetPattern(pattern)) {
+        issues.push(`${label}.${field}[${index}] 必须是安全相对路径或 glob`);
+      }
+    }
+  }
+  for (const field of ["expectedDownloadBytes", "expectedExpandedBytes"]) {
+    if (value[field] !== undefined && (!Number.isSafeInteger(value[field]) || value[field] < 0)) {
+      issues.push(`${label}.${field} 必须是非负安全整数`);
+    }
+  }
+  if (
+    value.maximumDownloadBytes !== undefined
+    && (!Number.isSafeInteger(value.maximumDownloadBytes) || value.maximumDownloadBytes < 1)
+  ) {
+    issues.push(`${label}.maximumDownloadBytes 必须是正安全整数`);
+  }
+  if (
+    value.maximumExpandedBytes !== undefined
+    && (!Number.isSafeInteger(value.maximumExpandedBytes) || value.maximumExpandedBytes < 1)
+  ) {
+    issues.push(`${label}.maximumExpandedBytes 必须是正安全整数`);
+  }
+  if (value.supportsStreaming !== undefined && typeof value.supportsStreaming !== "boolean") {
+    issues.push(`${label}.supportsStreaming 必须是布尔值`);
+  }
+}
+
+function validateAssetSourceEvidence(value, label, issues) {
+  if (value === undefined) return;
+  const entries = array(value, label, issues);
+  for (const [index, entry] of entries.entries()) {
+    if (!isRecord(entry)) {
+      issues.push(`${label}[${index}] 必须是对象`);
+      continue;
+    }
+    if (!new Set(["paper", "repository", "dataset_registry"]).has(entry.source)) {
+      issues.push(`${label}[${index}].source 无效`);
+    }
+    required(entry.locator, `${label}[${index}].locator`, issues);
+    if (entry.path !== undefined && !safeRelativePath(entry.path)) {
+      issues.push(`${label}[${index}].path 必须是安全相对路径`);
+    }
+    if (entry.commit !== undefined) required(entry.commit, `${label}[${index}].commit`, issues);
+    if (
+      entry.resolver !== undefined
+      && !new Set(["exact_url", "append_path", "huggingface_model", "huggingface_dataset"]).has(entry.resolver)
+    ) {
+      issues.push(`${label}[${index}].resolver 无效`);
+    }
+    if (entry.suffix !== undefined && !safeAssetPattern(entry.suffix)) {
+      issues.push(`${label}[${index}].suffix 必须是安全相对路径`);
+    }
+    if (entry.resolver === "append_path" && !textValue(entry.suffix)) {
+      issues.push(`${label}[${index}].resolver=append_path 时必须声明 suffix`);
+    }
+    if (entry.suffix !== undefined && entry.resolver !== "append_path") {
+      issues.push(`${label}[${index}].suffix 只适用于 resolver=append_path`);
+    }
+  }
+}
+
+function validateHardwareBenchmarkProtocol(value, label, issues, { requiresComparator }) {
+  if (!isRecord(value)) {
+    issues.push(`${label} 对硬件敏感指标必须完整声明批量、精度、预热、计时重复、同步、输入构造和确切实现入口`);
+    return;
+  }
+  const batchSizes = Array.isArray(value.batchSize) ? value.batchSize : [value.batchSize];
+  if (!batchSizes.length || batchSizes.some((batchSize) =>
+    !Number.isInteger(batchSize) || batchSize < 1)) {
+    issues.push(`${label}.batchSize 必须是正整数或非空正整数数组`);
+  }
+  required(value.dtype, `${label}.dtype`, issues);
+  if (!Number.isInteger(value.warmupIterations) || value.warmupIterations < 1) {
+    issues.push(`${label}.warmupIterations 必须是正整数`);
+  }
+  if (!Number.isInteger(value.measurementIterations) || value.measurementIterations < 1) {
+    issues.push(`${label}.measurementIterations 必须是正整数`);
+  }
+  required(value.timer, `${label}.timer`, issues);
+  required(value.synchronization, `${label}.synchronization`, issues);
+  required(value.inputConstruction, `${label}.inputConstruction`, issues);
+  const implementations = array(value.implementations, `${label}.implementations`, issues);
+  if (requiresComparator && implementations.length < 2) {
+    issues.push(`${label}.implementations 对相对速度指标必须至少声明被测实现和比较实现`);
+  }
+  const implementationIds = new Set();
+  for (const [index, implementation] of implementations.entries()) {
+    if (!isRecord(implementation)) {
+      issues.push(`${label}.implementations[${index}] 必须是对象`);
+      continue;
+    }
+    required(implementation.id, `${label}.implementations[${index}].id`, issues);
+    required(implementation.callable, `${label}.implementations[${index}].callable`, issues);
+    required(implementation.provenance, `${label}.implementations[${index}].provenance`, issues);
+    if (implementationIds.has(implementation.id)) {
+      issues.push(`${label}.implementations[${index}].id 重复`);
+    }
+    implementationIds.add(implementation.id);
+  }
+}
+
+function normalizeClaimReproduction(claim, index, measurements, issues, inventoryOnly = false) {
+  if (inventoryOnly && claim.reproduction?.status === "deferred") {
+    required(claim.reproduction.reason, `claims[${index}].reproduction.reason`, issues);
+    return claim.reproduction;
+  }
+  if (!isRecord(claim.reproduction)) {
+    issues.push(`claims[${index}].reproduction 必须是对象`);
+    return claim.reproduction;
+  }
+  const status = claim.reproduction.status;
+  if (!REPRODUCTION_DISPOSITIONS.has(status)) {
+    issues.push(`claims[${index}].reproduction.status 无效`);
+    return claim.reproduction;
+  }
+  const implementationOrigin = claim.reproduction.implementationOrigin;
+  if (
+    implementationOrigin !== undefined
+    && !new Set([...IMPLEMENTATION_ORIGINS, "insufficient"]).has(implementationOrigin)
+  ) {
+    issues.push(`claims[${index}].reproduction.implementationOrigin 无效`);
+  }
+  if (status === "planned" && implementationOrigin === "insufficient") {
+    issues.push(`claims[${index}] 已计划执行，implementationOrigin 不能是 insufficient`);
+  }
+  if (status === "blocked" && implementationOrigin && implementationOrigin !== "insufficient") {
+    issues.push(`claims[${index}] 已阻塞，implementationOrigin 必须是 insufficient`);
+  }
+  const contextualWithoutMeasurement = claim.type === "method"
+    || claim.type === "limitation"
+    || (Array.isArray(claim.reproduction.derivedFromClaimIds)
+      && claim.reproduction.derivedFromClaimIds.length > 0);
+  if (status === "planned" && measurements.length === 0 && contextualWithoutMeasurement) {
+    return {
+      ...claim.reproduction,
+      status: "not_applicable",
+      reason: typeof claim.reproduction.reason === "string" && claim.reproduction.reason.trim()
+        ? claim.reproduction.reason
+        : "No paper-reported measurement is attached to this claim, so CiteArk keeps it as contextual research structure instead of scheduling an independent measurement-based reproduction.",
+    };
+  }
+  if (
+    (claim.type === "finding" || claim.type === "measurement")
+    && measurements.length === 0
+    && !contextualWithoutMeasurement
+  ) {
+    return {
+      ...claim.reproduction,
+      status: "blocked",
+      implementationOrigin: "insufficient",
+      reason: typeof claim.reproduction.reason === "string" && claim.reproduction.reason.trim()
+        ? claim.reproduction.reason
+        : "This empirical claim has no safely extractable paper-reported measurement or direct decision rule for an automatic experiment.",
+    };
+  }
+  if (status === "not_applicable" && !contextualWithoutMeasurement) {
+    return {
+      ...claim.reproduction,
+      status: "blocked",
+      implementationOrigin: "insufficient",
+      reason: typeof claim.reproduction.reason === "string" && claim.reproduction.reason.trim()
+        ? claim.reproduction.reason
+        : "This empirical claim does not yet have a complete executable measurement binding.",
+    };
+  }
+  if (status !== "planned") {
+    required(claim.reproduction.reason, `claims[${index}].reproduction.reason`, issues);
+  }
+  if (status === "not_applicable") {
+    const derived = claim.reproduction.derivedFromClaimIds;
+    if (derived !== undefined && (!Array.isArray(derived) || derived.some((value) => typeof value !== "string" || !value))) {
+      issues.push(`claims[${index}].reproduction.derivedFromClaimIds 必须是非空字符串数组`);
+    }
+  }
+  return claim.reproduction;
+}
+
+function validateCoverageInventory(value, claimIds, sourceIds, issues) {
+  if (!isRecord(value)) {
+    issues.push("coverage 必须是对象");
+    return value;
+  }
+  const items = array(value.items, "coverage.items", issues);
+  if (items.length === 0) issues.push("coverage.items 必须至少包含一项论文经验结果盘点");
+  const itemIds = new Set();
+  items.forEach((item, index) => {
+    const label = `coverage.items[${index}]`;
+    if (!isRecord(item)) return issues.push(`${label} 必须是对象`);
+    required(item.id, `${label}.id`, issues);
+    if (itemIds.has(item.id)) issues.push(`coverage item id 重复：${item.id}`);
+    itemIds.add(item.id);
+    required(item.description, `${label}.description`, issues);
+    validateLocator(item.sourceLocator, `${label}.sourceLocator`, sourceIds, issues);
+    if (!COVERAGE_STATUSES.has(item.status)) issues.push(`${label}.status 无效`);
+    const coveredClaims = array(item.claimIds, `${label}.claimIds`, issues);
+    for (const claimId of coveredClaims) {
+      if (!claimIds.has(claimId)) issues.push(`${label} 引用了不存在的 claim：${claimId}`);
+    }
+    if (item.status === "represented" && coveredClaims.length === 0) {
+      issues.push(`${label}.status=represented 时必须引用至少一个 claim`);
+    }
+    if (item.status !== "represented") required(item.reason, `${label}.reason`, issues);
+  });
+  return value;
+}
+
+function validateMeasurement(value, label, issues) {
+  if (!isRecord(value)) {
+    issues.push(`${label} 必须是对象`);
+    return;
+  }
+  required(value.metric, `${label}.metric`, issues);
+  required(value.unit, `${label}.unit`, issues);
+  if (value.value !== undefined && (typeof value.value !== "number" || !Number.isFinite(value.value))) {
+    issues.push(`${label}.value 必须是有限数值`);
+  }
+  if (
+    value.verificationTolerance !== undefined
+    && (
+      typeof value.verificationTolerance !== "number"
+      || !Number.isFinite(value.verificationTolerance)
+      || value.verificationTolerance < 0
+    )
+  ) {
+    issues.push(`${label}.verificationTolerance 必须是非负有限数值`);
+  }
+  if (
+    value.evidenceBasis !== undefined
+    && !new Set(["reported_numeric", "digitized_figure", "derived_reported_relation"])
+      .has(value.evidenceBasis)
+  ) {
+    issues.push(`${label}.evidenceBasis 无效`);
+  }
+  if (
+    value.extractionUncertainty !== undefined
+    && (
+      typeof value.extractionUncertainty !== "number"
+      || !Number.isFinite(value.extractionUncertainty)
+      || value.extractionUncertainty < 0
+    )
+  ) {
+    issues.push(`${label}.extractionUncertainty 必须是非负有限数值`);
+  }
+  if (
+    value.evidenceBasis === "digitized_figure"
+    && value.extractionUncertainty === undefined
+  ) {
+    issues.push(`${label}.evidenceBasis=digitized_figure 时必须声明 extractionUncertainty`);
+  }
+}
+
+function validateLocator(value, label, sourceIds, issues) {
+  if (!isRecord(value)) {
+    issues.push(`${label} 必须是对象`);
+    return;
+  }
+  required(value.sourceId, `${label}.sourceId`, issues);
+  required(value.locator, `${label}.locator`, issues);
+  if (value.sourceId && !sourceIds.has(value.sourceId)) issues.push(`${label}.sourceId 不存在：${value.sourceId}`);
+}
+
+function array(value, label, issues) {
+  if (!Array.isArray(value)) {
+    issues.push(`${label} 必须是数组`);
+    return [];
+  }
+  return value;
+}
+
+function required(value, label, issues) {
+  if (typeof value !== "string" || !value.trim()) issues.push(`${label} 必须是非空字符串`);
+}