create-agdf 0.14.1 → 0.14.2

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-evaluation/gate-policy.js

@@ -0,0 +1,305 @@
+import { extractField, verifiedChangeEscalationTargets } from './verified-change.js';
+import { gateApprovalStatus, gateArtefactStatus, isDurableGateArtefactSatisfied, isInternalStepSatisfied, modeSliceDecision } from './run-state.js';
+
+function durableArtefactBlock(gate, nextGate) {
+  const label = gate === "QA" ? "QA report" : `${gate} artefact`;
+  const stablePath = gate === "QA" ? ".agdf/control/artefacts/<key>/QA_REPORT.md" : `.agdf/control/artefacts/<key>/${gate}.md`;
+  return {
+    status: "blocked",
+    current_gate: gate,
+    blocking_reason: `missing_durable_${gate.toLowerCase()}_artefact`,
+    missing_approval: "none",
+    allowed: [
+      `persist the approved ${label} in a stable artefact path such as ${stablePath}`,
+      "link the artefact from the selected RUN_STATE.md and MASTER_BACKLOG.md",
+      "run gate-check again",
+    ],
+    forbidden: nextGate
+      ? [`create ${nextGate}`, "create later-gate artefacts", "implement gated work", "claim QA or release readiness"]
+      : ["create later-gate artefacts", "implement gated work", "claim release readiness"],
+    next_allowed_action: `Persist the approved ${label} and link it from the AGDF control state before continuing.`,
+  };
+}
+
+export function isGateSatisfied(runState, gate) {
+  const status = gateApprovalStatus(runState, gate);
+  if (status === "not_applicable") return true;
+  if (status !== "approved") return false;
+  if (gate === "UAT") return true;
+  return isDurableGateArtefactSatisfied(runState, gate);
+}
+
+function qaNonPassDecision(runState) {
+  const status = gateArtefactStatus(runState, "QA").status;
+  return status === "revise" || status === "block" ? status : null;
+}
+
+export function transitionDecisionForRunState(runState, verifiedChange = null) {
+  if (gateApprovalStatus(runState, "UR") === "approved" && !isGateSatisfied(runState, "UR")) return durableArtefactBlock("UR", "PRD");
+
+  if (!isGateSatisfied(runState, "UR")) {
+    return {
+      status: "open",
+      current_gate: "UR",
+      blocking_reason: "none",
+      missing_approval: "Approval: UR",
+      allowed: ["clarify user need", "formulate and persist UR", "record evidence", "request exact UR approval"],
+      forbidden: ["create PRD", "create SD", "create TP", "run Brownfield Analysis", "implement code", "claim QA or release readiness"],
+      next_allowed_action: "Clarify the user requirement, persist the UR, and request exact approval: Approval: UR",
+    };
+  }
+
+  if (gateApprovalStatus(runState, "PRD") === "approved" && !isGateSatisfied(runState, "PRD")) return durableArtefactBlock("PRD", "SD");
+
+  if (!isGateSatisfied(runState, "PRD")) {
+    if (!isInternalStepSatisfied(runState, "Brownfield Review")) {
+      return {
+        status: "open",
+        current_gate: "Brownfield Review",
+        blocking_reason: "none",
+        missing_approval: "none",
+        allowed: [
+          "run Brownfield Review after G-00",
+          "identify existing workstream, owners, SoT, reuse risks and open PRD/SD questions",
+          "mark Brownfield Review as done or not_applicable in the selected RUN_STATE.md",
+        ],
+        forbidden: ["create PRD before Brownfield Review is resolved", "create SD", "create TP", "implement code", "claim QA or release readiness"],
+        next_allowed_action: "Run Brownfield Review after G-00 before drafting PRD, or mark Brownfield Review not_applicable with evidence.",
+      };
+    }
+
+    const modeDecision = modeSliceDecision(runState);
+    if (modeDecision === "undecided") {
+      return {
+        status: "open",
+        current_gate: "Mode/Slice Decision",
+        blocking_reason: "none",
+        missing_approval: "none",
+        allowed: [
+          "decide whether the approved UR is quick_task, verified_change, structured_slice, structured_delivery or block",
+          "record scope reason, evidence and required next gate depth in the selected RUN_STATE.md",
+          "choose the next required gate depth before drafting PRD or implementing",
+        ],
+        forbidden: ["create PRD before process size is decided", "create SD", "create TP", "implement code", "claim QA or release readiness"],
+        next_allowed_action: "Record the Mode/Slice Decision from Brownfield Review with scope reason and evidence before choosing PRD depth or Quick Task execution.",
+      };
+    }
+
+    if (modeDecision === "block") {
+      return {
+        status: "blocked",
+        current_gate: "Mode/Slice Decision",
+        blocking_reason: "mode_slice_decision_blocked",
+        missing_approval: "none",
+        allowed: ["resolve ownership, SoT, evidence, impact or product-direction uncertainty", "run gate-check again"],
+        forbidden: ["create PRD", "create SD", "create TP", "implement code", "claim QA or release readiness"],
+        next_allowed_action: "Resolve the Brownfield Review blocker before choosing a delivery path.",
+      };
+    }
+
+    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",
+        blocking_reason: "none",
+        missing_approval: "none",
+        allowed: ["implement the narrow approved UR scope", "run relevant checks", "record evidence and close with OR-lite"],
+        forbidden: ["expand scope beyond the Brownfield Review decision", "create broad PRD/SD/TP artefacts by ritual", "claim QA or release readiness without evidence"],
+        next_allowed_action: "Proceed as a Quick Task within the Brownfield Review scope and record verification evidence.",
+      };
+    }
+
+    if (modeDecision === "verified_change") {
+      const state = verifiedChange?.status ?? "missing";
+      const escalationTarget = verifiedChange?.escalation_target ?? "structured_slice";
+      if (state === "executed") {
+        return {
+          status: "open",
+          current_gate: "OR",
+          blocking_reason: "none",
+          missing_approval: "none",
+          allowed: ["use the Verified Change mini-closeout", "offer delivery closeout when requested"],
+          forbidden: ["create PRD, SD, TP, QA or UAT by ritual", "commit, push, open PR or release automatically"],
+          next_allowed_action: "Close the executed Verified Change with its compact record and offer delivery closeout; do not perform VCS actions automatically.",
+        };
+      }
+      if (state === "escalated" || (state === "invalid" && verifiedChangeEscalationTargets.has(escalationTarget))) {
+        return {
+          status: "open",
+          current_gate: "PRD",
+          blocking_reason: state === "escalated" ? "verified_change_escalated" : "verified_change_invalid_escalated",
+          missing_approval: "Approval: PRD",
+          allowed: ["draft the structured PRD required by the declared escalation target", "retain the Verified Change escalation evidence"],
+          forbidden: ["implement through Verified Change", "create SD or TP before PRD approval", "claim QA or release readiness"],
+          next_allowed_action: `Proceed as ${escalationTarget}: draft the required PRD and request exact approval: Approval: PRD.`,
+        };
+      }
+      if (state === "eligible") {
+        return {
+          status: "open",
+          current_gate: "Verified Change Execution",
+          blocking_reason: "none",
+          missing_approval: "none",
+          allowed: ["implement only declared source and derived paths", "run declared propagation and validation commands", "record execution evidence and mini-closeout"],
+          forbidden: ["touch unlisted paths", "add prohibited impacts", "claim QA, UAT or release readiness"],
+          next_allowed_action: "Implement only the eligible Verified Change record scope, then record passing propagation and validation evidence.",
+        };
+      }
+      return {
+        status: state === "missing" || state === "draft" ? "open" : "blocked",
+        current_gate: "Verified Change Execution",
+        blocking_reason: state === "invalid" ? "verified_change_invalid" : "verified_change_record_required",
+        missing_approval: "none",
+        allowed: ["create or refine the compact Verified Change record", "capture baseline paths", "prove fail-closed eligibility with doctor and gate-check"],
+        forbidden: ["implement candidate changes", "claim validation, QA, UAT or release readiness"],
+        next_allowed_action: "Create or repair VERIFIED_CHANGE.md, capture the baseline and satisfy every eligibility check before implementation; escalate when any condition cannot be proven.",
+      };
+    }
+
+    return {
+      status: "open",
+      current_gate: "PRD",
+      blocking_reason: "none",
+      missing_approval: "Approval: PRD",
+      allowed: ["draft or refine PRD", "define scope", "define acceptance criteria", "define non-goals", "request exact PRD approval"],
+      forbidden: ["create SD", "create TP", "run Brownfield Analysis as implementation preparation", "implement code", "claim QA or release readiness"],
+      next_allowed_action: modeDecision === "structured_slice"
+        ? "Draft or refine the smallest PRD slice justified by Brownfield Review; do not implement before required artefacts are approved."
+        : "Draft or refine the PRD; do not implement before PRD, SD and TP are approved.",
+    };
+  }
+
+  if (gateApprovalStatus(runState, "SD") === "approved" && !isGateSatisfied(runState, "SD")) return durableArtefactBlock("SD", "TP");
+
+  if (!isGateSatisfied(runState, "SD")) {
+    return {
+      status: "open",
+      current_gate: "SD",
+      blocking_reason: "none",
+      missing_approval: "Approval: SD",
+      allowed: ["draft or refine Solution Design", "define architecture", "define ownership", "request exact SD approval"],
+      forbidden: ["create TP", "implement code", "claim QA or release readiness"],
+      next_allowed_action: "Draft or refine the Solution Design; do not implement before SD and TP are approved.",
+    };
+  }
+
+  if (gateApprovalStatus(runState, "TP") === "approved" && !isGateSatisfied(runState, "TP")) return durableArtefactBlock("TP", "Brownfield Analysis");
+
+  if (!isGateSatisfied(runState, "TP")) {
+    return {
+      status: "open",
+      current_gate: "TP",
+      blocking_reason: "none",
+      missing_approval: "Approval: TP",
+      allowed: ["draft or refine Task/Test Plan", "define task IDs", "define test evidence", "request exact TP approval"],
+      forbidden: ["implement code", "claim QA or release readiness"],
+      next_allowed_action: "Draft or refine the Task/Test Plan; do not implement before TP is approved.",
+    };
+  }
+
+  const implementationStepsRequired = gateApprovalStatus(runState, "TP") === "approved";
+  if (implementationStepsRequired && !isInternalStepSatisfied(runState, "Brownfield Analysis")) {
+    return {
+      status: "open",
+      current_gate: "Brownfield Analysis",
+      blocking_reason: "none",
+      missing_approval: "none",
+      allowed: ["run Brownfield Analysis for the approved TP scope", "verify existing owners, reuse paths and regression risks"],
+      forbidden: ["implement before Brownfield evidence supports the approved TP path", "claim QA or release readiness"],
+      next_allowed_action: "Run Brownfield Analysis for the approved TP scope before CD+Tests.",
+    };
+  }
+
+  if (implementationStepsRequired && !isInternalStepSatisfied(runState, "CD+Tests")) {
+    return {
+      status: "open",
+      current_gate: "CD+Tests",
+      blocking_reason: "none",
+      missing_approval: "none",
+      allowed: ["implement the approved TP tasks", "run the approved test plan", "record implementation and test evidence"],
+      forbidden: ["claim QA pass", "request UAT approval", "release"],
+      next_allowed_action: "Implement the approved TP scope, run its tests, and record CD+Tests evidence before CR.",
+    };
+  }
+
+  if (implementationStepsRequired && !isInternalStepSatisfied(runState, "CR")) {
+    return {
+      status: "open",
+      current_gate: "CR",
+      blocking_reason: "none",
+      missing_approval: "none",
+      allowed: ["run mandatory code review", "record correctness, regression, security and maintainability findings", "fix blocking review findings"],
+      forbidden: ["claim QA pass", "request UAT approval", "release"],
+      next_allowed_action: "Run Code Review for the implemented TP scope and resolve blocking findings before QA.",
+    };
+  }
+
+  const qaNonPass = qaNonPassDecision(runState);
+  if (qaNonPass) {
+    const blocked = qaNonPass === "block";
+    return {
+      status: blocked ? "blocked" : "open",
+      current_gate: "QA",
+      blocking_reason: blocked ? "qa_blocked" : "qa_revise_required",
+      missing_approval: "none",
+      allowed: blocked
+        ? ["route the blocking QA findings to their authoritative owner", "record the next permitted remediation or upstream decision", "rerun QA only after the blocker is resolved"]
+        : ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
+      forbidden: ["request QA approval", "request UAT approval", "release", "claim delivery readiness"],
+      next_allowed_action: blocked
+        ? "Resolve or route the blocking QA findings through their authoritative owner, then rerun the required delivery steps. Do not request Approval: QA from a block report."
+        : "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
+    };
+  }
+
+  if (gateApprovalStatus(runState, "QA") === "approved" && !isGateSatisfied(runState, "QA")) return durableArtefactBlock("QA", "UAT");
+
+  if (isGateSatisfied(runState, "QA") && !isGateSatisfied(runState, "UAT")) {
+    return {
+      status: "open",
+      current_gate: "UAT",
+      blocking_reason: "none",
+      missing_approval: "Approval: UAT",
+      allowed: ["request exact UAT approval", "prepare non-operative delivery summary"],
+      forbidden: ["release", "push", "open PR", "commit without explicit user instruction and required approval"],
+      next_allowed_action: "Request exact approval: Approval: UAT before delivery handoff.",
+    };
+  }
+
+  if (isGateSatisfied(runState, "UAT")) {
+    return {
+      status: "open",
+      current_gate: "OR",
+      blocking_reason: "none",
+      missing_approval: "none",
+      allowed: ["produce OR or delivery closeout", "prepare commit, push or PR handoff when requested"],
+      forbidden: ["commit, push, open PR or release automatically"],
+      next_allowed_action: "Produce delivery closeout or requested handoff; do not perform VCS actions automatically.",
+    };
+  }
+
+  return {
+    status: "open",
+    current_gate: "QA",
+    blocking_reason: "none",
+    missing_approval: "Approval: QA",
+    allowed: ["run QA gate", "persist or refine the QA report", "request exact QA approval"],
+    forbidden: ["request UAT approval", "release", "claim delivery readiness before QA approval and report evidence"],
+    next_allowed_action: "Run the QA gate, persist the QA report, and request exact approval: Approval: QA",
+  };
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/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/generated/plugins/copilot/agdf/runtime/create-agdf/lib/control-evaluation/required-files.js

@@ -0,0 +1,9 @@
+import { join } from "node:path";
+
+export const doctorRequiredFiles = Object.freeze([
+  join(".agdf", "control", "AGDF_RUN.md"),
+  join(".agdf", "control", "MASTER_BACKLOG.md"),
+  join(".agdf", "control", "SOT_REGISTRY.md"),
+  join(".agdf", "control", "CONTEXT_GRAPH.md"),
+  join(".agdf", "control", "AGENT_QUALITY_CONTRACTS.json"),
+]);