create-agdf 0.20.2 → 0.30.0

package/generated/.opencode/contracts/closeout.md

@@ -65,7 +65,7 @@ An explicit Parent/programme run may project two independent evidence values:
 - `startable: true` requires at least one evidenced `Aggregate | includes | child_run:<run_id>` row
   whose Child has a completed OR;
 - `final_ready: true` additionally requires one valid declared acceptance artefact beneath
-  `.agdf/control/artefacts/`, concrete aggregation evidence and
+  the selected Run documents/evidence roles, concrete aggregation evidence and
   `programme_aggregation_missing_evidence: none`.
 
 `final_ready: true` always implies `startable: true`. Failed prerequisites stay false with explicit

package/generated/.opencode/contracts/control-scaffold.md

@@ -50,51 +50,68 @@ in the surrounding control artefact when they are relevant.
 
 ### Run-Scoped Control State
 
-Canonical mutable run state lives at `.agdf/control/runs/<run_id>/RUN_STATE.md`, one file per run.
-Repository-level discovery is derived; do not maintain a writable active-run dashboard. Select with
-`--run`, then `AGDF_RUN_ID`, or automatically only when exactly one run is active. Ambiguity fails
-closed. Legacy `AGDF_RUN.md` is migration input or an explicitly rendered non-authoritative projection,
-never a second writable owner. Read-only commands must not migrate state.
-
-`run-create` writes a sealed run. The seal covers the run state and every file listed under
-Artefacts; an unrecorded edit blocks `doctor` and `gate-check` with `AGDF_RUN_SEAL_MISMATCH`. After
-changing either, call `run-update --run <run_id> --revision <revision_id>` before `gate-check`; it
-advances the revision and refuses Approvals changes. Only `run-approve` records an approval. Both run
-on the surface-local validator. The seal detects unrecorded edits; it is not a signature.
-Keep one `Artefacts` row per type: update the existing placeholder row instead of appending another.
-`run-update` and all run writers reject duplicate rows without advancing the revision. Remove the
-extra row and retry `run-update` to record the correction. Duplicate rows in older sealed runs also
-block `doctor` and gate presentation.
-
-When a repository needs durable AGDF state, use the plugin-local `control/` scaffold as the starting point.
-
-- `config.json` stores project language preferences. Use `artifact_language` for generated AGDF artefacts. `chat_language` is the direct-command presentation default; dispatcher calls supply `presentation_language` under their current-request language contract. This presentation override never changes `artifact_language`. Runtime rules remain English. Authoring continuations supply the resolved languages and any required localized approval-summary heading before drafting.
-- `.agdf/control/runs/<run_id>/RUN_STATE.md` is the canonical current-run dashboard; legacy `AGDF_RUN.md` is migration input or an explicit non-authoritative projection.
-- `MASTER_BACKLOG.md` is the living pointer for active delivery work.
-- `BROWNFIELD_REVIEW.md` records the post-UR existing-system view and Mode/Slice Decision before PRD depth or Quick Task execution is chosen.
-- `SOT_REGISTRY.md` prevents parallel sources of truth.
-- `CONTEXT_GRAPH.md` stores durable Brownfield findings, decisions, risks, evidence and exit criteria.
-- `AGENT_QUALITY_CONTRACTS.json` stores reusable block, revise and warning conditions.
-- `memory_target`, `multi_scope_state` and branch/workspace evidence fields make ambiguity and persistence decisions visible without turning chat history into the source of truth.
-- OR reports live under `.agdf/control/artefacts/<key>/OR.md` when a run closeout is steering-relevant or should be auditable beyond the chat.
-
-### Human-readable Master Backlog
-
-The Markdown backlog is a human steering view; CLI reports are its normalized
-machine projection.
-
-- Use readable status labels such as `In progress`, `Awaiting UAT` and
-  `Completed` in Markdown.
-- Use links relative to `MASTER_BACKLOG.md`, such as
-  `[UR](artefacts/<key>/UR.md)`, instead of exposing long raw paths.
-- Keep `Priority`, `Key`, `Work item`, `Status`, `Artefacts`, `Current spec`
-  and `Next step` visible for active and planned work.
-- Keep one canonical template. Generated surface copies remain derived output.
-- Normalize human labels and link targets only at the CLI parser boundary.
-- Existing wide rows, raw paths and snake_case statuses remain supported for
-  backward compatibility.
-
-The scaffold is not a second documentation site. Link to authoritative artefacts instead of copying them.
+Canonical mutable state lives at `.agdf/control/runs/<run_id>/RUN_STATE.md`.
+Only explicit `control_layout: run-folders-v1` and Run version 4 are supported.
+Missing/old/unknown layouts or versions are unsupported, not an empty store or
+an invitation to migrate, reset or fall back. Read-only inspection preserves bytes.
+
+One Run owns `documents/`, `evidence/`, `control/presentations/` and
+`history/` below its directory. Pending operation journals live in `control/` only
+while required; source archives live in `history/revisions/<operation_id>/`.
+The creation receipt and `history/planning/UR.md` preserve handed-off planning
+provenance without an origin JSON copy. Project configuration, templates, SoT,
+curated context and target-wide multi-Run closure previews remain project-wide.
+
+Identity, objective, mode and typed records are canonical. Current gate, approval
+status, current document pointers, document relationships, evidence summaries and
+inventory derive through the existing parser/evaluator boundary. Do not persist
+parallel current tables, a generated state file, global dashboard or maintained index.
+Independent Parent/programme relations use the authored Relationships section;
+derived document bindings never become hand-editable rows.
+
+`run-create` creates a sealed unapproved Run. Current CLI aliases and fixed MCP
+groups share input normalization and captured configuration. Every original UUID
+binds its effective input. Exact replay acknowledges that original effect only;
+changed intent, stale bindings and unknown ownership fail closed. No command
+repairs arbitrary edits by resealing them. Only `approval.record` records a fresh
+deliberate exact gate reply to the frozen presentation. Local seals are cooperative
+integrity checks, not signatures or independent human identity proof.
+
+Current persisted families are Run 4, RunOperation 4, ArtefactBinding 3,
+ApprovalOperation 4, presentation 7, source proposal 3, source receipt 4,
+revision archive 2 and transaction journal 7. Existing resolved/1 wrapping and
+resolution version 1 are mandatory; captured active configuration includes the
+current layout. Unchanged record families retain their current shape. Source
+revision policy 2 preserves its existing eligibility, confirmation, invalidation
+and reassessment boundaries. Content seal domain is agdf-run-seal/2; approval
+seal domain is agdf-approval-seal/4. No old codec/default omission is accepted.
+Current optional QA-deviation and preview payloads retain their capability semantics.
+
+An ArtefactBinding contains exact source/destination and inline reviewer attestation;
+there is no separate RECORD/REVIEW JSON. Internal steps reference their canonical
+EvidenceBinding identity instead of copying report and source-set metadata.
+The writer publishes typed facts and owned output atomically. Independent Run locks,
+resource claims and exact original-operation recovery remain mandatory. Unsupported
+journals and foreign bytes never grant relocation, deletion or recovery permission.
+
+A Run ends as superseded or abandoned only through the current closure preview/apply
+owner with exact deliberate confirmation. The target-wide preview changes no Run.
+Each applied Run gets its own lifecycle receipt; its subsequent writers reject with
+lifecycle_ended. Continuing work needs a new Run. Pending repository closure conflicts
+retain the existing fail-closed boundary.
+
+Planning is UR-only under `planned/<plan_id>/UR.md`. Core inventory derives from
+planned entries and Runs. The optional Codex planning extension authors planning
+inputs through existing ur-definition; explicit source-bound handoff creates one
+unapproved Run. Core does not require that extension. See control/planned-urs.md.
+
+The normative worktree rule is owned by
+[task-target-resolution.md](task-target-resolution.md#worktree-placement-and-assigned-checkout).
+`config.json` stores project language preferences: artifact_language for authored artefacts,
+chat_language for direct presentation defaults; current explicit presentation_language
+never changes artifact_language. Runtime rules remain English.
+Keep config preferences, SoT, context and quality contracts under their existing
+project owners. No central Masterbacklog participates in reading or writing control.
 
 ## Agent-Native Runtime And CLI Verification
 
@@ -126,7 +143,7 @@ They make the repository state checkable, but they do not replace the native ski
 ## Delivery Map
 
 `delivery-map --json` is the machine-readable delivery picture for the selected canonical control state.
-It derives, but does not replace, the selected `RUN_STATE.md` and `MASTER_BACKLOG.md` state.
+It derives from the selected `RUN_STATE.md` and its registered sources. Current inventory also includes independent planned URs.
 
 It must expose:
 

package/generated/.opencode/contracts/gate-artifact-preparation.md

@@ -4,16 +4,48 @@ This contract guides the `gate-check` skill when canonical gate evaluation retur
 `control.next_operation.type: prepare_gate_artifact`. It is procedural guidance only; canonical
 Run State, gate evaluation and exact approval remain authoritative.
 
+## Typed MCP control transport
+
+When the current host lists the fixed MCP control groups, use them for every eligible control step in Quick Task, Verified Change, Structured Slice and Structured Delivery. External source edits, actual test execution and Git actions remain external work. Read agdf_inspect/operation-contract for exact schemas and agdf_inspect/authoring-inputs for the current versioned template and all exact source chunks. Follow every cursor. Do not require local template/proof discovery, hashing or a validator shell switch.
+
+For explicit first setup, read agdf_inspect/project-state with the confirmed existing Git target and no Run/revision. Only deliberate setup uses agdf_project/project.initialize with the returned target_id and one original UUID. This fixed canonical scaffold operation creates no Run/approval and never repairs/migrates/installs or grants permissions. Matching authored governance is read-only unchanged observation; conflicts/unowned partial states stay protected. After uncertainty inspect operation-status module project.initialize/<original UUID> before exact replay. Setup success returns the creation help next call. No diagnosis or creation implicitly initializes.
+
+When native MCP is unavailable, the installed CLI/validator supports read-only
+`project-state --dir ABSOLUTE_GIT_ROOT --json` and
+`operation-status --dir ABSOLUTE_GIT_ROOT --module project.initialize/ORIGINAL_UUID --json`.
+These share Core facts; optional `--language TAG` selects presentation. This CLI status route
+supports project.initialize only; existing MCP operation families are unchanged. For explicit setup,
+`agdf-project --command-file REQUEST.json` uses the exact project.initialize envelope returned by
+project-state. Preserve target, original UUID, payload and receipt; inspect original status after
+uncertainty before eligible exact replay. Read exits: 0 complete available (including pending),
+2 blocked/unavailable/incomplete, 1 usage error. Unknown/absent never proves nonexecution.
+Missing Run/document, stale revision and runtime failures retain distinct causes. Preserve deleted
+state and original identity; never recreate sources or wait blindly for a known missing path.
+
+Create independent work with agdf_run/run.create using a semantic title and one original operation UUID; observe lost responses with pre-Run operation-status for that original UUID. Never ask the human for Run/revision IDs. An unbound or incomplete inventory cannot establish assignment.
+
+Transfer UTF-8 material using agdf_record/material.stage: begin declares up to four slots and byte counts (128 KiB/file, 512 KiB/set); append supplies exact canonical base64 (no line breaks) of at most 16 KiB raw bytes at the returned offset; seal validates all bytes and returns material references/digests. Requests remain <=64 KiB. Buffers are private to the serving generation, expire after ten minutes/two idle minutes and are bounded to four sets/two MiB. They are not files or approval. Correct a rejected offset/slot/revision using the returned diagnostics; never publish protected files as a workaround. After a generation loss, restage identical semantic bytes, preserve the original mutation UUID and inspect its receipt before retrying. Reference IDs may change; semantic digests may not.
+
+Record UR/internal/evidence/route/review via step.record; replace only a registered unapproved UR with agdf_revise/ur_draft.replace. Formal artefact.record takes the material, exact gate, reviewer, explicit reviewed:true and update_draft. Follow authoring-inputs recording.mode/update_draft and current operation help: initial uses false; explicit replace_unapproved or renew_invalidated_binding uses true and fresh current source/review. draft_registered false after a source revision does not erase historical binding obligations. Effective analytical next_operation selects the actual template/format, including UX reassessment at an outer PRD gate; never substitute the gate template or require source-code lookup. Actual reviewed source mapping remains required; Core retains its reviewed relationship and proof atomically, never inventing an independent semantic review. Approved sources use the existing reviewed source_revision.preview/apply owner, including a staged EVIDENCE JSON proposal; archive/receipt retains its exact logical reference without publishing a generic caller-selected file. Preserve deliberate confirmation and original-UUID recovery.
+
+Verified Change uses verified_change.record phases eligibility/execution, the same read-only Git observations and unchanged compact evaluator. Core captures baseline/actual paths; scope escape escalates. Stage Mini-Closeout in its Verified Change slot and use closeout.record with the returned exact confirmation. Quick Task uses its existing review/evidence and OR-lite owner. No mode accepts hand edits or reseals as a control path. Presentation prepare/deliver follows interaction.md; only a new deliberate exact human reply reaches approval.record.
+
+The following local path/CLI forms remain compatibility fallback for hosts without these listed capabilities. They do not override typed MCP continuations.
+
 ## Common Route
 
-- Use only the supplied `gate`, `artifact_path`, `template_path`, `source_artifacts`, `target`,
+- With MCP use only the returned current gate/Run/revision, bound template and exact source
+  chunks from `authoring-inputs`; its template role and digest identify the version-matched owner.
+  CLI fallback uses only the supplied `gate`, `artifact_path`, `template_path`, `source_artifacts`, `target`,
   `run_id` and `revision_id`. `template_path` is the absolute canonical authoring template from the
   installed, version-matched plugin for PRD, SD, TP or QA Report preparation. Repository scaffold
   copies are derived references only. Do not rediscover or substitute a run, target, source
   artifact or template. A missing or unsafe template blocks authoring without fallback or mutation.
 - Prepare only the named current-gate artifact from the supplied approved sources.
-  Record with `run-step --step artefact --gate <PRD|SD|TP|QA>
-  --evidence .agdf/control/artefacts/<run_id>/<input.json> --run <run_id> --revision <revision_id>`.
+  With MCP use `agdf_record/artefact.record` and the bounded reviewed material above.
+  CLI fallback records with `run-step --step artefact --gate <PRD|SD|TP|QA>
+  --evidence <reviewed-material.md> --reviewer <name> --reviewed true
+  --update-draft <true|false> --run <run_id> --revision <revision_id> --operation <uuid>`.
   Do not publish a pointer and its required source relationship in separate accepted revisions.
 - After persistence, redispatch `gate-check` for the same target/run and use its fresh revision,
   gate route and approval presentation. Do not reuse this operation or ask for approval until the
@@ -22,13 +54,13 @@ Run State, gate evaluation and exact approval remain authoritative.
   dependent authoring. Use interaction.md Bounded internal recovery only for its dispatched eligible
   analytical owner; other conditions stay blocked. Never infer approval or create later-gate work.
 
-## Reviewed Recording Input (version 1)
+## Reviewed Material Recording
 
 ### Language and approval summary preparation
 
 Use the supplied `artifact_language` from `.agdf/control/config.json` for the artefact and
 the resolved `presentation_language` for user-facing text. The configured chat language is
-the direct-command default; dispatcher presentation input follows its current-request contract.
+the direct-command default; MCP may inherit a known matching configured language; a different current-request language needs an explicit presentation_language override. CLI and complete Core language remain explicit.
 Neither the request language nor English runtime/template text changes the artefact language.
 When `approval_summary_required` is true, before recording include exactly one
 `## <approval_summary_heading>` section with the supplied heading verbatim and a complete
@@ -67,49 +99,27 @@ correction stays with the existing authoring continuation, once per diagnosed co
 by canonical replacement and fresh evaluation. A ready draft still needs actual editing intent;
 status is read-only, protected sources and unrelated blockers remain stopped.
 
-Prepare files under `.agdf/control/artefacts/<run_id>/` before recording. The single shared Core
-relationship registry selects PRD-derived_from-UR, SD-derived_from-PRD, TP-derived_from-SD or
-QA_REPORT-tests-TP. UR-approved_by remains exclusively approval-owned. QA recording copies an
-existing report's explicit Decision/Status value (`pass | revise | block`); it does not decide QA.
-
-The JSON object has exactly these fields:
-
-- `schema_version`: string `1`.
-- `target_id`: existing local command-target identity, SHA-256 of `agdf-command-target/1`, NUL,
-  and the canonical real absolute governance target. This is a binding, not authority.
-- `run_id`, `expected_revision_id`: the supplied selected run and current revision.
-- `destination`: exactly `type`, `path`, `digest`, `status`; logical registry type, canonical
-  run-local `<type>.md`, full canonical SHA-256 and `draft` for PRD/SD/TP, report decision for QA.
-- `source`: exactly `type`, `path`, `digest`; the registry's approved source and canonical digest.
-- `relationship`: exactly `from`, `relationship`, `to`; the explicit registry triple.
-- `review`: exactly `reviewer`, `path`, `digest`; named reviewer, separate contained mapping file
-  and its canonical SHA-256. Do not overwrite an earlier sealed proof file.
-- `update_draft`: boolean; true only for an explicit current-gate draft update.
-
-The mapping file is JSON with exactly `schema_version`, `target_id`, `run_id`, `relationship`,
-`destination`, `source`, `reviewer`, `reviewed`. Identity and source/destination objects match
-the recording input exactly; reviewer matches review.reviewer, and reviewed is boolean true.
-Digests use the existing canonical text/line-ending semantics. This is cooperative review
-attestation, never independent proof of a human review or semantic derivation. QA/review assesses
-the meaning. A prose header or gate order is not machine proof.
-
-The existing operation checks current permission, contained non-symlink files, exact approved
-sources and revision under locks. It appends its sealed Artefact Bindings receipt/history and
-publishes pointer, relationship and audit together. The receipt is writer-owned; do not hand-author
-it. An allowed draft replacement supersedes the prior active binding, retaining history. A changed
-draft is accepted only when its prior binding reconstructs the recorded seal and every other
-bound/approved byte remains unchanged. Otherwise stop with explicit maintenance/revision recovery.
-
-Before presentation/approval, a recorded eligible current artefact must have its evidenced source
-relationship. Missing artefacts remain draftable; a relationship-only blocker must not redraft the
-artefact repeatedly. Only authorized bound continuation can attempt one exact previously sealed
-proof correction before output. The shared Core continuation service coordinates this operation
-and fresh routing; the dispatcher service itself only reads and routes. Explicit status, doctor,
-evaluation and run-present never correct.
-Unknown/malformed/foreign/stale/ambiguous proof, missing full approval integrity or unrelated
-blockers remain blocked; legacy absence grants no correction permission. A successful correction
-creates a new audited revision and fresh evaluation without another approval. Terminal output
-already emitted is never intercepted. Older runtimes have no automatic correction capability.
+Record reviewed material through `artefact.record`: `gate`, exact bounded `material`,
+`reviewer`, explicit `reviewed: true` and boolean `update_draft`. The writer derives
+PRD-derived_from-UR, SD-derived_from-PRD, TP-derived_from-SD and QA_REPORT-tests-TP
+from the existing registry and current exact approved source. UR-approved_by remains
+exclusively approval-owned. QA recording preserves the report's explicit result;
+it never decides QA. This is cooperative review attestation, not independent proof
+of human review or semantic correctness.
+
+Core publishes the canonical document under the Run documents role, its binding
+and revision atomically. Source/destination mapping and reviewer are recorded once
+in the typed binding; there are no RECORD/REVIEW JSON inputs or duplicate proofs.
+An unapproved replacement supersedes its previous binding while retaining history.
+The previous canonical bytes must still be valid before recording; stage the new
+material instead of editing a bound document. Approved sources require the current
+source-revision preview/apply owner and exact deliberate confirmation.
+
+Before presentation, an eligible recorded artefact must have the exact current
+source relationship. Missing, stale, foreign or malformed bindings remain blocked.
+Do not hand-author a receipt, repair a seal or automatically adopt unknown edits.
+Read-only status, doctor, evaluation and presentation never correct state. After
+an allowed recording, evaluate the new revision and prepare a fresh exact decision.
 
 ## Gate-Specific Work
 

package/generated/.opencode/contracts/gate-transition.md

@@ -50,7 +50,7 @@ They must not override AGDF gates, approvals or the Runtime Contract.
 - Internal mandatory steps: `Brownfield Review -> Mode/Slice Decision -> Verified Change Execution | Brownfield Analysis -> CD+Tests -> CR -> OR`
 - On the approved-TP path, `CD+Tests` and `CR` are satisfied only by `done`; `not_applicable` may satisfy Brownfield Review or Brownfield Analysis, but it must not bypass implementation/test evidence or mandatory Code Review.
 - Exact approval formula: `Approval: <GateName>`
-- Legacy alias: `Freigabe: <GateName>` may be accepted when reviewing older German runs, but all new outputs must use `Approval: <GateName>`.
+- Older approval wording and unsupported Run/receipt formats grant no current authority. Preserve their bytes; never convert, reseal or infer a current approval from them.
 - Implicit consent is not approval. Phrases such as "ok", "go ahead", "do it", "approved", "continue", "leg los" or "looks good" are work intent, not gate approval.
 - The earliest blocking gate wins.
 - For UR, PRD, SD, TP and QA, approval and durable artefact presence are separate requirements. A gate is not satisfied by approval text alone when its artefact is missing from `.agdf/control/` or not linked to the authoritative repository SoT.
@@ -63,17 +63,15 @@ They must not override AGDF gates, approvals or the Runtime Contract.
   UR first; only then may revalidation determine whether `Approval: UR` is ready. This branch is
   unreachable for `target_unresolved` and never creates a free-standing legacy live run.
 - Brownfield Review and its route may be recorded while the UR card is ready, so that card can name the next gate; this grants nothing beyond the pending `Approval: UR`.
-- `Approval: UR` permits Brownfield Review after G-00 first. The review records its Mode/Slice Decision in the same internal operation when evidence is sufficient; the user is told that no action is required now. A separate `Mode/Slice Decision` step is fail-closed recovery for incomplete or legacy review state, not a normal user decision. UR approval never permits implementation by itself and does not preselect PRD.
+- `Approval: UR` permits Brownfield Review after G-00 first. The review records its Mode/Slice Decision in the same internal operation when evidence is sufficient; the user is told that no action is required now. A separate `Mode/Slice Decision` step is fail-closed recovery for incomplete current review evidence, not a normal user decision. UR approval never permits implementation by itself and does not preselect PRD.
 - PRD, SD and TP depth is chosen after Brownfield Review through the Mode/Slice Decision, not before existing-system impact is understood.
-- The Mode/Slice Decision must be visible before any PRD shortcut, Quick Task execution or implementation: record the decision, required next gate, scope reason and evidence in the selected canonical `RUN_STATE.md` or an equivalent linked control artefact.
+- The Mode/Slice Decision must be visible before any PRD shortcut, Quick Task execution or implementation: use the typed route owner to record mode, scope reason and exact evidence in the selected Run; current and next gates are derived from its facts.
 - `Approval: PRD` permits Solution Design drafting, not implementation.
 - Before presenting a PRD approval, the PRD `Approval Decisions` table must resolve every `before_prd` product, acceptance, owner and release-scope decision and name its PRD owner. Collect related missing answers in one request. `later_sd` and `later_tp` rows may remain open only with a named owner; they cannot silently carry a product decision past PRD approval. The runtime suppresses `run-present` and `run-approve` when PRD readiness is open.
 - The `criteria-chain-v1` contract keeps PRD acceptance as the sole product source: every PRD criterion has one stable `criterion_id`; SD maps every criterion exactly once to its design, source-of-truth owner, decision and compatibility/risk treatment; TP maps every criterion and SD decision to task IDs, scenario IDs, expected results and evidence. Existing gate readiness checks suppress the SD or TP presentation when a marked artefact has incomplete or inconsistent mappings. Do not create a parallel acceptance register or copy acceptance prose downstream.
 - A clarification after approval that does not change approved scope, behavior or acceptance may be attributed as run evidence without changing the approved PRD. The no-mode `run-revise --run <run_id> --revision <revision_id>` remains the early PRD-to-SD revision path before downstream artefacts are linked. It requires a revised PRD, new `run-present` and a new deliberate `Approval: PRD`.
-- Versioned approved-source revision uses the existing `source_revision.preview` then separately confirmed `source_revision.apply` owner. Proposal schema 2 and receipt schema 3 bind `policy_version: 2`, original initiating phase, concrete source statements, exact quality/source-set/result assessment and full impact/quality digests. In an active structured Run before deliberate UAT approval, UR may reopen from PRD/SD/TP/CD+Tests/QA/pending UAT; PRD from SD/TP/CD+Tests/QA/pending UAT; SD from TP/CD+Tests/QA/pending UAT; TP from CD+Tests/QA/pending UAT. The actually approved earliest changed statement determines the source, never the phase or a keyword. Unknown or conflicting upstream intent requires clarification; pure implementation defects with unchanged sources stay under the valid TP and checks. Unapproved drafts use existing authoring/update, not approved-source revision.
+- Versioned approved-source revision uses the existing `source_revision.preview` then separately confirmed `source_revision.apply` owner. Proposal schema 3 and receipt schema 4 bind `policy_version: 2`, original initiating phase, concrete source statements, exact quality/source-set/result assessment and full impact/quality digests. In an active structured Run before deliberate UAT approval, UR may reopen from PRD/SD/TP/Brownfield Analysis/CD+Tests/QA/pending UAT; PRD from SD/TP/Brownfield Analysis/CD+Tests/QA/pending UAT; SD from TP/Brownfield Analysis/CD+Tests/QA/pending UAT; TP from Brownfield Analysis/CD+Tests/QA/pending UAT. The current receipt alone binds policy 2; older receipt/proposal alternatives are unsupported. All active writers must use the same current model. The actually approved earliest changed statement determines the source, never the phase or a keyword. Unknown or conflicting upstream intent requires clarification; pure implementation defects with unchanged sources stay under the valid TP and checks. Unapproved drafts use existing authoring/update, not approved-source revision.
 - New preview binds exact target/Run/revision/UUID, reviewed proposal, source bytes, registered quality facts and impact. Unchanged verified upstream approvals remain exact; selected and transitive downstream source approvals/bindings require renewal. Affected or unknown analytical/quality fulfillment is reassessed; UR requires fresh post-UR Review/Mode and required UX. Lower-source analytical retention requires exact current writer-owned applicability and specific rationale. Archive affected reports, approvals and presentations before atomic application under existing locks/journal; affected QA report and approval lose current authority together, and pending old UAT material is superseded. Fresh applicable checks/reviews and QA precede renewed UAT. Deliberate UAT approval, done OR, completed/closed/foreign/stale/damaged or incompatible pending state prohibits this path.
-- Legacy proposal schema 1 and source receipt schemas 1/2 keep their original predicates: active structured CD+Tests before QA/UAT, or UR at SD with approved UR/PRD and linked draft SD before downstream work. Historical verification selects the original receipt policy and archived initiating state; never widen old proof retrospectively or rewrite its bytes. Unsupported new versions reject concretely. The existing early PRD reopening boundary remains unchanged.
-- Under legacy policy 1, the same explicit preview/apply owner also supports UR revision in an active structured Run at SD with exact approved UR/PRD and a linked, reviewed draft SD, before SD approval, linked TP, implementation, reviews or closeout. Its reviewed proposal binds the current UR/PRD/SD sources, marks applicable analyses for reassessment and returns the same Run to UR. Other cases remain unsupported by legacy policy 1; expanded cases require the version 2 proposal and proof. The no-mode PRD boundary is unchanged. The canonical fixed-group MCP revision facade uses the same reviewed preview/apply owner and deliberate confirmation; it grants no gate approval.
 - Source revision apply archives the exact previous sources, mappings, presentations (including pending SD cards) and Run before its atomic commit. Append-only `Source Revisions` in the sealed Run determine invalidated bindings; archive files are historical evidence only. Old files, approvals, replies and presentations never authorize renewal. Draft and record the affected sources through their current owners, present them afresh and obtain new deliberate approvals.
 - UR revision requires fresh post-UR Review/Mode and required UX. Later source revision retains only reviewed exact applicable analytical inputs; reassessment routes existing owners before dependent source authoring. Every approved-source revision clears preparation, CD+Tests and review fulfillment; retained code/tests require fresh assessment under the renewed TP. Read-only inspection never recovers. Use explicit `--inspect`/`--recover` for the exact pending operation; a replay reports its historical effect separately from current state and grants no approval.
 - `Approval: SD` permits Task/Test Plan drafting, not implementation.
@@ -197,6 +195,7 @@ This table is the canonical transition model. Skills may reference it, but must
 | QA report is `revise` with an eligible explicit evidence-only deviation proposal and no QA acceptance | `QA` | present the exact scope, risks, consequences and follow-up; request contextual acceptance under quality.md | UAT, release and treating missing tests as passed | `Approval: QA` |
 | QA approved with report `pass`/`passed` or a current exact human deviation-acceptance receipt, UAT not approved | `UAT` | request `Approval: UAT`, carry accepted deviations and original QA result into the non-operative summary | release and automatic VCS actions | `Approval: UAT` |
 | UAT approved | `OR` | produce OR or delivery closeout; prepare VCS handoff only when requested | automatic commit, push, PR or release | none |
+| Run lifecycle `superseded` or `abandoned` | closed at its last gate | read its history; start a new run that may reference it | every run write, approval, presentation, revision, recovery and delivery continuation | none |
 
 
 ## Brownfield Modes

package/generated/.opencode/contracts/interaction.md

@@ -1,5 +1,23 @@
 # AGDF Runtime Contract — Interaction
 
+## MCP preferences and complete inputs
+
+The versioned meta/agdf-defaults.json and adjacent schema own shipped preferences; the existing
+.agdf/control/config.json is the sole project override. Explicit valid call/request > confirmed
+project > plugin applies to chat_language, artifact_language, presentation_route and gate_check_variant.
+Missing optional preferences inherit; present invalid recognized settings are actionable errors.
+Defaults never activate missing/incomplete control or write/repair configuration. Locale packs and
+contract constants retain their existing owners.
+
+MCP may omit presentation_language when the resolved preference matches the current request;
+otherwise send its explicit BCP 47 override. CLI --language and complete Core input remain explicit.
+Seven command groups may omit schema_version/assurance, and presentation.deliver may omit route.
+Only inspect gate-check inherits variant. Current native adapters still require explicit working_directory;
+omission without private trustworthy task context fails before effect. No target/process/plugin-directory guess.
+All authority/state/reply bindings remain explicit. Existing inspect/help shows effective values/source;
+no extra routine configuration call is needed. Original-operation snapshots and immutable presentations
+retain their bound values after preference changes; existing replay/recovery stays the only owner.
+
 ## Run Status Card
 
 When a run needs an operational status view, use the Run Status Card as a compact projection of existing control state.
@@ -7,7 +25,7 @@ It must not introduce a second gate model or override `gate-check`, `delivery-ma
 
 - `mode`: `quick_task | verified_change | structured_delivery | unknown`
 - `run_id`: the exactly selected canonical run
-- `presentation_language`: the resolved complete locale-pack tag; a valid unsupported requested tag resolves to the registry's deterministic `en` pack, while a missing or invalid dispatch value fails before this card exists and an incomplete or invalid registry fails closed
+- `presentation_language`: the resolved complete locale-pack tag; a valid unsupported requested tag resolves to the registry's deterministic `en` pack, while an invalid explicit value fails; omitted MCP language resolves from confirmed-project/plugin preferences before this card exists and an incomplete or invalid registry fails closed
 - `status`: `open | blocked | pass | warn | revise | block | in_progress`
 - `current_gate`: current user gate or internal step
 - `mode_slice_decision`: `undecided | quick_task | verified_change | structured_slice | structured_delivery | block`
@@ -83,7 +101,7 @@ requires fresh evaluator eligibility and carries the evaluated record scope and
 missing Git observations retain their concrete refusal. Inspect current evidence before resuming and
 perform only unfinished obligations. Applicable completed Quick Task CR or executed Verified Change
 routes `compact_closeout` to release-or: Quick Task uses existing OR-lite recording, Verified Change
-uses its linked Mini-Closeout and existing run-update boundary, never unsupported closeout.record.
+uses its linked Mini-Closeout through the current typed recording/closeout owner and exact confirmation.
 Completed Runs stay terminal. No persistent execution marker or exactly-once guarantee is added.
 
 When a bound authorized continuation corrects one missing relationship from exact previously
@@ -159,13 +177,13 @@ template:
 
 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 prepared decision is **pre-approval**; its one Markdown document contains the
+  effect and exact `Approval:` value. Historical Gate Transition Cards remain audit projections.
 - 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.
+  template, without repeating the prepared decision summary.
 - 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.
@@ -186,116 +204,15 @@ compact human card collapses internal sub-states to stable human labels:
 all raw values unchanged.
 
 
-## Gate Transition Card
-
-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 first visible line of that envelope is the localized neutral decision 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. Approval-directed titles such as `Approve solution design`
-are also invalid. The decision title appears exactly once and does not replace,
-merge or reorder either required card block.
-
-The compact approval-time Run Status Card contains exactly five operational
-fields: selected run, readiness status, current gate, a localized human-readable
-required decision and one neutral instruction to choose approve, request revision
-or decline. It does not contain the exact approval value or 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. Every ready-gate presentation renders the complete operational Run Status Card exactly once, between the compact approval-time Run Status Card and the Gate Transition Card, consumed verbatim from the code-owned status presentation; when it is undeliverable, the localized status-presentation failure line with its concrete diagnostic codes takes its place and the decision is still requested.
-The exact-approval once-only requirement applies to the compact approval-time Run Status Card and the Gate Transition Card only; the complete Run Status Card may carry the missing approval as audit data.
-
-The first scan across both cards reveals the requested decision, readiness,
-required approval, approval effect, remaining boundary and next transition.
-Identity and artefact references provide supporting context without competing
-with that sequence. Across the two cards, the exact `Approval: <GateName>` value
-appears exactly once, in the Gate Transition Card. The later native prompt or
-exact-text request may repeat it only as the required input.
-
-The canonical `interaction-presentation.js` owner builds and validates one
-immutable snapshot, then renders both complete Markdown blocks and the approval
-interaction. The public additive `approval_presentation` schema contains
-`schema_version`, selected run/revision/gate/locale identity, fixed sequence,
-both rendered blocks, canonical prompt/options/exact-text fallback and
-`authorizes: false`. It is a valid object only for a ready user gate and `null`
-otherwise. Agents and surface adapters transmit these blocks without rebuilding
-headings, fields, ordering, locale copy or Markdown.
-
-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:
-
-1. **Where am I?** A localized human-readable gate title, deterministic human
-   run title, selected `run_id` as secondary context, compact `UR · PRD · SD · TP`
-   artefact links and a clear ready-for-decision state.
-2. **What does this decision do?** The exact `Approval: <GateName>` value, its
-   concrete next outcome and the most important boundary that remains.
-3. **What happens next?** The immediate agent-controlled action and the next
-   actual user decision when one exists; otherwise a plain statement that no
-   further user action is required now.
-
-Use this compact composition:
+## Prepared decision presentation
 
-```text
-<localized gate title> · <human run title> · `<run_id>`
-<UR link or localized missing text> · <PRD link or localized missing text> · <SD link or localized missing text> · <TP link or localized missing text>
-<localized ready-for-decision line>
+Current presentation records use version 6. The existing run-presentation owner renders one immutable Markdown decision document: neutral title, one complete source-authored/localized summary, decision effect, one exact Chat decision route and supporting version/source identity. Never repeat the summary as a brief plus details, append operational cards or add another questionnaire. The separate companion string is a short location/title/version pointer without a copied summary or decision question. The document reader returns these exact prepared Markdown bytes; source artefacts remain separately available through bound authoring-input reads. Older versions retain their original envelope/snapshot/approval proof; do not regenerate historical bytes.
 
-<localized approve heading>
-`Approval: <GateName>` <localized concrete effect>. <localized remaining boundary>.
+Preparation is not display or delivery. With MCP, agdf_prepare/presentation.prepare opens no UI and returns a typed presentation.deliver continuation. Ordinary delivery immediately selects full_markdown and returns the whole prepared Markdown once. An optional agdf_decision_view opens only a labelled non-primary read-only preview of the same document. Its live view may acknowledge exact rendered bytes, current visibility, server nonce, owner epoch and independently bound current-surface identity through the scoped view channel. A model-supplied boolean, client name/version, UI advertisement or action qualification is insufficient. The current SDK adapter supplies no trustworthy current-surface identity, so it cannot claim confirmed UI delivery.
 
-<localized next heading>
-<localized immediate agent action>. <localized next user decision or no-action statement>.
-```
-
-Resolve all AGDF-owned explanatory text through the canonical Interaction
-Locale Registry. `en` and `de` are initial reviewed packs, not a closed locale
-list. A valid unsupported requested locale uses the complete English pack. Missing or invalid
-external dispatch input fails before governance evaluation; internal rendering without a
-request-specific language supplies explicit `en`. An incomplete or invalid registry fails closed.
-Gate identifiers, `run_id`, canonical paths and exact
-approval values are never translated. The visible gate title is localized;
-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 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,
-and the next block states plainly that no further user decision is required
-now. Brownfield Analysis must not be presented as a user gate.
-
-If snapshot validation or rendering fails, emit no partial card and forbid native
-invocation. Perform a fresh gate evaluation. Show only the localized exact-text
-request when the same gate remains ready and the canonical approval value is
-independently valid. Otherwise report the current non-ready reason and request no
-decision. Never patch, guess or model-reconstruct missing presentation content.
+presentation.deliver selects ui_primary only for a fresh matching live confirmation from that current surface. Chat then receives only the pointer. Otherwise it retires the probe and selects full_markdown. Selection is monotonic: late/foreign observations cannot change Markdown or restore a primary view. Replay returns historical delivery status without another summary/question. Explicit fallback first removes UI primary status/actions and retires the view, then returns the exact Markdown. Expiry, teardown, navigation and source changes invalidate view authority. Retained offline pixels cannot prove current display or reading. Readable but action-unqualified UI has disabled buttons and the exact Chat route. Display and delivery never constitute intent, approval, host qualification or release authority.
 
+The operational Run Status Card and Gate Transition Card remain deterministic read/audit projections. They are not additional blocks in the current prepared decision document. Historical format descriptions and locale fields do not require duplicating them in version 6.
 
 ## Native Interaction Contract
 
@@ -370,14 +287,12 @@ selected owner observed; it never supplies request applicability, target authori
 gate permission.
 
 Before presenting `gate_approval` for any user gate (`UR`, `PRD`, `SD`, `TP`,
-`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.
+`QA`, or `UAT`), prepare the exact selected Run/revision and deliver the single
+Markdown decision document above. Confirmed current UI receives that document
+with only its short Chat pointer; every other case receives full Markdown in Chat.
+Operational status and historical transition cards are separate read/audit views;
+never prepend them to this decision or repeat its summary or question. Optional
+native controls must preserve this same document and deliberate decision authority.
 
 ### Approval Summary Source and Completeness
 
@@ -445,7 +360,7 @@ 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. first execute `run-present --run <run_id> --gate <gate> --revision <revision_id>`; retain its presentation_id and show its exact returned text. A `presentation_required` dispatch result may already carry the same preview as `presentation.semantic_block: approval_preview` with identical `summary_digest`; the agent may show it, but asks the gate question only after `run-present` returned a `presentation_id`. This contains the complete deterministic or embedded localized summary, bound by `summary_digest`, and a clickable link to the exact durable artefact with its digest, run, gate and revision; UAT summarizes and lists its existing evidence rows. Missing or invalid summary material makes presentation unavailable and returns a targeted non-authorizing recovery. This explicit writing operation prepares a binding but never proves human visibility. Then forward the exact single decision presentation for the current surface. Show purpose, proposed change, consequences, material risks and exact document access before one approving action/formula. Keep technical identity in details. Do not append another status/transition card or approval questionnaire; ordinary discussion stays in Chat;
+3. with available MCP use agdf_prepare/presentation.prepare followed by presentation.deliver as specified above; stop after forwarding the selected text. CLI/unsupported-host fallback: first execute `run-present --run <run_id> --gate <gate> --revision <revision_id>`; retain its presentation_id and show its exact returned text. A `presentation_required` dispatch result may already carry the same preview as `presentation.semantic_block: approval_preview` with identical `summary_digest`; the agent may show it, but asks the gate question only after `run-present` returned a `presentation_id`. This contains the complete deterministic or embedded localized summary, bound by `summary_digest`, and a clickable link to the exact durable artefact with its digest, run, gate and revision; UAT summarizes and lists its existing evidence rows. Missing or invalid summary material makes presentation unavailable and returns a targeted non-authorizing recovery. This explicit writing operation prepares a binding but never proves human visibility. Then forward the exact single decision presentation for the current surface. Show purpose, proposed change, consequences, material risks and exact document access before one approving action/formula. Keep technical identity in details. Do not append another status/transition card or approval questionnaire; ordinary discussion stays in Chat;
 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;
@@ -457,6 +372,11 @@ Before presenting `gate_approval`, the agent must:
    work even when it awaits evidence, approval, or repair; it is not evidence that a previous gate was
    approved. Stop at the next decision or blocker in the same turn. Do not wait for “continue”.
 
+A run closure follows the same deliberate-reply rule without being a gate approval. Show the
+returned `run-close` or `closure.preview` text verbatim, wait for the owner's reply and apply only
+with that verbatim reply as the confirmation; the agent never supplies `Close runs: <preview_id>`
+itself, and the receipt records the same cooperative assurance as an approval.
+
 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
@@ -686,7 +606,7 @@ For one same-scope match redispatch intake_mode resume with run_id and expected_
 the inventory. The dispatcher rechecks target, active lifecycle, integrity and revision before gate
 presentation or continuation. A changed assignment returns fresh evidence for comparison; it does
 not silently adopt the newer scope or another run. Missing or invalid inventory blocks assignment
-and never becomes a no-match result. For a clear independent scope with no match use intake_mode
+and never becomes a no-match result. A new intake uses `run-<original-operation-uuid>` as its prospective ID. The current `run-create --title ... --operation <uuid>` command derives that exact ID; arbitrary named Run creation is unsupported. For a clear independent scope with no match use intake_mode
 new and an unused run_id, even when unrelated runs exist, without asking the user to select an ID
 or authorize bookkeeping again. If plausible scopes overlap, ask one focused question about the
 requested work; do not offer a technical Run-ID choice. Status and explicit run-selection requests
@@ -744,14 +664,11 @@ remains an explicit evidence gap; do not silently install, reconnect or claim co
 
 ### Bound native and remote Chat delivery
 
-The existing Core presentation owner returns one source-authored decision brief and the complete
-validated summary. Only a qualified native card actually displayed on this current request surface supports `presentation_delivery.mode: native_plus_chat`: show the native card and forward one independently decidable private Chat summary, announcing either its approval button or the exact gate formula. A capability advertisement, emitted resource, render-only card or Mac-only display does not prove current or iPad visibility. Unconfirmed/unsupported surface receives the complete `full_chat` decision once, with no invisible-button instructions. Later optional native opening uses the same presentation; it creates no second request or authority. Never append
-another approval questionnaire, status card or technical transition dump to this decision moment.
-Rendering support, App-action qualification and current business eligibility remain separate.
+Use the version-6 prepared decision delivery contract above. Rendering support, observed current-surface display, primary delivery, action qualification, current eligibility and human intent are separate states. Never infer an opened current card from capability or qualification, or copy the full summary into its Chat pointer.
 
 When the human asks “Dokument lesen” / “Read document”, use existing `agdf_inspect` operation
 `presentation-document` with the returned target/Run/gate/revision/presentation binding. Deliver
-the exact original-language bytes as complete ordered chunks, following every `next_cursor` and
+the exact prepared Markdown bytes as complete ordered chunks, following every `next_cursor` and
 showing completeness and version provenance. Do not replace it with the current filesystem file,
 a paraphrase or a Mac-only link. Discussing or reading never decides. If exact remote material or
 synchronized Chat access is unavailable, explain that limitation and do not invite blind approval.