create-agdf 0.8.1 → 0.8.3

package/bin/create-agdf.js

@@ -26,7 +26,10 @@ import {
   verifyLegacyProjection,
 } from "../lib/control-state/index.js";
 import {
+  attachApprovalOrientationSnapshot,
   buildArtefactRefs,
+  buildRunCandidates,
+  buildQualityReadiness,
   canonicalizeLanguageTag,
   formatArtefactRefs,
   gateTitle,
@@ -59,7 +62,7 @@ const agdfFragmentPath = "AGENTS.agdf.md";
 const openCodeConfigFragmentPath = "opencode.agdf.json";
 const userGateOrder = ["UR", "PRD", "SD", "TP", "QA", "UAT"];
 const durableGateArtefacts = new Set(["UR", "PRD", "SD", "TP", "QA"]);
-const internalStepArtefacts = new Set(["Brownfield Review", "Verified Change", "Brownfield Analysis", "CD+Tests", "CR"]);
+const internalStepArtefacts = new Set(["Brownfield Review", "Verified Change", "Brownfield Analysis", "CD+Tests", "TP Review", "Clean Implementation Review", "Clean Review", "CR", "Code Review"]);
 const deliveryRelationships = [
   { from: "UR", relationship: "approved_by", to: "Approval: UR", requiredBy: "UR" },
   { from: "PRD", relationship: "derived_from", to: "UR", requiredBy: "PRD" },
@@ -1916,6 +1919,7 @@ function readRunState(targetDir, selection = {}) {
   let runPath = join(".agdf", "control", "AGDF_RUN.md");
   const canonicalRoot = join(targetDir, ".agdf", "control", "runs");
   let resolutionError;
+  let candidateRuns = [];
   if (existsSync(canonicalRoot)) {
     try {
       const selected = resolveRuns(targetDir, {
@@ -1927,6 +1931,21 @@ function readRunState(targetDir, selection = {}) {
         : selected.run.path;
     } catch (error) {
       resolutionError = error.message;
+      if (resolutionError.startsWith("AGDF_ACTIVE_RUN_AMBIGUOUS")) {
+        const active = resolveRuns(targetDir, { allActive: true }).runs.map((run) => {
+          const controlState = parseControlState(run.content, {
+            userGates: userGateOrder,
+            internalSteps: [...internalStepArtefacts],
+          });
+          return {
+            ...run,
+            control_state: controlState,
+            current_artefact_heading: readArtefactHeading(targetDir, controlState.artefacts.get(controlState.current_gate)),
+            ur_heading: readArtefactHeading(targetDir, controlState.artefacts.get("UR")),
+          };
+        });
+        candidateRuns = buildRunCandidates(active);
+      }
     }
   }
   if (resolutionError || !existsSync(join(targetDir, runPath))) {
@@ -1946,6 +1965,7 @@ function readRunState(targetDir, selection = {}) {
       quality_outlook: "",
       source_scope: {},
       memory: {},
+      candidate_runs: candidateRuns,
       resolution_error: resolutionError,
     };
   }
@@ -2263,6 +2283,36 @@ function buildStatusCard({
   };
 }
 
+function statusFromReviewArtefact(artefact) {
+  if (!artefact) return "unknown";
+  const text = `${artefact.status ?? ""} ${artefact.notes ?? ""}`.toLowerCase();
+  for (const status of ["block", "revise", "warn", "pass"]) {
+    if (new RegExp(`\\b${status}(?:ed)?\\b`).test(text)) return status;
+  }
+  return "unknown";
+}
+
+function qualityReadinessForRunState(runState, nextAction) {
+  const artefacts = runState.artefacts;
+  const plan = artefacts.get("TP Review");
+  const clean = artefacts.get("Clean Implementation Review") ?? artefacts.get("Clean Review");
+  const code = artefacts.get("CR") ?? artefacts.get("Code Review");
+  const qa = artefacts.get("QA");
+  if (![plan, clean, code, qa].some(Boolean)) return null;
+  const reviewRows = [plan, clean, code, qa].filter(Boolean);
+  const decisive = reviewRows.find((artefact) => /\b(?:block|revise)\b/i.test(`${artefact.status ?? ""} ${artefact.notes ?? ""}`));
+  const readiness = buildQualityReadiness({
+    planCoverage: statusFromReviewArtefact(plan),
+    solutionIntegrity: statusFromReviewArtefact(clean),
+    codeQuality: statusFromReviewArtefact(code),
+    qaDecision: statusFromReviewArtefact(qa),
+    decisiveReason: decisive?.notes ?? "",
+    nextAction,
+  });
+  if (!readiness) return null;
+  return Object.freeze({ ...readiness, decisive_reference: decisive?.path ?? "" });
+}
+
 function resolvedArtefactFile(targetDir, rawPath) {
   const normalizedPath = String(rawPath ?? "").replace(/^`|`$/g, "").trim();
   if (!normalizedPath || isAbsolute(normalizedPath) || normalizedPath.includes("<") || normalizedPath.includes(">")) return "";
@@ -2333,6 +2383,10 @@ function isGateSatisfied(runState, gate) {
   return isDurableGateArtefactSatisfied(runState, gate);
 }
 
+function qaRevisionRequired(runState) {
+  return gateArtefactStatus(runState, "QA").status === "revise";
+}
+
 function transitionDecisionForRunState(runState, verifiedChange = null) {
   if (gateApprovalStatus(runState, "UR") === "approved" && !isGateSatisfied(runState, "UR")) return durableArtefactBlock("UR", "PRD");
 
@@ -2533,6 +2587,18 @@ function transitionDecisionForRunState(runState, verifiedChange = null) {
     };
   }
 
+  if (qaRevisionRequired(runState)) {
+    return {
+      status: "open",
+      current_gate: "QA",
+      blocking_reason: "qa_revise_required",
+      missing_approval: "none",
+      allowed: ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
+      forbidden: ["request QA approval", "request UAT approval", "release", "claim delivery readiness"],
+      next_allowed_action: "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
+    };
+  }
+
   if (gateApprovalStatus(runState, "QA") === "approved" && !isGateSatisfied(runState, "QA")) return durableArtefactBlock("QA", "UAT");
 
   if (isGateSatisfied(runState, "QA") && !isGateSatisfied(runState, "UAT")) {
@@ -2638,8 +2704,20 @@ function evaluateGateCheck(targetDir, selection = {}) {
     chatLanguage: presentationLocale,
     findings: deliveryMap.findings,
   });
+  const humanPresentation = buildHumanPresentation(targetDir, runState, currentGate, presentationLocale);
   Object.defineProperty(statusCard, "humanPresentation", {
-    value: buildHumanPresentation(targetDir, runState, currentGate, presentationLocale),
+    value: humanPresentation,
+    enumerable: false,
+  });
+  attachApprovalOrientationSnapshot(statusCard, {
+    ready: status === "open" && missingApproval === `Approval: ${currentGate}`,
+    humanPresentation,
+    revisionId: extractField(runState.content ?? "", "revision_id"),
+    registry: interactionLocales,
+    requestedLocale: presentationLocale,
+  });
+  Object.defineProperty(statusCard, "runState", {
+    value: runState,
     enumerable: false,
   });
 
@@ -2658,6 +2736,7 @@ function evaluateGateCheck(targetDir, selection = {}) {
     doctor_summary: doctorReport.summary,
     evidence_refs: runState.evidence_refs,
     quality_outlook: deriveQualityOutlook(runState, deliveryMap.findings),
+    candidate_runs: runState.candidate_runs ?? [],
     status_card: statusCard,
     delivery_map: {
       relationships: deliveryMap.relationships,
@@ -2695,6 +2774,21 @@ function printGateCheckStatusCard(report) {
   console.log(`${labels.allowed}: ${primary.actions[card.current_gate] ?? primary.none}`);
   console.log(`${labels.step}: ${primary.actions[card.current_gate] ?? primary.none}`);
   console.log(`${labels.quality}: ${primary.quality}`);
+  const readiness = qualityReadinessForRunState(card.runState, report.next_allowed_action);
+  if (readiness) {
+    const quality = localePack(interactionLocales, card.presentation_language).qualityReadiness;
+    console.log("");
+    console.log(`${quality.title}: ${primary.status[readiness.status] ?? readiness.status}`);
+    for (const row of readiness.rows) {
+      console.log(`${quality.rows[row.id]}: ${primary.status[row.status] ?? quality.unknown}`);
+    }
+    const reason = readiness.decisive_reason
+      || (readiness.status === "pass" ? primary.none : quality.fallbackReasons[readiness.decisive_dimension] || primary.none);
+    console.log(`${quality.reason}: ${reason}`);
+    if (readiness.status !== "pass" && readiness.decisive_reference) console.log(`${quality.reference}: ${readiness.decisive_reference}`);
+    console.log(`${quality.nextAction}: ${readiness.next_action || primary.none}`);
+    console.log(`${quality.decisionOwner}: ${quality.decisionOwnerValue}`);
+  }
 }
 
 function printGateCheckReport(report, json, statusCard = false) {

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

@@ -62,16 +62,18 @@ For a ready `gate_approval`:
 
 1. Resolve exactly one selected run and evaluate the current gate.
 2. Confirm the required durable artefact is present and ready before presenting a question.
-3. Render a separate localized Gate Transition Card immediately before any native question or exact-text fallback. It includes the deterministic human run title and `UR · PRD · SD · TP` links from the selected run. Never put the card only into the question, button description or hidden tool context.
-4. Treat the operational Run Status Card as evaluation and audit input, not as the approval-time product surface. Do not paste its table, raw keys, machine statuses, evidence or diagnostic detail into the transition card.
-5. Compose the transition card as one human-readable gate title with `run_id`, one ready-for-decision line, one short approval-effect block and one short next-transition block. It must answer only: where am I, what does this decision do, and what happens next.
-6. Distinguish internal process steps from user decisions in natural language. For example, after `Approval: TP`, say that pre-implementation Brownfield Analysis runs next and that no further user action is required now; do not expose `next_user_gate: none` or `user_action_required: no`, and do not ask for a second approval for Brownfield Analysis.
-7. Ask exactly one question that names the selected `run_id` and `current_gate`.
-8. Offer options in stable order: exact `Approval: <GateName>`, localized revise and localized decline. Add explicit cancel only where supported after decline; otherwise host dismissal maps to cancel. Never preselect, skip, auto-submit or reorder an option.
-9. Use the surface adapter declared in the canonical plugin definition only when it can wait for deliberate input without auto-resolution; otherwise request the same exact approval in concise text.
-10. Re-run gate evaluation for the same run and expected gate after the response and immediately before persistence.
-11. Reject a missing artefact, ambiguous or wrong run, wrong gate, stale expected gate, timeout/default, hook-supplied answer, agent message, technical permission outcome or plan approval.
-12. Persist accepted input only through the existing control-state workflow.
+3. Build one immutable, non-authorizing presentation snapshot from the selected evaluated run and current revision identity.
+4. Compose one Approval Orientation Envelope as one immediately preceding assistant message containing two distinct blocks. Render the compact localized approval-time Run Status Card first. It contains exactly selected run, readiness status, current gate, missing exact approval, one next action and quality outlook; omit raw keys, machine statuses, evidence, diagnostics and allowed/forbidden inventories.
+5. In the same assistant message, render a separate localized Gate Transition Card second, immediately before any native question or exact-text fallback. It includes the deterministic human run title and `UR · PRD · SD · TP` links from the selected run. Never put either card only into the question, button description or hidden tool context. Do not invoke the native question tool until the complete two-card envelope is visible.
+6. Compose the transition card as one human-readable gate title with `run_id`, one ready-for-decision line, one short approval-effect block and one short next-transition block. It must answer only: where am I, what does this decision do, and what happens next. Run and gate identity may anchor both cards; do not duplicate status rows, action inventories or the native question.
+7. Distinguish internal process steps from user decisions in natural language. For example, after `Approval: TP`, say that pre-implementation Brownfield Analysis runs next and that no further user action is required now; do not expose `next_user_gate: none` or `user_action_required: no`, and do not ask for a second approval for Brownfield Analysis.
+8. Ask exactly one question that names the selected `run_id` and `current_gate`.
+9. Offer options in stable order: exact `Approval: <GateName>`, localized revise and localized decline. Add explicit cancel only where supported after decline; otherwise host dismissal maps to cancel. Never preselect, skip, auto-submit or reorder an option.
+10. Use the surface adapter declared in the canonical plugin definition only when it can wait for deliberate input without auto-resolution; otherwise request the same exact approval in concise text.
+11. Render both cards once in that single complete assistant message. If the native attempt is unavailable or not applied, continue to exact text without repeating either card.
+12. Re-run gate evaluation for the same run and expected gate after the response and immediately before persistence.
+13. Reject a missing artefact, ambiguous or wrong run, wrong gate, stale expected gate, timeout/default, hook-supplied answer, agent message, technical permission outcome or plan approval.
+14. Persist accepted input only through the existing control-state workflow.
 
 Before composing the question, resolve the configured chat locale from `.agdf/control/config.json` through `../agdf-interaction-locales.json`: exact complete pack, language subtag, then English fallback. German and English are initial packs, not a closed language list. Keep `Approval: <GateName>` exactly unchanged in every language, and do not mix presentation languages within one interaction. Labels and descriptions use the same resolved locale; host-owned UI chrome remains host-owned and may use a different language.
 
@@ -84,6 +86,13 @@ apply or safely return the native question on that attempt, switch immediately
 to the exact textual approval. Do not ask the user to request the buttons again
 and do not create a retry loop or simulated control.
 
+State the outcome visibly: `presented`, `unavailable_before_invocation`,
+`attempted_not_applied` or `unsafe_to_wait`. For every fallback, say in the
+configured locale why a native control was not usable, show the exact approval
+value and confirm that authority is unchanged. This transient outcome is not
+approval evidence. A new explicit user request may reopen the unchanged decision
+only after fresh run/gate/artefact revalidation; never retry automatically.
+
 Surface behavior:
 
 - Codex: invoke the native short-question/request-user-input control on the first eligible attempt when callable, ask one gate question and omit auto-resolution; if it is not rendered or applied, use exact text immediately.
@@ -184,10 +193,12 @@ Keep the result short and operational. Render the Runtime Contract's compact hum
 
 When an approval is missing, also include `Next gate after approval` and `Allowed after approval` exactly as constrained by the Runtime Contract. Keep forbidden outputs, evidence and next-skill detail in the concise surrounding text when relevant; they are not extra status-card rows.
 
-This operational status table is for status reporting. When the same response
-immediately requests a ready gate approval, replace the table in the visible
-approval experience with the Gate Transition Card defined above, then invoke
-the native question or exact-text fallback. Do not show both cards.
+This complete operational status table remains the status-reporting and detail
+surface. When the same response immediately requests a ready gate approval,
+render its six-field compact approval-time projection first, then the Gate
+Transition Card in the same immediately preceding assistant message, then
+invoke exactly one native question or exact-text fallback. Both cards derive
+from the same snapshot and are shown exactly once.
 
 If this skill creates or updates control artefacts, do not paste full file bodies into the chat.
 List paths, summarize the decision, name the blocker or approval needed, and keep the durable content in the files.

package/generated/.github/skills/agdf-interaction-locales.json

@@ -29,6 +29,27 @@
         "forbidden": "Forbidden now",
         "artefacts": "Artefacts"
       },
+      "qualityReadiness": {
+        "title": "Quality Readiness",
+        "rows": {
+          "plan_coverage": "Plan coverage",
+          "solution_integrity": "Solution integrity",
+          "code_quality": "Code quality",
+          "qa_decision": "QA decision"
+        },
+        "reason": "Reason",
+        "reference": "Evidence report",
+        "nextAction": "Next action",
+        "decisionOwner": "Decision owner",
+        "decisionOwnerValue": "QA Gate",
+        "unknown": "evidence missing",
+        "fallbackReasons": {
+          "plan_coverage": "Plan coverage requires revision before QA can pass.",
+          "solution_integrity": "Solution integrity requires revision before QA can pass.",
+          "code_quality": "Code quality findings require revision before QA can pass.",
+          "qa_decision": "QA evidence requires revision before the gate can pass."
+        }
+      },
       "gateTitles": {
         "UR": "User requirements",
         "PRD": "Product requirements",
@@ -115,6 +136,27 @@
         "forbidden": "Aktuell verboten",
         "artefacts": "Artefakte"
       },
+      "qualityReadiness": {
+        "title": "Quality Readiness",
+        "rows": {
+          "plan_coverage": "Planabdeckung",
+          "solution_integrity": "Lösungsintegrität",
+          "code_quality": "Code-Qualität",
+          "qa_decision": "QA-Entscheidung"
+        },
+        "reason": "Grund",
+        "reference": "Nachweisbericht",
+        "nextAction": "Nächste Aktion",
+        "decisionOwner": "Entscheidungsinstanz",
+        "decisionOwnerValue": "QA-Gate",
+        "unknown": "Nachweis fehlt",
+        "fallbackReasons": {
+          "plan_coverage": "Die Planabdeckung muss vor einem QA-Pass überarbeitet werden.",
+          "solution_integrity": "Die Lösungsintegrität muss vor einem QA-Pass überarbeitet werden.",
+          "code_quality": "Code-Qualitätsbefunde müssen vor einem QA-Pass überarbeitet werden.",
+          "qa_decision": "Die QA-Nachweise müssen vor einem QA-Pass überarbeitet werden."
+        }
+      },
       "gateTitles": {
         "UR": "Nutzeranforderungen",
         "PRD": "Produktanforderungen",

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

@@ -28,6 +28,13 @@ 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.
 
+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
+quality and QA decision in that order. Name `agdf-qa-gate` as the sole decision owner, show one
+decisive reason and one permissible next action, and keep detailed reports as evidence links or
+on-demand detail. The projection is non-authorizing and must not replace the Run Status Card,
+Gate Transition Card or the durable QA report.
+
 ## Rules
 1. No QA pass without strong evidence.
 2. TP is the reference, not merely working code.

package/generated/.github/skills/agdf-runtime-contract.md

@@ -145,15 +145,55 @@ and `Allowed after approval` when a missing approval exists, `Next step` and
 `Quality outlook`. Keep mode, forbidden actions, evidence and next-skill detail
 in the surrounding control artefact when they are relevant.
 
+## Quality Readiness Projection
+
+After CD+Tests, when any of the four review/QA artefacts exists, surfaces may show one compact
+derived `Quality Readiness` projection. It answers the user-facing question "what is the current
+quality outcome and what should happen next?" without replacing evidence or creating another
+decision authority.
+
+- It contains exactly four rows, in this order: `Plan coverage` from `agdf-task-plan-review`,
+  `Solution integrity` from `agdf-clean-implementation-review`, `Code quality` from `agdf-code-review`,
+  and `QA decision` from `agdf-qa-gate`.
+- `agdf-qa-gate` is always labeled as the sole decision owner. The other three rows are evidence
+  dimensions, not competing pass/revise/block decisions.
+- Overall status reuses canonical severity ordering. Missing or conflicting required evidence
+  must not render `pass`; surface `revise` or `block` with the decisive reason and one permitted
+  next action instead.
+- The projection is derived, non-persistent and non-authorizing. It cannot accept an approval,
+  advance a gate, suppress a report or replace the Run Status Card, Gate Transition Card, JSON
+  projection or durable review artefacts.
+- Show compact rows on `pass`. On `revise` or `block`, expand only the decisive row with its
+  canonical report reference; do not paste complete reports into chat.
+
 ## Gate Transition Card
 
-The Gate Transition Card is the primary user-facing orientation message for a
-ready `gate_approval`. It is derived from the Run Status Card and canonical
-post-approval transition, but it is not another state model, persisted record,
-renderer or approval authority. The Run Status Card remains the operational,
-CLI and audit projection; the Gate Transition Card turns only the decision-
-relevant subset into concise product copy immediately before the host-native
-question or exact-text fallback.
+Every ready `gate_approval` uses one fixed visible sequence: first the compact
+approval-time Run Status Card, then the Gate Transition Card, then exactly one
+native question or exact-text fallback. Both cards derive from one immutable,
+non-authorizing presentation snapshot produced after canonical selected-run,
+gate and durable-artefact readiness evaluation. The snapshot never selects a
+run, decides a gate, persists state or grants approval.
+
+The two distinct card blocks form one Approval Orientation Envelope in one
+immediately preceding assistant message. The agent must complete that message
+before invoking any native question tool or emitting an exact-text approval
+request. Splitting the cards across separate assistant turns or invoking the
+tool after only one card is a failed interaction, not a valid presentation.
+
+The compact approval-time Run Status Card contains exactly six operational
+fields: selected run, readiness status, current gate, missing exact approval,
+one next action and quality outlook. It uses localized human-readable labels
+and must not contain evidence, diagnostic codes, raw control-state keys,
+allowed/forbidden inventories or machine values. The complete Run Status Card remains the operational,
+CLI and audit projection and remains available for complete detail outside the
+approval-time compact view.
+
+The Gate Transition Card is the second orientation message. It is derived from
+the same snapshot and canonical post-approval transition, but it is not another
+state model, persisted record, renderer or approval authority. It turns only
+the decision-relevant subset into concise product copy immediately before the
+host-native question or exact-text fallback.
 
 The card answers exactly three user questions, in this order:
 
@@ -189,11 +229,13 @@ for example, the German title may be `Lösungsdesign` while the authorization
 value remains `Approval: SD`. Meaning, ordering and authority boundaries are
 identical across locale packs.
 
-The approval-time card must not be a Markdown table or dashboard. It must not
+The Gate Transition Card must not be a Markdown table or dashboard. It must not
 present raw control-state keys, machine status values, diagnostic codes,
 evidence lists, allowed/forbidden inventories or implementation detail that is
 not needed for the decision. It must not repeat the native question. The card
 normally fits in one title, one readiness line and two short content blocks.
+Run and gate identity may appear in both cards to anchor the shared snapshot;
+status rows, action inventories and transition prose must not be duplicated.
 
 For `Approval: TP`, the effect is permission to run pre-implementation
 Brownfield Analysis, implementation remains gated until that analysis passes,
@@ -359,19 +401,20 @@ response_origin: deliberate_user_input for gate_approval
 This envelope is not a new persisted record. The selected canonical `RUN_STATE.md` and existing artefact chain remain the durable authority.
 
 Before presenting `gate_approval` for any user gate (`UR`, `PRD`, `SD`, `TP`,
-`QA`, or `UAT`), the agent must emit the localized Gate Transition Card as a
-separate, immediately preceding interaction block. The card is not optional,
-not hidden in the question text and not replaced by a host button label.
-Native buttons or exact-text fallback may appear only after this card. The
-underlying Run Status Card fields remain available to evaluation and audit,
-but their dashboard projection must not be pasted into this approval-time
-message.
+`QA`, or `UAT`), the agent must emit the compact localized Run Status Card and
+the localized Gate Transition Card as two distinct blocks in that order within
+one immediately preceding assistant message. Neither card is optional, hidden
+in the question text or replaced by a host button label. Do not invoke the
+native question tool until the complete two-card envelope is visible. Native
+buttons or exact-text fallback may appear only after both cards. Render the two
+cards once per eligible attempt; an unavailable or not-applied native control
+proceeds to exact text without repeating them.
 
 Before presenting `gate_approval`, the agent must:
 
 1. resolve exactly one selected run;
 2. run the canonical gate evaluation and confirm that the current gate's durable artefact is present and ready;
-3. emit the separate localized Gate Transition Card immediately before the gate question, then ask exactly one gate question that identifies `run_id` and `current_gate` and offers the exact approving value `Approval: <GateName>` followed by stable `revise` and `decline` outcomes; host-owned dismissal maps to `cancel` where only three choices are available;
+3. build one immutable non-authorizing presentation snapshot, emit its compact Run Status Card and Gate Transition Card in that order immediately before the gate question, then ask exactly one gate question that identifies `run_id` and `current_gate` and offers the exact approving value `Approval: <GateName>` followed by stable `revise` and `decline` outcomes; host-owned dismissal maps to `cancel` where only three choices are available;
 4. wait for deliberate user input without a timeout, default, preselection, hook-supplied answer or agent-to-agent substitute;
 5. re-run canonical gate evaluation against the same `run_id` and expected gate immediately before persistence;
 6. reject missing evidence, ambiguous or wrong run, wrong gate, stale state and any response that is no longer valid;
@@ -382,6 +425,15 @@ host control is presented, or the agent immediately uses the exact-text
 fallback. A host that does not apply the control does not trigger a second
 native prompt. AGDF must not simulate or force host-owned presentation.
 
+An eligible interaction must make its presentation outcome visible and
+distinguishable: `presented`, `unavailable_before_invocation`,
+`attempted_not_applied`, or `unsafe_to_wait`. This is transient presentation
+evidence only, never a persisted approval, selected-run authority or substitute
+for post-response revalidation. A textual fallback names the outcome, gives the
+exact approval value and confirms that authority is unchanged. A fresh explicit
+user request may reopen the unchanged decision after revalidation; it is not an
+automatic retry.
+
 A free-form native response is valid only when the existing exact-approval validator accepts it for the current gate after revalidation. A localized label, description, option position, recommendation style or host action never authorizes a gate. Revise, decline and cancel outcomes never advance a gate.
 
 Surface adapter rules:

package/generated/.opencode/AGDF.md

@@ -51,13 +51,13 @@ Structured Delivery Mode must respect gates, reviews and closeout discipline.
 |---|---|---|
 | `agdf-delivery-path-search` | high-impact planning decisions with several plausible next delivery steps before implementation | read-only advisory search; never grants gate permission or replaces gate-check |
 | `agdf-brownfield-analysis` | after gate-check permits Brownfield Review or implementation preparation, before non-trivial changes in existing systems | clarifies reuse, owners, risks and Mode/Slice Decision; never bypasses gate-check; Brownfield Review is not implementation permission |
-| `agdf-clean-implementation-review` | inspect workarounds, fallbacks, parallel structures or symptom fixes | not a TP or QA substitute |
-| `agdf-code-review` | mandatory CR step after code changes, focused on defects, regression and security findings | does not replace TP review, clean review or QA |
+| `agdf-clean-implementation-review` | evidence dimension: inspect whether the solution is structurally clean | supports Quality Readiness; not a TP or QA substitute |
+| `agdf-code-review` | evidence dimension: review the actual diff for defects, regression and security findings | supports Quality Readiness; does not replace QA |
 | `agdf-delivery-closeout` | commit/PR-near handoff after QA/OR/UAT | never performs VCS actions automatically |
 | `agdf-gate-check` | new build/change intent, unclear approval, Structured Delivery, later-gate artefact requested | does not create later artefacts or skip Mode/Slice Decision after Brownfield Review |
-| `agdf-qa-gate` | final QA decision | only instance for `pass | revise | block` |
+| `agdf-qa-gate` | sole final Quality Readiness decision | only instance for `pass | revise | block` |
 | `agdf-release-or` | auditable closeout for every relevant run | not a QA substitute |
-| `agdf-task-plan-review` | after implementation and before QA, verify TP coverage | no final QA decision |
+| `agdf-task-plan-review` | evidence dimension: verify whether the approved Task Plan was fulfilled | supports Quality Readiness; no final QA decision |
 
 Select exactly one primary skill first.
 Add more only when they cover a distinct concrete risk dimension.

package/generated/.opencode/agdf-interaction-locales.json

@@ -29,6 +29,27 @@
         "forbidden": "Forbidden now",
         "artefacts": "Artefacts"
       },
+      "qualityReadiness": {
+        "title": "Quality Readiness",
+        "rows": {
+          "plan_coverage": "Plan coverage",
+          "solution_integrity": "Solution integrity",
+          "code_quality": "Code quality",
+          "qa_decision": "QA decision"
+        },
+        "reason": "Reason",
+        "reference": "Evidence report",
+        "nextAction": "Next action",
+        "decisionOwner": "Decision owner",
+        "decisionOwnerValue": "QA Gate",
+        "unknown": "evidence missing",
+        "fallbackReasons": {
+          "plan_coverage": "Plan coverage requires revision before QA can pass.",
+          "solution_integrity": "Solution integrity requires revision before QA can pass.",
+          "code_quality": "Code quality findings require revision before QA can pass.",
+          "qa_decision": "QA evidence requires revision before the gate can pass."
+        }
+      },
       "gateTitles": {
         "UR": "User requirements",
         "PRD": "Product requirements",
@@ -115,6 +136,27 @@
         "forbidden": "Aktuell verboten",
         "artefacts": "Artefakte"
       },
+      "qualityReadiness": {
+        "title": "Quality Readiness",
+        "rows": {
+          "plan_coverage": "Planabdeckung",
+          "solution_integrity": "Lösungsintegrität",
+          "code_quality": "Code-Qualität",
+          "qa_decision": "QA-Entscheidung"
+        },
+        "reason": "Grund",
+        "reference": "Nachweisbericht",
+        "nextAction": "Nächste Aktion",
+        "decisionOwner": "Entscheidungsinstanz",
+        "decisionOwnerValue": "QA-Gate",
+        "unknown": "Nachweis fehlt",
+        "fallbackReasons": {
+          "plan_coverage": "Die Planabdeckung muss vor einem QA-Pass überarbeitet werden.",
+          "solution_integrity": "Die Lösungsintegrität muss vor einem QA-Pass überarbeitet werden.",
+          "code_quality": "Code-Qualitätsbefunde müssen vor einem QA-Pass überarbeitet werden.",
+          "qa_decision": "Die QA-Nachweise müssen vor einem QA-Pass überarbeitet werden."
+        }
+      },
       "gateTitles": {
         "UR": "Nutzeranforderungen",
         "PRD": "Produktanforderungen",