create-agdf 0.10.3 → 0.11.2

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.10.3",
+  "version": "0.11.2",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Operating system for governed AI-assisted delivery.",
@@ -168,6 +168,12 @@
       "useFor": "after gate-check permits Brownfield Review or implementation preparation, before non-trivial changes in existing systems",
       "boundary": "clarifies reuse, owners, risks and Mode/Slice Decision; never bypasses gate-check; Brownfield Review is not implementation permission"
     },
+    {
+      "slug": "ux-intent-definition",
+      "discovery": "automatic",
+      "useFor": "after approved UR and post-UR routing for medium/high UI/UX impact or ambiguous low-impact product semantics before PRD readiness",
+      "boundary": "non-authorizing analytical PRD input; never creates product intent, gate permission, technical design or a parallel product source of truth"
+    },
     {
       "slug": "clean-implementation-review",
       "discovery": "automatic",

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

@@ -89,6 +89,10 @@ Helper commands are deterministic proof and automation interfaces, not the norma
 Machine-readable outputs should stay agent-friendly: stable decisions, blocking gate or current gate, missing approval, allowed outputs, forbidden outputs, next step, evidence and findings.
 They make the repository state checkable, but they do not replace the native skill workflow or the durable control artefacts.
 
+### Repository Activation Diagnosis Boundary
+
+`doctor --json` on the resolved surface-local validator is the sole canonical, code-owned, tool-shell-safe activation probe. Plugin `AGDF_*` environment variables set by the OpenCode `shell.env` hook are an internal plugin status channel consumed by `opencode-status`, not an agent-facing diagnosis proof; host shell-env propagation to spawned tool shells is not guaranteed and is OpenCode-owned. A relative glob or `grep` for `.agdf/control/config.json` must not be used as proof of presence or absence of `.agdf/control/config.json`; an absolute `read` or the canonical CLI probe is required.
+
 ## Delivery Map
 
 `delivery-map --json` is the machine-readable delivery picture for the selected canonical control state.

package/generated/plugins/agdf/meta/contracts/gate-transition.md

@@ -99,6 +99,31 @@ Mode/Slice Decision rules:
 
 A Mode/Slice Decision without scope reason and evidence is not recorded. Treat it as missing and keep the next step at `Mode/Slice Decision`.
 
+### UI/UX Impact And UX Intent Definition
+
+The existing `brownfield-analysis` `post_ur_review` mode is the single proportional routing owner for
+both Greenfield and Brownfield delivery. It records:
+
+- `delivery_context: greenfield | brownfield`
+- `ui_ux_impact: none | low | medium | high`
+- `ui_ux_impact_reason`
+- `ux_intent_definition_required: yes | no`
+
+Classify impact as:
+
+- `none`: no user-facing capability, decision, state, feedback or recovery behavior changes;
+- `low`: a bounded user-facing change preserves unambiguous intent, working modes, effective-state,
+  activation and recovery semantics;
+- `medium`: a bounded capability materially changes its primary action, working mode, effective
+  state, visible state type, blocker, activation or recovery behavior; or
+- `high`: the change spans capabilities or modes, creates competing or safety-relevant authority,
+  adds high-consequence decisions or materially changes cross-surface activation and recovery.
+
+`medium | high` requires `ux-intent-definition` before PRD readiness. `low` requires it when any
+mandatory PRD UX semantics remain ambiguous. `none` records the analytical decision
+`not_applicable`. The skill is an internal, non-authorizing step: it adds no gate, approval value or
+implementation permission. A required `blocked` result keeps PRD readiness closed.
+
 
 ## Gate Transition Model
 

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

@@ -83,6 +83,64 @@ Structured Delivery skills use this shape when relevant:
 - `required_next_step`: exactly the next clean step
 - `impact_codes`: affected Quality Contract codes, if the target repo has a registry
 
+
+## Normalized Review Gaps
+
+This section is the sole normative owner for review-gap classification and routing. An applicable
+finding from Task Plan Review, Clean Implementation Review or Code Review carries exactly one
+normalized gap type and one routing target:
+
+| gap_type | meaning | routing_target |
+|---|---|---|
+| `requirements_gap` | approved product behavior or an acceptance criterion is missing or contradictory | `PRD`; use `UR` only when user intent or scope changed |
+| `design_gap` | technical ownership, architecture, fallback policy, exit criterion or a prohibited parallel structure was not decided | `SD` |
+| `plan_gap` | an approved requirement or design obligation lacks an executable task, test or evidence mapping | `TP` |
+| `implementation_gap` | code or a surface does not fulfil an approved requirement, design or task | `CD+Tests` |
+| `evidence_gap` | required test, runtime or visible evidence is absent or insufficient | `evidence_obligation` |
+| `emergent_risk` | implementation exposes a concrete risk not reasonably decidable from approved artefacts | earliest affected `UR | PRD | SD | TP | CD+Tests | evidence_obligation` target after explicit assessment |
+
+Normalized finding rows use these fields in order:
+
+`finding_id | gap_type | routing_target | gap_status | evidence | required_next_step`
+
+- `finding_id` is stable within the durable review report.
+- `gap_type` is exactly one type from the table above.
+- `routing_target` is exactly `UR | PRD | SD | TP | CD+Tests | evidence_obligation` and must agree
+  with the fixed route above. `requirements_gap` may use `UR` only with evidence of changed user
+  intent or scope. `emergent_risk` requires an explicit earliest-owner assessment.
+- `gap_status` is exactly `open | resolved`.
+- `evidence` names concrete source, diff, test, observation or missing proof.
+- `required_next_step` is exactly one executable action consistent with the routing target.
+
+Missing, unknown or contradictory fields fail closed as an open gap. Consumers must not silently
+reclassify a finding. Classification is non-authorizing: it cannot edit or approve UR, PRD, SD or TP,
+advance a gate or replace a review decision. `qa-gate` consumes the normalized findings and cannot
+return `pass` while any applicable finding is open or invalid.
+
+`none` is permitted only as a presentation sentinel on a fulfilled UX Intent Fidelity row.
+It is not a seventh normalized finding type and must not appear in a normalized finding row.
+
+A consumer may repeat the field order and allowed scalar values needed to emit valid output. It must
+reference this section for meanings and routes instead of maintaining a second complete mapping.
+
+## UX Intent Fidelity
+
+When an approved PRD contains applicable UX criteria, `task-plan-review` produces an additional
+evidence matrix with these columns in order:
+
+`prd_criterion | working_mode_state | task_id | visible_evidence | fidelity_status | gap_type`
+
+`fidelity_status` is exactly `fulfilled | partial | missing | not_verifiable`. A fulfilled row uses
+the `none` sentinel. Any non-fulfilled row uses the applicable normalized type from `Normalized
+Review Gaps`; it may also emit the normalized finding shape when routing detail is required.
+
+This matrix verifies PRD-to-TP coverage and TP-to-code/surface fulfilment. It does not create product
+requirements and does not decide QA. A missing implementation-relevant PRD requirement is a
+`requirements_gap` and routes to PRD revision. `qa-gate` consumes this evidence and cannot return
+`pass` while an applicable row is `partial`, `missing` or `not_verifiable`, or while a visible-behavior
+claim has code evidence without visible evidence. The four-row Quality Readiness projection and
+`qa-gate` sole decision ownership remain unchanged.
+
 A skill may briefly remind this shape, but must not duplicate a complete code or rule matrix.
 
 
@@ -97,4 +155,3 @@ It must distinguish:
 - interpretations
 - missing evidence
 - the next permissible step
-

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.10.3",
+  "version": "0.11.2",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Operating system for governed AI-assisted delivery.",
@@ -168,6 +168,12 @@
       "useFor": "after gate-check permits Brownfield Review or implementation preparation, before non-trivial changes in existing systems",
       "boundary": "clarifies reuse, owners, risks and Mode/Slice Decision; never bypasses gate-check; Brownfield Review is not implementation permission"
     },
+    {
+      "slug": "ux-intent-definition",
+      "discovery": "automatic",
+      "useFor": "after approved UR and post-UR routing for medium/high UI/UX impact or ambiguous low-impact product semantics before PRD readiness",
+      "boundary": "non-authorizing analytical PRD input; never creates product intent, gate permission, technical design or a parallel product source of truth"
+    },
     {
       "slug": "clean-implementation-review",
       "discovery": "automatic",

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

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.10.3",
+  "version": "0.11.2",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [

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

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.10.3",
+  "version": "0.11.2",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "f95766cb6826e5e2a27c39ac6ddfc720ed8d3388e07f40411cffcccca925a7ed"
+  "digest": "a4508a485d3954d88c3ba4cd12f007c046f803d181b40bf97ada2f81913224cc"
 }

package/generated/plugins/agdf/scripts/check-runtime-integrity.mjs

@@ -137,6 +137,7 @@ const expectedControlFiles = [
   "templates/artefacts/BROWNFIELD_REVIEW.md",
   "templates/artefacts/VERIFIED_CHANGE.md",
   "templates/artefacts/PRD.md",
+  "templates/artefacts/UX_INTENT_DEFINITION.md",
   "templates/artefacts/SD.md",
   "templates/artefacts/TP.md",
   "templates/artefacts/QA_REPORT.md",
@@ -375,6 +376,36 @@ if (!gateCheckSkill.includes("`status_presentation.markdown` verbatim")) {
 if (gateCheckSkill.includes("| Run status | Value |")) {
   failures.push("gate-check must not maintain a second operational status-card template");
 }
+if (!gateCheckSkill.includes("## Repository Activation Diagnosis")) {
+  failures.push("gate-check must own the repository activation diagnosis section");
+}
+if (!gateCheckSkill.includes("`doctor --json` on the resolved surface-local validator is the sole canonical, code-owned, tool-shell-safe activation probe")) {
+  failures.push("gate-check must name doctor --json as the sole canonical activation probe");
+}
+if (!gateCheckSkill.includes("must not be used as the only proof of activation")) {
+  failures.push("gate-check must forbid AGDF_* env vars as sole activation proof");
+}
+if (!gateCheckSkill.includes("must not be used as proof of presence or absence of `.agdf/control/config.json`")) {
+  failures.push("gate-check must forbid relative glob/grep as activation proof");
+}
+for (const antiPattern of [
+  "AGDF_CONTROL_DIR` to confirm",
+  "AGDF_CONTROL_DIR` to verify",
+  "AGDF_CONTROL_DIR` to check",
+  "relative glob to confirm",
+  "relative glob to verify",
+]) {
+  if (gateCheckSkill.includes(antiPattern)) failures.push(`gate-check must not instruct agents to use anti-pattern diagnosis: ${antiPattern}`);
+}
+if (!runtimeContract.includes("### Repository Activation Diagnosis Boundary")) {
+  failures.push("control-scaffold contract must own the repository activation diagnosis boundary");
+}
+if (!runtimeContract.includes("not an agent-facing diagnosis proof")) {
+  failures.push("control-scaffold contract must classify AGDF_* env vars as non-agent-facing diagnosis");
+}
+if (!runtimeContract.includes("must not be used as proof of presence or absence of `.agdf/control/config.json`")) {
+  failures.push("control-scaffold contract must forbid relative glob/grep as activation proof");
+}
 if (!runtimeContract.includes("### Deterministic Operational Presentation")
   || !/must\s+not reconstruct a table/.test(runtimeContract)) {
   failures.push("interaction contract must own deterministic operational status presentation");
@@ -517,6 +548,37 @@ if (isFile(pagesIndexPath) && !read(pagesIndexPath).includes("{skills.length} Co
   failures.push("Pages skill heading must derive its count from skills.length");
 }
 
+if (isFile(pagesSiteDataPath)) {
+  const pagesSiteData = read(pagesSiteDataPath);
+  for (const requiredWorkflowPhrase of [
+    "Conditional: UX Intent Definition",
+    "Post-UR routing records Greenfield or Brownfield and UI/UX impact",
+    "This fail-closed analysis is not a gate",
+    "The approved PRD is the sole product authority",
+    "Task Plan Review then verifies UX Intent Fidelity",
+    "QA cannot pass partial, missing or not-verifiable criteria",
+  ]) {
+    if (!pagesSiteData.includes(requiredWorkflowPhrase)) {
+      failures.push(`Pages workflow must preserve UX-intent lifecycle phrase: ${requiredWorkflowPhrase}`);
+    }
+  }
+}
+
+if (isFile(pagesIndexPath)) {
+  const pagesIndex = read(pagesIndexPath);
+  for (const requiredFidelityPhrase of [
+    "Approved PRD contract",
+    "requirements_gap",
+    "not_verifiable",
+    "Incomplete UX Intent Fidelity prevents a QA pass",
+    "{skills.map(skill => (",
+  ]) {
+    if (!pagesIndex.includes(requiredFidelityPhrase)) {
+      failures.push(`Pages fidelity evidence must preserve phrase: ${requiredFidelityPhrase}`);
+    }
+  }
+}
+
 if (codexPlugin && pluginDefinition) {
   if (codexPlugin.name !== pluginDefinition.id) failures.push("Codex plugin manifest name must match canonical AGDF plugin definition");
   if (codexPlugin.version !== pluginDefinition.version) failures.push("Codex plugin manifest version must match canonical AGDF plugin definition");
@@ -911,6 +973,8 @@ const contextGraphTemplatePath = join(controlRoot, "templates", "CONTEXT_GRAPH.m
 const sotRegistryTemplatePath = join(controlRoot, "templates", "SOT_REGISTRY.md");
 const qualityContractsPath = join(controlRoot, "templates", "AGENT_QUALITY_CONTRACTS.json");
 const brownfieldReviewTemplatePath = join(controlRoot, "templates", "artefacts", "BROWNFIELD_REVIEW.md");
+const uxIntentTemplatePath = join(controlRoot, "templates", "artefacts", "UX_INTENT_DEFINITION.md");
+const prdTemplatePath = join(controlRoot, "templates", "artefacts", "PRD.md");
 const verifiedChangeTemplatePath = join(controlRoot, "templates", "artefacts", "VERIFIED_CHANGE.md");
 const orTemplatePath = join(controlRoot, "templates", "artefacts", "OR.md");
 const backlogTemplatePath = join(controlRoot, "templates", "MASTER_BACKLOG.md");
@@ -980,11 +1044,84 @@ if (isFile(sotRegistryTemplatePath)) {
 
 if (isFile(brownfieldReviewTemplatePath)) {
   const brownfieldReviewTemplate = read(brownfieldReviewTemplatePath);
-  for (const required of ["Existing-System View", "Reuse And Parallel-Structure Risk", "Mode / Slice Decision", "transparency_note", "Next Permissible Step"]) {
+  for (const required of ["Existing-System View", "Reuse And Parallel-Structure Risk", "Mode / Slice Decision", "transparency_note", "Next Permissible Step", "delivery_context", "ui_ux_impact", "ui_ux_impact_reason", "ux_intent_definition_required", "ux_intent_definition_result"]) {
     if (!brownfieldReviewTemplate.includes(required)) failures.push(`BROWNFIELD_REVIEW.md missing control field: ${required}`);
   }
 }
 
+if (isFile(uxIntentTemplatePath)) {
+  const template = read(uxIntentTemplatePath);
+  for (const required of ["Decision: ready | blocked | not_applicable", "effective_state_authority_by_mode", "primary_state_presentation_owner_by_mode", "recovery_paths", "Proposed PRD Acceptance Criteria", "non-authorizing analytical input"]) {
+    if (!template.includes(required)) failures.push(`UX_INTENT_DEFINITION.md missing contract field: ${required}`);
+  }
+  if (/^Gate:|^Gate approval:|Approval:/m.test(template)) failures.push("UX_INTENT_DEFINITION.md must not carry gate or approval authority");
+}
+
+if (isFile(prdTemplatePath)) {
+  const template = read(prdTemplatePath);
+  for (const required of ["UX Intent And Success", "Working Modes And Effective State", "effective_state_authority", "primary_state_presentation_owner", "Activation, Blockers, Recovery And Transitions", "visible retry", "stable `criterion_id`"]) {
+    if (!template.includes(required)) failures.push(`PRD.md missing mandatory UX requirement: ${required}`);
+  }
+}
+
+if (isFile(join(skillRoot, "ux-intent-definition", "SKILL.md"))) {
+  const skill = read(join(skillRoot, "ux-intent-definition", "SKILL.md"));
+  for (const required of ["ready | blocked | not_applicable", "effective_state_authority_by_mode", "primary_state_presentation_owner_by_mode", "A required blocked result prevents PRD readiness", "not a user gate"]) {
+    if (!skill.includes(required)) failures.push(`ux-intent-definition SKILL.md missing invariant: ${required}`);
+  }
+}
+
+const normalizedGapFieldOrder = "finding_id | gap_type | routing_target | gap_status | evidence | required_next_step";
+const normalizedGapMappingHeader = "| gap_type | meaning | routing_target |";
+const qualityContractPath = join(contractsDir, "quality.md");
+if (isFile(qualityContractPath)) {
+  const contract = read(qualityContractPath);
+  for (const required of [
+    "## Normalized Review Gaps",
+    normalizedGapFieldOrder,
+    "requirements_gap",
+    "design_gap",
+    "plan_gap",
+    "implementation_gap",
+    "evidence_gap",
+    "emergent_risk",
+    "UR | PRD | SD | TP | CD+Tests | evidence_obligation",
+    "gap_status` is exactly `open | resolved",
+    "It is not a seventh normalized finding type",
+  ]) {
+    if (!contract.includes(required)) failures.push(`quality contract missing normalized review-gap invariant: ${required}`);
+  }
+}
+
+for (const skillName of ["task-plan-review", "clean-implementation-review", "code-review", "qa-gate"]) {
+  const path = join(skillRoot, skillName, "SKILL.md");
+  if (!isFile(path)) continue;
+  const skill = read(path);
+  for (const required of ["§Normalized Review Gaps", "fail closed"]) {
+    if (!skill.includes(required)) failures.push(`${skillName} SKILL.md missing normalized review-gap consumer invariant: ${required}`);
+  }
+  if (skillName !== "qa-gate" && !skill.includes(normalizedGapFieldOrder)) {
+    failures.push(`${skillName} SKILL.md missing normalized finding field order`);
+  }
+  if (skill.includes(normalizedGapMappingHeader)) {
+    failures.push(`${skillName} SKILL.md must not duplicate the complete normalized gap mapping`);
+  }
+}
+
+if (isFile(join(skillRoot, "task-plan-review", "SKILL.md"))) {
+  const skill = read(join(skillRoot, "task-plan-review", "SKILL.md"));
+  for (const required of ["## UX Intent Fidelity", "prd_criterion | working_mode_state | task_id | visible_evidence | fidelity_status | gap_type", "requirements_gap", "not_verifiable"]) {
+    if (!skill.includes(required)) failures.push(`task-plan-review SKILL.md missing UX fidelity invariant: ${required}`);
+  }
+}
+
+if (isFile(join(skillRoot, "qa-gate", "SKILL.md"))) {
+  const skill = read(join(skillRoot, "qa-gate", "SKILL.md"));
+  for (const required of ["UX Intent Fidelity", "visible evidence", "requirements_gap"]) {
+    if (!skill.includes(required)) failures.push(`qa-gate SKILL.md missing UX fidelity consumption: ${required}`);
+  }
+}
+
 if (isFile(verifiedChangeTemplatePath)) {
   const verifiedChangeTemplate = read(verifiedChangeTemplatePath);
   for (const required of ["related_ur", "canonical_owner", "allowed_source_paths", "allowed_derived_paths", "baseline_tracked_paths", "baseline_untracked_paths", "escalation_target", "validation_commands"]) {

package/generated/plugins/agdf/skills/brownfield-analysis/SKILL.md

@@ -35,6 +35,11 @@ When `.agdf/control/` is present, persist or link `post_ur_review` output under
 
 Do not mix both modes silently. Name the active mode in the output.
 
+In `post_ur_review`, also record `delivery_context`, `ui_ux_impact`, `ui_ux_impact_reason` and
+`ux_intent_definition_required` using the single classification and routing contract in
+`../../meta/contracts/gate-transition.md`. Greenfield records make existing-system evidence explicitly
+not applicable; Brownfield records cite repository evidence. Do not create a second Greenfield router.
+
 ## Rules
 1. Brownfield first: understand the existing codebase before PRD/SD decisions when existing-system impact is possible, and again before implementation.
 2. Brownfield Review after `Approval: UR` is a sizing and routing step. It must visibly decide `quick_task`, `verified_change`, `structured_slice`, `structured_delivery`, or `block` before PRD depth or implementation is chosen. Persist the completed review and its decision, scope reason, evidence and required next gate in the same internal operation; mark the review `done` only after both the artefact and canonical run projection are complete. An interrupted, incomplete or legacy record stays at fail-closed `Mode/Slice Decision` recovery without another user approval.
@@ -124,6 +129,10 @@ Use a concise structure:
 - required_next_step:
 ```
 
+For `post_ur_review`, include the four UI/UX routing fields immediately after `scope`. If UX intent
+definition is required, its `ready | blocked | not_applicable` result must be visible before PRD
+readiness. A required `blocked` result is at least `revise` for this routing step.
+
 ## Pass / Revise / Block Guidance
 - `pass`: existing owners are understood, reuse path is clear, and no blocking drift or parallel structure risk remains.
 - `revise`: relevant evidence, tests, ownership, or reuse path is incomplete.

package/generated/plugins/agdf/skills/clean-implementation-review/SKILL.md

@@ -24,6 +24,8 @@ Use these focused runtime-contract modules:
 - `../../meta/contracts/context-graph.md`
 
 Clean-review-specific output must make the primary solution, fallbacks, workarounds, parallel structures, exit criteria, and next cleanup/review step visible.
+Applicable findings must use `../../meta/contracts/quality.md` §Normalized Review Gaps. This skill
+must distinguish a missing upstream decision from implementation that violates an approved decision.
 
 ## Rules
 1. Clean primary solution before fallback.
@@ -35,6 +37,10 @@ Clean-review-specific output must make the primary solution, fallbacks, workarou
 7. Maintainability matters; "works somehow" is not enough.
 8. Async execute paths must not decide product rules again.
 9. Shared finalization or merge rules belong in one owner.
+10. Missing canonical ownership, fallback policy, exit criteria or parallel-structure decisions are
+    upstream gaps; do not invent those decisions during review.
+11. Actual code that violates an approved design or plan is an implementation gap.
+12. Missing, unknown or contradictory classifications fail closed and stay open.
 
 ## When To Use
 - after `CD+Tests`
@@ -89,6 +95,16 @@ Use this compact structure:
 - required_next_step:
 ```
 
+When findings exist, append:
+
+```text
+## Normalized Findings
+| finding_id | gap_type | routing_target | gap_status | evidence | required_next_step |
+|---|---|---|---|---|---|
+```
+
+Use the shared Quality Contract for meanings and routes; do not copy its complete mapping here.
+
 ## Pass / Revise / Block Guidance
 - `pass`: primary solution is clean, tested, and integrated with existing owners.
 - `revise`: solution works but contains avoidable fallback, unclear ownership, or missing evidence.
@@ -106,3 +122,5 @@ This skill must not:
 - hide unjustified workarounds
 - treat green tests as proof of solution integrity
 - decide final QA
+- create a missing design, plan or product decision during review
+- silently repair or reclassify an invalid normalized finding

package/generated/plugins/agdf/skills/code-review/SKILL.md

@@ -23,6 +23,8 @@ Use these focused runtime-contract modules:
 - `../../meta/contracts/context-graph.md`
 
 Code-review-specific output must make actual findings, missing review scope, evidence strength, and the next required step visible.
+Applicable findings must use `../../meta/contracts/quality.md` §Normalized Review Gaps. Concrete diff
+defects remain Code Review findings; missing upstream constraints route to their authoritative owner.
 
 ## Rules
 1. Review the actual diff and impacted code, not intent alone.
@@ -33,6 +35,9 @@ Code-review-specific output must make actual findings, missing review scope, evi
 6. Brownfield owners and existing conventions are binding unless deviation is justified.
 7. Distinguish blocking defects from fixable review findings.
 8. CR does not grant QA pass.
+9. Do not turn Code Review into a static requirements checklist or invent missing upstream constraints.
+10. A genuinely new implementation risk uses `emergent_risk` with an explicit earliest-owner assessment.
+11. Missing, unknown or contradictory classifications fail closed and stay open.
 
 ## When To Use
 - after `CD+Tests`
@@ -81,6 +86,16 @@ Use this compact structure:
 - required_next_step:
 ```
 
+When findings exist, append:
+
+```text
+## Normalized Findings
+| finding_id | gap_type | routing_target | gap_status | evidence | required_next_step |
+|---|---|---|---|---|---|
+```
+
+Use the shared Quality Contract for meanings and routes; do not copy its complete mapping here.
+
 ## Decision Guidance
 - `pass`: no meaningful review finding remains evident in reviewed scope.
 - `revise`: fixable correctness, regression, or maintainability issues remain.
@@ -100,3 +115,5 @@ This skill must not:
 - hide missing review scope
 - generate style-only findings
 - duplicate TP Review or QA as if they were the same step
+- invent a requirement, design decision or plan obligation to justify a finding
+- silently repair or reclassify an invalid normalized finding

package/generated/plugins/agdf/skills/gate-check/SKILL.md

@@ -69,6 +69,12 @@ for a native-capable adapter.
 
 The CLI reports are validators and JSON evidence, not the primary user experience, not a required ritual for normal work and not a second rule system. If a report says `blocked`, do not continue with later-gate artefacts until the reported blocker is resolved.
 
+## Repository Activation Diagnosis
+
+`doctor --json` on the resolved surface-local validator is the sole canonical, code-owned, tool-shell-safe activation probe. Determine whether a repository is AGDF-active through `doctor --json` (or `gate-check --json` for a selected run), not through plugin `AGDF_*` environment variables, not through a relative glob, not through a relative `grep`, and not through a relative `read` of `.agdf/control/config.json`.
+
+Plugin `AGDF_*` environment variables set by the OpenCode `shell.env` hook are convenience only and must not be used as the only proof of activation; host shell-env propagation to spawned tool shells is not guaranteed and is OpenCode-owned, not AGDF-owned. A relative glob or `grep` for `.agdf/control/config.json` must not be used as proof of presence or absence of `.agdf/control/config.json`; an absolute `read` or the canonical CLI probe is required.
+
 ## Native Interaction Path
 
 `../../meta/contracts/interaction.md` is the complete normative owner for interaction kinds, locale,

package/generated/plugins/agdf/skills/qa-gate/SKILL.md

@@ -31,6 +31,8 @@ Use these focused runtime-contract modules:
 QA-specific `decision` is exactly `pass | revise | block`.
 `pass` is allowed only when TP coverage, Brownfield fit, solution integrity, and relevant documentation/Context Graph impact are sufficiently evidenced.
 `sot_drift` must not pass silently as a warning.
+Consume applicable findings through `../../meta/contracts/quality.md` §Normalized Review Gaps.
+QA must not maintain a second mapping or reclassify review findings.
 
 When post-CD+Tests review evidence exists, present the Runtime Contract's derived Quality
 Readiness projection before the detailed QA report: Plan coverage, Solution integrity, Code
@@ -48,6 +50,11 @@ Gate Transition Card or the durable QA report.
 6. Solution integrity is mandatory.
 7. Always output exactly one decision: `pass`, `revise`, or `block`.
 8. Open risks, missing tests, partial TP coverage, or side effects must be visible.
+9. Applicable UX Intent Fidelity rows must all be `fulfilled` with suitable visible evidence before `pass`.
+10. A `requirements_gap` routes to PRD revision; QA must not invent or accept the missing criterion.
+11. Any applicable normalized finding that is `open`, missing, unknown, contradictory or supported by
+    insufficient evidence prevents `pass`.
+12. A `resolved` finding counts only when its durable review evidence proves the routed correction or decision.
 
 ## When To Use
 - after `CD+Tests`
@@ -82,14 +89,16 @@ If evidence is missing, lower the decision accordingly.
 2. Verify TP coverage.
 3. Verify P0/P1 completion.
 4. Verify Brownfield fit.
-5. Verify solution integrity.
-6. Verify tests and evidence strength.
-7. Verify documentation and Context Graph impact if relevant.
-8. Decide:
+5. Verify UX Intent Fidelity when applicable, including visible evidence for visible-behavior claims.
+6. Consume normalized findings without reclassification; fail closed on every open or invalid row.
+7. Verify solution integrity.
+8. Verify tests and evidence strength.
+9. Verify documentation and Context Graph impact if relevant.
+10. Decide:
    - `pass`
    - `revise`
    - `block`
-9. State the single required next step.
+11. State the single required next step.
 
 ## Output
 Use this shape:
@@ -125,3 +134,4 @@ This skill must not:
 - replace UAT
 - treat missing reviews as completed
 - downgrade SoT drift to harmless warning
+- silently repair, normalize or reroute a review finding

package/generated/plugins/agdf/skills/task-plan-review/SKILL.md

@@ -27,6 +27,8 @@ Use these focused runtime-contract modules:
 
 TP-specific output must evaluate every relevant `task_id` with completion status, AC coverage, evidence, missing evidence, and QA-relevant gaps.
 If `context_graph_required_action` is not `none`, the affected task is complete only if follow-up, evidence, or an intentionally open gap is visible.
+Applicable review gaps must use `../../meta/contracts/quality.md` §Normalized Review Gaps. This skill
+must not maintain its own type-to-route mapping.
 
 ## Rules
 1. The Task Plan is the reference, not plausible code.
@@ -39,6 +41,12 @@ If `context_graph_required_action` is not `none`, the affected task is complete
 8. P0/P1 gaps must be handed to QA.
 9. Out-of-scope changes must be reported.
 10. When evidence is unclear, fail closed to at least `partially_done`.
+11. When approved PRD UX criteria apply, verify both PRD-to-TP coverage and TP-to-code/surface fulfilment.
+12. Never invent a missing UX requirement. Report `requirements_gap` and route it to PRD revision.
+13. Visible behavior requires visible evidence; code evidence alone is `not_verifiable`.
+14. A fulfilled UX Intent Fidelity row uses `none`; every non-fulfilled applicable row uses one
+    normalized gap type and a contract-valid route.
+15. Missing, unknown or contradictory classifications fail closed and stay open.
 
 ## Clarifications
 ### TP Slice Before Target State
@@ -90,6 +98,27 @@ Use this compact structure:
 - required_next_step:
 ```
 
+When applicable, append:
+
+```text
+## UX Intent Fidelity
+| prd_criterion | working_mode_state | task_id | visible_evidence | fidelity_status | gap_type |
+|---|---|---|---|---|---|
+```
+
+Use `fulfilled | partial | missing | not_verifiable` for `fidelity_status` and
+the shared Quality Contract for `gap_type`. `none` is allowed only on a fulfilled row.
+
+When an applicable gap needs routing detail, append:
+
+```text
+## Normalized Findings
+| finding_id | gap_type | routing_target | gap_status | evidence | required_next_step |
+|---|---|---|---|---|---|
+```
+
+Use only contract-defined values. Do not reconstruct the type-to-route mapping locally.
+
 Completion status:
 
 - `fully_done`
@@ -122,3 +151,7 @@ This skill must not:
 - hide partial work
 - upgrade missing evidence into confidence
 - reinterpret the TP scope
+- create or silently repair product requirements
+- treat code existence as visible UX evidence
+- emit `none` as a normalized finding type
+- silently repair or reclassify an invalid finding