create-agdf 0.13.2 → 0.13.3

package/lib/control-evaluation/delivery-map.js

@@ -3,8 +3,9 @@ import { join } from 'node:path';
 import { aggregate, resolveRuns } from '../control-state/index.js';
 import { resolveConfiguredChatLanguage } from '../cli/runtime-context.js';
 import { isGateSatisfied, transitionDecisionForRunState } from './gate-policy.js';
-import { gateApprovalStatus, readRunState } from './run-state.js';
+import { gateApprovalStatus, readRunState, resolvedArtefactFile } from './run-state.js';
 import { allowNoActiveRuns, filled, isPlaceholderValue, markdownSection, parseBacklogSection, readTargetFile } from './shared.js';
+import { evaluateReconciliationState } from './parent-reconciliation.js';
 
 const deliveryRelationships = [
   { from: "UR", relationship: "approved_by", to: "Approval: UR", requiredBy: "UR" },
@@ -38,8 +39,10 @@ function severityFromImpact(value) {
   return null;
 }
 
-export function analyzeDeliveryMap(runState) {
+export function analyzeDeliveryMap(runState, dependencies = {}) {
   const findings = [];
+  const reconciliation = evaluateReconciliationState(runState, dependencies);
+  findings.push(...reconciliation.findings);
   const relationships = deliveryRelationships.map((expected) => {
     const row = findRelationship(runState, expected);
     const required = relationshipRequired(runState, expected.requiredBy);
@@ -142,6 +145,8 @@ export function analyzeDeliveryMap(runState) {
     context_graph: runState.context_graph,
     source_scope: runState.source_scope,
     memory: runState.memory,
+    parent_reconciliation: reconciliation.parent_reconciliation,
+    programme_aggregation: reconciliation.programme_aggregation,
     findings,
   };
 }
@@ -215,7 +220,10 @@ export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}
   }
   const doctorReport = evaluateDoctor(targetDir, selection);
   const runState = readRunState(targetDir, selection);
-  const map = analyzeDeliveryMap(runState);
+  const map = analyzeDeliveryMap(runState, {
+    loadRun: (runId) => readRunState(targetDir, { runId }),
+    resolveFile: (path) => resolvedArtefactFile(targetDir, path),
+  });
   const gateDecision = transitionDecisionForRunState(runState);
   const currentGate = gateDecision.current_gate;
 
@@ -262,6 +270,8 @@ export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}
     context_graph: map.context_graph,
     source_scope: map.source_scope,
     memory: map.memory,
+    parent_reconciliation: map.parent_reconciliation,
+    programme_aggregation: map.programme_aggregation,
     findings: map.findings,
     doctor_status: doctorReport.status,
     doctor_summary: doctorReport.summary,

package/lib/control-evaluation/doctor.js

@@ -4,7 +4,7 @@ import { aggregate, resolveRuns, verifyLegacyProjection } from '../control-state
 import { doctorRequiredFiles } from './required-files.js';
 import { analyzeDeliveryMap } from './delivery-map.js';
 import { evaluateVerifiedChange } from './verified-change.js';
-import { analyzeArtefactRoleConsistency, analyzeDurableGateArtefactConsistency, modeSliceDecision, readRunState } from './run-state.js';
+import { analyzeArtefactRoleConsistency, analyzeDurableGateArtefactConsistency, modeSliceDecision, readRunState, resolvedArtefactFile } from './run-state.js';
 import { addFinding, allowNoActiveRuns, filled, hasFilledEvidenceRow, hasFilledTableRow, isPlaceholderValue, markdownSection, nonEmptyTableRows, parseBacklogSection, parseQualityContracts, readTargetFile, runSelectionRecovery, tableRows } from './shared.js';
 
 export function evaluateDoctor(targetDir, selection = {}) {
@@ -45,6 +45,7 @@ export function evaluateDoctor(targetDir, selection = {}) {
     };
   }
   const findings = [];
+  let reconciliation;
   const hasCanonicalRuns = existsSync(join(targetDir, ".agdf", "control", "runs"));
   if (hasCanonicalRuns) {
     const projection = verifyLegacyProjection(targetDir);
@@ -221,7 +222,11 @@ export function evaluateDoctor(targetDir, selection = {}) {
     for (const finding of analyzeArtefactRoleConsistency(targetDir, runState)) {
       addFinding(findings, finding.severity, finding.code, finding.message, finding.path, finding.next_step);
     }
-    for (const finding of analyzeDeliveryMap(runState).findings) {
+    reconciliation = analyzeDeliveryMap(runState, {
+      loadRun: (runId) => readRunState(targetDir, { runId }),
+      resolveFile: (path) => resolvedArtefactFile(targetDir, path),
+    });
+    for (const finding of reconciliation.findings) {
       addFinding(findings, finding.severity, finding.code, finding.message, finding.path, finding.next_step);
     }
   }
@@ -241,6 +246,8 @@ export function evaluateDoctor(targetDir, selection = {}) {
       revise: findings.filter((finding) => finding.severity === "revise").length,
       warn: findings.filter((finding) => finding.severity === "warn").length,
     },
+    parent_reconciliation: reconciliation?.parent_reconciliation,
+    programme_aggregation: reconciliation?.programme_aggregation,
     findings,
   };
 }

package/lib/control-evaluation/gate-check.js

@@ -225,7 +225,10 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     ? evaluateVerifiedChange(targetDir, runState)
     : null;
   const transitionDecision = transitionDecisionForRunState(runState, verifiedChange);
-  const deliveryMap = analyzeDeliveryMap(runState);
+  const deliveryMap = analyzeDeliveryMap(runState, {
+    loadRun: (runId) => readRunState(targetDir, { runId }),
+    resolveFile: (path) => resolvedArtefactFile(targetDir, path),
+  });
   const doctorBlocker = doctorReport.findings.find((finding) => finding.severity === "block");
   const doctorRevise = doctorReport.findings.find((finding) => finding.severity === "revise");
   const routesInvalidVerifiedChange = modeSliceDecision(runState) === "verified_change"
@@ -344,6 +347,8 @@ export function evaluateGateCheck(targetDir, selection = {}) {
       context_graph: deliveryMap.context_graph,
       source_scope: deliveryMap.source_scope,
       memory: deliveryMap.memory,
+      parent_reconciliation: deliveryMap.parent_reconciliation,
+      programme_aggregation: deliveryMap.programme_aggregation,
       findings: deliveryMap.findings,
     },
     verified_change: verifiedChange,

package/lib/control-evaluation/gate-policy.js

@@ -1,4 +1,4 @@
-import { verifiedChangeEscalationTargets } from './verified-change.js';
+import { extractField, verifiedChangeEscalationTargets } from './verified-change.js';
 import { gateApprovalStatus, gateArtefactStatus, isDurableGateArtefactSatisfied, isInternalStepSatisfied, modeSliceDecision } from './run-state.js';
 
 function durableArtefactBlock(gate, nextGate) {
@@ -98,6 +98,21 @@ export function transitionDecisionForRunState(runState, verifiedChange = null) {
     }
 
     if (modeDecision === "quick_task") {
+      if (
+        extractField(runState.content ?? "", "lifecycle") === "completed"
+        && runState.current_gate === "OR"
+        && runState.artefacts.get("OR")?.status === "done"
+      ) {
+        return {
+          status: "pass",
+          current_gate: "OR",
+          blocking_reason: "none",
+          missing_approval: "none",
+          allowed: ["use delivery closeout when explicitly requested"],
+          forbidden: ["repeat Quick Task execution", "commit, push, open PR or release automatically"],
+          next_allowed_action: "Use delivery closeout only when an operative VCS handoff is explicitly requested.",
+        };
+      }
       return {
         status: "open",
         current_gate: "Quick Task Execution",

package/lib/control-evaluation/parent-reconciliation.js

@@ -0,0 +1,284 @@
+import { RUN_ID_PATTERN } from "../control-state/run-state-parser.js";
+
+const parentPrefix = "parent_run:";
+const childPrefix = "child_run:";
+
+function filled(value) {
+  const text = String(value ?? "").trim();
+  return Boolean(text && text !== "none" && !text.includes("<"));
+}
+
+function exactTarget(value, prefix) {
+  const text = String(value ?? "").trim();
+  if (!text.startsWith(prefix)) return "";
+  const runId = text.slice(prefix.length);
+  return RUN_ID_PATTERN.test(runId) && `${prefix}${runId}` === text ? runId : "";
+}
+
+function warning(runState, code, message, nextStep) {
+  return {
+    severity: "warn",
+    code,
+    message,
+    path: runState.path,
+    next_step: nextStep,
+  };
+}
+
+function invalidDispositionInput(runState) {
+  const input = runState.parent_reconciliation ?? {};
+  if (!input.present) return false;
+  const counts = input.field_counts ?? {};
+  return counts.disposition !== 1
+    || counts.next_action !== 1
+    || !["action_required", "accepted_open"].includes(input.disposition)
+    || !filled(input.next_action);
+}
+
+function openResult(runState, {
+  code = "AGDF_PARENT_RECONCILIATION_OPEN",
+  targetRunId = "",
+  evidence = "",
+  missingEvidence,
+  nextAction,
+} = {}) {
+  const input = runState.parent_reconciliation ?? {};
+  const fieldCounts = input.field_counts ?? {};
+  const validDisposition = ["action_required", "accepted_open"].includes(input.disposition)
+    && fieldCounts.disposition === 1;
+  const validNextAction = filled(input.next_action) && fieldCounts.next_action === 1;
+  const declaredInputInvalid = input.present && (!validDisposition || !validNextAction);
+  const action = declaredInputInvalid ? nextAction : validNextAction ? input.next_action : nextAction;
+  const finalCode = declaredInputInvalid
+    ? "AGDF_PARENT_RECONCILIATION_EVIDENCE_INVALID"
+    : code;
+  return {
+    result: {
+      outcome: "open",
+      target_run_id: targetRunId,
+      disposition: validDisposition ? input.disposition : "action_required",
+      evidence,
+      missing_evidence: missingEvidence,
+      next_action: action,
+    },
+    findings: [warning(
+      runState,
+      finalCode,
+      targetRunId
+        ? `Child ${runState.run_id || "run"} has an open reconciliation handoff to Parent ${targetRunId}.`
+        : `Child ${runState.run_id || "run"} has invalid or ambiguous explicit Parent relationship evidence.`,
+      action,
+    )],
+  };
+}
+
+export function evaluateParentReconciliation(runState, { loadRun } = {}) {
+  const rows = runState.artefact_chain.filter((row) =>
+    row.from === "OR" && row.relationship === "reconciles_with"
+  );
+
+  if (!rows.length) {
+    return {
+      result: {
+        outcome: "not_applicable",
+        target_run_id: "",
+        disposition: "not_applicable",
+        evidence: "",
+        missing_evidence: "none",
+        next_action: "none",
+      },
+      findings: [],
+    };
+  }
+
+  if (rows.length !== 1) {
+    return openResult(runState, {
+      code: "AGDF_PARENT_RECONCILIATION_EVIDENCE_INVALID",
+      missingEvidence: "Exactly one explicit Parent relationship is required.",
+      nextAction: "Retain exactly one evidenced OR reconciles_with parent_run:<run_id> relationship.",
+    });
+  }
+
+  if (invalidDispositionInput(runState)) {
+    return openResult(runState, {
+      code: "AGDF_PARENT_RECONCILIATION_EVIDENCE_INVALID",
+      missingEvidence: "The Parent reconciliation disposition or next action is invalid or duplicated.",
+      nextAction: "Record one valid disposition and exactly one concrete Parent reconciliation next action.",
+    });
+  }
+
+  const row = rows[0];
+  const parentRunId = exactTarget(row.to, parentPrefix);
+  if (!parentRunId || parentRunId === runState.run_id || !filled(row.evidence)) {
+    return openResult(runState, {
+      code: "AGDF_PARENT_RECONCILIATION_EVIDENCE_INVALID",
+      targetRunId: parentRunId,
+      evidence: row.evidence,
+      missingEvidence: "The Parent run ID and concrete relationship evidence must be valid and unambiguous.",
+      nextAction: "Repair the explicit OR reconciles_with parent_run:<run_id> row and its evidence.",
+    });
+  }
+
+  let parent;
+  try {
+    parent = loadRun?.(parentRunId);
+  } catch {
+    parent = null;
+  }
+  if (!parent?.content || parent.resolution_error) {
+    return openResult(runState, {
+      targetRunId: parentRunId,
+      evidence: row.evidence,
+      missingEvidence: "The named Parent run is unavailable.",
+      nextAction: `Restore or select Parent run ${parentRunId}, then re-run Delivery Map.`,
+    });
+  }
+
+  const reciprocalRows = parent.artefact_chain.filter((candidate) =>
+    candidate.from === "Aggregate"
+      && candidate.relationship === "includes"
+      && candidate.to === `${childPrefix}${runState.run_id}`
+  );
+  if (reciprocalRows.length !== 1 || !filled(reciprocalRows[0]?.evidence)) {
+    return openResult(runState, {
+      targetRunId: parentRunId,
+      evidence: row.evidence,
+      missingEvidence: reciprocalRows.length > 1
+        ? "The Parent contains ambiguous reciprocal Child relationships."
+        : "The Parent lacks one evidenced reciprocal Aggregate includes Child relationship.",
+      nextAction: `Reconcile Child ${runState.run_id} in Parent ${parentRunId} through the Parent's governed scope.`,
+    });
+  }
+
+  return {
+    result: {
+      outcome: "resolved",
+      target_run_id: parentRunId,
+      disposition: "not_applicable",
+      evidence: reciprocalRows[0].evidence,
+      missing_evidence: "none",
+      next_action: "none",
+    },
+    findings: [],
+  };
+}
+
+function completedChild(runState, resolveFile) {
+  const orArtefact = runState?.artefacts?.get("OR");
+  return Boolean(
+    runState?.content
+      && orArtefact?.status === "done"
+      && filled(orArtefact.path)
+      && resolveFile?.(orArtefact.path),
+  );
+}
+
+export function evaluateProgrammeAggregation(runState, { loadRun, resolveFile } = {}) {
+  const rows = runState.artefact_chain.filter((row) =>
+    row.from === "Aggregate" && row.relationship === "includes"
+  );
+  const input = runState.programme_aggregation ?? {};
+  const explicitInput = filled(input.acceptance_ref)
+    || filled(input.evidence)
+    || (Boolean(input.missing_evidence) && input.missing_evidence !== "none");
+  const applicable = explicitInput || rows.length > 0;
+  if (!applicable) {
+    return {
+      result: {
+        applicable: false,
+        startable: false,
+        final_ready: false,
+        acceptance_ref: "",
+        evidence: [],
+        missing_evidence: [],
+        next_action: "none",
+      },
+      findings: [],
+    };
+  }
+
+  const invalidRows = [];
+  const seenChildRunIds = new Set();
+  for (const row of rows) {
+    const childRunId = exactTarget(row.to, childPrefix);
+    if (!childRunId || !filled(row.evidence) || seenChildRunIds.has(childRunId)) invalidRows.push(row);
+    else seenChildRunIds.add(childRunId);
+  }
+  const completedEvidence = [];
+  for (const row of rows) {
+    const childRunId = exactTarget(row.to, childPrefix);
+    if (!childRunId || !filled(row.evidence)) continue;
+    let child;
+    try {
+      child = loadRun?.(childRunId);
+    } catch {
+      child = null;
+    }
+    if (completedChild(child, resolveFile)) completedEvidence.push({ child_run_id: childRunId, evidence: row.evidence });
+  }
+
+  const fieldCounts = input.field_counts ?? {};
+  const acceptanceRefValid = fieldCounts.acceptance_ref === 1
+    && filled(input.acceptance_ref)
+    && input.acceptance_ref.startsWith(".agdf/control/artefacts/")
+    && Boolean(resolveFile?.(input.acceptance_ref));
+  const missingEvidenceValid = fieldCounts.missing_evidence === 1
+    && input.missing_evidence === "none";
+  const evidenceFieldValid = fieldCounts.evidence === 1 && filled(input.evidence);
+  const startable = completedEvidence.length > 0;
+  const finalReady = startable && acceptanceRefValid && missingEvidenceValid && evidenceFieldValid && invalidRows.length === 0;
+  const missingEvidence = [];
+  if (!startable) missingEvidence.push("No evidenced included Child has a completed OR.");
+  if (!acceptanceRefValid) missingEvidence.push("The declared programme acceptance artefact is missing or invalid.");
+  if (!evidenceFieldValid) missingEvidence.push("Programme aggregation evidence is missing or invalid.");
+  if (!missingEvidenceValid) missingEvidence.push(input.missing_evidence || "Programme missing-evidence state is not resolved.");
+  if (invalidRows.length) missingEvidence.push("One or more Aggregate includes Child rows are invalid.");
+  const nextAction = !startable
+    ? "Link at least one evidenced completed Child OR in the Parent Artefact Chain."
+    : !acceptanceRefValid
+      ? "Provide one valid repository-relative programme acceptance artefact reference."
+      : !evidenceFieldValid || !missingEvidenceValid
+        ? "Resolve the declared programme evidence gaps before final readiness."
+        : invalidRows.length
+          ? "Repair invalid Aggregate includes child_run:<run_id> rows."
+          : "none";
+  const findings = [];
+  if (invalidRows.length) {
+    findings.push(warning(
+      runState,
+      "AGDF_PROGRAMME_AGGREGATION_EVIDENCE_INVALID",
+      "Programme aggregation contains invalid explicit Child evidence.",
+      nextAction,
+    ));
+  }
+  if (!finalReady) {
+    findings.push(warning(
+      runState,
+      "AGDF_PROGRAMME_AGGREGATION_NOT_FINAL",
+      `Programme aggregation for ${runState.run_id || "run"} is ${startable ? "startable but not final-ready" : "not startable"}.`,
+      nextAction,
+    ));
+  }
+  return {
+    result: {
+      applicable: true,
+      startable,
+      final_ready: finalReady,
+      acceptance_ref: input.acceptance_ref,
+      evidence: completedEvidence,
+      missing_evidence: missingEvidence,
+      next_action: nextAction,
+    },
+    findings,
+  };
+}
+
+export function evaluateReconciliationState(runState, dependencies = {}) {
+  const parent = evaluateParentReconciliation(runState, dependencies);
+  const programme = evaluateProgrammeAggregation(runState, dependencies);
+  return {
+    parent_reconciliation: parent.result,
+    programme_aggregation: programme.result,
+    findings: [...parent.findings, ...programme.findings],
+  };
+}

package/lib/control-state/run-state-parser.js

@@ -105,6 +105,15 @@ function field(c, k) {
 function sectionField(c, h, k) {
   return field(section(c, h), k);
 }
+function sectionScalar(c, h, k) {
+  const body = section(c, h);
+  const escaped = k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = [...body.matchAll(new RegExp(`^- ${escaped}:[^\\S\\r\\n]*(.*)$`, "gm"))];
+  return {
+    value: clean(matches[0]?.[1] ?? ""),
+    count: matches.length,
+  };
+}
 function dataRows(c, h, header) {
   return rows(section(c, h)).filter(
     (r) =>
@@ -116,6 +125,7 @@ export function parseControlState(
   content,
   { userGates = [], internalSteps = [], closeoutArtefacts = [] } = {},
 ) {
+  const metaValues = scalarFields(content).values;
   const approvals = new Map();
   for (const h of ["Approvals", "Gate Checklist"])
     for (const [g, s, e] of rows(section(content, h))) {
@@ -146,8 +156,16 @@ export function parseControlState(
       ? "Mode/Slice Decision"
       : "Mode / Slice Decision",
     source = "Source And Scope State",
-    memory = "Knowledge Persistence Decision";
+    memory = "Knowledge Persistence Decision",
+    handoff = "Parent Reconciliation Handoff",
+    aggregation = "Programme Aggregation Readiness";
+  const disposition = sectionScalar(content, handoff, "parent_reconciliation_disposition");
+  const reconciliationNextAction = sectionScalar(content, handoff, "parent_reconciliation_next_action");
+  const acceptanceRef = sectionScalar(content, aggregation, "programme_acceptance_ref");
+  const aggregationEvidence = sectionScalar(content, aggregation, "programme_aggregation_evidence");
+  const aggregationMissingEvidence = sectionScalar(content, aggregation, "programme_aggregation_missing_evidence");
   return {
+    run_id: clean(metaValues.get("run_id") ?? ""),
     current_gate: field(content, "current_gate"),
     next_allowed_action: field(content, "next_allowed_action"),
     approvals,
@@ -223,5 +241,25 @@ export function parseControlState(
       reason: sectionField(content, memory, "memory_reason"),
       refs: sectionField(content, memory, "memory_refs"),
     },
+    parent_reconciliation: {
+      present: Boolean(section(content, handoff).trim()),
+      disposition: disposition.value,
+      next_action: reconciliationNextAction.value,
+      field_counts: {
+        disposition: disposition.count,
+        next_action: reconciliationNextAction.count,
+      },
+    },
+    programme_aggregation: {
+      present: Boolean(section(content, aggregation).trim()),
+      acceptance_ref: acceptanceRef.value,
+      evidence: aggregationEvidence.value,
+      missing_evidence: aggregationMissingEvidence.value,
+      field_counts: {
+        acceptance_ref: acceptanceRef.count,
+        evidence: aggregationEvidence.count,
+        missing_evidence: aggregationMissingEvidence.count,
+      },
+    },
   };
 }

package/lib/interaction-presentation.js

@@ -11,11 +11,28 @@ const QUALITY_DIMENSIONS = Object.freeze([
   Object.freeze({ id: "code_quality", owner: "code-review" }),
   Object.freeze({ id: "qa_decision", owner: "qa-gate" }),
 ]);
+const SCOPE_CLASSIFICATION_LIMITS = Object.freeze({
+  maxCodePointsPerField: 240,
+  minEscalationTriggers: 1,
+  maxEscalationTriggers: 3,
+});
+const SCOPE_CLASSIFICATION_MARKDOWN_CONTROL = /[\\`*_\[\]<>|]/;
+const SCOPE_CLASSIFICATION_LINE_STRUCTURE = /^(?:[#>+\-]\s|\d+\.\s)/;
 
 function plainObject(value) {
   return value && typeof value === "object" && !Array.isArray(value);
 }
 
+function scopeClassificationText(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  if (!normalized || /[\r\n\u2028\u2029]/.test(value)) return null;
+  if (Array.from(normalized).length > SCOPE_CLASSIFICATION_LIMITS.maxCodePointsPerField) return null;
+  if (SCOPE_CLASSIFICATION_MARKDOWN_CONTROL.test(normalized)) return null;
+  if (SCOPE_CLASSIFICATION_LINE_STRUCTURE.test(normalized)) return null;
+  return normalized;
+}
+
 function flattenKeys(value, prefix = "") {
   const keys = [];
   for (const [key, child] of Object.entries(value ?? {})) {
@@ -439,22 +456,22 @@ export function renderScopeClassificationCard(classification, {
   requestedLocale,
 } = {}) {
   if (!plainObject(classification)) return null;
-  const outcome = String(classification.outcome ?? "").trim();
-  const mode = String(classification.mode ?? "").trim();
-  const trivialBoundary = String(classification.trivial_boundary ?? "").trim();
-  const urTriggerEvaluation = String(classification.ur_trigger_evaluation ?? "").trim();
-  const allowedSummary = String(classification.allowed_summary ?? "").trim();
-  const forbiddenSummary = String(classification.forbidden_summary ?? "").trim();
-  const escalationTriggers = Array.isArray(classification.escalation_triggers)
-    ? classification.escalation_triggers.map((item) => String(item ?? "").trim()).filter(Boolean)
-    : [];
-  const challengePath = String(classification.challenge_path ?? "").trim();
-
-  if (outcome !== "ungated") return null;
-  if (!["quick_task", "verified_change"].includes(mode)) return null;
+  const { outcome, mode, trivial_boundary: trivialBoundary } = classification;
+  if (outcome !== "ungated" || mode !== "quick_task") return null;
   if (!["inside", "outside"].includes(trivialBoundary)) return null;
+
+  const urTriggerEvaluation = scopeClassificationText(classification.ur_trigger_evaluation);
+  const allowedSummary = scopeClassificationText(classification.allowed_summary);
+  const forbiddenSummary = scopeClassificationText(classification.forbidden_summary);
+  const challengePath = scopeClassificationText(classification.challenge_path);
   if (!urTriggerEvaluation || !allowedSummary || !forbiddenSummary || !challengePath) return null;
-  if (escalationTriggers.length === 0) return null;
+
+  if (!Array.isArray(classification.escalation_triggers)
+    || classification.escalation_triggers.length < SCOPE_CLASSIFICATION_LIMITS.minEscalationTriggers
+    || classification.escalation_triggers.length > SCOPE_CLASSIFICATION_LIMITS.maxEscalationTriggers) return null;
+  const escalationTriggers = classification.escalation_triggers.map(scopeClassificationText);
+  if (escalationTriggers.some((item) => !item)) return null;
+  if (new Set(escalationTriggers).size !== escalationTriggers.length) return null;
 
   let locale;
   try {

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

@@ -1,7 +1,8 @@
 import { DELIVERY_PATHS } from "./contracts.js";
+import { getProfileDefinition, isStagedProfile } from "./profiles.js";
 
 export function buildBlindPrompt(testCase, behaviorSources) {
-  if (testCase.profile_id === "staged-v2") {
+  if (testCase.profile_id && isStagedProfile(getProfileDefinition(testCase.profile_id))) {
     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.",

package/lib/proportionality-benchmark/contracts.js

@@ -19,7 +19,8 @@ export const OBSERVATION_SCHEMA = Object.freeze({
     decision_grounds: { type: "array", maxItems: 12, items: { type: "string", maxLength: 120 } },
   },
 });
-export const STAGED_OBSERVATION_SCHEMA = Object.freeze({
+function stagedObservationSchema(schemaVersion) {
+  return Object.freeze({
   type: "object",
   additionalProperties: false,
   required: [
@@ -27,7 +28,7 @@ export const STAGED_OBSERVATION_SCHEMA = Object.freeze({
     "observed_delivery_path", "path_evaluability", "rationale", "decision_grounds",
   ],
   properties: {
-    schema_version: { type: "string", const: "2" },
+    schema_version: { type: "string", const: schemaVersion },
     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] },
@@ -35,7 +36,15 @@ export const STAGED_OBSERVATION_SCHEMA = Object.freeze({
     rationale: { type: "string", maxLength: 600 },
     decision_grounds: { type: "array", maxItems: 12, items: { type: "string", maxLength: 120 } },
   },
-});
+  });
+}
+export const STAGED_OBSERVATION_SCHEMA = stagedObservationSchema("2");
+export const STAGED_V3_OBSERVATION_SCHEMA = stagedObservationSchema("3");
+export function stagedSchemaForVersion(schemaVersion) {
+  if (schemaVersion === "2") return STAGED_OBSERVATION_SCHEMA;
+  if (schemaVersion === "3") return STAGED_V3_OBSERVATION_SCHEMA;
+  fail(`unsupported staged schema ${schemaVersion}`);
+}
 
 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;
@@ -85,14 +94,14 @@ export function normalizeAgentOutput(raw) {
   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) {
+export function normalizeStagedAgentOutput(raw, requestedAxes, schemaVersion = "2") {
   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));
+  const allowed = new Set(Object.keys(stagedSchemaForVersion(schemaVersion).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 (value.schema_version !== schemaVersion || (!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 [
@@ -109,7 +118,7 @@ export function normalizeStagedAgentOutput(raw, requestedAxes) {
     if (!grounds.includes("ur") || !grounds.includes("brownfield") || !grounds.includes("quick_task")) fail("compact delivery evidence missing", "PROPORTIONALITY_OUTPUT_INVALID");
   }
   return {
-    schema_version: "2",
+    schema_version: schemaVersion,
     observed_next_permissible_stage: value.observed_next_permissible_stage,
     stage_evaluability: value.stage_evaluability,
     observed_delivery_path: value.observed_delivery_path,