@citeark/agent 0.3.20

package/src/reproduction/summary.mjs

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { extractRunnerCommandRecords } from "../execution/runner-audit.mjs";
+import { parseContractEvidence } from "../evidence/registry.mjs";
+import { isRecord, pathExists, readJson, safeRelativePath, writeJson } from "../util.mjs";
+import { planEvidencePaths } from "./plan.mjs";
+import { measurementInterpretation } from "./evidence-feedback.mjs";
+
+/** Build operational metadata from captured records; never create observations.
+ * The Agent summary and plan remain declarations. Independent integrity and
+ * scientific assessment still determine whether the captured evidence is valid.
+ */
+export async function materializeWorkspaceSummary(submission, contract, outputDirectory) {
+  const issues = [];
+  if (submission.schemaVersion !== "2.0") issues.push("workspace summary.schemaVersion must be 2.0");
+  if (!["completed", "partial", "failed"].includes(submission.status)) issues.push("workspace summary.status must be completed, partial or failed");
+  if (typeof submission.summary !== "string" || !submission.summary.trim()) issues.push("workspace summary.summary is required");
+  if (submission.limitations !== undefined && (!Array.isArray(submission.limitations)
+    || submission.limitations.some((item) => typeof item !== "string"))) issues.push("workspace summary.limitations must be strings");
+  if (submission.evidence !== undefined && !Array.isArray(submission.evidence)) issues.push("workspace summary.evidence must be an array");
+  if (issues.length) return { result: null, issues };
+
+  const evidence = new Map();
+  const missing = [];
+  const add = async (filename, description, explicit = false) => {
+    if (!safeRelativePath(filename)) {
+      issues.push(`Unsafe evidence path: ${String(filename)}`);
+      return;
+    }
+    if (filename === "result.json") return;
+    const target = path.join(outputDirectory, filename);
+    const stat = await lstat(target).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!stat) { if (explicit) missing.push(filename); return; }
+    const [root, resolved] = await Promise.all([realpath(outputDirectory), realpath(target)]);
+    if (!stat.isFile() || !resolved.startsWith(`${root}${path.sep}`)) {
+      issues.push(`Evidence is not a regular workspace file: ${filename}`);
+      return;
+    }
+    evidence.set(filename, { path: filename, description: description || `Preserved workspace evidence: ${filename}` });
+  };
+  for (const measurement of contract.measurements) {
+    await add(measurement.parser.evidencePath, `Raw parser input for ${measurement.measurementId}`);
+  }
+  for (const item of submission.evidence ?? []) {
+    if (!isRecord(item)) { issues.push("Each additional evidence item must specify path"); continue; }
+    await add(item.path, item.description, true);
+  }
+  for (const filename of await planEvidencePaths(outputDirectory)) await add(filename, "Research plan declaration retained for independent assessment");
+  for (const filename of ["progress.md", "experiment-records.jsonl"]) await add(filename);
+  const logDirectory = path.join(outputDirectory, "experiment-logs");
+  if (await pathExists(logDirectory)) {
+    for (const name of await readdir(logDirectory)) {
+      if (/^[a-f0-9-]{36}\.(?:stdout|stderr)\.log$/.test(name)) {
+        await add(`experiment-logs/${name}`, "Raw experiment command output captured by the execution helper");
+      }
+    }
+  }
+  // A summary need not enumerate every raw history. Preserve generated tables
+  // before the scientific machine disappears, independently of parser bindings.
+  async function retainRaw(directory = "") {
+    for (const entry of await readdir(path.join(outputDirectory, directory), { withFileTypes: true })) {
+      const relative = directory ? `${directory}/${entry.name}` : entry.name;
+      if (/(?:^|\/)(?:\.env[^/]*|auth\.json|credentials\.json|secrets\.json)$/i.test(relative)) continue;
+      if (entry.isDirectory()) await retainRaw(relative);
+      else if (entry.isFile() && relative !== "result.json" && /\.(?:json|jsonl|ndjson|csv|tsv|txt|log|parquet|arrow)$/i.test(relative))
+        await add(relative, "Original scientific table or history retained independently of the summary");
+    }
+  }
+  await retainRaw();
+  if (issues.length) return { result: null, issues };
+
+  const executionDirectory = path.resolve(outputDirectory, "../execution");
+  const runPath = path.resolve(outputDirectory, "../run.json");
+  const run = await pathExists(runPath) ? await readJson(runPath) : {};
+  const tracePath = path.join(executionDirectory, "trace.jsonl");
+  const trace = await pathExists(tracePath) ? await readFile(tracePath, "utf8") : "";
+  const commands = [...new Set(extractRunnerCommandRecords(trace, { runtime: run.runtime ?? contract.agent?.runtime })
+    .map((record) => record.command?.text).filter((command) => typeof command === "string" && command.trim()))];
+  const changesPath = path.join(executionDirectory, "workspace-changes.json");
+  const changes = await pathExists(changesPath) ? await readJson(changesPath) : {};
+  const codeChanges = [...new Set([...(changes.added ?? []), ...(changes.modified ?? []), ...(changes.deleted ?? [])]
+    .map((item) => item.path).filter(safeRelativePath))].map((filename) => ({
+      path: filename,
+      classification: "scientific",
+      reason: "Runner-observed workspace change; independent assessment determines its scientific effect.",
+    }));
+  // Availability is determined by parsing real bytes. Missing/bad bindings are
+  // disclosed as partial evidence, not a reason to restart expensive compute.
+  const parsed = await parseContractEvidence({ contract, outputDirectory,
+    result: { execution: { status: "partial" }, evidence: [...evidence.values()] },
+  });
+  const unavailable = parsed.measurements.filter((item) => item.availability.status !== "available");
+  const unresolvedInterpretations = contract.measurements.filter((item) => measurementInterpretation(item).status === "unresolved");
+  const limitations = [...(submission.limitations ?? [])];
+  if (unresolvedInterpretations.length) limitations.push(`Unresolved metric interpretation: ${unresolvedInterpretations.map((item) => `${item.measurementId}: ${measurementInterpretation(item).reason}`).join("; ")}`);
+  if (missing.length) limitations.push(`Listed evidence was absent: ${missing.join(", ")}.`);
+  if (unavailable.length) limitations.push(`Unresolved measurements: ${unavailable.map((item) => `${item.measurementId}: ${item.availability.reason}`).join("; ")}`);
+  if (!commands.length) limitations.push("The runner did not capture an execution command; completion is not established.");
+  const status = submission.status === "failed" ? "failed"
+    : submission.status === "partial" || missing.length || unavailable.length || unresolvedInterpretations.length || !commands.length ? "partial" : "succeeded";
+  const result = {
+    schemaVersion: "1.0",
+    execution: {
+      status,
+      summary: submission.summary,
+      failure: status === "succeeded" ? null : {
+        category: unavailable.length ? "metric_unavailable" : "execution_error",
+        stage: "measurement",
+        retryable: false,
+        reason: [submission.summary, ...limitations].join("\n"),
+      },
+    },
+    experiment: { commands, entrypoint: contract.protocol?.entrypoint ?? null, checkpoint: null },
+    codeChanges,
+    evidence: [...evidence.values()],
+    outputs: [],
+    limitations,
+    diagnosis: submission.summary,
+  };
+  // Keep the exact Agent submission in output/result.json. This coordinator
+  // projection is reconstructible and never takes its place as raw evidence.
+  await writeJson(path.join(executionDirectory, "workspace-result.json"), {
+    source: "platform-workspace-summary", contractDigest: contract.contractDigest,
+    executionPlanDigest: contract.executionPlan?.digest, result,
+  });
+  return { result, issues: [], parsed };
+}

package/src/reproduction/workspace-mode.mjs

@@ -0,0 +1,7 @@
+export function hasResearchWorkspace(contract) {
+  return [1, 2].includes(contract?.workspacePlan?.version);
+}
+
+export function usesWorkspaceSummary(contract) {
+  return contract?.workspacePlan?.version === 2;
+}

package/src/research/automatic-admission.mjs

@@ -0,0 +1,156 @@
+export const AUTOMATIC_RECONSTRUCTION_FIDELITIES = Object.freeze([
+  "exact",
+  "faithful",
+  "approximate",
+]);
+
+const AUTOMATIC_FIDELITIES = new Set(AUTOMATIC_RECONSTRUCTION_FIDELITIES);
+const REQUIRED_PREFLIGHT_CHECKS = Object.freeze([
+  "runtime",
+  "dependencies",
+  "entrypoint",
+  "parser",
+  "smoke_test",
+]);
+
+/**
+ * Automatic reproduction accepts honest independent reconstructions as well
+ * as exact and faithful protocols. Fidelity describes comparability; it does
+ * not decide whether useful evidence may be collected. Directional proxy work
+ * still requires an explicit researcher selection because it does not test the
+ * paper-bound measurement itself.
+ */
+export function automaticExperimentAdmission(experiment) {
+  const reasons = [];
+  if (!experiment?.measurements?.length) {
+    reasons.push({ code: "admission.numeric_targets_unresolved",
+      message: "计划保留了观察比较方法，但没有可验证的数值目标；定性判定规则尚未闭合" });
+  }
+  const agentPlanned = experiment?.protocol?.executionMode === "agent_planned";
+  const hasDevicePerformance = (experiment?.measurements ?? [])
+    .some((measurement) => measurement?.quantityKind === "device_performance");
+  const benchmark = experiment?.protocol?.benchmark;
+  const fidelity = experiment?.reconstructionFidelity
+    ?? (experiment?.implementationOrigin === "official" ? "faithful" : "approximate");
+  if (!AUTOMATIC_FIDELITIES.has(fidelity)) {
+    reasons.push({
+      code: "admission.proxy_requires_selection",
+      message: `${fidelity} 实验只提供替代性方向证据，需要研究者显式选择`,
+    });
+  }
+
+  if (benchmark?.comparisonIntent === "cross_hardware") {
+    reasons.push({
+      code: "admission.cross_hardware_requires_selection",
+      message: "跨硬件实验只能回答独立的可移植性问题，不能自动作为论文报告性能数值的复现目标",
+    });
+  }
+  if ((hasDevicePerformance || benchmark) && benchmark?.hardwareBinding === "unknown") {
+    reasons.push({
+      code: "admission.hardware_binding_unresolved",
+      message: "论文性能测量的硬件绑定尚未确定，不能在解析该条件前自动启动实验",
+    });
+  }
+
+  const preflight = experiment?.protocol?.preflight;
+  if (!preflight || (!agentPlanned && preflight.source !== "declared")) {
+    reasons.push({
+      code: "admission.preflight_not_declared",
+      message: agentPlanned
+        ? "自动复现必须具有结构化预检目标"
+        : "固定入口自动复现必须具有编译期声明的结构化预检",
+    });
+  }
+
+  const checks = new Set(
+    Array.isArray(preflight?.checks)
+      ? preflight.checks.map((check) => check?.kind).filter(Boolean)
+      : [],
+  );
+  for (const kind of REQUIRED_PREFLIGHT_CHECKS) {
+    if (!checks.has(kind)) {
+      reasons.push({
+        code: `admission.preflight_check_missing.${kind}`,
+        message: `自动预检缺少 ${kind} 检查`,
+      });
+    }
+  }
+
+  const assets = Array.isArray(preflight?.assets) ? preflight.assets : [];
+  const requiredAssets = assets.filter((asset) => asset?.required === true);
+  if (requiredAssets.some((asset) => asset?.kind === "dataset") && !checks.has("dataset_loader")) {
+    reasons.push({
+      code: "admission.dataset_loader_missing",
+      message: "必需数据集没有真实 loader 预检",
+    });
+  }
+  // Asset availability and locator quality are runtime observations, not an
+  // automatic-run verdict. The complete reproduction Agent may inspect the
+  // fixed paper/repository, find an allowed public transport, or report a
+  // concrete evidence-backed limitation. Static admission only decides
+  // whether the scientific plan is strict and structurally executable.
+
+  return {
+    schemaVersion: "0.1",
+    experimentId: experiment?.id ?? null,
+    fidelity,
+    automatic: reasons.length === 0,
+    reasons: uniqueReasons(reasons),
+    publicAssetsToProbe: requiredAssets
+      .filter((asset) => asset?.availability === "public_unverified")
+      .filter((asset) => (asset?.scientificRole ?? "execution_required") === "execution_required")
+      .map((asset) => ({
+        id: asset.id,
+        kind: asset.kind,
+        identity: asset.identity,
+        sourceUrls: Array.isArray(asset.sourceUrls) ? [...asset.sourceUrls] : [],
+        registryDatasetId: asset.registryDatasetId,
+        scientificRole: asset.scientificRole ?? "execution_required",
+        acquisition: asset.acquisition ?? { mode: "auto" },
+        sourceEvidence: Array.isArray(asset.sourceEvidence) ? [...asset.sourceEvidence] : [],
+      })),
+  };
+}
+
+export function automaticClaimCoverage(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)
+    && automaticExperimentAdmission(experiment).automatic,
+  );
+  const coveredIds = new Set();
+  for (const experiment of bound) {
+    for (const measurement of experiment.measurements ?? []) {
+      if (requiredIds.has(measurement?.reportedMeasurementId)) {
+        coveredIds.add(measurement.reportedMeasurementId);
+      }
+    }
+  }
+  return {
+    bound,
+    coveredIds,
+    missingIds: [...requiredIds].filter((measurementId) => !coveredIds.has(measurementId)),
+  };
+}
+
+export function automaticAdmissionByExperiment(research) {
+  return new Map(
+    (Array.isArray(research?.experiments) ? research.experiments : [])
+      .map((experiment) => [experiment.id, automaticExperimentAdmission(experiment)]),
+  );
+}
+
+function uniqueReasons(reasons) {
+  const seen = new Set();
+  return reasons.filter((reason) => {
+    const key = `${reason.code}\u0000${reason.assetId ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/research/compiler-coverage.mjs

@@ -0,0 +1,85 @@
+import { reproductionScopeIssues } from "./reproduction-scope.mjs";
+import { automaticClaimCoverage } from "./automatic-admission.mjs";
+import { continuationRepairTargets } from "./continuation-selection.mjs";
+
+const BLOCKER_KINDS = new Set(["scientific_input", "access", "resources", "budget", "decision_rule"]);
+const nonempty = (value) => typeof value === "string" && value.trim().length > 0;
+
+/** A planning obligation, not a claim of scientific support or feasibility. */
+export function reviewCompilerCoverage(research, context = {}, previousInventory = []) {
+  const claims = Array.isArray(research?.claims) ? research.claims : [];
+  const targets = context.repairBaselineResearch ? continuationRepairTargets(context.continuation) : [];
+  const targetIds = new Set(targets.map((target) => target.experimentId));
+  const selected = targets.length ? new Set(targets.flatMap((target) =>
+    (context.repairBaselineResearch.experiments ?? [])
+      .filter((experiment) => experiment.id === target.experimentId)
+      .flatMap((experiment) => (experiment.measurements ?? []).map((measurement) => `${target.claimId}/${measurement.reportedMeasurementId}`)),
+  )) : null;
+  // Scope comes from the host's immutable continuation baseline, never from
+  // the candidate's choice to omit experiments or to label claims deferred.
+  const experiments = (Array.isArray(research?.experiments) ? research.experiments : [])
+    .filter((experiment) => !selected || targetIds.has(experiment.id));
+  const inventory = claims.flatMap((claim) => {
+    const measurements = Array.isArray(claim.reportedMeasurements) ? claim.reportedMeasurements : [];
+    if (measurements.length) return measurements.map((measurement) => ({
+      claimId: claim.id, measurementId: measurement.id, sourceLocator: measurement.sourceLocator ?? claim.sourceLocator,
+    }));
+    return ["finding", "measurement"].includes(claim.type)
+      ? [{ claimId: claim.id, measurementId: null, sourceLocator: claim.sourceLocator }]
+      : [];
+  }).filter((item) => !selected || selected.has(`${item.claimId}/${item.measurementId}`));
+  const inventoryOnly = research.compilationStage === "inventory";
+  const obligations = [];
+  for (const claim of claims) {
+    const required = inventory.filter((item) => item.claimId === claim.id);
+    if (!required.length) continue;
+    const coverage = automaticClaimCoverage(claim, experiments);
+    const blocker = claim.reproduction?.blocker;
+    const supportedBlocker = BLOCKER_KINDS.has(blocker?.kind) && nonempty(blocker?.evidence)
+      && !(blocker.kind === "budget" && (context.computeContext?.limits?.maximumCost === null));
+    const blockerIds = new Set(Array.isArray(blocker?.measurementIds) ? blocker.measurementIds : []);
+    for (const item of required) {
+      const planned = item.measurementId !== null && coverage.coveredIds.has(item.measurementId);
+      const blocked = supportedBlocker && (
+        (claim.reproduction?.status === "blocked" && coverage.coveredIds.size === 0 && !Array.isArray(blocker.measurementIds))
+        || blockerIds.has(item.measurementId)
+      );
+      obligations.push({
+        ...item,
+        status: inventoryOnly ? "recorded" : planned ? "planned" : context.licensePolicy?.executable === false ? "license_restricted" : blocked ? "blocked" : "unresolved",
+        ...(blocked ? { blocker } : {}),
+      });
+    }
+  }
+  // Keep the first discovered inventory across correction attempts. Regrouping
+  // measurements into better claims is allowed; silently deleting them is not.
+  const currentMeasurements = new Set(inventory.filter((item) => item.measurementId).map((item) => item.measurementId));
+  const currentClaims = new Set(claims.map((claim) => claim.id));
+  const dropped = previousInventory.filter((item) => item.measurementId
+    ? !currentMeasurements.has(item.measurementId)
+    : !currentClaims.has(item.claimId));
+  const unresolved = obligations.filter((item) => item.status === "unresolved");
+  const issues = reproductionScopeIssues(research, context.reproductionScope);
+  if (unresolved.length) issues.push(
+    `Compiler coverage incomplete: ${unresolved.map((item) => `${item.claimId}/${item.measurementId ?? "decision_rule"}`).join(", ")}. `
+    + "Bind each known empirical measurement to an experiment, or record a concrete blocker with kind and source/probe evidence. "
+    + "Keep the requested preset separate from scientific planning: a lower preset must not remove a valid experiment package. Reuse appropriate data, software, traces, model weights and simulation outputs when scientifically justified; never regenerate upstream artifacts as an automatic fallback. Complete source inventory does not require executing every package. "
+    + "An objective-only agent_planned experiment with measurement bindings is a valid planning route; describe unresolved assumptions and the bounded runtime probe in its objective. "
+    + "Unverified commands, public assets or runtime estimates alone do not establish a blocker, and planning a probe does not establish full-workload feasibility. "
+    + "For a partially planned claim, blocker.measurementIds must identify exactly the unbound measurements it prevents. "
+    + "A deferred label, representative subset, another benchmark, or an unsupported estimate is not a completed planning decision. "
+    + "Preserve every existing valid experiment. Operational details can be resolved by the execution Agent, but missing experiments cannot. "
+    + "This requirement still applies on the final correction attempt; unresolved scope cannot be published as an executable plan.",
+  );
+  if (dropped.length) issues.push(
+    `Compiler coverage inventory lost: ${dropped.map((item) => `${item.claimId}/${item.measurementId ?? "decision_rule"}`).join(", ")}. `
+    + "Restore these previously identified results. You may regroup measurements into scientifically appropriate claims while preserving their measurement ids; deleting difficult scope cannot satisfy coverage.",
+  );
+  return {
+    version: 1, stage: inventoryOnly ? "inventory" : "execution_plan", scope: selected ? "continuation" : "full_paper", complete: issues.length === 0,
+    inventory: [...previousInventory, ...inventory.filter((item) => !previousInventory.some((previous) =>
+      item.measurementId ? previous.measurementId === item.measurementId : previous.claimId === item.claimId && previous.measurementId === null,
+    ))],
+    obligations, issues,
+  };
+}

package/src/research/compiler-failure.mjs

@@ -0,0 +1,24 @@
+import { CiteArkError } from "../util.mjs";
+
+/**
+ * Semantic validation retries belong to one Research Compiler run. Once that
+ * bounded repair loop is exhausted, starting a fresh Processing Worker with
+ * the same inputs only repeats model spend, so the outer worker must fail
+ * closed. Provider and transport failures retain their explicit retryability.
+ */
+export function researchCompilationFailure(validationIssues, providerFailure = null) {
+  const issues = (Array.isArray(validationIssues) ? validationIssues : [])
+    .map((issue) => String(issue ?? "").trim())
+    .filter(Boolean);
+  return new CiteArkError(
+    `研究编译失败：\n- ${issues.join("\n- ")}`,
+    {
+      exitCode: 2,
+      retryable: providerFailure ? providerFailure.retryable === true : false,
+      failureCode: providerFailure?.code ?? "research_compilation.validation_exhausted",
+      failureCategory: providerFailure?.failureCategory ?? "research_compilation",
+      recoveryAction: providerFailure?.recoveryAction
+        ?? "保留编译现场并停止自动重跑；修正规则或输入后创建显式续跑任务",
+    },
+  );
+}

package/src/research/compiler-normalization-guards.mjs

@@ -0,0 +1,112 @@
+const HARDWARE_SENSITIVE_METRIC = /(?:^|[_ -])(time|latency|throughput|memory|energy|runtime|duration|wall(?:[_ -]?clock)?|speed(?:up)?|flops?|joules?|watts?)(?:$|[_ -])/i;
+
+export function commandVerifiesDependencies(value) {
+  const command = textValue(value) ?? "";
+  return /(?:\b(?:from\s+[A-Za-z_][A-Za-z0-9_.]*\s+import|import\s+[A-Za-z_][A-Za-z0-9_.]*)\b|\b(?:pip|pip3|uv\s+pip|npm|pnpm|yarn)\s+(?:check|show|list|ls|freeze)\b|(?:^|[;&|]\s*|\|\|\s*)(?:make|cmake|ninja)(?:\s|$)|\bcommand\s+-v\s+[A-Za-z0-9_.+-]+)/i.test(command);
+}
+
+export function isSimpleScriptEntrypoint(value) {
+  const entrypoint = textValue(value) ?? "";
+  if (/^[A-Za-z0-9._/-]+$/.test(entrypoint.trim())) return true;
+  return /^\s*(?:bash|sh|python(?:3(?:\.\d+)?)?)\s+(?:\/job\/workspace\/repository\/)?[A-Za-z0-9._/-]+\s*$/i
+    .test(entrypoint);
+}
+
+export function hardwareSensitiveMetric(value) {
+  return HARDWARE_SENSITIVE_METRIC.test(textValue(value) ?? "");
+}
+
+export function explicitlyUnderspecifiedHardwareProtocol(experiment, bindings = []) {
+  if (!bindings.some(({ measurement, reported }) =>
+    hardwareSensitiveMetric(measurement?.metric ?? reported?.metric))) return false;
+  const description = [
+    experiment?.title,
+    experiment?.protocol?.objective,
+    experiment?.protocol?.instructions,
+  ].map(textValue).filter(Boolean).join(" ");
+  return /(?:paper|article|source|authors?)[\s\S]{0,180}(?:does not|doesn't|did not|never|fails? to|without)[\s\S]{0,180}(?:provide|report|specify|identify|determine)[\s\S]{0,120}(?:hardware|cpu|gpu|device|host|thread|core|timer|timing|benchmark|callable|protocol|measurement conditions?)/i
+    .test(description)
+    || /(?:hardware|cpu|gpu|device|host|thread|core|timer|timing|benchmark|callable|protocol|measurement conditions?)[\s\S]{0,180}(?:not|never|unknown|unspecified|underspecified)[\s\S]{0,120}(?:paper|article|source|reported|provided|specified|identified|determined)/i
+      .test(description);
+}
+
+export function claimHasExplicitHardwareProtocolBlocker(claim) {
+  if (claim?.reproduction?.status !== "blocked") return false;
+  if (!(claim?.reportedMeasurements ?? []).some((measurement) =>
+    hardwareSensitiveMetric(measurement?.metric))) return false;
+  const reason = textValue(claim?.reproduction?.reason) ?? "";
+  return /(?:hardware|cpu|gpu|device|host|thread|core|timer|timing|benchmark|callable|protocol|measurement conditions?)[\s\S]{0,180}(?:unknown|missing|not (?:provided|reported|specified|identified|determined)|unspecified|underspecified)/i
+    .test(reason)
+    || /(?:unknown|missing|not (?:provided|reported|specified|identified|determined)|unspecified|underspecified)[\s\S]{0,180}(?:hardware|cpu|gpu|device|host|thread|core|timer|timing|benchmark|callable|protocol|measurement conditions?)/i
+      .test(reason);
+}
+
+export function sanitizeParserPreflightCommand(commandValue, bindings = []) {
+  let command = textValue(commandValue);
+  if (!command) return { command, replacements: [] };
+  const fixtureLike = /(?:fixture|parser[-_]?sample|write_text|write_bytes|json\.(?:loads|dump)|open\s*\([^)]*,\s*["']w|(?:printf|echo)\b)/i
+    .test(command);
+  if (!fixtureLike) return { command, replacements: [] };
+
+  const replacements = [];
+  for (const { measurement, reported } of bindings) {
+    if (typeof reported?.value !== "number" || !Number.isFinite(reported.value)) continue;
+    const scale = Number(measurement?.parser?.config?.scale ?? 1);
+    const offset = Number(measurement?.parser?.config?.offset ?? 0);
+    const candidates = [reported.value];
+    if (Number.isFinite(scale) && scale !== 0 && Number.isFinite(offset)) {
+      candidates.push(stableNumber((reported.value - offset) / scale));
+    }
+    const sentinel = Number.isFinite(scale) && Math.abs(scale) > 1
+      ? 0.314159
+      : 1.234567;
+    for (const candidate of [...new Set(candidates.filter(Number.isFinite))]) {
+      if (Math.abs(candidate - sentinel) < 1e-12) continue;
+      const literal = numericLiteralPattern(candidate);
+      const matcher = new RegExp(`(^|[:=,\\s"'\\[{(]|\\\\t)(${literal})(?![0-9.])`, "g");
+      const before = command;
+      command = command.replace(matcher, (_match, prefix) => `${prefix}${sentinel}`);
+      if (command !== before) replacements.push({
+        measurementId: measurement?.reportedMeasurementId ?? reported?.id ?? null,
+        target: candidate,
+        sentinel,
+      });
+    }
+  }
+  return { command, replacements };
+}
+
+export function parserPreflightTargetLeaks(commandValue, bindings = []) {
+  const command = textValue(commandValue);
+  if (!command) return [];
+  return bindings.flatMap(({ measurement, reported }) => {
+    if (typeof reported?.value !== "number" || !Number.isFinite(reported.value)) return [];
+    const scale = Number(measurement?.parser?.config?.scale ?? 1);
+    const offset = Number(measurement?.parser?.config?.offset ?? 0);
+    const candidates = [reported.value];
+    if (Number.isFinite(scale) && scale !== 0 && Number.isFinite(offset)) {
+      candidates.push(stableNumber((reported.value - offset) / scale));
+    }
+    return [...new Set(candidates.filter(Number.isFinite))].filter((candidate) => {
+      const literal = numericLiteralPattern(candidate);
+      return new RegExp(`(?:^|[:=,\\s"'\\[{(]|\\\\t)${literal}(?![0-9.])`).test(command);
+    });
+  });
+}
+
+function numericLiteralPattern(value) {
+  if (Number.isInteger(value)) return `${escapeRegExp(String(value))}(?:\\.0+)?`;
+  return escapeRegExp(String(value));
+}
+
+function stableNumber(value) {
+  return Number.isFinite(value) ? Number(value.toPrecision(12)) : value;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function textValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/src/research/compiler-repair.mjs

@@ -0,0 +1,3 @@
+export function needsCompilerRepairGeneration(authorized, compilerStatus, cloudState) {
+  return authorized === true && compilerStatus === 'invalid_result' && cloudState === 'SUCCEEDED';
+}