create-agdf 0.13.2 → 0.13.3

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

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { createHash } from "node:crypto";
-import { dirname, relative, resolve, sep } from "node:path";
-import { fail, validateBaseline } from "./contracts.js";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { DELIVERY_PATHS, fail, validateBaseline } from "./contracts.js";
+import { getProfileDefinition, isStagedProfile } from "./profiles.js";
 
 function inside(root, candidate) {
   const target = resolve(root, candidate);
@@ -21,7 +22,7 @@ function existingInside(root, candidate) {
 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;
+const stagedForbidden = /expected_|evidence_ref|classification|threshold|reason_code|target_rationale|grading_value|baseline_(version|path)|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;
@@ -30,31 +31,140 @@ export function validateStagedBlindScenario(scenario, evidencePack = null, basel
     || 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 (evidencePack) {
+    const leakageEvidence = JSON.parse(JSON.stringify(evidencePack));
+    const escalation = leakageEvidence.bounded_change_facts?.escalation;
+    if (escalation) {
+      if (!["structured_slice", "structured_delivery"].includes(escalation.target)) fail(`invalid structured escalation target ${scenario.scenario_id}`, "PROPORTIONALITY_LEAKAGE");
+      delete escalation.target;
+    }
+    if (stagedForbidden.test(JSON.stringify(leakageEvidence))) 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;
 }
+function recursiveFiles(root) {
+  return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(root, entry.name);
+    return entry.isDirectory() ? recursiveFiles(path) : [path];
+  });
+}
+const requiredProtectedV2Files = [
+  "evals/proportionality/staged-manifest.json",
+  "evals/proportionality/staged-scenarios.json",
+  "evals/proportionality/fixtures/staged-catalog.json",
+  ".agdf/control/artefacts/agdf-staged-proportionality-observation/STAGED_PROPORTIONALITY_BASELINE.json",
+  ".agdf/control/artefacts/agdf-staged-proportionality-observation/STAGED_PROPORTIONALITY_REPORT.json",
+  ".agdf/control/artefacts/agdf-staged-proportionality-observation/STAGED_PROPORTIONALITY_REPORT.md",
+  ".agdf/control/artefacts/agdf-staged-proportionality-observation/QA_REPORT.md",
+  ".agdf/control/artefacts/agdf-staged-proportionality-observation/OR.md",
+];
+const requiredProtectedV2Root = "evals/proportionality/observations/codex-gpt-5.6-sol-agdf-0.11.4-staged-v2-20260729-r3";
+export function validateHistoryInventory(repoRoot, root, manifest) {
+  const inventoryPath = existingInside(root, manifest.history_provenance_path);
+  const inventory = JSON.parse(readFileSync(inventoryPath, "utf8"));
+  if (inventory.schema_version !== "1" || inventory.profile_id !== manifest.profile_id || inventory.inventory_version !== manifest.history_inventory_version) fail("history inventory version mismatch", "PROPORTIONALITY_HISTORY_DRIFT");
+  const declared = Object.keys(inventory.protected_files ?? {}).sort();
+  if (requiredProtectedV2Files.some((path) => !declared.includes(path))) fail("protected history inventory omits required staged-v2 evidence", "PROPORTIONALITY_HISTORY_DRIFT");
+  if (!Array.isArray(inventory.protected_roots) || inventory.protected_roots.length !== 1 || inventory.protected_roots[0] !== requiredProtectedV2Root) fail("protected history root mismatch", "PROPORTIONALITY_HISTORY_DRIFT");
+  if (declared.some((path) => !requiredProtectedV2Files.includes(path) && !path.startsWith(`${requiredProtectedV2Root}/`))) fail("protected history inventory contains an out-of-bound path", "PROPORTIONALITY_HISTORY_DRIFT");
+  for (const path of declared) {
+    const target = existingInside(repoRoot, path);
+    if (sha256(target) !== inventory.protected_files[path]) fail(`protected history drift ${path}`, "PROPORTIONALITY_HISTORY_DRIFT");
+  }
+  for (const protectedRoot of inventory.protected_roots ?? []) {
+    const absolute = existingInside(repoRoot, protectedRoot);
+    const actual = recursiveFiles(absolute).map((path) => relative(repoRoot, path).split(sep).join("/")).sort();
+    const expected = declared.filter((path) => path === protectedRoot || path.startsWith(`${protectedRoot}/`));
+    if (actual.length !== expected.length || actual.some((path, index) => path !== expected[index])) fail(`protected history inventory incomplete ${protectedRoot}`, "PROPORTIONALITY_HISTORY_DRIFT");
+  }
+  return inventory;
+}
+const verifiedFactGroups = ["ownership_boundary", "prohibited_impacts", "deterministic_controls", "baseline_state", "escalation"];
+const impactFacts = ["product_semantics", "runtime", "policy", "persistence", "architecture", "security", "external_api", "cli_contract", "release", "cross_host"];
+const depthTriggerFamilies = ["behavior_or_policy", "architecture_or_runtime", "persistence_or_security", "external_contract", "release_or_cross_host", "unbounded_coordination"];
+const depthChecks = ["scope_boundary", "owner_map", "affected_surfaces", "validation_path", "rollback_boundary", "coordination_boundary", "uncertainty_register"];
+const semanticDepthTargets = {
+  "PB-021": "behavior_or_policy",
+  "PB-031": "architecture_or_runtime",
+  "PB-033": "persistence_or_security",
+  "PB-034": "unbounded_coordination",
+  "PB-036": "release_or_cross_host",
+  "PB-037": "external_contract",
+};
+export function validateV3Facts(index, fixtures, baseline) {
+  for (const caseId of ["PB-008", "PB-010", "PB-011"]) {
+    const scenarios = index.scenarios.filter((item) => item.case_id === caseId);
+    if (!scenarios.length) fail(`missing targeted semantics ${caseId}`);
+    for (const scenario of scenarios) {
+      if (caseId === "PB-008" && (!scenario.decision_state_facts || typeof scenario.decision_state_facts.effective_control_state !== "string" || typeof scenario.decision_state_facts.currently_permitted_action !== "string" || typeof scenario.decision_state_facts.mutation_intent !== "string" || scenario.decision_state_facts.unresolved_target !== true)) fail(`incomplete decision-state facts ${scenario.scenario_id}`);
+      if (["PB-010", "PB-011"].includes(caseId) && (!scenario.task_semantics?.requested_action || !scenario.task_semantics?.semantic_effect || !scenario.task_semantics?.excluded_effects?.length)) fail(`incomplete task semantics ${scenario.scenario_id}`);
+    }
+  }
+  for (const caseId of ["PB-016", "PB-017", "PB-020"]) {
+    const pack = fixtures.evidence_packs[`EP-${caseId}`]?.bounded_change_facts;
+    const missingGroup = verifiedFactGroups.find((key) => !(key in (pack ?? {})));
+    if (!pack || missingGroup) fail(`incomplete verified-change facts ${caseId}: missing ${missingGroup ?? "bounded_change_facts"}; restore the declared facts and rerun`);
+    if (pack.ownership_boundary.canonical_owner_count !== 1 || pack.ownership_boundary.bounded !== true || !Number.isInteger(pack.ownership_boundary.source_path_count) || pack.ownership_boundary.source_path_count < 1 || !Number.isInteger(pack.ownership_boundary.derived_path_count) || pack.ownership_boundary.derived_path_count < 0) fail(`conflicting ownership-boundary facts ${caseId}; correct the facts and rerun`);
+    if (!/^[a-f0-9]{40}$/.test(pack.baseline_state.commit ?? "") || pack.baseline_state.tracked_candidate_paths_clean !== true || pack.baseline_state.untracked_candidate_paths_clean !== true || !Array.isArray(pack.baseline_state.conflicts) || pack.baseline_state.conflicts.length) fail(`conflicting baseline-state facts ${caseId}; correct the facts and rerun`);
+    if (pack.deterministic_controls.validation !== true || pack.deterministic_controls.propagation !== true) fail(`conflicting deterministic-control facts ${caseId}; correct the facts and rerun`);
+    if (pack.prohibited_impacts.complete !== true || impactFacts.some((key) => pack.prohibited_impacts.impacts?.[key] !== false)) fail(`conflicting prohibited-impact facts ${caseId}; correct the facts and rerun`);
+    if (!["structured_slice", "structured_delivery"].includes(pack.escalation.target) || !Array.isArray(pack.escalation.conditions) || !pack.escalation.conditions.length) fail(`conflicting escalation facts ${caseId}; correct the facts and rerun`);
+  }
+  const structuredCases = baseline.cases.filter((item) => ["structured_slice", "structured_delivery"].includes(item.expected_delivery_path));
+  for (const item of structuredCases) {
+    const facts = fixtures.evidence_packs[`EP-${item.case_id}`]?.structured_depth_facts;
+    if (!facts || facts.depth_policy_version !== 1 || facts.fact_state !== "complete" || !Array.isArray(facts.conflicts) || facts.conflicts.length) fail(`incomplete structured-depth facts ${item.case_id}; correct the facts and rerun`);
+    if (depthTriggerFamilies.some((key) => typeof facts.trigger_families?.[key] !== "boolean")) fail(`incomplete depth triggers ${item.case_id}; complete all six trigger families and rerun`);
+    if (depthChecks.some((key) => typeof facts.bounded_checks?.[key] !== "string" || !facts.bounded_checks[key])) fail(`incomplete depth checks ${item.case_id}; complete all seven bounded checks and rerun`);
+    if (semanticDepthTargets[item.case_id] && (facts.semantic_eval_target !== semanticDepthTargets[item.case_id] || facts.trigger_families[facts.semantic_eval_target] !== true)) fail(`invalid semantic depth target ${item.case_id}`);
+  }
+  if (new Set(Object.values(semanticDepthTargets)).size !== depthTriggerFamilies.length) fail("semantic depth target coverage mismatch");
+}
 export function loadCorpus(repoRoot, profileId = "legacy-v1") {
+  const profile = getProfileDefinition(profileId);
   const root = existingInside(repoRoot, "evals/proportionality");
-  if (profileId === "staged-v2") {
-    const manifest = JSON.parse(readFileSync(existingInside(root, "staged-manifest.json"), "utf8"));
+  if (isStagedProfile(profile)) {
+    const manifest = JSON.parse(readFileSync(existingInside(repoRoot, profile.manifest_path), "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 versionMismatch = [
+      ["manifest.profile_id", manifest.profile_id, profile.profile_id],
+      ["manifest.schema_version", manifest.schema_version, profile.schema_version],
+      ["manifest.protocol_version", manifest.protocol_version, profile.protocol_version],
+      ["index.schema_version", index.schema_version, profile.schema_version],
+      ["index.profile_id", index.profile_id, profile.profile_id],
+      ["fixtures.schema_version", fixtures.schema_version, profile.schema_version],
+      ["fixtures.profile_id", fixtures.profile_id, profile.profile_id],
+      ["fixtures.fixture_version", fixtures.fixture_version, manifest.fixture_version],
+      ["baseline.schema_version", baseline.schema_version, profile.schema_version],
+      ["baseline.baseline_version", baseline.baseline_version, manifest.baseline_version],
+    ].find(([, actual, expected]) => actual !== expected);
+    if (versionMismatch || !manifest.corpus_version || !manifest.fixture_version) fail(`staged profile version mismatch: ${versionMismatch?.[0] ?? "manifest corpus/fixture version"}`);
+    if (profile.strict_version_links) {
+      const strictMismatch = [
+        ["index.corpus_version", index.corpus_version, manifest.corpus_version],
+        ["baseline.profile_id", baseline.profile_id, profile.profile_id],
+        ["baseline.protocol_version", baseline.protocol_version, profile.protocol_version],
+        ["manifest.adapter_version", manifest.adapter_version, profile.adapter_version],
+        ["manifest.runner_version", manifest.runner_version, profile.runner_version],
+        ["manifest.report_version", manifest.report_version, profile.report_version],
+      ].find(([, actual, expected]) => actual !== expected);
+      if (strictMismatch || !manifest.history_inventory_version) fail(`staged profile version mismatch: ${strictMismatch?.[0] ?? "manifest.history_inventory_version"}`);
+    }
+    const baselineCaseIds = baseline.cases.map((item) => item.case_id);
+    const scenarioIds = index.scenarios.map((item) => item.scenario_id);
+    if (baseline.cases.length !== 40 || new Set(baselineCaseIds).size !== 40 || baselineCaseIds.some((id) => !/^PB-\d{3}$/.test(id))) fail("staged case identity mismatch");
+    if (!Array.isArray(index.scenario_ids) || index.scenario_ids.length !== 72 || index.scenarios.length !== 72 || new Set(index.scenario_ids).size !== 72 || new Set(scenarioIds).size !== 72 || scenarioIds.some((id) => !index.scenario_ids.includes(id))) fail("staged corpus coverage mismatch");
+    const pathSet = new Set(baseline.cases.map((item) => item.expected_delivery_path));
+    if (DELIVERY_PATHS.some((path) => !pathSet.has(path)) || [...pathSet].some((path) => !DELIVERY_PATHS.includes(path)) || baseline.cases.filter((item) => item.adversarial).length < 10) fail("staged baseline coverage mismatch");
     const expectedIds = new Set(baseline.scenarios.map((item) => item.scenario_id));
+    if (baseline.scenarios.length !== 72 || expectedIds.size !== 72 || baseline.scenarios.some((item) => !baselineCaseIds.includes(item.case_id) || item.scenario_id.split(":")[0] !== item.case_id)) fail("staged scenario baseline mismatch");
     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}`);
@@ -64,18 +174,19 @@ export function loadCorpus(repoRoot, profileId = "legacy-v1") {
         baseline.scenarios.find((item) => item.scenario_id === scenario.scenario_id),
       );
     }
+    const historyProvenance = profile.history_provenance ? validateHistoryInventory(repoRoot, root, manifest) : undefined;
+    if (profile.semantic_fact_validation) validateV3Facts(index, fixtures, baseline);
     const cases = index.scenarios.map((scenario) => ({
       ...scenario,
-      profile_id: "staged-v2",
+      profile_id: profile.profile_id,
       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 };
+    return { profile_id: profile.profile_id, profile, manifest, baseline, fixtures, ...(historyProvenance ? { history_provenance: historyProvenance } : {}), cases };
   }
-  if (profileId !== "legacy-v1") fail(`unknown proportionality profile ${profileId}`);
-  const manifest = JSON.parse(readFileSync(existingInside(root, "manifest.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync(existingInside(repoRoot, profile.manifest_path), "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"));
@@ -106,5 +217,5 @@ export function loadCorpus(repoRoot, profileId = "legacy-v1") {
     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 };
+  return { profile_id: "legacy-v1", profile, manifest, baseline, fixtures, provenance, cases };
 }

package/lib/proportionality-benchmark/evaluator.js

@@ -1,6 +1,7 @@
 import { DELIVERY_PATHS, PATH_RANK, STAGES, fail, stable } from "./contracts.js";
 import { sourceFingerprint } from "./source-fingerprint.js";
-import { ADAPTER_VERSION, STAGED_ADAPTER_VERSION } from "./live-recorder.js";
+import { ADAPTER_VERSION } from "./live-recorder.js";
+import { getProfileDefinition, isStagedProfile } from "./profiles.js";
 
 export function classifyObservation(expected, observation) {
   if (observation.ambiguous || observation.observed_delivery_path === null) return "ambiguous";
@@ -50,22 +51,25 @@ function stagedCoverageResult(expected, rows, reason) {
   };
 }
 function evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats }) {
-  const provenanceKeys = ["series_id", "profile_id", "protocol_version", "corpus_version", "fixture_version", "surface", "runtime_version", "model", "agdf_version", "baseline_version", "adapter_version"];
+  const profile = getProfileDefinition(corpus.profile_id);
+  const provenanceKeys = ["series_id", "profile_id", "protocol_version", "corpus_version", "fixture_version", "surface", "runtime_version", "model", "agdf_version", "baseline_version", "adapter_version", ...(profile.evidence_kind_provenance ? ["evidence_kind"] : []), ...(profile.series_profile_metadata ? ["runner_version"] : [])];
   const first = observations[0] ?? {};
   const observationIds = new Set();
   const byScenario = new Map(corpus.cases.map((item) => [item.scenario_id, []]));
   for (const observation of observations) {
     if (!byScenario.has(observation.scenario_id) || observation.case_id !== observation.scenario_id.split(":")[0]) fail(`unknown staged observation ${observation.scenario_id ?? "unknown"}`);
-    if (observation.schema_version !== "2" || observation.evidence_kind !== "live_agent_observation" || !Number.isInteger(observation.repeat) || observation.repeat < 1) fail(`invalid observation ${observation.observation_id ?? "unknown"}`);
+    if (observation.schema_version !== profile.schema_version || !profile.evidence_kinds.includes(observation.evidence_kind) || !Number.isInteger(observation.repeat) || observation.repeat < 1) fail(`invalid observation ${observation.observation_id ?? "unknown"}`);
     if (!observation.observation_id || observationIds.has(observation.observation_id)) fail(`duplicate observation ${observation.observation_id ?? "unknown"}`);
     if (observation.execution_status !== "completed" || observation.redaction_status !== "pass" || observation.mutation_status !== "pass") fail(`unsafe observation status ${observation.observation_id}`);
     if (!Number.isFinite(Date.parse(observation.recorded_at))) fail(`invalid observation timestamp ${observation.observation_id}`);
-    if (
-      observation.baseline_version !== corpus.baseline.baseline_version
-      || observation.corpus_version !== corpus.manifest.corpus_version
-      || observation.fixture_version !== corpus.manifest.fixture_version
-    ) fail(`baseline provenance drift at ${observation.observation_id}`);
-    if (provenanceKeys.some((key) => observation[key] !== first[key])) fail(`series provenance drift at ${observation.observation_id}`);
+    const versionDrift = [
+      ["baseline_version", corpus.baseline.baseline_version],
+      ["corpus_version", corpus.manifest.corpus_version],
+      ["fixture_version", corpus.manifest.fixture_version],
+    ].find(([key, expected]) => observation[key] !== expected);
+    if (versionDrift) fail(`baseline provenance drift (${versionDrift[0]}) at ${observation.observation_id}`);
+    const provenanceDrift = provenanceKeys.find((key) => observation[key] !== first[key]);
+    if (provenanceDrift) fail(`series provenance drift (${provenanceDrift}) at ${observation.observation_id}`);
     observationIds.add(observation.observation_id);
     byScenario.get(observation.scenario_id).push(observation);
   }
@@ -74,7 +78,7 @@ function evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats }
     const rows = byScenario.get(expected.scenario_id).sort((a, b) => a.repeat - b.repeat);
     const repeats = new Set(rows.map((item) => item.repeat));
     if (rows.length < minimumRepeats || repeats.size !== rows.length) return stagedCoverageResult(expected, rows, "coverage");
-    const fingerprint = sourceFingerprint(repoRoot, blind, corpus.fixtures, STAGED_ADAPTER_VERSION);
+    const fingerprint = sourceFingerprint(repoRoot, blind, corpus.fixtures, profile.adapter_version);
     const stale = rows.some((item) => item.source_fingerprint !== fingerprint);
     const invalidAxes = rows.some((item) => (
       expected.stage_required !== (item.stage_evaluability === "evaluated")
@@ -130,9 +134,9 @@ function evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats }
     ...(ambiguous.length ? ["ambiguous_or_incomplete"] : []),
   ];
   return stable({
-    schema_version: "2",
-    profile_id: "staged-v2",
-    protocol_version: "2",
+    schema_version: profile.schema_version,
+    profile_id: profile.profile_id,
+    protocol_version: profile.protocol_version,
     evidence_boundary: corpus.manifest.evidence_boundary,
     baseline_version: corpus.baseline.baseline_version,
     corpus_version: corpus.manifest.corpus_version,
@@ -142,7 +146,13 @@ function evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats }
     agdf_version: first.agdf_version ?? null,
     adapter_version: first.adapter_version ?? null,
     runtime_version: first.runtime_version ?? null,
-    runner_version: "2.0.0",
+    runner_version: profile.runner_version,
+    ...(profile.repository_replay_non_claim ? {
+      evidence_class: first.evidence_kind ?? "none",
+      report_version: profile.report_version,
+      authenticated_live_host_evidence: false,
+      live_host_non_claim: "No authenticated staged-v3 live-host series was executed or accepted by this repository replay.",
+    } : {}),
     freshness_status: scenarios.some((item) => item.blocking_reasons.includes("stale")) ? "stale" : "fresh",
     minimum_repeats: minimumRepeats,
     valid_observations: observations.length,
@@ -164,7 +174,7 @@ function evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats }
 }
 export function evaluateSeries({ repoRoot, corpus, observations, minimumRepeats = 3 }) {
   if (!Number.isInteger(minimumRepeats) || minimumRepeats < 3) fail("minimum repeats must be at least 3");
-  if (corpus.profile_id === "staged-v2") return evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats });
+  if (isStagedProfile(getProfileDefinition(corpus.profile_id))) return evaluateStagedSeries({ repoRoot, corpus, observations, minimumRepeats });
   const provenanceKeys = ["series_id", "surface", "runtime_version", "model", "agdf_version", "baseline_version", "adapter_version"];
   const first = observations[0] ?? {};
   const observationIds = new Set();

package/lib/proportionality-benchmark/index.js

@@ -3,5 +3,6 @@ export * from "./contracts.js";
 export * from "./corpus-loader.js";
 export * from "./evaluator.js";
 export * from "./live-recorder.js";
+export * from "./profiles.js";
 export * from "./report.js";
 export * from "./source-fingerprint.js";

package/lib/proportionality-benchmark/live-recorder.js

@@ -5,11 +5,31 @@ import { dirname, join } from "node:path";
 import { executeStructuredAgent } from "../live-agent/read-only-structured.js";
 import { changedPaths, snapshotWorkspace } from "../skill-evals/workspace.js";
 import { buildBlindPrompt } from "./blind-prompt.js";
-import { normalizeAgentOutput, normalizeStagedAgentOutput, OBSERVATION_SCHEMA, STAGED_OBSERVATION_SCHEMA, fail } from "./contracts.js";
+import { normalizeAgentOutput, normalizeStagedAgentOutput, OBSERVATION_SCHEMA, fail, stagedSchemaForVersion } from "./contracts.js";
+import { getProfileDefinition, isStagedProfile } from "./profiles.js";
 import { behaviorSourceText, sourceFingerprint } from "./source-fingerprint.js";
 
-export const ADAPTER_VERSION = "1.1.0";
-export const STAGED_ADAPTER_VERSION = "2.1.0";
+export const ADAPTER_VERSION = getProfileDefinition("legacy-v1").adapter_version;
+export const STAGED_ADAPTER_VERSION = getProfileDefinition("staged-v2").adapter_version;
+export const STAGED_V3_ADAPTER_VERSION = getProfileDefinition("staged-v3").adapter_version;
+export function isRetryableObservationError(error) {
+  return error?.code === "GENERATOR_TIMEOUT";
+}
+export function observationAttemptFailure(error, attemptCount, attemptLimit) {
+  const messages = {
+    GENERATOR_TIMEOUT: "read-only process timed out",
+    PROPORTIONALITY_OUTPUT_INVALID: "agent output failed the structured contract",
+    PROPORTIONALITY_REDACTION_FAILED: "agent output failed redaction",
+    PROPORTIONALITY_MUTATION: "agent mutated the disposable fixture",
+  };
+  return {
+    status: "invalid",
+    code: error?.code ?? "EXECUTION_ERROR",
+    message: messages[error?.code] ?? "agent execution failed",
+    retryable: isRetryableObservationError(error),
+    remaining_attempt_budget: Math.max(0, attemptLimit - attemptCount),
+  };
+}
 function runtimeVersion(surface) {
   try { return execFileSync(surface, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim(); }
   catch { return `${surface} version unavailable`; }
@@ -40,8 +60,9 @@ export async function recordObservation({
 }) {
   if (!/^[a-z0-9][a-z0-9._-]{2,79}$/i.test(seriesId) || !Number.isInteger(repeat) || repeat < 1) fail("invalid series or repeat");
   if (!surface || !model || !agdfVersion || !baselineVersion) fail("surface, model, AGDF version and baseline version are required");
-  const staged = testCase.profile_id === "staged-v2";
-  const adapterVersion = staged ? STAGED_ADAPTER_VERSION : ADAPTER_VERSION;
+  const profile = getProfileDefinition(testCase.profile_id ?? "legacy-v1");
+  const staged = isStagedProfile(profile);
+  const adapterVersion = profile.adapter_version;
   const fingerprint = sourceFingerprint(repoRoot, testCase, fixture, adapterVersion);
   const fixtureRoot = mkdtempSync(join(tmpdir(), "agdf-proportionality-"));
   let output;
@@ -55,7 +76,7 @@ export async function recordObservation({
     const before = snapshotWorkspace(fixtureRoot);
     try {
       output = await execute({
-        surface, cwd: fixtureRoot, model, timeoutMs, outputSchema: staged ? STAGED_OBSERVATION_SCHEMA : OBSERVATION_SCHEMA,
+        surface, cwd: fixtureRoot, model, timeoutMs, outputSchema: staged ? stagedSchemaForVersion(profile.schema_version) : OBSERVATION_SCHEMA,
         prompt: buildBlindPrompt(testCase, behaviorSourceText(repoRoot)),
       });
     } catch (error) { executionError = error; }
@@ -63,18 +84,19 @@ export async function recordObservation({
     const mutations = changedPaths(before, after);
     if (mutations.length) fail(`agent mutated fixture: ${mutations.join(", ")}`, "PROPORTIONALITY_MUTATION");
     if (executionError) throw executionError;
-    const normalized = staged ? normalizeStagedAgentOutput(output, testCase.requested_axes) : normalizeAgentOutput(output);
+    const normalized = staged ? normalizeStagedAgentOutput(output, testCase.requested_axes, profile.schema_version) : normalizeAgentOutput(output);
     const observation = {
-      schema_version: staged ? "2" : "1",
+      schema_version: profile.schema_version,
       observation_id: `${seriesId}:${staged ? testCase.scenario_id : testCase.case_id}:${repeat}`,
       case_id: testCase.case_id,
       ...(staged ? {
-        profile_id: "staged-v2",
-        protocol_version: "2",
+        profile_id: profile.profile_id,
+        protocol_version: profile.protocol_version,
         corpus_version: testCase.corpus_version,
         fixture_version: testCase.fixture_version,
         scenario_id: testCase.scenario_id,
         lifecycle_stage: testCase.lifecycle_stage,
+        ...(profile.series_profile_metadata ? { runner_version: profile.runner_version } : {}),
       } : {}),
       series_id: seriesId,
       repeat,

package/lib/proportionality-benchmark/profiles.js

@@ -0,0 +1,102 @@
+const definitions = {
+  "legacy-v1": {
+    profile_id: "legacy-v1",
+    family: "legacy",
+    manifest_path: "evals/proportionality/manifest.json",
+    schema_version: "1",
+    protocol_version: "1",
+    adapter_version: "1.1.0",
+    runner_version: "1.0.0",
+    report_version: "1.0.0",
+    observation_key: "case_id",
+    fixture_strategy: "catalog_fixture",
+    evidence_kinds: ["live_agent_observation"],
+    evidence_kind_provenance: false,
+    history_provenance: false,
+    semantic_fact_validation: false,
+    fingerprint_profile_metadata: false,
+    repository_replay_non_claim: false,
+    strict_version_links: false,
+    series_profile_metadata: false,
+  },
+  "staged-v2": {
+    profile_id: "staged-v2",
+    family: "staged",
+    manifest_path: "evals/proportionality/staged-manifest.json",
+    schema_version: "2",
+    protocol_version: "2",
+    adapter_version: "2.1.0",
+    runner_version: "2.0.0",
+    report_version: "2.0.0",
+    observation_key: "scenario_id",
+    fixture_strategy: "staged_catalog",
+    evidence_kinds: ["live_agent_observation"],
+    evidence_kind_provenance: false,
+    history_provenance: false,
+    semantic_fact_validation: false,
+    fingerprint_profile_metadata: false,
+    repository_replay_non_claim: false,
+    strict_version_links: false,
+    series_profile_metadata: false,
+  },
+  "staged-v3": {
+    profile_id: "staged-v3",
+    family: "staged",
+    manifest_path: "evals/proportionality/staged-v3-manifest.json",
+    schema_version: "3",
+    protocol_version: "3",
+    adapter_version: "3.0.0",
+    runner_version: "3.0.0",
+    report_version: "3.0.0",
+    observation_key: "scenario_id",
+    fixture_strategy: "staged_catalog",
+    evidence_kinds: ["synthetic_replay", "live_agent_observation"],
+    evidence_kind_provenance: true,
+    history_provenance: true,
+    semantic_fact_validation: true,
+    fingerprint_profile_metadata: true,
+    repository_replay_non_claim: true,
+    strict_version_links: true,
+    series_profile_metadata: true,
+  },
+};
+
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const item of Object.values(value)) deepFreeze(item);
+  }
+  return value;
+}
+
+export const PROPORTIONALITY_PROFILES = deepFreeze(definitions);
+export const SUPPORTED_PROFILE_IDS = Object.freeze(Object.keys(PROPORTIONALITY_PROFILES));
+
+export function getProfileDefinition(profileId) {
+  const definition = PROPORTIONALITY_PROFILES[profileId];
+  if (!definition) throw Object.assign(new Error(`unknown proportionality profile ${profileId}`), { code: "PROPORTIONALITY_PROFILE_UNKNOWN" });
+  return definition;
+}
+
+export function isStagedProfile(profileOrId) {
+  const definition = typeof profileOrId === "string" ? getProfileDefinition(profileOrId) : profileOrId;
+  return definition.family === "staged";
+}
+
+export function observationKey(profileOrId, testCase) {
+  const definition = typeof profileOrId === "string" ? getProfileDefinition(profileOrId) : profileOrId;
+  const value = testCase[definition.observation_key];
+  if (!value) throw new Error(`missing ${definition.observation_key} for ${definition.profile_id}`);
+  return definition.observation_key === "scenario_id" ? value.replaceAll(":", "__") : value;
+}
+
+export function fixtureForProfile(profileOrId, corpus) {
+  const definition = typeof profileOrId === "string" ? getProfileDefinition(profileOrId) : profileOrId;
+  return definition.fixture_strategy === "staged_catalog"
+    ? corpus.fixtures
+    : corpus.fixtures.fixtures[corpus.manifest.fixture_id];
+}
+
+export function profileUsage() {
+  return SUPPORTED_PROFILE_IDS.join("|");
+}

package/lib/proportionality-benchmark/report.js

@@ -1,11 +1,20 @@
+import { getProfileDefinition, isStagedProfile } from "./profiles.js";
+
 export function renderMarkdown(report) {
-  if (report.profile_id === "staged-v2") {
+  if (report.profile_id && isStagedProfile(getProfileDefinition(report.profile_id))) {
     const lines = [
       "# AGDF Staged Proportionality Observation",
       "",
       `- Status: \`${report.status}\``,
       `- Evidenzgrenze: ${report.evidence_boundary}`,
       `- Profil/Protokoll: \`${report.profile_id}\` / \`${report.protocol_version}\``,
+      ...(report.evidence_class ? [
+        `- Corpus/Baseline: \`${report.corpus_version}\` / \`${report.baseline_version}\``,
+        `- Report-Version: \`${report.report_version}\``,
+        `- Evidenzklasse: \`${report.evidence_class}\``,
+        `- Authentifizierte Live-Host-Evidenz: \`${report.authenticated_live_host_evidence}\``,
+        `- Live-Host-Nichtbehauptung: ${report.live_host_non_claim}`,
+      ] : []),
       `- Serie: \`${report.series_id ?? "none"}\``,
       `- Surface/Modell: \`${report.surface ?? "none"}\` / \`${report.model ?? "none"}\``,
       `- Runtime/AGDF/Adapter/Runner: \`${report.runtime_version ?? "none"}\` / \`${report.agdf_version ?? "none"}\` / \`${report.adapter_version ?? "none"}\` / \`${report.runner_version}\``,

package/lib/proportionality-benchmark/source-fingerprint.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { stable } from "./contracts.js";
+import { getProfileDefinition } from "./profiles.js";
 
 export const BEHAVIOR_SOURCES = Object.freeze([
   "plugin/meta/agdf-agent-router.md",
@@ -24,7 +25,10 @@ export function behaviorSourceText(repoRoot) {
 }
 export function sourceFingerprint(repoRoot, testCase, fixture, adapterVersion) {
   const hash = createHash("sha256");
-  hash.update(JSON.stringify(stable({ testCase, fixture, adapterVersion })));
-  for (const path of [...BEHAVIOR_SOURCES, ...IMPLEMENTATION_SOURCES]) hash.update(path).update(readFileSync(join(repoRoot, path)));
+  const selectedProfile = testCase.profile_id ? getProfileDefinition(testCase.profile_id) : null;
+  const profile = selectedProfile?.fingerprint_profile_metadata ? selectedProfile : null;
+  hash.update(JSON.stringify(stable(profile ? { testCase, fixture, adapterVersion, profile } : { testCase, fixture, adapterVersion })));
+  const sources = profile ? [...BEHAVIOR_SOURCES, ...IMPLEMENTATION_SOURCES, "create-agdf/lib/proportionality-benchmark/profiles.js"] : [...BEHAVIOR_SOURCES, ...IMPLEMENTATION_SOURCES];
+  for (const path of sources) hash.update(path).update(readFileSync(join(repoRoot, path)));
   return hash.digest("hex");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -36,10 +36,12 @@
     "test:package-build": "node ./scripts/package-build-test.js",
     "test:lifecycle": "node ./scripts/lifecycle-test.js",
     "test:control-state": "node ./scripts/control-state-test.js",
+    "test:parent-reconciliation": "node ./scripts/parent-reconciliation-test.js",
     "test:interaction-presentation": "node ./scripts/interaction-presentation-test.js",
     "test:verified-change": "node ./scripts/verified-change-test.js",
     "test:runtime-integrity-layout": "node ./scripts/runtime-integrity-layout-test.js",
     "test:runtime-integrity-negative": "node ./scripts/runtime-integrity-negative-test.js",
+    "test:agent-skills-conformance": "node ./scripts/agent-skills-conformance-test.js",
     "test:skill-evals": "node ./scripts/skill-evals-test.js",
     "eval:skills": "node ./scripts/run-skill-evals.js",
     "eval:skills:record": "node ./scripts/record-skill-evals.js",
@@ -48,7 +50,7 @@
     "test:proportionality": "node ./scripts/proportionality-benchmark-test.js",
     "test:release-bootstrap": "node ./scripts/release-bootstrap-smoke-test.js",
     "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run release:prepare && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:skill-evals && npm run eval:skills && npm run test:proportionality && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
+    "smoke-test": "npm run release:prepare && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:parent-reconciliation && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:agent-skills-conformance && npm run test:skill-evals && npm run eval:skills && npm run test:proportionality && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
     "prepack": "npm run release:prepare"
   },
   "keywords": [