create-agdf 0.11.4 → 0.13.0

package/lib/interaction-presentation.js

@@ -349,6 +349,91 @@ export function renderOperationalStatusCard(statusCard, {
   });
 }
 
+export function renderTaskTargetOrientation(resolution, {
+  registry,
+  requestedLocale,
+} = {}) {
+  if (!plainObject(resolution)) return null;
+
+  const resolutionState = String(resolution.resolution_state ?? "").trim();
+  const reasonCode = String(resolution.reason_code ?? "").trim();
+  const primaryTarget = String(resolution.primary_target ?? "").trim();
+  const governanceTarget = String(resolution.governance_target ?? "").trim();
+  const workingDirectory = String(resolution.working_directory ?? "").trim();
+  const nextAction = String(resolution.next_action ?? "").trim();
+  if (typeof resolution.target_changed !== "boolean") return null;
+  const targetChanged = resolution.target_changed === true;
+  const evidenceSources = Array.isArray(resolution.evidence_sources)
+    ? resolution.evidence_sources.map((item) => String(item ?? "").trim()).filter(Boolean)
+    : null;
+
+  const resolvedReasons = new Set(["explicit_target", "continued_target"]);
+  const unresolvedReasons = new Set([
+    "multiple_plausible_targets",
+    "target_content_mismatch",
+    "target_unavailable",
+    "no_reliable_target",
+  ]);
+
+  if (!["resolved", "unresolved"].includes(resolutionState)) return null;
+  if (!workingDirectory || evidenceSources === null) return null;
+  if (resolutionState === "resolved") {
+    if (!resolvedReasons.has(reasonCode) || !primaryTarget || nextAction) return null;
+  } else if (!unresolvedReasons.has(reasonCode) || primaryTarget || governanceTarget || !nextAction || targetChanged) {
+    return null;
+  }
+
+  let locale;
+  try {
+    locale = resolvePresentationLocale(registry, requestedLocale);
+  } catch {
+    return null;
+  }
+  if (!locale) return null;
+
+  const pack = localePack(registry, locale);
+  const labels = pack?.taskTargetResolution;
+  if (!plainObject(labels) || !plainObject(labels.reasonCodes)) return null;
+  const reason = labels.reasonCodes[reasonCode];
+  if (!reason) return null;
+
+  const rows = resolutionState === "resolved"
+    ? [
+        [labels.state, labels.resolved],
+        [labels.primaryTarget, primaryTarget],
+        [labels.governanceTarget, governanceTarget || labels.none],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.reason, reason],
+        ...(targetChanged ? [[labels.targetChanged, labels.yes]] : []),
+      ]
+    : [
+        [labels.state, labels.unresolved],
+        [labels.reason, reason],
+        [labels.evidenceSources, evidenceSources.join("; ") || labels.none],
+        [labels.workingDirectory, workingDirectory],
+        [labels.nextAction, nextAction],
+      ];
+
+  const markdown = [
+    `## ${labels.title}`,
+    "",
+    `| ${labels.field} | ${labels.value} |`,
+    "|---|---|",
+    ...rows.map(([label, value]) => `| ${markdownCell(label)} | ${markdownCell(value)} |`),
+  ].join("\n");
+
+  return Object.freeze({
+    schema_version: "1",
+    semantic_block: "task_target_orientation",
+    presentation_language: locale,
+    resolution_state: resolutionState,
+    reason_code: reasonCode,
+    markdown,
+    authorizes: false,
+  });
+}
+
 export function renderScopeClassificationCard(classification, {
   registry,
   requestedLocale,

package/lib/live-agent/read-only-structured.js

@@ -0,0 +1,43 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { guardedExecFileSync } from "../delivery-path-search/transports/read-only-guard.js";
+
+export function executeStructuredAgent({ surface, cwd, prompt, model, outputSchema, timeoutMs = 120000 }) {
+  if (surface === "codex") {
+    const temp = mkdtempSync(join(tmpdir(), "agdf-live-codex-"));
+    try {
+      const schemaPath = join(temp, "schema.json");
+      const outputPath = join(temp, "output.json");
+      writeFileSync(schemaPath, `${JSON.stringify(outputSchema, null, 2)}\n`, "utf8");
+      const args = [
+        "exec", "--sandbox", "read-only", "--ephemeral", "--ignore-user-config",
+        "--skip-git-repo-check", "--output-schema", schemaPath,
+        "--output-last-message", outputPath, "--color", "never",
+      ];
+      if (model) args.push("--model", model);
+      args.push(prompt);
+      guardedExecFileSync("codex", args, {
+        cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs,
+      });
+      return readFileSync(outputPath, "utf8");
+    } finally {
+      rmSync(temp, { recursive: true, force: true });
+    }
+  }
+  if (surface === "claude") {
+    const args = [
+      "-p", "--disallowedTools", "Edit,Write,Bash", "--output-format", "json",
+      "--json-schema", JSON.stringify(outputSchema),
+    ];
+    if (model) args.push("--model", model);
+    args.push(prompt);
+    const raw = guardedExecFileSync("claude", args, {
+      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs,
+    });
+    const envelope = JSON.parse(raw);
+    if (envelope.is_error) throw new Error(`claude live adapter failed: ${envelope.result ?? "unknown error"}`);
+    return envelope.result;
+  }
+  throw new Error(`unsupported live surface: ${surface}`);
+}

package/lib/proportionality-benchmark/blind-prompt.js

@@ -0,0 +1,37 @@
+import { DELIVERY_PATHS } from "./contracts.js";
+
+export function buildBlindPrompt(testCase, behaviorSources) {
+  if (testCase.profile_id === "staged-v2") {
+    return [
+      "Perform a read-only, non-authorizing AGDF benchmark classification. Do not modify files, invoke tools, persist control state, or claim a real approval.",
+      "Synthetic fixture state is measurement input only. Return only JSON matching the supplied schema.",
+      `Allowed stages: ${testCase.allowed_stages.join(", ")}.`,
+      `Allowed paths: ${DELIVERY_PATHS.join(", ")}.`,
+      `Requested axes: ${testCase.requested_axes.join(", ")}. Every requested axis must use evaluated with one non-null allowed value. Non-requested axes must be null with not_evaluable_yet.`,
+      "eventual_delivery_path is a benchmark candidate, never an operative Mode/Slice Decision.",
+      "compact_delivery requires visible approved UR, completed Brownfield analysis, and stored quick_task context in decision_grounds.",
+      `Scenario ID: ${testCase.scenario_id}`,
+      `Case ID: ${testCase.case_id}`,
+      `Lifecycle stage: ${testCase.lifecycle_stage}`,
+      `Task: ${testCase.task_summary}`,
+      `Repository context: ${testCase.repository_context}`,
+      `Control-state context: ${testCase.control_state_context}`,
+      `Evidence pack: ${JSON.stringify(testCase.evidence_pack ?? {})}`,
+      "Current canonical routing sources follow:",
+      behaviorSources,
+    ].join("\n\n");
+  }
+  return [
+    "Classify the delivery path AGDF would select for this task. Do not modify files or invoke tools.",
+    "Return only JSON matching the supplied schema. Do not reveal hidden reasoning.",
+    `Allowed paths: ${DELIVERY_PATHS.join(", ")}.`,
+    "Use null plus ambiguous=true when the evidence does not support one path.",
+    "compact_delivery requires decision_grounds that visibly reference approved UR, completed Brownfield analysis, and stored quick_task context.",
+    `Case ID: ${testCase.case_id}`,
+    `Task: ${testCase.task_summary}`,
+    `Repository context: ${testCase.repository_context}`,
+    `Control-state context: ${testCase.control_state_context}`,
+    "Current canonical routing sources follow:",
+    behaviorSources,
+  ].join("\n\n");
+}

package/lib/proportionality-benchmark/contracts.js

@@ -0,0 +1,120 @@
+export const DELIVERY_PATHS = Object.freeze([
+  "trivial_change", "quick_task", "compact_delivery",
+  "verified_change", "structured_slice", "structured_delivery",
+]);
+export const PATH_RANK = Object.freeze(Object.fromEntries(DELIVERY_PATHS.map((path, index) => [path, index])));
+export const STAGES = Object.freeze([
+  "ungated_execution", "ur", "brownfield_review", "prd", "sd", "tp",
+  "brownfield_analysis", "cd_tests", "cr", "qa", "uat", "or", "blocked",
+]);
+export const OBSERVATION_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "observed_delivery_path", "ambiguous", "rationale", "decision_grounds"],
+  properties: {
+    schema_version: { type: "string", const: "1" },
+    observed_delivery_path: { type: ["string", "null"], enum: [...DELIVERY_PATHS, null] },
+    ambiguous: { type: "boolean" },
+    rationale: { type: "string", maxLength: 600 },
+    decision_grounds: { type: "array", maxItems: 12, items: { type: "string", maxLength: 120 } },
+  },
+});
+export const STAGED_OBSERVATION_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schema_version", "observed_next_permissible_stage", "stage_evaluability",
+    "observed_delivery_path", "path_evaluability", "rationale", "decision_grounds",
+  ],
+  properties: {
+    schema_version: { type: "string", const: "2" },
+    observed_next_permissible_stage: { type: ["string", "null"], enum: [...STAGES, null] },
+    stage_evaluability: { type: "string", enum: ["evaluated", "not_evaluable_yet"] },
+    observed_delivery_path: { type: ["string", "null"], enum: [...DELIVERY_PATHS, null] },
+    path_evaluability: { type: "string", enum: ["evaluated", "not_evaluable_yet"] },
+    rationale: { type: "string", maxLength: 600 },
+    decision_grounds: { type: "array", maxItems: 12, items: { type: "string", maxLength: 120 } },
+  },
+});
+
+const forbiddenBaselineKeys = new Set(["observed_delivery_path", "classification", "status", "passed"]);
+const forbiddenText = /(api[_-]?key|access[_-]?token|cookie|authorization:\s*bearer|hidden reasoning|\/Users\/[^/\s]+|[A-Z]:\\Users\\[^\\\s]+)/i;
+export function fail(message, code = "PROPORTIONALITY_SCHEMA_INVALID") {
+  throw Object.assign(new Error(message), { code });
+}
+export function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+  return value;
+}
+export function validateBaseline(value) {
+  if (value?.schema_version !== "1" || value?.baseline_version !== "1.0.0") fail("unsupported baseline");
+  if (!Array.isArray(value.cases) || value.cases.length !== 40) fail("baseline must contain exactly 40 cases");
+  const ids = new Set();
+  for (const item of value.cases) {
+    if (!/^PB-\d{3}$/.test(item.case_id) || ids.has(item.case_id)) fail(`invalid or duplicate case ${item.case_id}`);
+    if (!DELIVERY_PATHS.includes(item.expected_delivery_path)) fail(`unknown path for ${item.case_id}`);
+    if (!item.task_summary || !item.rationale || !item.evidence_ref || item.evidence_ref.startsWith("/")) fail(`incomplete case ${item.case_id}`);
+    for (const key of forbiddenBaselineKeys) if (key in item) fail(`baseline contains forbidden field ${key}`);
+    ids.add(item.case_id);
+  }
+  if (new Set(value.cases.map((item) => item.expected_delivery_path)).size !== DELIVERY_PATHS.length) fail("baseline path coverage incomplete");
+  if (value.cases.filter((item) => item.adversarial).length < 10) fail("adversarial coverage too small");
+  return value;
+}
+export function normalizeAgentOutput(raw) {
+  let value;
+  try { value = typeof raw === "string" ? JSON.parse(raw) : raw; }
+  catch { fail("agent output is not JSON", "PROPORTIONALITY_OUTPUT_INVALID"); }
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail("agent output is not an object", "PROPORTIONALITY_OUTPUT_INVALID");
+  const allowedKeys = new Set(["schema_version", "observed_delivery_path", "ambiguous", "rationale", "decision_grounds"]);
+  if (Object.keys(value).some((key) => !allowedKeys.has(key))) fail("agent output contains unknown fields", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (value.schema_version !== "1" || typeof value.ambiguous !== "boolean") fail("agent output contract mismatch", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (value.observed_delivery_path !== null && !DELIVERY_PATHS.includes(value.observed_delivery_path)) fail("unknown observed path", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (typeof value.rationale !== "string" || value.rationale.length > 600 || forbiddenText.test(value.rationale)) fail("unsafe rationale", "PROPORTIONALITY_REDACTION_FAILED");
+  if (!Array.isArray(value.decision_grounds) || value.decision_grounds.length > 12 || value.decision_grounds.some((item) => typeof item !== "string" || item.length > 120 || forbiddenText.test(item))) fail("unsafe decision grounds", "PROPORTIONALITY_REDACTION_FAILED");
+  let path = value.observed_delivery_path;
+  let ambiguous = value.ambiguous || path === null;
+  if (path === "compact_delivery") {
+    const grounds = value.decision_grounds.map((item) => item.toLowerCase()).join(" ");
+    if (!grounds.includes("ur") || !grounds.includes("brownfield") || !grounds.includes("quick_task")) {
+      path = null;
+      ambiguous = true;
+    }
+  }
+  if (ambiguous) path = null;
+  return { schema_version: "1", observed_delivery_path: path, ambiguous, rationale: value.rationale, decision_grounds: [...value.decision_grounds] };
+}
+export function normalizeStagedAgentOutput(raw, requestedAxes) {
+  let value;
+  try { value = typeof raw === "string" ? JSON.parse(raw) : raw; }
+  catch { fail("agent output is not JSON", "PROPORTIONALITY_OUTPUT_INVALID"); }
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail("agent output is not an object", "PROPORTIONALITY_OUTPUT_INVALID");
+  const allowed = new Set(Object.keys(STAGED_OBSERVATION_SCHEMA.properties));
+  if (Object.keys(value).some((key) => !allowed.has(key))) fail("agent output contains unknown fields", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (value.schema_version !== "2" || (!STAGES.includes(value.observed_next_permissible_stage) && value.observed_next_permissible_stage !== null)) fail("invalid staged contract", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (!DELIVERY_PATHS.includes(value.observed_delivery_path) && value.observed_delivery_path !== null) fail("invalid staged path", "PROPORTIONALITY_OUTPUT_INVALID");
+  if (!["evaluated", "not_evaluable_yet"].includes(value.stage_evaluability) || !["evaluated", "not_evaluable_yet"].includes(value.path_evaluability)) fail("invalid staged evaluability", "PROPORTIONALITY_OUTPUT_INVALID");
+  for (const [axis, observed, evaluability] of [
+    ["next_permissible_stage", value.observed_next_permissible_stage, value.stage_evaluability],
+    ["eventual_delivery_path", value.observed_delivery_path, value.path_evaluability],
+  ]) {
+    const requested = requestedAxes.includes(axis);
+    if (requested !== (evaluability === "evaluated") || (requested ? observed === null : observed !== null)) fail(`axis invariant failed: ${axis}`, "PROPORTIONALITY_OUTPUT_INVALID");
+  }
+  if (typeof value.rationale !== "string" || value.rationale.length > 600 || forbiddenText.test(value.rationale)) fail("unsafe rationale", "PROPORTIONALITY_REDACTION_FAILED");
+  if (!Array.isArray(value.decision_grounds) || value.decision_grounds.length > 12 || value.decision_grounds.some((item) => typeof item !== "string" || item.length > 120 || forbiddenText.test(item))) fail("unsafe decision grounds", "PROPORTIONALITY_REDACTION_FAILED");
+  if (value.observed_delivery_path === "compact_delivery") {
+    const grounds = value.decision_grounds.join(" ").toLowerCase();
+    if (!grounds.includes("ur") || !grounds.includes("brownfield") || !grounds.includes("quick_task")) fail("compact delivery evidence missing", "PROPORTIONALITY_OUTPUT_INVALID");
+  }
+  return {
+    schema_version: "2",
+    observed_next_permissible_stage: value.observed_next_permissible_stage,
+    stage_evaluability: value.stage_evaluability,
+    observed_delivery_path: value.observed_delivery_path,
+    path_evaluability: value.path_evaluability,
+    rationale: value.rationale,
+    decision_grounds: [...value.decision_grounds],
+  };
+}

package/lib/proportionality-benchmark/corpus-loader.js

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, relative, resolve, sep } from "node:path";
+import { fail, validateBaseline } from "./contracts.js";
+
+function inside(root, candidate) {
+  const target = resolve(root, candidate);
+  const rel = relative(root, target);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep}`)) fail(`unsafe corpus path ${candidate}`);
+  return target;
+}
+function existingInside(root, candidate) {
+  const target = inside(root, candidate);
+  if (!existsSync(target)) fail(`missing corpus path ${candidate}`);
+  const canonicalRoot = realpathSync(root);
+  const canonicalTarget = realpathSync(target);
+  const rel = relative(canonicalRoot, canonicalTarget);
+  if (rel === ".." || rel.startsWith(`..${sep}`)) fail(`corpus path escapes through symlink ${candidate}`);
+  return target;
+}
+function sha256(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+const stagedForbidden = /expected_|evidence_ref|classification|threshold|trivial_change|compact_delivery|verified_change|structured_slice|structured_delivery/i;
+export function validateStagedBlindScenario(scenario, evidencePack = null, baselineScenario = null) {
+  if (stagedForbidden.test(JSON.stringify(scenario))) fail(`staged scenario leakage ${scenario.scenario_id}`, "PROPORTIONALITY_LEAKAGE");
+  const quickTaskReferences = JSON.stringify(scenario).match(/quick_task/gi)?.length ?? 0;
+  if (quickTaskReferences && (
+    scenario.lifecycle_stage !== "post_brownfield_decision"
+    || scenario.control_state_context !== "A durable UR is approved. Brownfield analysis is complete and the stored mode/slice decision is quick_task."
+    || quickTaskReferences !== 1
+  )) fail(`staged scenario path leakage ${scenario.scenario_id}`, "PROPORTIONALITY_LEAKAGE");
+  if (evidencePack && stagedForbidden.test(JSON.stringify(evidencePack))) fail(`staged evidence-pack leakage ${scenario.scenario_id}`, "PROPORTIONALITY_LEAKAGE");
+  if (baselineScenario && (
+    JSON.stringify(scenario).includes(baselineScenario.rationale)
+    || JSON.stringify(evidencePack ?? {}).includes(baselineScenario.rationale)
+  )) fail(`staged rationale leakage ${scenario.scenario_id}`, "PROPORTIONALITY_LEAKAGE");
+  return scenario;
+}
+export function loadCorpus(repoRoot, profileId = "legacy-v1") {
+  const root = existingInside(repoRoot, "evals/proportionality");
+  if (profileId === "staged-v2") {
+    const manifest = JSON.parse(readFileSync(existingInside(root, "staged-manifest.json"), "utf8"));
+    const index = JSON.parse(readFileSync(existingInside(root, manifest.scenarios_path), "utf8"));
+    const fixtures = JSON.parse(readFileSync(existingInside(root, manifest.fixture_path), "utf8"));
+    const baselinePath = existingInside(repoRoot, manifest.baseline_path);
+    const baseline = JSON.parse(readFileSync(baselinePath, "utf8"));
+    if (
+      manifest.profile_id !== "staged-v2"
+      || baseline.schema_version !== "2"
+      || baseline.baseline_version !== manifest.baseline_version
+      || !manifest.corpus_version
+      || !manifest.fixture_version
+      || fixtures.fixture_version !== manifest.fixture_version
+    ) fail("staged profile version mismatch");
+    if (baseline.cases.length !== 40 || index.scenarios.length !== 72 || new Set(index.scenario_ids).size !== 72) fail("staged corpus coverage mismatch");
+    const expectedIds = new Set(baseline.scenarios.map((item) => item.scenario_id));
+    if (index.scenarios.some((item) => !expectedIds.has(item.scenario_id)) || baseline.scenarios.some((item) => !index.scenario_ids.includes(item.scenario_id))) fail("staged scenario baseline mismatch");
+    for (const scenario of index.scenarios) {
+      if (scenario.evidence_pack_id && !fixtures.evidence_packs[scenario.evidence_pack_id]) fail(`missing evidence pack ${scenario.scenario_id}`);
+      validateStagedBlindScenario(
+        scenario,
+        scenario.evidence_pack_id ? fixtures.evidence_packs[scenario.evidence_pack_id] : null,
+        baseline.scenarios.find((item) => item.scenario_id === scenario.scenario_id),
+      );
+    }
+    const cases = index.scenarios.map((scenario) => ({
+      ...scenario,
+      profile_id: "staged-v2",
+      corpus_version: manifest.corpus_version,
+      fixture_version: manifest.fixture_version,
+      allowed_stages: ["ungated_execution", "ur", "brownfield_review", "prd", "sd", "tp", "brownfield_analysis", "cd_tests", "cr", "qa", "uat", "or", "blocked"],
+      evidence_pack: scenario.evidence_pack_id ? fixtures.evidence_packs[scenario.evidence_pack_id] : null,
+    }));
+    return { profile_id: "staged-v2", manifest, baseline, fixtures, cases };
+  }
+  if (profileId !== "legacy-v1") fail(`unknown proportionality profile ${profileId}`);
+  const manifest = JSON.parse(readFileSync(existingInside(root, "manifest.json"), "utf8"));
+  const provenance = JSON.parse(readFileSync(existingInside(root, "legacy-v1-provenance.json"), "utf8"));
+  const index = JSON.parse(readFileSync(existingInside(root, "cases.json"), "utf8"));
+  const fixtures = JSON.parse(readFileSync(existingInside(root, "fixtures/catalog.json"), "utf8"));
+  const baselinePath = existingInside(repoRoot, manifest.baseline_path);
+  const baseline = validateBaseline(JSON.parse(readFileSync(baselinePath, "utf8")));
+  if (manifest.schema_version !== "1" || index.schema_version !== "1" || manifest.baseline_version !== baseline.baseline_version) fail("manifest/corpus version mismatch");
+  if (provenance.profile_id !== "legacy-v1" || Object.keys(provenance.source_fingerprints ?? {}).length !== 40) fail("legacy provenance incomplete");
+  for (const [path, expectedHash] of Object.entries(provenance.files ?? {})) {
+    const target = existingInside(repoRoot, path);
+    if (sha256(target) !== expectedHash) fail(`legacy provenance drift ${path}`, "PROPORTIONALITY_HISTORY_DRIFT");
+  }
+  if (!Array.isArray(index.case_ids) || index.case_ids.length !== 40 || new Set(index.case_ids).size !== 40) fail("blind corpus must list 40 unique ids");
+  if (Object.keys(index.case_contexts ?? {}).some((id) => !index.case_ids.includes(id))) fail("case context references unknown id");
+  if (Object.values(index.case_contexts ?? {}).some((value) => typeof value !== "string" || /expected_delivery_path|compact_delivery|structured_slice|structured_delivery|verified_change|trivial_change/i.test(value))) fail("case context contains result label");
+  const baselineIds = new Set(baseline.cases.map((item) => item.case_id));
+  if (index.case_ids.some((id) => !baselineIds.has(id)) || baseline.cases.some((item) => !index.case_ids.includes(item.case_id))) fail("baseline/corpus ids differ");
+  const artefactRoot = realpathSync(resolve(repoRoot, ".agdf/control/artefacts"));
+  for (const item of baseline.cases) {
+    const evidence = resolve(dirname(baselinePath), item.evidence_ref);
+    if (!existsSync(evidence)) fail(`unresolvable evidence_ref ${item.case_id}`);
+    const rel = relative(artefactRoot, realpathSync(evidence));
+    if (rel === ".." || rel.startsWith(`..${sep}`)) fail(`unsafe evidence_ref ${item.case_id}`);
+  }
+  const fixture = fixtures.fixtures?.[index.fixture_id];
+  if (!fixture || "expected_delivery_path" in fixture || "rationale" in fixture) fail("invalid blind fixture");
+  const cases = baseline.cases.map(({ case_id, task_summary }) => ({
+    case_id, task_summary, fixture_id: index.fixture_id,
+    repository_context: fixture.repository_context,
+    control_state_context: index.case_contexts?.[case_id] ?? fixture.control_state_context,
+  }));
+  return { profile_id: "legacy-v1", manifest, baseline, fixtures, provenance, cases };
+}