create-agdf 0.8.4 → 0.8.6

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

@@ -28,7 +28,19 @@
         "lifecycle": "Delivery status",
         "allowed": "Allowed now",
         "forbidden": "Forbidden now",
-        "artefacts": "Artefacts"
+        "artefacts": "Artefacts",
+        "breadcrumb": "Path",
+        "breadcrumbFulfilled": "\u2713",
+        "breadcrumbCurrent": "\u25cf",
+        "breadcrumbOpen": "\u25cb",
+        "breadcrumbSeparator": " \u00b7 "
+      },
+      "internalStateLabels": {
+        "verifiedChange": "Compact change under review",
+        "verifiedChangeEscalated": "Escalated to structured delivery",
+        "contextGraphMaintained": "Project memory maintained",
+        "contextGraphOpenGap": "Graph gap open",
+        "multiScopeBlocked": "Ambiguous scope, clarification needed"
       },
       "qualityReadiness": {
         "title": "Quality Readiness",
@@ -63,7 +75,18 @@
         "Brownfield Analysis": "Implementation preparation",
         "CD+Tests": "Implementation and tests",
         "CR": "Code review",
-        "OR": "Delivery report"
+        "OR": "Delivery report",
+        "Verified Change": "Verified change",
+        "Quick Task": "Quick task",
+        "Block": "Block"
+      },
+      "gateActionTitles": {
+        "UR": "Approve user requirements",
+        "PRD": "Approve product requirements",
+        "SD": "Approve solution design",
+        "TP": "Approve task and test plan",
+        "QA": "Approve quality decision",
+        "UAT": "Accept delivery result"
       },
       "interaction": {
         "ready": "Ready for your decision",
@@ -120,6 +143,18 @@
           "TP": "Run pre-implementation Brownfield Analysis; implementation starts only if it passes.",
           "QA": "Prepare the user-acceptance decision; release remains blocked.",
           "UAT": "Prepare the delivery report; version-control and release actions still require explicit instruction."
+        },
+        "narration": {
+          "gateSatisfied": "{gate} approved",
+          "noAction": "no user action required now",
+          "gates": {
+            "UR": { "agentNext": "Agent runs Brownfield Review next" },
+            "PRD": { "agentNext": "Agent drafts the Solution Design next" },
+            "SD": { "agentNext": "Agent drafts the Task and Test Plan next" },
+            "TP": { "agentNext": "Agent runs pre-implementation Brownfield Analysis next" },
+            "QA": { "agentNext": "Agent prepares the user-acceptance decision", "userAction": "user acceptance decision next" },
+            "UAT": { "agentNext": "Agent prepares the delivery report" }
+          }
         }
       }
     },
@@ -143,7 +178,19 @@
         "lifecycle": "Lieferstatus",
         "allowed": "Jetzt erlaubt",
         "forbidden": "Aktuell verboten",
-        "artefacts": "Artefakte"
+        "artefacts": "Artefakte",
+        "breadcrumb": "Pfad",
+        "breadcrumbFulfilled": "\u2713",
+        "breadcrumbCurrent": "\u25cf",
+        "breadcrumbOpen": "\u25cb",
+        "breadcrumbSeparator": " \u00b7 "
+      },
+      "internalStateLabels": {
+        "verifiedChange": "Kompakte Änderung wird geprüft",
+        "verifiedChangeEscalated": "Eskaliert zu structured delivery",
+        "contextGraphMaintained": "Projektgedächtnis wird gepflegt",
+        "contextGraphOpenGap": "Graph-Lücke offen",
+        "multiScopeBlocked": "Mehrdeutiger Scope, Klärung nötig"
       },
       "qualityReadiness": {
         "title": "Quality Readiness",
@@ -178,7 +225,18 @@
         "Brownfield Analysis": "Implementierungsvorbereitung",
         "CD+Tests": "Implementierung und Tests",
         "CR": "Code-Review",
-        "OR": "Lieferbericht"
+        "OR": "Lieferbericht",
+        "Verified Change": "Verified Change",
+        "Quick Task": "Quick Task",
+        "Block": "Block"
+      },
+      "gateActionTitles": {
+        "UR": "Nutzeranforderung freigeben",
+        "PRD": "Produktanforderungen freigeben",
+        "SD": "Lösungsdesign freigeben",
+        "TP": "Umsetzungsplan freigeben",
+        "QA": "Qualitätsentscheidung freigeben",
+        "UAT": "Ergebnis abnehmen"
       },
       "interaction": {
         "ready": "Bereit für deine Entscheidung",
@@ -235,6 +293,18 @@
           "TP": "Die Brownfield-Analyse vor der Implementierung durchführen; die Implementierung startet nur nach bestandenem Ergebnis.",
           "QA": "Die Nutzerabnahme vorbereiten; die Veröffentlichung bleibt gesperrt.",
           "UAT": "Den Lieferbericht vorbereiten; Versionskontroll- und Veröffentlichungsaktionen benötigen weiterhin eine ausdrückliche Anweisung."
+        },
+        "narration": {
+          "gateSatisfied": "{gate} genehmigt",
+          "noAction": "keine Nutzeraktion erforderlich",
+          "gates": {
+            "UR": { "agentNext": "Agent führt Brownfield Review als Nächstes durch" },
+            "PRD": { "agentNext": "Agent entwirft als Nächstes das Lösungsdesign" },
+            "SD": { "agentNext": "Agent entwirft als Nächstes den Aufgaben- und Testplan" },
+            "TP": { "agentNext": "Agent führt Brownfield-Analyse vor Implementierung durch" },
+            "QA": { "agentNext": "Agent bereitet die Nutzerabnahme vor", "userAction": "Nutzerabnahme als Nächstes" },
+            "UAT": { "agentNext": "Agent bereitet den Lieferbericht vor" }
+          }
         }
       }
     }

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Codex-first operating system for governed AI-assisted delivery.",
@@ -97,6 +97,9 @@
           "decline"
         ],
         "dismissOutcome": "cancel",
+        "approvalValueTransport": "decorated_label_only",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
         "technicalPermissionOwner": "codex_host"
       },
       "claude": {
@@ -109,6 +112,9 @@
           "decline"
         ],
         "dismissOutcome": "cancel",
+        "approvalValueTransport": "decorated_label_only",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
         "technicalPermissionOwner": "claude_host"
       },
       "opencode": {
@@ -121,6 +127,9 @@
           "decline"
         ],
         "dismissOutcome": "cancel",
+        "approvalValueTransport": "decorated_label_only",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
         "technicalPermissionOwner": "opencode_host"
       },
       "fallback": {
@@ -133,6 +142,9 @@
           "decline",
           "cancel"
         ],
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
         "technicalPermissionOwner": "host_specific"
       }
     }

package/generated/plugins/agdf/meta/agdf-runtime-contract.md

@@ -36,10 +36,12 @@ After `Approval: UR`, Brownfield Review may select `verified_change` only when a
 1. exactly one repository-relative canonical owner and bounded source/derived paths;
 2. no gate, permission, security, persistence, architecture, external API, CLI or release behavior impact;
 3. deterministic propagation when derived paths exist, plus at least one deterministic validation command;
-4. tracked and untracked worktree baseline paths captured before eligibility, with no candidate path already dirty; and
+4. a full baseline commit plus tracked and untracked worktree baseline paths captured before eligibility, with no candidate path already dirty; and
 5. an explicit `structured_slice` or `structured_delivery` escalation target.
 
-The record is the compact eligibility, execution and mini-closeout artefact. A missing, failed, unknown or ambiguous field/check must fail closed: mark the record `escalated` and continue at its declared structured target. Unrelated paths already dirty at baseline remain isolated; newly introduced unlisted paths invalidate the compact path. An executed record requires passing validation evidence and, where applicable, passing propagation evidence.
+The record is the compact Brownfield selection, eligibility, execution and mini-closeout artefact. The selected run may link the same normalized record path as Brownfield Review, Verified Change and OR only in `verified_change` mode and only with lifecycle-consistent role states; separate Brownfield and OR files remain supported. Permitted control paths derive only from recognized, explicitly linked artefacts beneath the selected run's own artefact directory.
+
+A missing, failed, unknown or ambiguous field/check must fail closed: mark the record `escalated` and continue at its declared structured target. Unrelated paths already dirty at baseline remain isolated; newly introduced unlisted paths invalidate the compact path. An executed record requires a machine-readable exact changed-path snapshot with passing scope status, passing validation evidence and, where applicable, passing propagation evidence. Active runs compare that snapshot with the current post-baseline worktree. Completed executed runs validate the persisted snapshot and record evidence without being retroactively invalidated by later unrelated live-worktree changes.
 
 ### Non-Normative Trivial Change Boundary
 
@@ -145,6 +147,65 @@ 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.
 
+### Breadcrumb
+
+The compact human Run Status Card may include a single-line path-derived breadcrumb that
+shows the user's position in the delivery journey. It is derived from the Mode/Slice
+Decision and the Approvals table — not a fixed template.
+
+| Mode/Slice | Breadcrumb gates |
+|---|---|
+| structured_delivery / structured_slice | `UR · PRD · SD · TP · QA · UAT` |
+| verified_change | `UR · Verified Change · OR` |
+| quick_task | `UR · Quick Task` |
+| block | `UR · Block` |
+
+- `✓` fulfilled, `●` current, `○` open.
+- Non-applicable gates are absent (no `–` placeholders, no thinned standard template).
+- `verified_change` is one collapsed node, not a degraded standard route.
+- The breadcrumb is a derived, non-authorising projection. It does not add a new gate
+  model or override the Gate Transition Model.
+- The machine-readable `status_card` JSON may carry a derived `breadcrumb` array
+  `[{gate, status}]` for the presentation layer; this is additive and does not replace
+  any existing field.
+
+### Post-Acceptance Transition Narration
+
+After each accepted gate approval, the agent emits exactly one status line using the
+template:
+
+```text
+<what was satisfied> → <what the agent does next internally> → <user action: yes/no>
+```
+
+This narration is temporally and structurally separate from the Gate Transition Card:
+
+- The Gate Transition Card is **pre-approval** (in the orientation envelope); it is
+  subjunctive and contains the exact `Approval:` value.
+- The narration is **post-acceptance** (after the gate advanced); it is indicative and
+  does not contain the `Approval:` value.
+- Both never appear in the same assistant message.
+- The narration does not repeat the decision's effect (the card's job) and uses its own
+  template, not the card's three-question form.
+- For internal steps (Brownfield Review, Brownfield Analysis), the narration states what
+  the agent does next and that no user action is required, without exposing
+  `next_user_gate: none` or asking for a second approval.
+
+### Internal-State Collapse
+
+The derived-projection principle above applies explicitly to internal sub-states. The
+full Run Status Card (machine/audit projection) keeps all fields unchanged. Only the
+compact human card collapses internal sub-states to stable human labels:
+
+| Internal sub-state | Human label | Stays explicit |
+|---|---|---|
+| `verified_change`: missing/draft/invalid/eligible/executed | "Compact change under review" | `escalated` → "Escalated to structured delivery" |
+| `context_graph_required_action`: link/update/create/resolve_drift | "Project memory maintained" | `open_gap` → "Graph gap open" |
+| `multi_scope_state`: clear/ambiguous | (not shown) | `blocked` → "Ambiguous scope, clarification needed" |
+
+`open_gap` and `escalated` remain explicitly visible. The full machine projection retains
+all raw values unchanged.
+
 ## Quality Readiness Projection
 
 After CD+Tests, when any of the four review/QA artefacts exists, surfaces may show one compact
@@ -181,6 +242,14 @@ 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 first visible line of that envelope is the localized action-oriented title
+of the current user gate, rendered as a level-two Markdown heading or equivalent
+accessible host heading inside the compact approval-time Run Status Card.
+`AGDF Status`, `Run Status Card`, `Gate Transition Card`, raw gate identifiers
+and machine values are semantic or diagnostic labels only and must not become
+the primary heading. The action title appears exactly once and does not replace,
+merge or reorder either required card block.
+
 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
@@ -390,7 +459,7 @@ interaction_kind: clarification | tool_permission | gate_approval | blocked | st
 surface: codex | claude | opencode | fallback
 run_id: required for gate_approval
 current_gate: required for gate_approval
-native_attempt_required: true only for an eligible gate_approval before the first adapter attempt
+native_attempt_required: true only after ready-gate and adapter-capability preflight prove exact value transport and safe deliberate waiting
 prompt: required
 options: required for a structured question
 effects: required when the interaction can cause side effects
@@ -421,11 +490,13 @@ Before presenting `gate_approval`, the agent must:
 6. reject missing evidence, ambiguous or wrong run, wrong gate, stale state and any response that is no longer valid;
 7. persist an accepted approval only through the existing control-state workflow.
 
-For an eligible `gate_approval`, `native_attempt_required` is a mandatory orchestration signal. The
-agent must make exactly one configured native adapter attempt after the two orientation cards and
-before any exact-text fallback. Hooks may prepare context but must not answer, approve or replace
-the adapter attempt. The signal is absent or false for clarification, blocked, status-only,
-internal-step and non-ready interactions.
+For a ready `gate_approval`, interaction kind and native capability are separate. Evaluate callability,
+deliberate wait safety and canonical approval-value transport before invocation. `native_attempt_required`
+is true only when current evidence proves `exact_option_value` or `separate_label_and_value` transport
+with safe deliberate waiting. Decorated-only, missing, conflicting or unknown capability fails closed to
+`unavailable_before_invocation`; unsafe waiting fails closed to `unsafe_to_wait`. Both expose false and use
+exact text without invoking the adapter. A report-only CLI evaluation has no verified current host adapter
+and therefore exposes false. Hooks may prepare context but must not answer, approve or replace an eligible attempt.
 
 The first eligible native-attempt has a single bounded outcome: the declared
 host control is presented, or the agent immediately uses the exact-text

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

@@ -26,14 +26,14 @@ When `.agdf/control/` is present, persist or link `post_ur_review` output under
 
 ## Modes
 
-- `post_ur_review`: use after approved durable UR to size and route the work. Output must decide `quick_task`, `structured_slice`, `structured_delivery`, or `block` with scope reason and evidence.
+- `post_ur_review`: use after approved durable UR to size and route the work. Output must decide `quick_task`, `verified_change`, `structured_slice`, `structured_delivery`, or `block` with scope reason and evidence.
 - `pre_implementation_analysis`: use after approved durable TP to verify the implementation path before `CD+Tests`. Output must focus on reuse path, owners, regression risk, test impact and minimal clean implementation.
 
 Do not mix both modes silently. Name the active mode in the output.
 
 ## 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`, `structured_slice`, `structured_delivery`, or `block` before PRD depth or implementation is chosen.
+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.
 3. Reuse-before-create: prefer existing modules, services, components, tables, endpoints, tests, and configuration.
 4. Minimal clean slice: choose the smallest durable intervention, not merely the smallest technical diff.
 5. No silent parallel structures.
@@ -106,7 +106,7 @@ Use a concise structure:
 ## Brownfield Analysis
 - mode: post_ur_review | pre_implementation_analysis
 - decision: pass | revise | block | not_applicable
-- mode_slice_decision: quick_task | structured_slice | structured_delivery | block
+- mode_slice_decision: quick_task | verified_change | structured_slice | structured_delivery | block
 - required_next_gate: none | PRD | SD | TP | Brownfield Analysis
 - artefact: .agdf/control/artefacts/<key>/BROWNFIELD_REVIEW.md | none
 - scope:

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

@@ -63,29 +63,30 @@ 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. 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.
+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. Its first visible line is the localized action-oriented gate title as a level-two Markdown heading or equivalent accessible host heading; generic AGDF/card labels and raw gate IDs cannot be the primary heading. 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.
+11. Render both cards once in that single complete assistant message. Never merge, reverse, omit or duplicate them; the action heading does not replace either card. 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.
 
-The ready-gate projection must expose `native_attempt_required: true`. Treat this as a mandatory
-orchestration instruction: after rendering the two cards, invoke the configured native question
-adapter exactly once before using the exact-text fallback. A hook, permission result or session
-context message cannot replace that attempt or supply its answer. For every non-ready interaction,
-the signal is absent or false and no approval control may be shown.
+Before projecting a ready gate, evaluate adapter callability, deliberate wait safety and canonical
+approval-value transport. Expose `native_attempt_required: true` only when that preflight proves
+`exact_option_value` or `separate_label_and_value` transport with safe deliberate waiting. Decorated-only,
+missing, conflicting or unknown capability exposes false and `unavailable_before_invocation`; unsafe
+waiting exposes false and `unsafe_to_wait`. In both cases use exact text without invoking the adapter.
+A hook, permission result or session context message cannot replace an eligible attempt or supply its answer.
 
 Before composing the question, resolve the configured chat locale from `.agdf/control/config.json` through `plugin/meta/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.
 
 For the transition card, use the complete resolved locale pack. The initial German pack includes `Bereit für deine Entscheidung`, `Jetzt freigeben` and `Danach`; the initial English pack includes `Ready for your decision`, `Approve now` and `Next`. Keep each card in one locale. Use a localized human-readable gate title rather than an internal status label, while leaving the exact gate identifier and approval value unchanged. Do not render a Markdown table, dashboard rows, raw control-state keys, diagnostic codes, evidence lists, a duplicated gate question or a false user gate in the approval-time card.
 
-The primary option remains exactly `Approval: SD`; only explanatory copy and non-authoritative outcome labels are localized. Concrete localized copy belongs to the user-facing interaction layer or the approved delivery artefact, not to English runtime rules.
+The primary option is derived exactly as `Approval: <GateName>` from the evaluated current gate; only explanatory copy and non-authoritative outcome labels are localized. Concrete localized copy belongs to the user-facing interaction layer or the approved delivery artefact, not to English runtime rules.
 
 Make exactly one native-attempt for the ready gate. If the host does not render,
 apply or safely return the native question on that attempt, switch immediately
@@ -112,6 +113,18 @@ A free-form response must still exactly match the current gate's approval formul
 
 Every primary chat card shows the selected run's `UR`, `PRD`, `SD` and `TP` in that order. Render an existing canonical path as a readable link and a missing artefact as localized non-link text; never guess paths. Resolve the human run title from current artefact heading, approved UR heading, Objective, then normalized `run_id`. Status, blocked, clarification and internal-step interactions use the same locale and artefact projection but do not show approval buttons. Keep raw process keys and machine status values in JSON or audit detail.
 
+### Breadcrumb Rendering
+
+The compact human Run Status Card includes a single-line path-derived breadcrumb showing the user's position in the delivery journey. Derive it from the Mode/Slice Decision and the Approvals table — not a fixed template. Use `✓` for fulfilled, `●` for current, `○` for open, separated by ` · `. Non-applicable gates are absent. See the Runtime Contract §Breadcrumb for the path templates and the derived `breadcrumb` array.
+
+### Post-Acceptance Transition Narration
+
+After each accepted gate approval is persisted, emit exactly one narration line using the template `<what was satisfied> → <what the agent does next internally> → <user action: yes/no>`. This generalizes the existing TP pattern (step 7 above) to every gate advancement. The narration is post-acceptance only: it never appears in the same message as the Gate Transition Card, never contains the `Approval:` value, and never repeats the decision's effect. For internal steps (Brownfield Review, Brownfield Analysis), state what the agent does next and that no user action is required, without exposing `next_user_gate: none` or asking for a second approval. See the Runtime Contract §Post-Acceptance Transition Narration for the full contract.
+
+### Internal-State Collapse in the Human Card
+
+When rendering the compact human Run Status Card, collapse internal sub-states (`verified_change` sub-states, `context_graph_required_action`, `multi_scope_state`) to stable human labels. `escalated`, `open_gap` and `blocked` remain explicitly visible. The full machine/audit projection retains all raw values unchanged. See the Runtime Contract §Internal-State Collapse for the complete mapping table.
+
 ## Rules
 1. Fail closed when a required approval or artefact status is missing.
 2. The earliest blocking gate wins.
@@ -125,7 +138,7 @@ Every primary chat card shows the selected run's `UR`, `PRD`, `SD` and `TP` in t
 10. Approval of one user gate permits work on the next allowed gate artefact or required internal step only; it never skips directly to implementation.
 11. New product semantics, functional change or user-visible behaviour change requires a durable UR in `.agdf/control/` or a linked authoritative repository SoT before Brownfield Review, PRD, SD, TP, Brownfield Analysis or implementation.
 12. Approval text and durable artefact presence are separate requirements for UR, PRD, SD, TP and QA report decisions. Approval text without the corresponding persisted or linked artefact keeps the current gate at that gate.
-13. After Brownfield Review, decide the process size before drafting PRD or implementing: `quick_task | structured_slice | structured_delivery | block`.
+13. After Brownfield Review, decide the process size before drafting PRD or implementing: `quick_task | verified_change | structured_slice | structured_delivery | block`.
 14. The Mode/Slice Decision must be visible and evidenced before any Quick Task execution, PRD shortcut or implementation. A decision value without scope reason and evidence is still missing.
 15. Missing or incomplete control state must not push setup work back to the user. For a fresh request, draft the current minimal artefact in the response and request the exact approval. Initialize or write `.agdf/control/` only when durable control state is explicitly requested, already live for the repository, or required for a deterministic CLI/CI setup path. Implementation remains forbidden.
 16. Branch names, uncommitted diffs, generated summaries and chat history are not sufficient scope proof when durable artefacts or approvals are missing or conflicting.

package/generated/plugins/agdf/skills/release-or/SKILL.md

@@ -43,9 +43,10 @@ Use the Runtime Contract definition of `Relevant Run` to decide whether OR is ma
 9. End with the immediately permissible next step.
 10. `CD+Tests` is not completion.
 11. When moving a backlog item to Completed or Superseded, use the canonical human-readable table and link the final OR with a document-relative Markdown link.
-12. Keep machine status normalization in the CLI; do not write internal snake_case status values into the human-facing backlog.
-13. Reconcile Context Graph impact before clean closeout: report `context_graph_reconciliation: resolved | not_applicable | open_gap`.
-14. If Context Graph work remains unresolved, report it as an explicit open gap and do not describe the run as cleanly handoff-ready.
+12. For an executed `verified_change`, a lifecycle-consistent complete Mini-Closeout in the linked `VERIFIED_CHANGE.md` is the compact OR target; do not require a separate `OR.md` by ritual.
+13. Keep machine status normalization in the CLI; do not write internal snake_case status values into the human-facing backlog.
+14. Reconcile Context Graph impact before clean closeout: report `context_graph_reconciliation: resolved | not_applicable | open_gap`.
+15. If Context Graph work remains unresolved, report it as an explicit open gap and do not describe the run as cleanly handoff-ready.
 15. After writing or updating `MASTER_BACKLOG.md`, run `doctor --json` (or the locally available equivalent) and resolve any `AGDF_BACKLOG_STATUS_UNKNOWN` or `AGDF_BACKLOG_ARTEFACT_LABEL_UNKNOWN` finding before closeout. See the AGDF control scaffold's `MASTER_BACKLOG.md` template Rules section for the canonical status/artefact label vocabulary.
 
 ## When To Use

package/lib/control-state/run-state-parser.js

@@ -76,6 +76,24 @@ function rows(s) {
 function clean(v = "") {
   return v.replace(/^`|`$/g, "").trim();
 }
+export function parseArtefactPathCell(value = "") {
+  const raw = String(value).trim();
+  if (!raw) return { raw, path: "", format: "plain", reason: "empty" };
+  const ticks = [...raw].filter((character) => character === "`").length;
+  if (ticks === 0) return { raw, path: raw, format: "plain", reason: "none" };
+  if (ticks === 2 && raw.startsWith("`") && raw.endsWith("`")) {
+    const path = raw.slice(1, -1).trim();
+    if (path && !path.includes("`")) return { raw, path, format: "code_span", reason: "none" };
+  }
+  return {
+    raw,
+    path: "",
+    format: "invalid",
+    reason: ticks === 1 || raw.startsWith("`") !== raw.endsWith("`")
+      ? "unmatched_delimiter"
+      : "embedded_delimiter",
+  };
+}
 function meaningful(v = "") {
   return Boolean(v && !(v.startsWith("`") && v.includes("|")));
 }
@@ -96,7 +114,7 @@ function dataRows(c, h, header) {
 }
 export function parseControlState(
   content,
-  { userGates = [], internalSteps = [] } = {},
+  { userGates = [], internalSteps = [], closeoutArtefacts = [] } = {},
 ) {
   const approvals = new Map();
   for (const h of ["Approvals", "Gate Checklist"])
@@ -111,8 +129,17 @@ export function parseControlState(
     }
   const artefacts = new Map();
   for (const [t, p, s, n] of rows(section(content, "Artefacts"))) {
-    if (userGates.includes(t) || internalSteps.includes(t))
-      artefacts.set(t, { path: p ?? "", status: clean(s), notes: n ?? "" });
+    if (userGates.includes(t) || internalSteps.includes(t) || closeoutArtefacts.includes(t)) {
+      const parsedPath = parseArtefactPathCell(p ?? "");
+      artefacts.set(t, {
+        path: parsedPath.path,
+        status: clean(s),
+        notes: n ?? "",
+        raw_path: parsedPath.raw,
+        path_format: parsedPath.format,
+        path_reason: parsedPath.reason,
+      });
+    }
   }
   const mapRows = (h, header, fn) => dataRows(content, h, header).map(fn);
   const mode = section(content, "Mode/Slice Decision").trim()