create-agdf 0.13.1 → 0.13.3

package/generated/plugins/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/agdf/runtime/create-agdf/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/generated/plugins/agdf/runtime/create-agdf/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/generated/plugins/agdf/runtime/create-agdf/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agdf/local-validator-runtime",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "private": true,
   "type": "module"
 }

package/generated/plugins/agdf/runtime/runtime-manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "891fac7000205be2f6ca0d257ad553ad52651a167737726f8bf3ea9d106c03e7"
+  "digest": "496bee4ca4033209f031b78a3041f7d056c6a046cd069b29752f118ef01da266"
 }