create-agdf 0.10.2 → 0.11.0

package/generated/AGENTS.md

@@ -13,6 +13,7 @@ Therefore generated Copilot skill names use the AGDF prefix:
 
 - `agdf-delivery-path-search`
 - `agdf-brownfield-analysis`
+- `agdf-ux-intent-definition`
 - `agdf-clean-implementation-review`
 - `agdf-code-review`
 - `agdf-delivery-closeout`
@@ -39,6 +40,10 @@ Do not infer active scope from branch names, uncommitted workspace deltas, chat
 If multiple active scopes are plausible, list the evidenced lines and route to `agdf-gate-check` or workstate clarification instead of choosing silently.
 After `Approval: UR`, run lightweight Brownfield Review before PRD when Brownfield, ownership, runtime, policy, persistence, architecture, UI or UX impact is possible.
 Brownfield Review must produce a Mode/Slice Decision: `quick_task`, `verified_change`, `structured_slice`, `structured_delivery` or `block`.
+That same review records the shared UI/UX impact classification. Run `agdf-ux-intent-definition` before
+PRD readiness for medium/high impact and for low impact with ambiguous mandatory PRD semantics. It is
+an internal analytical step, not a gate or product authority; a required blocked result keeps PRD
+readiness closed.
 Make that decision visible before coding or drafting later artefacts: state the selected path, scope reason, evidence and next required gate in the live control state or linked artefact.
 Do not assume the full PRD/SD/TP chain before that decision; use only as much gate depth as the reviewed change size justifies. A user-visible change is not automatically Verified Change eligible; any missing or ambiguous record condition escalates to the declared structured target before implementation.
 
@@ -51,6 +56,7 @@ 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-ux-intent-definition` | after approved UR and post-UR routing for medium/high UI/UX impact or ambiguous low-impact product semantics before PRD readiness | non-authorizing analytical PRD input; never creates product intent, gate permission, technical design or a parallel product source of truth |
 | `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 |

package/generated/plugins/agdf/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "AI Governance & Delivery Framework (AGDF) brings an operating system for governed AI-assisted delivery to Claude Code, combining workflow skills, control templates and machine-readable repository checks for gate decisions, Brownfield analysis, task-plan review, QA decisions, durable run state and auditable closeout.",
   "keywords": [
     "agentic",

package/generated/plugins/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Operating system for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/plugins/agdf/control/templates/artefacts/BROWNFIELD_REVIEW.md

@@ -17,6 +17,18 @@ Status: `draft | done | not_applicable | superseded`
 
 What approved UR scope is being sized and routed?
 
+## UI / UX Impact Routing
+
+- delivery_context: `greenfield | brownfield`
+- ui_ux_impact: `none | low | medium | high`
+- ui_ux_impact_reason:
+- ux_intent_definition_required: `yes | no`
+- ux_intent_definition_result: `ready | blocked | not_applicable`
+
+Use the single classification contract in `meta/contracts/gate-transition.md`. A required `blocked`
+result prevents PRD readiness. Greenfield explicitly marks existing-system evidence not applicable;
+Brownfield cites repository evidence.
+
 ## Existing-System View
 
 | Area | Existing owner or artefact | Evidence | Impact |

package/generated/plugins/agdf/control/templates/artefacts/PRD.md

@@ -11,31 +11,63 @@ Owner:
 
 What exactly must be delivered?
 
-## 2. Acceptance Criteria
+## 2. UX Intent And Success
 
-Which observable outcomes must be true?
+- ui_ux_impact: none | low | medium | high
+- ux_intent_definition: <ready analysis reference | directly defined low-impact semantics | justified not_applicable>
+- primary_user_intent:
+- success_signal:
+- primary_decision_or_action:
 
-## 3. Non-Goals
+Every field must be populated or explicitly justified as `not_applicable`. Medium/high impact requires
+a `ready` UX Intent Definition result before this PRD is ready.
+
+## 3. Working Modes And Effective State
+
+For every user-relevant working mode, define:
+
+| working_mode | effective_state | visible_state_types | effective_state_authority | primary_state_presentation_owner |
+|---|---|---|---|---|
+|  |  |  |  |  |
+
+Product/system authority decides what is effectively true. Presentation ownership identifies the
+primary surface that communicates state and next action. Technical storage, derivation and component
+ownership remain Solution Design concerns.
+
+## 4. Activation, Blockers, Recovery And Transitions
+
+- activation_and_deactivation:
+- blockers_and_visible_next_actions:
+- recovery_paths: <include visible retry for recoverable transient failure>
+- relevant_state_transitions: <trigger, source, target, visible feedback, next action, failure/rollback>
+
+## 5. Acceptance Criteria
+
+Every applicable UX criterion must include a stable `criterion_id`, `working_mode`, `source_state`,
+trigger/action, expected effective state, visible feedback, blocker/failure behavior, recovery/next
+action, observable success and required evidence. Specify observable behavior, not implementation.
+
+## 6. Non-Goals
 
 What remains out of scope?
 
-## 4. Users And Roles
+## 7. Users And Roles
 
 Who is affected and who decides?
 
-## 5. Constraints
+## 8. Constraints
 
 Which business, operational, legal, security or compatibility constraints apply?
 
-## 6. Evidence Requirements
+## 9. Evidence Requirements
 
 Which evidence must later support QA?
 
-## 7. Risks And Open Questions
+## 10. Risks And Open Questions
 
 Which questions must SD, TP or Brownfield Analysis clarify later?
 
-## 8. Next Step
+## 11. Next Step
 
 Review this PRD and approve only with:
 

package/generated/plugins/agdf/control/templates/artefacts/UX_INTENT_DEFINITION.md

@@ -0,0 +1,51 @@
+# UX Intent Definition: <Title>
+
+Status: draft | ready | blocked | not_applicable
+Decision: ready | blocked | not_applicable
+Based on: approved UR and post-UR routing evidence
+Date:
+Owner:
+
+This is non-authorizing analytical input. It is not a user-gate artefact, carries no approval and
+grants no implementation permission. After PRD approval, the PRD is the sole product authority.
+
+## 1. Routing Evidence
+
+- delivery_context: greenfield | brownfield
+- ui_ux_impact: none | low | medium | high
+- ui_ux_impact_reason:
+- ux_intent_definition_required: yes | no
+
+## 2. Intent And Success
+
+- primary_user_intent:
+- success_signal:
+- primary_decision_or_action:
+
+## 3. Working Modes And State
+
+- working_modes:
+- effective_state_by_mode:
+- visible_state_types:
+- effective_state_authority_by_mode:
+- primary_state_presentation_owner_by_mode:
+
+## 4. Activation, Blockers, Recovery And Transitions
+
+- activation_paths:
+- blockers:
+- recovery_paths:
+- relevant_state_transitions:
+
+## 5. Proposed PRD Acceptance Criteria
+
+- proposed_prd_acceptance_criteria:
+
+## 6. Decision Evidence
+
+- blocking_reason:
+- open_product_questions:
+- affected_outputs:
+- evidence:
+- missing_evidence:
+- required_next_step:

package/generated/plugins/agdf/meta/agdf-agent-router.md

@@ -14,6 +14,7 @@ Therefore plugin skill names are intentionally unprefixed:
 - `gate-check`
 - `delivery-path-search`
 - `brownfield-analysis`
+- `ux-intent-definition`
 - `task-plan-review`
 - `clean-implementation-review`
 - `code-review`
@@ -40,6 +41,10 @@ Do not infer active scope from branch names, uncommitted workspace deltas, chat
 If multiple active scopes are plausible, list the evidenced lines and route to `gate-check` or workstate clarification instead of choosing silently.
 After `Approval: UR`, run lightweight Brownfield Review before PRD when Brownfield, ownership, runtime, policy, persistence, architecture, UI or UX impact is possible.
 Brownfield Review must produce a Mode/Slice Decision: `quick_task`, `verified_change`, `structured_slice`, `structured_delivery` or `block`.
+That same review records the shared UI/UX impact classification. Run `ux-intent-definition` before
+PRD readiness for medium/high impact and for low impact with ambiguous mandatory PRD semantics. It is
+an internal analytical step, not a gate or product authority; a required blocked result keeps PRD
+readiness closed.
 Make that decision visible before coding or drafting later artefacts: state the selected path, scope reason, evidence and next required gate in the live control state or linked artefact.
 Do not assume the full PRD/SD/TP chain before that decision; use only as much gate depth as the reviewed change size justifies. A user-visible change is not automatically Verified Change eligible; any missing or ambiguous record condition escalates to the declared structured target before implementation.
 
@@ -52,6 +57,7 @@ Structured Delivery Mode must respect gates, reviews and closeout discipline.
 |---|---|---|
 | `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 |
 | `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 |
+| `ux-intent-definition` | after approved UR and post-UR routing for medium/high UI/UX impact or ambiguous low-impact product semantics before PRD readiness | non-authorizing analytical PRD input; never creates product intent, gate permission, technical design or a parallel product source of truth |
 | `clean-implementation-review` | evidence dimension: inspect whether the solution is structurally clean | supports Quality Readiness; not a TP or QA substitute |
 | `code-review` | evidence dimension: review the actual diff for defects, regression and security findings | supports Quality Readiness; does not replace QA |
 | `delivery-closeout` | commit/PR-near handoff after QA/OR/UAT | never performs VCS actions automatically |

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

@@ -11,6 +11,9 @@
     "en": {
       "statusCard": {
         "title": "AGDF status-card",
+        "status": "Status",
+        "field": "Status field",
+        "value": "Value",
         "run": "Selected run",
         "humanTitle": "Run title",
         "gate": "Current gate",
@@ -107,6 +110,7 @@
         "exactTextRequest": "To approve, reply exactly with `{approval}`; otherwise request revision or decline.",
         "decisionFollows": "will be the next user decision",
         "presentationFailure": "Approval cards could not be rendered safely.",
+        "statusPresentationFailure": "Status card could not render safely.",
         "nonReadyDecision": "No decision requested: {reason}.",
         "approveDescription": "Approve this gate with the exact authorization value.",
         "reviseLabel": "Revise",
@@ -214,6 +218,9 @@
     "de": {
       "statusCard": {
         "title": "AGDF-Statuskarte",
+        "status": "Status",
+        "field": "Statusfeld",
+        "value": "Wert",
         "run": "Ausgewählter Run",
         "humanTitle": "Run-Titel",
         "gate": "Aktuelles Gate",
@@ -310,6 +317,7 @@
         "exactTextRequest": "Zur Freigabe exakt mit `{approval}` antworten; andernfalls Überarbeitung anfordern oder ablehnen.",
         "decisionFollows": "ist die nächste Nutzerentscheidung",
         "presentationFailure": "Die Freigabekarten konnten nicht sicher dargestellt werden.",
+        "statusPresentationFailure": "Statuskarte nicht sicher darstellbar.",
         "nonReadyDecision": "Keine Entscheidung angefordert: {reason}.",
         "approveDescription": "Dieses Gate mit dem exakten Freigabewert autorisieren.",
         "reviseLabel": "Überarbeiten",

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "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/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/interaction.md

@@ -40,6 +40,29 @@ It must not introduce a second gate model or override `gate-check`, `delivery-ma
 
 `next_gate_after_approval` and `allowed_after_approval` must be `none` when no approval is missing, when the current step is internal, or when the run is in OR/completed handoff. They must not imply implementation, QA, release, commit, push or PR authority unless the existing gate model already allows that authority.
 
+### Deterministic Operational Presentation
+
+`status_card` is the canonical machine/audit projection. The same evaluation also exposes an additive
+`status_presentation` object with selected run/revision/gate/locale identity, `semantic_block:
+run_status_card`, one compact Markdown block with localized labels and canonical evaluated values,
+and `authorizes: false`. The full raw and evidence-bearing projection remains available unchanged in
+`status_card` JSON for audit and automation; it is not duplicated into the primary chat card.
+Fresh legacy-compatible control state without a durable revision uses the explicit non-authorizing
+identity `unversioned`; ready approval presentation remains impossible without a real revision.
+
+`interaction-presentation.js` is the only owner that may select, label, order, localize and render the
+operational status fields. The gate-check CLI, skills and surface adapters consume
+`status_presentation.markdown` verbatim. They may add concise surrounding explanation, but they must
+not reconstruct a table, omit or rename fields, substitute generic gate actions for evaluated
+`allowed_now`/`forbidden_now`, or maintain another status-card template. If the projection is missing
+or its selected run, revision, gate or locale identity is stale, presentation fails closed rather
+than falling back to model-generated status Markdown.
+
+This determinism protects semantic parity, permission boundaries and evidence visibility across
+hosts. It does not standardize host chrome or unrelated conversational prose. `approval_presentation`
+remains the separate decision-time projection and is present only for a ready user gate; both public
+presentations derive from the same `status_card` snapshot and neither grants approval.
+
 
 ### Breadcrumb
 

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-interaction-locales.json

@@ -11,6 +11,9 @@
     "en": {
       "statusCard": {
         "title": "AGDF status-card",
+        "status": "Status",
+        "field": "Status field",
+        "value": "Value",
         "run": "Selected run",
         "humanTitle": "Run title",
         "gate": "Current gate",
@@ -107,6 +110,7 @@
         "exactTextRequest": "To approve, reply exactly with `{approval}`; otherwise request revision or decline.",
         "decisionFollows": "will be the next user decision",
         "presentationFailure": "Approval cards could not be rendered safely.",
+        "statusPresentationFailure": "Status card could not render safely.",
         "nonReadyDecision": "No decision requested: {reason}.",
         "approveDescription": "Approve this gate with the exact authorization value.",
         "reviseLabel": "Revise",
@@ -214,6 +218,9 @@
     "de": {
       "statusCard": {
         "title": "AGDF-Statuskarte",
+        "status": "Status",
+        "field": "Statusfeld",
+        "value": "Wert",
         "run": "Ausgewählter Run",
         "humanTitle": "Run-Titel",
         "gate": "Aktuelles Gate",
@@ -310,6 +317,7 @@
         "exactTextRequest": "Zur Freigabe exakt mit `{approval}` antworten; andernfalls Überarbeitung anfordern oder ablehnen.",
         "decisionFollows": "ist die nächste Nutzerentscheidung",
         "presentationFailure": "Die Freigabekarten konnten nicht sicher dargestellt werden.",
+        "statusPresentationFailure": "Statuskarte nicht sicher darstellbar.",
         "nonReadyDecision": "Keine Entscheidung angefordert: {reason}.",
         "approveDescription": "Dieses Gate mit dem exakten Freigabewert autorisieren.",
         "reviseLabel": "Überarbeiten",

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.2",
+  "version": "0.11.0",
   "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/lib/cli/validation-handlers.js

@@ -24,7 +24,8 @@ export function createValidationHandlers(io = console) {
         const output = printApprovalEnvelope(report, { io, reEvaluate: () => evaluateGateCheck(options.dir, options) });
         return output.status === "blocked" ? 2 : 0;
       }
-      printGateCheckReport(report, options.json, options.statusCard, io);
+      const presentationRendered = printGateCheckReport(report, options.json, options.statusCard, io);
+      if (presentationRendered === false) return 2;
       return report.status === "blocked" ? 2 : 0;
     }],
     ["delivery-map", (options) => {

package/generated/plugins/agdf/runtime/create-agdf/lib/control-evaluation/gate-check.js

@@ -1,4 +1,4 @@
-import { attachApprovalOrientationSnapshot, buildArtefactRefs, buildQualityReadiness, formatArtefactRefs, gateTitle, localePack, renderApprovalOrientationSnapshot, resolveHumanRunTitle } from '../interaction-presentation.js';
+import { attachApprovalOrientationSnapshot, buildArtefactRefs, buildQualityReadiness, gateTitle, localePack, renderApprovalOrientationSnapshot, renderOperationalStatusCard, resolveHumanRunTitle } from '../interaction-presentation.js';
 import { interactionLocales, resolveConfiguredChatLanguage } from '../cli/runtime-context.js';
 import { evaluateDoctor } from './doctor.js';
 import { analyzeDeliveryMap, deriveQualityOutlook } from './delivery-map.js';
@@ -292,6 +292,11 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     enumerable: false,
   });
   const revisionId = extractField(runState.content ?? "", "revision_id");
+  const statusPresentation = renderOperationalStatusCard(statusCard, {
+    registry: interactionLocales,
+    humanPresentation,
+    revisionId,
+  });
   const approvalOrientation = attachApprovalOrientationSnapshot(statusCard, {
     ready: isReadyUserGateApproval({ status, currentGate, missingApproval }),
     humanPresentation,
@@ -323,6 +328,7 @@ export function evaluateGateCheck(targetDir, selection = {}) {
     native_attempt_required: statusCard.native_attempt_required,
     candidate_runs: runState.candidate_runs ?? [],
     status_card: statusCard,
+    status_presentation: statusPresentation,
     approval_presentation: renderApprovalOrientationSnapshot(approvalOrientation, {
       registry: interactionLocales,
       expectedIdentity: {
@@ -392,28 +398,12 @@ export function printApprovalEnvelope(report, { io = console, reEvaluate } = {})
 
 function printGateCheckStatusCard(report, io) {
   const card = report.status_card;
-  const labels = localePack(interactionLocales, card.presentation_language).statusCard;
-  const primary = localePack(interactionLocales, card.presentation_language).primary;
-  const presentation = card.humanPresentation ?? {
-    runTitle: card.run_id,
-    gateTitle: gateTitle(interactionLocales, card.presentation_language, card.current_gate),
-    artefactRefs: buildArtefactRefs({}, interactionLocales, card.presentation_language),
-  };
-  io.log(`${labels.title}: ${primary.status[card.status] ?? card.status}`);
-  io.log(`${labels.run}: ${card.run_id}`);
-  io.log(`${labels.humanTitle}: ${presentation.runTitle}`);
-  io.log(`${labels.gate}: ${card.current_gate} — ${presentation.gateTitle}`);
-  io.log(`${labels.lifecycle}: ${primary.lifecycle[card.delivery_state] ?? primary.lifecycle.unknown}`);
-  io.log(`${labels.artefacts}: ${formatArtefactRefs(presentation.artefactRefs)}`);
-  io.log(`${labels.blocked}: ${card.blocking_condition === "none" ? primary.none : primary.blocked}`);
-  io.log(`${labels.missing}: ${card.missing_approval === "none" ? primary.none : card.missing_approval}`);
-  if (card.next_gate_after_approval !== "none") {
-    io.log(`${labels.nextGate}: ${card.next_gate_after_approval} — ${gateTitle(interactionLocales, card.presentation_language, card.next_gate_after_approval)}`);
-    io.log(`${labels.allowedAfter}: ${primary.afterApproval[card.current_gate] ?? primary.actions[card.current_gate]}`);
+  if (!report.status_presentation?.markdown) {
+    io.log(localePack(interactionLocales, card?.presentation_language || "en").interaction.statusPresentationFailure);
+    return false;
   }
-  io.log(`${labels.allowed}: ${primary.actions[card.current_gate] ?? primary.none}`);
-  io.log(`${labels.step}: ${primary.actions[card.current_gate] ?? primary.none}`);
-  io.log(`${labels.quality}: ${primary.quality}`);
+  io.log(report.status_presentation.markdown);
+  const primary = localePack(interactionLocales, card.presentation_language).primary;
   const readiness = qualityReadinessForRunState(card.runState, report.next_allowed_action);
   if (readiness) {
     const quality = localePack(interactionLocales, card.presentation_language).qualityReadiness;
@@ -429,17 +419,17 @@ function printGateCheckStatusCard(report, io) {
     io.log(`${quality.nextAction}: ${readiness.next_action || primary.none}`);
     io.log(`${quality.decisionOwner}: ${quality.decisionOwnerValue}`);
   }
+  return true;
 }
 
 export function printGateCheckReport(report, json, statusCard = false, io = console) {
   if (json) {
     io.log(JSON.stringify(report, null, 2));
-    return;
+    return true;
   }
 
   if (statusCard) {
-    printGateCheckStatusCard(report, io);
-    return;
+    return printGateCheckStatusCard(report, io);
   }
 
   io.log(`AGDF gate-check: ${report.status}`);
@@ -456,4 +446,5 @@ export function printGateCheckReport(report, json, statusCard = false, io = cons
   for (const item of report.forbidden) io.log(`- ${item}`);
   io.log("");
   io.log(`Next allowed action: ${report.next_allowed_action}`);
+  return true;
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/interaction-presentation.js

@@ -269,6 +269,86 @@ export function formatArtefactRefs(refs) {
   return refs.map((ref) => ref.exists ? `[${ref.label}](${ref.path})` : ref.missingLabel).join(" · ");
 }
 
+function markdownCell(value) {
+  return String(value ?? "")
+    .replaceAll("\\", "\\\\")
+    .replaceAll("|", "\\|")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replace(/\r?\n/g, "<br>");
+}
+
+function operationalList(value, none) {
+  if (!Array.isArray(value) || value.length === 0) return none;
+  return value.map((item) => String(item ?? "").trim()).filter(Boolean).join("\n") || none;
+}
+
+function operationalBreadcrumb(value, labels) {
+  if (!Array.isArray(value) || value.length === 0) return "";
+  const marker = {
+    fulfilled: labels.breadcrumbFulfilled,
+    current: labels.breadcrumbCurrent,
+    open: labels.breadcrumbOpen,
+  };
+  return value.map((item) => `${marker[item?.status] ?? labels.breadcrumbOpen} ${String(item?.gate ?? "").trim()}`)
+    .filter((item) => item.trim())
+    .join(labels.breadcrumbSeparator);
+}
+
+export function renderOperationalStatusCard(statusCard, {
+  registry,
+  humanPresentation,
+  revisionId = "",
+} = {}) {
+  if (!plainObject(statusCard) || !plainObject(humanPresentation)) return null;
+  const runId = String(statusCard.run_id ?? "").trim();
+  const currentGate = String(statusCard.current_gate ?? "").trim();
+  const revision = String(revisionId ?? "").trim() || "unversioned";
+  const locale = resolvePresentationLocale(registry, statusCard.presentation_language);
+  if (!runId || !currentGate || !locale) return null;
+
+  const pack = localePack(registry, locale);
+  const labels = pack.statusCard;
+  const primary = pack.primary;
+  const none = primary.none;
+  const gateLabel = String(humanPresentation.gateTitle ?? "").trim() || gateTitle(registry, locale, currentGate);
+  const runTitle = displaySafeTitle(humanPresentation.runTitle, normalizedRunTitle(runId));
+  const breadcrumb = operationalBreadcrumb(statusCard.breadcrumb, labels);
+  const rows = [
+    [labels.run, `${runTitle} · \`${runId}\``],
+    ...(breadcrumb ? [[labels.breadcrumb, breadcrumb]] : []),
+    [labels.status, primary.status[statusCard.status] ?? statusCard.status],
+    [labels.gate, `${gateLabel} (\`${currentGate}\`)`],
+    [labels.allowed, operationalList(statusCard.allowed_now, none)],
+    [labels.forbidden, operationalList(statusCard.forbidden_now, none)],
+    [labels.blocked, statusCard.blocking_condition === "none" ? none : statusCard.blocking_condition],
+    [labels.missing, statusCard.missing_approval === "none" ? none : statusCard.missing_approval],
+    [labels.nextGate, statusCard.next_gate_after_approval === "none" ? none : statusCard.next_gate_after_approval],
+    [labels.allowedAfter, statusCard.allowed_after_approval === "none" ? none : statusCard.allowed_after_approval],
+    [labels.step, statusCard.next_step || none],
+    [labels.quality, statusCard.quality_outlook || none],
+  ];
+  const markdown = [
+    `## ${labels.title}`,
+    "",
+    `| ${labels.field} | ${labels.value} |`,
+    "|---|---|",
+    ...rows.map(([label, value]) => `| ${markdownCell(label)} | ${markdownCell(value)} |`),
+  ].join("\n");
+
+  return Object.freeze({
+    schema_version: "1",
+    semantic_block: "run_status_card",
+    run_id: runId,
+    revision_id: revision,
+    current_gate: currentGate,
+    presentation_language: locale,
+    markdown,
+    authorizes: false,
+  });
+}
+
 export function gateOptions(registry, requestedLocale, gate, { includeCancel = false } = {}) {
   const pack = localePack(registry, requestedLocale);
   const options = [