create-agdf 0.14.5 → 0.20.1

package/lib/scaffold/plan.js

@@ -1,19 +1,17 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { generatedRoot, languageConfigContent, pluginDefinition } from "../cli/runtime-context.js";
-export { doctorRequiredFiles } from "../control-evaluation/required-files.js";
+export { doctorRequiredFiles } from "#agdf-core/control-evaluation/required-files.js";
 
 const codexSkillNames = pluginDefinition.skillSet.map((skill) => `${pluginDefinition.codex.skillPrefix}${skill.slug}`);
 const globalOpenCodeSkillNames = pluginDefinition.skillSet.map((skill) => `${pluginDefinition.opencode.globalSkillPrefix}${skill.slug}`);
-const contractModules = [
-  "gate-transition.md",
-  "interaction.md",
-  "modes.md",
-  "quality.md",
-  "context-graph.md",
-  "control-scaffold.md",
-  "closeout.md",
-];
+const contractModules = pluginDefinition.runtimeContract.modules.map((modulePath) => {
+  const prefix = "meta/contracts/";
+  if (!modulePath.startsWith(prefix) || modulePath.slice(prefix.length).includes("/")) {
+    throw new Error(`Invalid definition-owned runtime contract module path: ${modulePath}`);
+  }
+  return modulePath.slice(prefix.length);
+});
 const codexPluginFiles = [
   join(".agents", "plugins", "marketplace.json"),
   join("plugins", "agdf", ".codex-plugin", "plugin.json"),
@@ -62,10 +60,6 @@ const controlFiles = [
   join(".agdf", "control", "templates", "artefacts", "OR.md"),
 ];
 const liveControlFiles = [
-  {
-    path: join(".agdf", "control", "AGDF_RUN.md"),
-    source: join(".agdf", "control", "templates", "AGDF_RUN.md"),
-  },
   {
     path: join(".agdf", "control", "MASTER_BACKLOG.md"),
     source: join(".agdf", "control", "templates", "MASTER_BACKLOG.md"),

package/lib/scaffold/presentation.js

@@ -4,7 +4,46 @@ import { pluginDefinition } from "../cli/runtime-context.js";
 import { printLifecycleResult } from "../lifecycle/presentation.js";
 import { createLifecycleResult } from "../lifecycle/result.js";
 
-export function printNextSteps(target, destination, files, removedOpenCodeAgents = [], { verbose = false, json = false, io = console } = {}) {
+export function createCanonicalInitLifecycleResult(destination, initialization) {
+  if (!initialization || !["created", "unchanged", "repaired"].includes(initialization.status)) {
+    throw new Error("Canonical init presentation requires a created, unchanged or repaired result.");
+  }
+  const created = initialization.files
+    .filter((file) => file.action === "created")
+    .map((file) => Object.freeze({ kind: "create", path: file.path }));
+  const retained = initialization.files
+    .filter((file) => file.action === "preserved_exact")
+    .map((file) => file.path);
+  return createLifecycleResult({
+    operation: "control_init",
+    result: "success",
+    surface: "generic",
+    scope: "repository",
+    target: destination,
+    operationOutcome: initialization.status,
+    verification: {
+      status: "healthy",
+      evidence: [".agdf/control/runs", ...initialization.files.map((file) => file.path)],
+    },
+    installation: { status: "not_applicable" },
+    activation: { status: "not_applicable" },
+    delivery: { status: "not_evaluated" },
+    restart: { required: false, reason: "none" },
+    next_action: {
+      kind: "control_setup",
+      text: "Create or migrate one canonical run with an explicit run id before drafting durable delivery state.",
+    },
+    changes: created,
+    retained,
+  });
+}
+
+export function printNextSteps(target, destination, files, removedOpenCodeAgents = [], {
+  verbose = false,
+  json = false,
+  io = console,
+  initialization = null,
+} = {}) {
   const repositorySurface = { "codex-repo": "codex", "opencode-repo": "opencode" }[target];
   const verified = files.every((file) => {
     const path = join(destination, file.path);
@@ -19,6 +58,7 @@ export function printNextSteps(target, destination, files, removedOpenCodeAgents
       result: verified ? "success" : "partial",
       surface: repositorySurface,
       scope: "repository",
+      target: destination,
       version: { expected: pluginDefinition.version, status: "expected" },
       verification: { status: verified ? "healthy" : "degraded", evidence: files.map((file) => file.path) },
       installation: { status: verified ? "healthy" : "degraded" },
@@ -30,6 +70,15 @@ export function printNextSteps(target, destination, files, removedOpenCodeAgents
     if (!verbose || json) return;
   }
 
+  if (target === "init") {
+    const report = createCanonicalInitLifecycleResult(destination, initialization);
+    if (json) {
+      printLifecycleResult(report, { json: true, io });
+      return;
+    }
+    printLifecycleResult(report, { compact: true, io });
+  }
+
   if (verbose) {
     io.log("");
     io.log(`AGDF bootstrap complete in ${destination}`);
@@ -64,7 +113,8 @@ export function printNextSteps(target, destination, files, removedOpenCodeAgents
     io.log(`- AGDF language preference: artefacts=${language.artifact_language}, chat=${language.chat_language}, runtime=${language.runtime_language}.`);
   }
   if (target === "init") {
-    io.log("- Create or migrate a canonical run, then fill its RUN_STATE.md with the current gate, evidence and next allowed action.");
+    io.log("- Create the canonical run with `run-create --run <run_id>` and record each later step with `run-step` instead of editing RUN_STATE.md by hand.");
+    io.log("- An active delivery intake continues without a second setup prompt: write the UR, record it with `run-step --step ur`, then dispatch gate-check with `--intake`.");
     io.log("- Run the installed `agdf doctor` to check the control state before the next agent run.");
     io.log("- Commit the live control files once they represent the repository's current delivery state.");
     return;
@@ -77,7 +127,7 @@ export function printNextSteps(target, destination, files, removedOpenCodeAgents
   if (target === "opencode-repo") {
     io.log("- Install the global OpenCode surface once with npx --yes @agdf/cli@latest opencode if it is not already installed.");
     io.log("- Start or restart OpenCode in this repository; valid .agdf/control/config.json activates the global AGDF runtime here.");
-    io.log("- Load agdf-global-gate-check through OpenCode's native skill tool for new build/change intent or unclear approval before later artefacts or implementation.");
+    io.log("- After positive Request Activation selects actual delivery work, load agdf-global-gate-check through OpenCode's native skill tool before later artefacts or implementation. Unclear approval alone never activates AGDF.");
     io.log("- Existing .opencode files are left untouched as a compatibility path; this command does not copy a second runtime surface.");
   }
   io.log("- Commit the generated files so the repository becomes the source of truth.");

package/lib/skill-dispatch/binding.js

@@ -0,0 +1,9 @@
+import process from "node:process";
+import { createDispatchBinding as buildBinding } from "#agdf-core/skill-dispatch/binding.js";
+import { createRuntimeProbe } from "../runtime/runtime-probe.js";
+export { createRuntimeProbe, runtimeEnvironment } from "../runtime/runtime-probe.js";
+export { validateDispatchBinding, unavailableDispatchContext } from "#agdf-core/skill-dispatch/binding.js";
+const probeRuntime = createRuntimeProbe();
+export function createDispatchBinding(options, dependencies = {}) {
+  return buildBinding({ executable: process.execPath, versions: process.versions, ...options }, { probe: probeRuntime, ...dependencies });
+}

package/opencode-plugin.js

@@ -1,8 +1,73 @@
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
 import { evaluateOpenCodeRepositoryActivation } from "./lib/installers/opencode-activation.js";
 import { executeOpenCodeAutomaticRuntimeCheck } from "./lib/runtime-check-consent/service.js";
+import { createDispatchBinding, unavailableDispatchContext } from "./lib/skill-dispatch/binding.js";
 
 const packageJson = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8"));
+const requestActivationMarkers = Object.freeze({
+  start: "<!-- AGDF-REQUEST-ACTIVATION-GUARD:START -->",
+  end: "<!-- AGDF-REQUEST-ACTIVATION-GUARD:END -->",
+});
+
+function normalizeLf(content) {
+  return content.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+
+function validateRequestActivationIdentity(identity) {
+  if (identity?.owner !== "request_activation_contract"
+      || identity?.path !== "meta/contracts/request-activation.md"
+      || identity?.policy_version !== 1
+      || !/^sha256:[0-9a-f]{64}$/.test(identity?.guard_fingerprint ?? "")) {
+    throw new Error("AGDF Request Activation binding identity is invalid.");
+  }
+  return Object.freeze({ ...identity });
+}
+
+function contractFromRequestActivationContent(rawContent) {
+  const content = normalizeLf(rawContent);
+  const { start, end } = requestActivationMarkers;
+  if (content.split(start).length !== 2 || content.split(end).length !== 2) {
+    throw new Error("AGDF Request Activation Guard markers must occur exactly once.");
+  }
+  const startIndex = content.indexOf(start);
+  const endIndex = content.indexOf(end, startIndex);
+  if (endIndex < startIndex) throw new Error("AGDF Request Activation Guard markers are out of order.");
+  const guard = content.slice(startIndex, endIndex + end.length);
+  const readMetadata = (name, pattern) => {
+    const matches = [...guard.matchAll(pattern)];
+    if (matches.length !== 1) throw new Error(`AGDF Request Activation Guard ${name} must occur exactly once.`);
+    return matches[0][1];
+  };
+  const identity = validateRequestActivationIdentity({
+    owner: readMetadata("owner", /- `owner`: `([^`]+)`/g),
+    path: readMetadata("path", /- `path`: `([^`]+)`/g),
+    policy_version: Number(readMetadata("policy_version", /- `policy_version`: `(\d+)`/g)),
+    guard_fingerprint: readMetadata("guard_fingerprint", /- `guard_fingerprint`: `(sha256:[0-9a-f]{64})`/g),
+  });
+  const fingerprintInput = guard.replace(
+    /- `guard_fingerprint`: `sha256:[0-9a-f]{64}`/,
+    "- `guard_fingerprint`: `sha256:<computed>`",
+  );
+  const computed = `sha256:${createHash("sha256").update(fingerprintInput).digest("hex")}`;
+  if (identity.guard_fingerprint !== computed) {
+    throw new Error(`AGDF Request Activation Guard fingerprint mismatch: declared ${identity.guard_fingerprint}, computed ${computed}.`);
+  }
+  return Object.freeze({ identity, kernel: guard });
+}
+
+function readRequestActivationContract() {
+  const candidates = [
+    new URL("./generated/.opencode/contracts/request-activation.md", import.meta.url),
+    new URL("../plugins/agdf/meta/contracts/request-activation.md", import.meta.url),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return contractFromRequestActivationContent(readFileSync(candidate, "utf8"));
+  }
+  throw new Error("AGDF Request Activation Contract is unavailable from the installed package.");
+}
 
 const readValidatorExpectedVersion = () => {
   try {
@@ -29,33 +94,47 @@ export const AGDFPlugin = async ({ directory, client }, dependencies = {}) => {
     repositorySurface: repositoryActivation.legacy_surface,
     };
   };
+  const validatorPath = dependencies.validatorPath ?? fileURLToPath(new URL("../../agdf/bin/agdf-local.js", import.meta.url));
+  const activationContract = readRequestActivationContract();
+  const activationIdentity = validateRequestActivationIdentity(
+    dependencies.requestActivationIdentity ?? activationContract.identity,
+  );
+  if (Object.entries(activationContract.identity).some(([key, value]) => activationIdentity[key] !== value)) {
+    throw new Error("AGDF Request Activation dependency identity does not match the installed kernel.");
+  }
+  const activeContext = () => {
+    try {
+      const binding = createDispatchBinding({
+        validator: validatorPath,
+        surface: "opencode",
+        expectedVersion: packageJson.version,
+        requestActivation: {
+          owner: activationIdentity.owner,
+          policy_version: activationIdentity.policy_version,
+          guard_fingerprint: activationIdentity.guard_fingerprint,
+        },
+      });
+      return [
+        `AGDF dispatcher binding: ${JSON.stringify(binding)}`,
+        `AGDF runtime facts: ${JSON.stringify({ active: true, version: packageJson.version })}`,
+      ].join("\n");
+    } catch { return unavailableDispatchContext(); }
+  };
 
-  const activeGuidance = [
-    "## AGDF Runtime Reminder",
-    "This repository is AGDF-active through `.agdf/control/config.json`; use the globally installed AGDF runtime surface.",
-    "For new build/change intent or unclear approval, load the native `agdf-global-gate-check` skill before later artefacts or implementation.",
-    "Use the config-local `agdf/bin/agdf-local.js gate-check --status-card` for compact interactive status. Use `--json` only as deterministic proof for automation or audit evidence, and summarize it instead of mirroring full JSON into chat.",
-  ].join("\n");
-
-  const inactiveGuidance = [
-    "## AGDF Plugin Notice",
-    "The AGDF OpenCode npm plugin is loaded, but this repository has no valid `.agdf/control/config.json`.",
-    "Do not apply AGDF gates from the global plugin alone. Create or repair durable AGDF control state with `npx --yes @agdf/cli@latest opencode-repo` when governance should be active here.",
-  ].join("\n");
-
-  const appendGuidance = async (output, key) => {
+  const appendContentOnce = async (output, key, content) => {
+    if (!content) return;
     if (!output || !Array.isArray(output[key])) {
       try {
         await safeLog({
           service: "agdf",
           level: "warn",
-          message: `AGDF OpenCode guidance degraded: ${key} output is unavailable`,
+          message: `AGDF OpenCode context degraded: ${key} output is unavailable`,
           extra: { key, repositoryActivation: activation().state },
         });
       } catch {}
       return;
     }
-    output[key].push(activation().active ? activeGuidance : inactiveGuidance);
+    if (!output[key].includes(content)) output[key].push(content);
   };
 
   const safeToast = async (message, variant) => {
@@ -90,12 +169,6 @@ export const AGDFPlugin = async ({ directory, client }, dependencies = {}) => {
           message: currentStatus.active ? "AGDF OpenCode active through durable control" : "AGDF OpenCode global hook active without durable control",
           extra: { ...currentStatus, automatic_runtime_check: { effective: runtimeCheck.effective, reason: runtimeCheck.reason, ran: runtimeCheck.ran } },
         });
-        if (!currentStatus.active) {
-          await safeToast(
-            "AGDF: No valid .agdf/control/config.json. Run npx --yes @agdf/cli@latest opencode-repo to activate governance.",
-            "warning",
-          );
-        }
         const validatorVersion = readValidatorExpectedVersion();
         if (validatorVersion && validatorVersion !== packageJson.version) {
           await client.app.log({
@@ -124,13 +197,13 @@ export const AGDFPlugin = async ({ directory, client }, dependencies = {}) => {
     },
 
     "experimental.chat.system.transform": async (_input, output) => {
-      await appendGuidance(output, "system");
-      const runtimeCheck = currentAutomaticCheck();
-      if (runtimeCheck.ran && runtimeCheck.output && Array.isArray(output?.system)) output.system.push(runtimeCheck.output);
+      if (!activation().active) return;
+      await appendContentOnce(output, "system", activeContext());
     },
 
     "experimental.session.compacting": async (_input, output) => {
-      await appendGuidance(output, "context");
+      if (!activation().active) return;
+      await appendContentOnce(output, "context", activationContract.kernel);
     },
   };
 };

package/package.json

@@ -1,70 +1,37 @@
 {
   "name": "create-agdf",
-  "version": "0.14.5",
+  "version": "0.20.1",
   "description": "Install AGDF plugins, bootstrap supported repository surfaces and validate durable governance state.",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "files": [
     "bin",
     "lib",
-    "generated",
+    "generated/.agdf",
+    "generated/.agents",
+    "generated/.opencode",
+    "generated/opencode.json",
+    "generated/plugins/agdf",
+    "generated/plugins/copilot/agdf",
+    "generated/submissions/openai/agdf",
     "opencode-plugin.js",
     "README.md",
-    "NOTICE"
+    "NOTICE",
+    "runtime/core"
   ],
   "exports": {
     ".": "./opencode-plugin.js",
+    "./control-command": "./lib/control-command.js",
     "./cli": "./bin/create-agdf.js",
+    "./mcp-dispatch-runtime": "./lib/mcp-dispatch-runtime.js",
     "./opencode-plugin": "./opencode-plugin.js"
   },
   "bin": {
     "create-agdf": "./bin/create-agdf.js"
   },
-  "scripts": {
-    "sync-package-assets": "node ./scripts/sync-package-assets.js",
-    "build:public-plugin": "node ./scripts/build-public-plugin.js",
-    "install:claude": "node ./scripts/install-local-plugin.js claude",
-    "install:codex": "node ./scripts/install-local-plugin.js codex",
-    "install:copilot": "node ./scripts/install-local-plugin.js copilot",
-    "install:opencode": "node ./scripts/install-local-plugin.js opencode",
-    "test:release-version-coherence": "node ./scripts/release-version-coherence-test.js",
-    "release:bump": "node ./scripts/release-bump.js",
-    "test:release-bump": "node ./scripts/release-bump-test.js",
-    "test:distribution-profile-history": "node ./scripts/distribution-profile-history-test.js",
-    "test:public-plugin": "node ./scripts/public-plugin-test.js",
-    "release:prepare": "npm run sync-package-assets && npm run test:distribution-profile-history && npm run test:release-bump && npm run test:release-version-coherence && npm run test:public-plugin",
-    "test:delivery-path-search": "node ./scripts/delivery-path-search-test.js",
-    "test:delivery-path-search-unit": "node ./scripts/delivery-path-search-unit-test.js",
-    "test:delivery-path-search-generator": "node ./scripts/delivery-path-search-generator-test.js",
-    "test:opencode-hardening": "node ./scripts/opencode-hardening-test.js",
-    "test:runtime-check-consent": "node ./scripts/runtime-check-consent-test.js",
-    "test:cli-modularization": "node ./scripts/cli-modularization-test.js",
-    "test:local-validator": "node ./scripts/local-validator-test.js",
-    "test:local-marketplace": "node ./scripts/local-marketplace-test.js",
-    "test:claude-cache-recovery": "node ./scripts/claude-cache-recovery-test.js",
-    "test:copilot-profile": "node ./scripts/copilot-profile-test.js",
-    "test:local-development-install": "npm run release:prepare && node ./scripts/local-development-install-test.js",
-    "test:package-contents": "node ./scripts/package-contents-test.js",
-    "test:package-build": "node ./scripts/package-build-test.js",
-    "test:lifecycle": "node ./scripts/lifecycle-test.js",
-    "test:copilot-repository-retention": "node ./scripts/copilot-repository-retention-test.js",
-    "test:control-state": "node ./scripts/control-state-test.js",
-    "test:parent-reconciliation": "node ./scripts/parent-reconciliation-test.js",
-    "test:interaction-presentation": "node ./scripts/interaction-presentation-test.js",
-    "test:verified-change": "node ./scripts/verified-change-test.js",
-    "test:runtime-integrity-layout": "node ./scripts/runtime-integrity-layout-test.js",
-    "test:runtime-integrity-negative": "node ./scripts/runtime-integrity-negative-test.js",
-    "test:agent-skills-conformance": "node ./scripts/agent-skills-conformance-test.js",
-    "test:skill-evals": "node ./scripts/skill-evals-test.js",
-    "eval:skills": "node ./scripts/run-skill-evals.js",
-    "eval:skills:record": "node ./scripts/record-skill-evals.js",
-    "eval:proportionality:record": "node ./scripts/record-proportionality-benchmark.js",
-    "eval:proportionality": "node ./scripts/run-proportionality-benchmark.js",
-    "test:proportionality": "node ./scripts/proportionality-benchmark-test.js",
-    "test:release-bootstrap": "node ./scripts/release-bootstrap-smoke-test.js",
-    "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run release:prepare && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:claude-cache-recovery && npm run test:copilot-profile && npm run test:local-development-install && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:copilot-repository-retention && npm run test:control-state && npm run test:parent-reconciliation && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:agent-skills-conformance && npm run test:skill-evals && npm run eval:skills && npm run test:proportionality && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
-    "prepack": "npm run release:prepare"
-  },
+  "scripts": {},
   "keywords": [
     "agdf",
     "copilot",
@@ -82,7 +49,11 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ArndtGold/ai-native-governance-delivery-framework.git",
-    "directory": "create-agdf"
+    "directory": "packages/cli"
   },
-  "homepage": "https://github.com/ArndtGold/ai-native-governance-delivery-framework/tree/main/create-agdf"
+  "homepage": "https://github.com/ArndtGold/ai-native-governance-delivery-framework/tree/main/packages/cli",
+  "imports": {
+    "#agdf-core": "./runtime/core/lib/index.js",
+    "#agdf-core/*": "./runtime/core/lib/*"
+  }
 }

package/runtime/core/lib/control-evaluation/acceptance-criteria.js

@@ -0,0 +1,61 @@
+import { section } from "./markdown-table.js";
+const CRITERION_ID = /^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+)*$/u;
+
+export const ACCEPTANCE_CRITERIA_FORMAT = Object.freeze({
+  section: "Acceptance Criteria", declaration: "criterion_id: <stable id>",
+  fields: "semicolon-separated inline fields or following bullet key: value lines",
+  id_pattern: CRITERION_ID.source,
+  examples: Object.freeze([
+    "## Acceptance Criteria\n- criterion_id: AC-001; observable_success: Saved choice remains selected",
+    "## Acceptance Criteria\n- criterion_id: AC-001\n  - observable_success: Saved choice remains selected",
+  ]),
+});
+
+// Shared readiness/presentation grammar, retaining legacy inline declarations.
+// Diagnostics refer to the original file and line, not a rewritten normal form.
+export function readAcceptanceCriteria(markdown, { source = "PRD" } = {}) {
+  const normalized = String(markdown).replace(/\r\n?/gu, "\n");
+  const body = section(normalized, "Acceptance Criteria");
+  const entries = [], diagnostics = [], openItems = [];
+  const report = (code, line, field, message) => {
+    diagnostics.push({ code, source, line, field, message }); openItems.push(message);
+  };
+  if (body === null) {
+    report("criteria_section_missing", 1, "Acceptance Criteria", "PRD Acceptance Criteria section is missing");
+    return { ids: [], entries, diagnostics, openItems };
+  }
+  const startLine = normalized.slice(0, normalized.indexOf(body)).split("\n").length;
+  let current = null;
+  const field = (clause, line) => {
+    const match = clause.trim().replace(/^[-*]\s*/u, "").match(/^([a-z][a-z0-9_-]*(?:\s+[a-z][a-z0-9_-]*)*)\s*:\s*(.*)$/iu);
+    if (!match) return;
+    const name = match[1].replace(/\s+/gu, "_").toLowerCase();
+    if (Object.hasOwn(current.fields, name)) {
+      report("criterion_field_duplicate", line, name, `Duplicate PRD criterion field ${name}: ${current.id}`); return;
+    }
+    current.fields[name] = match[2].trim(); current.field_lines[name] = line;
+  };
+  for (const [index, line] of body.split("\n").entries()) {
+    const lineNumber = startLine + index;
+    if (/criterion_id\s*:/iu.test(line)) {
+      const match = line.match(/criterion_id\s*:\s*([A-Za-z][A-Za-z0-9_-]*)\b(.*)$/iu);
+      const id = match?.[1]?.toUpperCase();
+      if (!id || !CRITERION_ID.test(id)) {
+        report("criterion_id_invalid", lineNumber, "criterion_id", "Every PRD acceptance criterion needs a stable criterion_id");
+        current = null; continue;
+      }
+      current = { id, fields: {}, source, line: lineNumber, field_lines: {} }; entries.push(current);
+      const tail = match[2].trim();
+      if (tail && !tail.startsWith(";")) report("criterion_fields_ambiguous", lineNumber, "criterion_id", `Ambiguous PRD criterion fields: ${id}`);
+      else for (const clause of tail.replace(/^;/u, "").split(/;\s*/u)) field(clause, lineNumber);
+    } else if (/^#{1,6}\s/u.test(line)) current = null;
+    else if (current && /^\s*[-*]\s*[^:]+:/u.test(line)) field(line, lineNumber);
+  }
+  if (!entries.length) report("criteria_missing", startLine, "criterion_id", "Add at least one stable criterion_id to PRD acceptance criteria");
+  const seen = new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.id)) report("criterion_id_duplicate", entry.line, "criterion_id", `Duplicate PRD criterion_id: ${entry.id}`);
+    seen.add(entry.id);
+  }
+  return { ids: entries.map(entry => entry.id), entries, diagnostics, openItems: [...new Set(openItems)] };
+}

package/runtime/core/lib/control-evaluation/backlog-vocabulary.d.ts

@@ -0,0 +1,3 @@
+export const SUMMARY_KINDS: readonly string[];
+export const SUMMARY_LABELS: Readonly<Record<string, readonly string[]>>;
+export function summaryLabel(kind: string, language?: string): string;

package/runtime/core/lib/control-evaluation/backlog-vocabulary.js

@@ -0,0 +1,15 @@
+// Descriptive saved labels only. Gate policy and QA remain the decision owners.
+export const SUMMARY_KINDS = Object.freeze(['work_pending', 'approval_pending', 'qa_report_pending',
+  'qa_evidence_open', 'qa_correction_open', 'qa_source_decision', 'qa_blocked', 'source_unconfirmed',
+  'closeout_pending', 'completed', 'unconfirmed']);
+export const SUMMARY_LABELS = Object.freeze({
+  work_pending: ['Work pending', 'Arbeit offen'], approval_pending: ['Approval pending', 'Freigabe ausstehend'],
+  qa_report_pending: ['QA report pending', 'QA-Bericht ausstehend'],
+  qa_evidence_open: ['QA evidence open', 'QA-Nachweis offen'],
+  qa_correction_open: ['QA correction open', 'QA-Korrektur offen'],
+  qa_source_decision: ['QA source decision required', 'QA: vorgelagerte Entscheidung erforderlich'],
+  qa_blocked: ['QA blocked', 'QA blockiert'], source_unconfirmed: ['Source unconfirmed', 'Quelle nicht bestätigt'],
+  closeout_pending: ['Closeout pending', 'Abschluss offen'], completed: ['Completed', 'Abgeschlossen'],
+  unconfirmed: ['Unconfirmed', 'Nicht bestätigt'],
+});
+export const summaryLabel = (kind, language = 'en') => SUMMARY_LABELS[kind]?.[language === 'de' ? 1 : 0] ?? SUMMARY_LABELS.unconfirmed[language === 'de' ? 1 : 0];

package/runtime/core/lib/control-evaluation/closeout-readiness.js

@@ -0,0 +1,103 @@
+import { extractField } from './verified-change.js';
+import { cleanStatusCell, filled, isPlaceholderValue, markdownSection, tableRows } from './shared.js';
+import { canonicalJson, digest } from '../control-state/approval-command-contract.js';
+import { readReportDecision } from './report-decision.js';
+import { STRUCTURED_REQUIRED_REVIEWS, reviewArtefactType } from '../control-state/evidence-bindings.js';
+import { inspectQaReports } from './qa-follow-up.js';
+
+export { STRUCTURED_REQUIRED_REVIEWS, reviewArtefactType };
+
+export const closeoutConfirmation = (runId, revisionId, operationId, orDigest) => `Close Run: ${runId} ${revisionId} ${operationId} ${orDigest}`;
+const value = (text, field, label) => cleanStatusCell(extractField(text, field) || (label ? text.match(new RegExp(`^${label}:[ \\t]*(.*)$`, 'mu'))?.[1] : ''));
+const concrete = text => filled(text) && !isPlaceholderValue(text) && !/^(?:tbd|todo|<)/iu.test(text);
+export function closeoutContext(text) {
+  return Object.fromEntries(['context_graph_impact', 'context_graph_refs', 'context_graph_reconciliation', 'context_graph_required_action',
+    'context_graph_gate_effect', 'context_graph_evidence', 'memory_target', 'memory_reason', 'memory_refs'].map(field => [field, value(text, field)]));
+}
+export const closeoutContextDigest = text => digest(`agdf-closeout-context/1\0${canonicalJson(closeoutContext(text))}`);
+
+// Shared observation of registered OR and prepared OR candidates. Legacy reports retain
+// their documented formats; the new writer additionally requires the complete template.
+export function evaluateCloseoutReadiness(state, report, readArtefact, { prepared = false } = {}) {
+  const findings = [], fail = reason => findings.push(reason), route = state.mode_slice_decision?.decision;
+  const structured = ['structured_slice', 'structured_delivery'].includes(route);
+  if (typeof report !== 'string' || Buffer.byteLength(report) > 131072) return { ready: false, findings: ['or_unavailable_or_oversized'] };
+  if (prepared) for (const [field, label] of [['run_id', 'Run'], ['report_mode', 'Report mode'], ...(structured ? [['status', 'Status']] : [])]) {
+    const declarations = [...report.matchAll(new RegExp(`^(?:- ${field}|${label}):[ \\t]*(.*)$`, 'gmu'))];
+    if (declarations.length !== 1) fail('or_field_ambiguous:' + field);
+  }
+  if (value(report, 'run_id', 'Run') !== state.run_id) fail('or_run_binding_invalid');
+  if (value(report, 'report_mode', 'Report mode') !== (structured ? 'OR-full' : 'OR-lite')) fail('or_mode_invalid');
+  if (!structured && route !== 'quick_task') return { ready: false, findings: ['closeout_route_unsupported'] };
+  const parent = state.reconciliation_state?.parent_reconciliation, programme = state.reconciliation_state?.programme_aggregation;
+  if (parent?.outcome === 'open' && parent.disposition !== 'accepted_open') fail('parent_reconciliation_required');
+  if (programme?.applicable && !programme.final_ready) fail('programme_aggregation_unfulfilled');
+  if (!structured) {
+    if (state.artefacts.get('CR')?.status !== 'done') fail('code_review_missing');
+    for (const section of ['Result', 'Evidence', 'Risk', 'Next Step']) if (!concrete(markdownSection(report, section).trim())) fail(`or_${section.toLowerCase().replaceAll(' ', '_')}_missing`);
+  } else {
+    if (!['done', 'completed', 'pass'].includes(value(report, 'status', 'Status'))) fail('or_status_unconfirmed');
+    for (const gate of ['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT']) {
+      if (state.approvals.get(gate)?.status !== 'approved') fail(`closeout_${gate.toLowerCase()}_approval_missing`);
+      if (gate !== 'UAT' && (!state.artefacts.get(gate)?.path || !(gate === 'QA' && state.qa_acceptance?.accepted)
+        && !['approved', ...(gate === 'QA' ? ['pass'] : [])].includes(state.artefacts.get(gate)?.status))) fail(`closeout_${gate.toLowerCase()}_artefact_missing`);
+    }
+    const steps = ['Brownfield Analysis', 'CD+Tests', 'CR', ...(prepared ? STRUCTURED_REQUIRED_REVIEWS : [])];
+    for (const step of steps) {
+      const type = reviewArtefactType(state, step), row = state.artefacts.get(type), association = state.evidence_applicability?.by_step.get(type);
+      const acceptedPlan = step === 'TP Review' && state.qa_acceptance?.accepted && row?.status === 'revise';
+      if (!row || !acceptedPlan && !['done', ...(step === 'Brownfield Analysis' ? ['not_applicable'] : [])].includes(row.status) || association && association.applicability !== 'current') fail('closeout_review_unfulfilled:' + step);
+      if (prepared && row?.status !== 'not_applicable') {
+        const text = row?.path ? readArtefact(row.path) : undefined;
+        if (!['pass', ...(acceptedPlan ? ['revise'] : [])].includes(readReportDecision(text))) fail('closeout_review_result_unconfirmed:' + step);
+      }
+    }
+    const qa = state.artefacts.get('QA'), qaText = qa?.path ? readArtefact(qa.path) : undefined;
+    if (!['pass', ...(state.qa_acceptance?.accepted ? ['revise'] : [])].includes(readReportDecision(qaText))) fail('closeout_qa_pass_unconfirmed');
+    if (state.qa_acceptance?.accepted && (value(report, 'qa_acceptance') !== 'accepted_with_deviations'
+      || value(report, 'accepted_qa_deviations_digest') !== state.qa_acceptance.digest)) fail('closeout_qa_deviations_not_disclosed');
+    const qaAssociation = state.evidence_applicability?.by_step.get('QA');
+    if (qaAssociation && qaAssociation.applicability !== 'current') fail('closeout_qa_association_not_current');
+    if (prepared && !state.qa_acceptance?.accepted) {
+      const quality = inspectQaReports('', state, state.run_id, 'pass', 64, true, { readArtefact });
+      if (quality.kind !== 'none' || quality.findings.length) fail('closeout_quality_unconfirmed');
+    }
+    const context = closeoutContext(report);
+    if (!['resolved', 'not_applicable'].includes(context.context_graph_reconciliation)
+      || !['none', 'warning'].includes(context.context_graph_gate_effect) || context.context_graph_required_action !== 'none'
+      || !concrete(context.context_graph_evidence)) fail('closeout_context_unresolved');
+    if (['revise', 'block'].includes(state.context_graph?.gate_effect) || state.context_graph?.reconciliation === 'open_gap') fail('run_context_obligation_open');
+    if ([...(state.missing_evidence ?? []), ...(state.risks ?? [])].some(row => ['revise', 'block'].includes(row.impact))) fail('run_required_obligation_open');
+    if (prepared) {
+      if (!['none', 'link_only', 'update_existing_node', 'new_node_required', 'sot_drift'].includes(context.context_graph_impact)
+        || context.context_graph_reconciliation === 'not_applicable' && (context.context_graph_impact !== 'none' || context.memory_target === 'context_graph')
+        || context.context_graph_reconciliation === 'resolved' && context.context_graph_impact !== 'none'
+          && (!concrete(context.context_graph_refs) || context.context_graph_refs === 'none')) fail('or_context_binding_invalid');
+      for (const field of ['run_id', 'related_ur', 'related_prd', 'related_sd', 'related_tp', 'related_qa_report', 'mode_slice_decision', 'current_gate', 'decision',
+        ...Object.keys(context), 'next_allowed_action', 'required_approval', 'forbidden_until_then']) {
+        if ([...report.matchAll(new RegExp(`^- ${field}:[ \\t]*(.*)$`, 'gmu'))].length !== 1) fail('or_field_ambiguous:' + field);
+      }
+      for (const [field, type] of Object.entries({ related_ur: 'UR', related_prd: 'PRD', related_sd: 'SD', related_tp: 'TP', related_qa_report: 'QA' })) {
+        if (value(report, field) !== state.artefacts.get(type)?.path) fail('or_source_reference_invalid:' + field);
+      }
+      if (value(report, 'mode_slice_decision') !== route || value(report, 'current_gate') !== 'OR' || value(report, 'decision') !== 'pass') fail('or_control_binding_invalid');
+      const gateRows = tableRows(markdownSection(report, 'Gate State')).filter(row => row[0] !== 'Gate or step');
+      for (const type of ['UR', 'PRD', 'SD', 'TP', 'Brownfield Review', 'Brownfield Analysis', 'CD+Tests', 'CR', 'QA', 'UAT']) {
+        const rows = gateRows.filter(row => row[0] === type), expected = state.approvals.has(type) ? state.approvals.get(type).status : state.artefacts.get(type)?.status;
+        const reference = state.artefacts.get(type)?.path || state.approvals.get(type)?.evidence;
+        if (rows.length !== 1 || rows[0][1] !== expected || !concrete(rows[0][2])
+          || cleanStatusCell(rows[0][2]) !== cleanStatusCell(reference)) fail('or_gate_state_unconfirmed:' + type);
+      }
+      for (const section of ['Gate State', 'Delivered', 'Not Delivered / Intentionally Deferred', 'Evidence', 'Missing Evidence', 'Risks And Open Items', 'Context Graph Impact', 'Knowledge Persistence Decision', 'Next Permissible Step']) {
+        const text = markdownSection(report, section).trim();
+        if (!concrete(text) || /<[^>]+>|\|[ \t]*\|/u.test(text)) fail('or_section_incomplete:' + section);
+      }
+      for (const section of ['Missing Evidence', 'Risks And Open Items']) if (/\|\s*(?:revise|block)\s*\|/u.test(markdownSection(report, section))) fail('or_required_obligation_open:' + section);
+      if (!['context_graph', 'sot_registry', 'scope_artifact', 'open_questions', 'none'].includes(context.memory_target)
+        || !concrete(context.memory_reason) || !concrete(context.memory_refs)) fail('or_knowledge_decision_incomplete');
+      if (value(report, 'required_approval') !== 'none') fail('or_required_approval_open');
+    }
+  }
+  return { ready: findings.length === 0, findings, route, context_digest: closeoutContextDigest(report),
+    parent_reconciliation: parent ?? null, programme_aggregation: programme ?? null };
+}