create-agdf 0.13.2 → 0.13.4

package/generated/plugins/agdf/meta/agent-skills-conformance.json

@@ -0,0 +1,86 @@
+{
+  "schemaVersion": 1,
+  "policyVersion": "2026-08-19",
+  "baseline": {
+    "id": "agent-skills-core-format",
+    "specificationUrl": "https://agentskills.io/specification",
+    "reviewedAt": "2026-08-19"
+  },
+  "classifications": [
+    "standard_strict",
+    "upstream_advisory",
+    "agdf_policy"
+  ],
+  "frontmatterProfile": {
+    "requiredFields": [
+      "name",
+      "description"
+    ],
+    "allowedFields": [
+      "name",
+      "description"
+    ],
+    "scalarStyles": [
+      "plain",
+      "single_quoted",
+      "double_quoted"
+    ]
+  },
+  "strictRules": {
+    "nameMaxCodePoints": 64,
+    "descriptionMaxCodePoints": 1024,
+    "namePattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+    "nameMustMatchParent": true
+  },
+  "advisoryRules": {
+    "skillMdMaxLines": 500
+  },
+  "agdfRules": {
+    "descriptionStartsWith": "Use this skill",
+    "requiresRuntimeContractResource": true
+  },
+  "surfaces": {
+    "source": {
+      "skillsRoot": "skills",
+      "sharedResourceRoots": [
+        "meta/contracts"
+      ],
+      "skillPrefixOwner": "codex",
+      "ignoredSkillEntries": []
+    },
+    "plugin": {
+      "skillsRoot": "skills",
+      "sharedResourceRoots": [
+        "meta/contracts"
+      ],
+      "skillPrefixOwner": "codex",
+      "ignoredSkillEntries": []
+    },
+    "copilot": {
+      "skillsRoot": ".",
+      "sharedResourceRoots": [
+        "contracts"
+      ],
+      "skillPrefixOwner": "copilot",
+      "ignoredSkillEntries": [
+        "contracts"
+      ]
+    },
+    "opencode": {
+      "skillsRoot": "skills",
+      "sharedResourceRoots": [
+        "contracts"
+      ],
+      "skillPrefixOwner": "opencode",
+      "ignoredSkillEntries": []
+    },
+    "public_candidate": {
+      "skillsRoot": "skills",
+      "sharedResourceRoots": [
+        "meta/contracts"
+      ],
+      "skillPrefixOwner": "codex",
+      "ignoredSkillEntries": []
+    }
+  }
+}

package/generated/plugins/agdf/meta/contracts/closeout.md

@@ -21,6 +21,55 @@ selected-run ceremony even when it is otherwise a relevant run. If a selected ca
 section or any other existing line.
 
 
+## Parent Reconciliation Handoff
+
+Parent reconciliation is an optional closeout coordination projection. It never grants, revokes or
+blocks Child gates, QA, UAT, OR completion or an otherwise valid delivery handoff.
+
+It activates only when the Child `Artefact Chain` contains exactly one evidenced row with:
+
+- `From`: `OR`
+- `Relationship`: `reconciles_with`
+- `To`: `parent_run:<run_id>` using the canonical run-id grammar
+
+Names, directories, branches, backlog proximity, chat history and evidence prose do not establish
+Parentage. Delivery Map is the single deterministic evaluator. It compares the Child row with one
+evidenced reciprocal Parent row `Aggregate | includes | child_run:<run_id>` and returns exactly one
+outcome:
+
+- `resolved`: the named Parent has exactly one evidenced reciprocal Child relationship;
+- `not_applicable`: the Child declares no qualifying Parent relationship; or
+- `open`: the explicit relationship is invalid, ambiguous, unavailable, stale or lacks reciprocal
+  evidence.
+
+An open outcome contains concrete evidence or missing evidence and exactly one next action. Optional
+Child handling input is limited to `action_required | accepted_open`. `accepted_open` keeps the
+outcome open and visible while allowing independently valid Child delivery to continue; it never
+asserts Parent reconciliation. Evaluation is read-only and must never mutate a Parent.
+
+`release-or` reports the evaluated result in the Child OR. `delivery-closeout` consumes that OR
+projection only; it must not search sibling runs, infer a relationship, reevaluate evidence or repair
+a Parent. Unresolved explicit reconciliation is warning-level coordination evidence, not a Child
+gate failure. Legacy runs without the optional relationship remain unchanged and add no routine
+visible ceremony.
+
+
+## Programme Aggregation Readiness
+
+An explicit Parent/programme run may project two independent evidence values:
+
+- `startable: true` requires at least one evidenced `Aggregate | includes | child_run:<run_id>` row
+  whose Child has a completed OR;
+- `final_ready: true` additionally requires one valid declared acceptance artefact beneath
+  `.agdf/control/artefacts/`, concrete aggregation evidence and
+  `programme_aggregation_missing_evidence: none`.
+
+`final_ready: true` always implies `startable: true`. Failed prerequisites stay false with explicit
+missing evidence and one next action; they are never silently promoted. These values are evidence
+projections only. They do not approve QA/UAT, create a gate or define the programme-specific
+acceptance criteria, which remain owned by the referenced programme artefact.
+
+
 ## Do Not Duplicate
 
 The explanatory framework lives in `docs/`.

package/generated/plugins/agdf/meta/contracts/control-scaffold.md

@@ -108,6 +108,8 @@ It must expose:
 - multi-scope ambiguity and branch/workspace evidence limits when present
 - memory persistence target, reason and references when present
 - Context Graph impact and gate effect
+- optional evaluated Parent reconciliation and programme aggregation readiness from the Closeout
+  Contract, without changing Child gate authority
 - the Run Status Card as a compact projection of current gate, next step and quality outlook
 - findings that explain why the delivery picture is `pass | warn | revise | block`
 

package/generated/plugins/agdf/meta/contracts/interaction.md

@@ -7,7 +7,7 @@ It must not introduce a second gate model or override `gate-check`, `delivery-ma
 
 - `mode`: `quick_task | verified_change | structured_delivery | unknown`
 - `run_id`: the exactly selected canonical run
-- `presentation_language`: the resolved complete locale-pack tag; absent, unsupported or incomplete packs resolve to the registry's deterministic `en` fallback
+- `presentation_language`: the resolved complete locale-pack tag; absent or unsupported requested locale tags resolve to the registry's deterministic `en` fallback, while an incomplete or invalid registry fails closed
 - `status`: `open | blocked | pass | warn | revise | block | in_progress`
 - `current_gate`: current user gate or internal step
 - `mode_slice_decision`: `undecided | quick_task | verified_change | structured_slice | structured_delivery | block`
@@ -206,8 +206,8 @@ Use this compact composition:
 
 Resolve all AGDF-owned explanatory text through the canonical Interaction
 Locale Registry. `en` and `de` are initial reviewed packs, not a closed locale
-list. English is the deterministic fallback for absent, unsupported or
-incomplete packs. Gate identifiers, `run_id`, canonical paths and exact
+list. English is the deterministic fallback for absent or unsupported requested locale tags; an
+incomplete or invalid registry fails closed. Gate identifiers, `run_id`, canonical paths and exact
 approval values are never translated. The visible gate title is localized;
 for example, the German title may be `Lösungsdesign` while the authorization
 value remains `Approval: SD`. Meaning, ordering and authority boundaries are
@@ -362,20 +362,30 @@ skill-local target-orientation template.
 
 ### Scope Classification Card
 
-When `gate-check` classifies a fresh scope as ungated (Quick Task or Trivial Change Boundary),
+When `gate-check` classifies a fresh scope as an ungated `quick_task` with a resolved Trivial
+Change Boundary result,
 the agent consumes the canonical `scope_classification.markdown` verbatim from
 `renderScopeClassificationCard` in `create-agdf/lib/interaction-presentation.js`. The card is a
 compact, localized, non-authorizing projection of the classification: mode, boundary result,
 UR-trigger evaluation, one currently-allowed line, one remains-forbidden line, escalation triggers
 and the challenge path. It carries `authorizes: false` and never renders approval controls.
 
-The card renders exactly once per fresh-scope ungated classification, before work proceeds. It must
-not appear for gated scopes, internal steps of a selected run, or as a substitute for the two-card
-approval envelope. Read-only requests keep the single read-only orientation sentence above; the
-scope classification card and the read-only orientation are mutually exclusive for the same request.
-
-If the classification input is missing, unknown, contradictory or the locale section is incomplete,
-the renderer returns `null` and the agent fails closed to the existing ceremony — never
+The card renders exactly once per valid fresh-scope Quick Task classification, before work proceeds.
+It must not appear for Verified Change, Structured Delivery, gated, ambiguous, unknown or selected-
+run states, internal steps of a selected run, or as a substitute for the two-card approval envelope.
+Read-only requests keep the single read-only orientation sentence above; the scope classification
+card and the read-only orientation are mutually exclusive for the same request.
+
+Every dynamic scalar and escalation-trigger item is a non-empty, single-line plain-text string of at
+most 240 Unicode code points. Markdown control tokens and line-leading heading, blockquote, list or
+ordered-list syntax are invalid. The escalation list contains 1–3 valid, distinct normalized items.
+The renderer rejects the complete input on any violation; it never coerces, truncates, sanitizes or
+partially retains invalid values.
+
+An unsupported requested locale resolves through the complete deterministic English fallback pack.
+A present incomplete or otherwise invalid registry is an invalid presentation source, not an
+unsupported locale: the renderer returns `null`. Missing, unknown or contradictory classification
+input likewise returns `null`, and the agent fails closed to the existing ceremony — never
 model-reconstructed Markdown. The card introduces no gate, no approval value, no persistence and no
 second presentation owner. `gate-check` must not maintain a skill-local card template.
 
@@ -390,7 +400,8 @@ fallback and human CLI output use the configured project chat language from
 
 - resolve an exact complete pack, then its language subtag, then deterministic English fallback;
 - `en` and `de` are the initial complete packs; additional reviewed complete packs are supported without changing runtime logic;
-- an incomplete pack is unsupported and must fail to English as a unit;
+- an unsupported requested locale must fail to English as a complete unit; an incomplete or invalid
+  registry is not an unsupported locale and must fail closed without presentation;
 - one interaction must not mix presentation languages, including labels and descriptions;
 - durable artefacts, runtime rules, task identifiers and machine-facing approval values remain English;
 - the exact approval value remains `Approval: <GateName>` in every locale;

package/generated/plugins/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-interaction-locales.json

@@ -45,8 +45,7 @@
         "value": "Value",
         "classification": "Classification",
         "mode": {
-          "quick_task": "Quick Task",
-          "verified_change": "Verified Change"
+          "quick_task": "Quick Task"
         },
         "boundary": {
           "inside": "Trivial change boundary satisfied",
@@ -296,8 +295,7 @@
         "value": "Wert",
         "classification": "Klassifizierung",
         "mode": {
-          "quick_task": "Quick Task",
-          "verified_change": "Verified Change"
+          "quick_task": "Quick Task"
         },
         "boundary": {
           "inside": "Trivial-Change-Boundary erfüllt",

package/generated/plugins/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",

package/generated/plugins/agdf/runtime/create-agdf/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/generated/plugins/agdf/runtime/create-agdf/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/generated/plugins/agdf/runtime/create-agdf/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/generated/plugins/agdf/runtime/create-agdf/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",