create-agdf 0.20.1 → 0.20.2

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-command-contract.js

@@ -1,7 +1,7 @@
 import { UR_AUTHORING_FORMAT } from '../control-evaluation/ur-readiness.js';
 import { PRD_DECISION_FORMAT } from '../control-evaluation/prd-readiness.js';
 import { SD_DECISION_FORMAT } from '../control-evaluation/sd-readiness.js';
-import { DIGEST_PATTERN, canonicalJson, digest } from './approval-command-contract.js';
+import { DIGEST_PATTERN, COOPERATIVE_ASSURANCE, canonicalJson, digest } from './approval-command-contract.js';
 import { RUN_ID_PATTERN, REVISION_ID_PATTERN, APPROVAL_GATES } from './run-identity.js';
 import { TASK_TARGET_SOURCES } from '../task-target-resolution.js';
 import { PRESENTATION_LANGUAGE_TAG_PATTERN_SOURCE } from '../interaction-presentation.js';
@@ -73,14 +73,128 @@ function payloadSchema(group, kind) {
     original_kind: enumeration(Object.keys(recoveryGroups).filter(original => recoveryGroups[original] === group)) })
     : RUN_COMMAND_DESCRIPTORS[kind].payload_schema;
 }
+// Canonical help is shared by expanded Core validation and operation help.
+const fieldHelp = Object.freeze({
+  schema_version: 'Contract version 1.',
+  presentation_language: 'Response BCP 47 language, e.g. de.',
+  working_directory: 'Absolute task directory for target resolution.',
+  target_source: 'Human task basis for this target; cwd alone is not authority.',
+  primary_target: 'Confirmed absolute target from resolution.',
+  target_id: 'Exact hash from current MCP target inspection; never guess.',
+  run_id: 'Scope-matching Run from inspection; recency is not authority.',
+  expected_revision_id: 'Current inspected revision; recovery retains original binding.',
+  operation_id: 'New command UUID; after handoff reuse original UUID/exact payload.',
+  assurance: 'Cooperative intent, not human proof or approval.',
+  command: 'Kind/payload; nested help: operation-contract.',
+  path: 'Contained Run-local source path; read the actual file before recording.',
+  digest: 'Canonical SHA-256 of the exact source bytes; never guess or reseal unrelated edits.',
+  gate: 'Exact gate named by current control, not permission to advance it.',
+  presentation_id: 'Immutable current presentation id from MCP inspection or preparation.',
+  response: 'Forward the new deliberate human reply for this exact presentation.',
+  confirmation: 'Exact concrete confirmation required by this operation contract.',
+  source_gate: 'Earliest actually changed approved source, determined from the reviewed proposal.',
+  preview_digest: 'Exact preview digest returned for the same reviewed proposal and binding.',
+  recovery_revision_id: 'Revision allowed by the original pending operation recovery contract.',
+  pending_digest: 'Exact pending operation digest from authoritative operation-status.',
+  original_kind: 'Original operation kind in this fixed permission group; preserve its identity.',
+});
+function describeFields(schema) {
+  const value = { ...schema };
+  if (value.properties) value.properties = Object.fromEntries(Object.entries(value.properties).map(([key, child]) =>
+    [key, { ...describeFields(child), ...(fieldHelp[key] ? { description: fieldHelp[key] } : {}) }]));
+  for (const key of ['oneOf', 'anyOf', 'allOf']) if (value[key]) value[key] = value[key].map(describeFields);
+  return value;
+}
+function commandSchema(group) {
+  return { oneOf: RUN_COMMAND_GROUPS[group].map(kind => strictObject({ kind: { const: kind },
+    payload: { ...payloadSchema(group, kind), description: RUN_COMMAND_DESCRIPTORS[kind].effects.join('; ') } })) };
+}
 export function commandGroupSchema(group) {
-  const kinds = RUN_COMMAND_GROUPS[group]; if (!kinds) throw Error('command_group_unsupported');
-  return strictObject({ ...envelope, command: { oneOf: kinds.map(kind => strictObject({ kind: { const: kind }, payload: payloadSchema(group, kind) })) } });
+  if (!RUN_COMMAND_GROUPS[group]) throw Error('command_group_unsupported');
+  return describeFields(strictObject({ ...envelope, command: commandSchema(group) }));
+}
+// Repeated immutable schema nodes become deterministic local references. Only
+// schema positions are traversed: a properties map is never itself a schema.
+export function compactCommandSchema(expanded) {
+  const visit = (node, transform, depth = 0) => {
+    const copy = { ...node };
+    if (copy.properties) copy.properties = Object.fromEntries(Object.entries(copy.properties).map(([key, child]) =>
+      [key, visit(child, transform, depth + 1)]));
+    for (const key of ['oneOf', 'anyOf', 'allOf']) if (copy[key]) copy[key] = copy[key].map(child => visit(child, transform, depth + 1));
+    if (copy.items) copy.items = visit(copy.items, transform, depth + 1);
+    return transform(copy, depth);
+  };
+  // Discovery keeps direct envelope and per-operation payload meaning; nested
+  // field detail remains in the expanded operation-contract from this owner.
+  const discovery = visit(expanded, (node, depth) => {
+    if (depth > 1) delete node.description;
+    return node;
+  });
+  // Restore every payload's concise meaning explicitly, without phrase policy.
+  discovery.properties.command.oneOf.forEach((row, i) => { row.properties.payload.description = expanded.properties.command.oneOf[i].properties.payload.description; });
+  const counts = new Map();
+  visit(discovery, node => { const { description, ...base } = node; const key = JSON.stringify(base); counts.set(key, (counts.get(key) ?? 0) + 1); return node; });
+  const definitions = {}, names = new Map();
+  const factor = (node, depth = 0, defining = false) => {
+    const { description, ...base } = node;
+    const key = JSON.stringify(base);
+    if (!defining && depth > 0 && (counts.get(key) ?? 0) > 1 && key.length >= 48) {
+      if (!names.has(key)) {
+        const name = `s${names.size}`; names.set(key, name);
+        definitions[name] = factor(base, depth, true);
+      }
+      return { $ref: `#/$defs/${names.get(key)}`, ...(description ? { description } : {}) };
+    }
+    const copy = { ...node };
+    if (copy.properties) copy.properties = Object.fromEntries(Object.entries(copy.properties).map(([name, child]) => [name, factor(child, depth + 1)]));
+    for (const name of ['oneOf', 'anyOf', 'allOf']) if (copy[name]) copy[name] = copy[name].map(child => factor(child, depth + 1));
+    if (copy.items) copy.items = factor(copy.items, depth + 1);
+    return copy;
+  };
+  const projected = factor(discovery);
+  if (names.size) projected.$defs = definitions;
+  return projected;
 }
+const openObject = { type: 'object', additionalProperties: true };
+const nullableObject = { ...openObject, type: ['object', 'null'] };
+const nullableString = { type: ['string', 'null'] };
+const resultProperties = {
+  schema_version: { const: '1' }, outcome: enumeration(['accepted', 'already_applied', 'rejected', 'recovery_required', 'effect_unknown']), authorizes: { const: false },
+  reason: { ...nullableString, minLength: 1 }, operation_id: { ...identity, type: ['string', 'null'] }, request_digest: { ...hash, type: ['string', 'null'] },
+  binding: { ...nullableObject, properties: { target_id: hash, run_id: envelope.run_id, expected_revision_id: identity, kind: string() }, required: ['target_id', 'run_id', 'expected_revision_id', 'kind'] },
+  receipt: nullableObject, effect: nullableObject,
+  current: { ...nullableObject, properties: { available: { type: 'boolean' }, revision: { type: 'integer' }, revision_id: identity }, required: ['available'] },
+  assurance: { ...openObject, properties: Object.fromEntries(Object.entries(COOPERATIVE_ASSURANCE).map(([key, value]) => [key, { const: value }])), required: Object.keys(COOPERATIVE_ASSURANCE) }, family_result: openObject,
+  historical_effect: { type: 'boolean' }, dispatch: enumeration(['not_dispatched', 'unknown']), recovery: nullableString,
+  diagnostics: { type: 'array', items: openObject },
+  presentation_delivery: { ...openObject, properties: { mode: enumeration(['native_plus_chat', 'full_chat']), display: enumeration(['confirmed', 'unconfirmed']),
+    text: { type: 'string' }, presentation_id: identity, revision_id: identity, document_digest: hash, document_language: nullableString, authorizes: { const: false } },
+    required: ['mode', 'display', 'text', 'presentation_id', 'revision_id', 'document_digest', 'document_language', 'authorizes'] },
+  app_capability: { type: 'string' }, app_reason: { type: 'string' }, app_display: { type: 'string' },
+};
+const resultVariants = [
+  { properties: { outcome: enumeration(['accepted', 'already_applied']), operation_id: { type: 'string' }, request_digest: { type: 'string' }, binding: { type: 'object' }, current: { type: 'object' } }, required: ['operation_id', 'request_digest', 'binding', 'receipt', 'effect', 'current', 'assurance', 'historical_effect', 'recovery', 'reason', 'family_result'] },
+  { properties: { outcome: enumeration(['rejected', 'recovery_required', 'effect_unknown']), reason: { type: 'string', minLength: 1 } }, required: ['reason'] },
+];
+export const RUN_COMMAND_RESULT_SCHEMA = freeze({ type: 'object', additionalProperties: true, properties: resultProperties,
+  required: ['schema_version', 'outcome', 'authorizes'], oneOf: resultVariants,
+  allOf: [{ oneOf: [
+    { properties: { outcome: enumeration(['accepted', 'already_applied', 'rejected']) } },
+    { properties: { outcome: enumeration(['recovery_required', 'effect_unknown']), recovery: { type: 'string', minLength: 1 } }, required: ['operation_id', 'recovery'] },
+  ] }] });
+// Essential envelope projection from the full model, not a second result owner.
+export function commandResultSchema() {
+  const keys = ['schema_version', 'outcome', 'authorizes', 'reason', 'operation_id', 'binding', 'receipt', 'recovery'];
+  const properties = Object.fromEntries(keys.map(key => [key, key === 'binding' ? { type: resultProperties.binding.type } : key === 'outcome' ? { type: 'string' } : resultProperties[key]]));
+  return { type: 'object', properties, required: RUN_COMMAND_RESULT_SCHEMA.required,
+    oneOf: resultVariants.map(variant => ({ ...variant, properties: Object.fromEntries(Object.entries(variant.properties).filter(([key]) => keys.includes(key))), required: variant.required.filter(key => keys.includes(key)) })) };
+}
+export function validateRunCommandResult(value) { return schemaDiagnostics(value, RUN_COMMAND_RESULT_SCHEMA); }
 export function commandGroupDefinition(group) {
   const definition = { name: group,
-    description: `${group}: ${RUN_COMMAND_GROUPS[group]?.join(', ')}. Exact target/Run/revision/UUID required. Cooperative caller intent only; tool permission never approves a gate. Inspect operation-contract before use; retry original UUID via operation-status after uncertainty. No VCS.`,
-    annotations: { readOnlyHint: false, destructiveHint: group !== 'agdf_prepare', idempotentHint: false, openWorldHint: false }, inputSchema: commandGroupSchema(group) };
+    description: `${group}: ${RUN_COMMAND_GROUPS[group]?.join(', ')}. Inspect operation-contract for payloads/bindings. Cooperative intent never approves a gate. After uncertainty inspect operation-status with original UUID/payload. No VCS.`,
+    annotations: { readOnlyHint: false, destructiveHint: group !== 'agdf_prepare', idempotentHint: false, openWorldHint: false },
+    inputSchema: compactCommandSchema(commandGroupSchema(group)), outputSchema: commandResultSchema() };
   if (Buffer.byteLength(JSON.stringify(definition)) > RUN_COMMAND_LIMITS.definition_bytes) throw Error('command_definition_budget_exceeded');
   return freeze(definition);
 }
@@ -88,14 +202,31 @@ export function commandGroupDefinition(group) {
 // No caller validator, accessor execution, coercion or default-expanded effect is allowed.
 export function schemaDiagnostics(value, schema, path = '$') {
   const errors = [];
-  if (schema.oneOf) return schema.oneOf.filter(choice => schemaDiagnostics(value, choice, path).length === 0).length === 1 ? [] : [{ path, code: 'one_of_invalid' }];
+  if (schema.oneOf && schema.oneOf.filter(choice => schemaDiagnostics(value, choice, path).length === 0).length !== 1) errors.push({ path, code: 'one_of_invalid' });
+  if (schema.allOf) for (const choice of schema.allOf) errors.push(...schemaDiagnostics(value, choice, path));
+  if (Array.isArray(schema.type)) {
+    const matches = schema.type.map(type => schemaDiagnostics(value, { ...schema, type }, path));
+    return matches.some(result => result.length === 0) ? errors : [...errors, { path, code: 'type_invalid' }];
+  }
+  if (schema.type === 'null' && value !== null) errors.push({ path, code: 'null_required' });
+  if (schema.type === 'integer' && !Number.isInteger(value)) errors.push({ path, code: 'integer_required' });
+  if (schema.type === 'boolean' && typeof value !== 'boolean') errors.push({ path, code: 'boolean_required' });
+  if (schema.type === 'array') {
+    if (!Array.isArray(value)) return [...errors, { path, code: 'array_required' }];
+    for (let i = 0; i < value.length; i++) {
+      const field = Object.getOwnPropertyDescriptor(value, String(i));
+      if (!field || !Object.hasOwn(field, 'value')) errors.push({ path, code: 'accessor_forbidden' });
+      else if (schema.items) errors.push(...schemaDiagnostics(field.value, schema.items, `${path}[${i}]`));
+    }
+  }
   if (Object.hasOwn(schema, 'const') && value !== schema.const) errors.push({ path, code: 'constant_invalid' });
   if (schema.enum && !schema.enum.includes(value)) errors.push({ path, code: 'enum_invalid' });
-  if (schema.type === 'object') {
+  if (schema.type === 'object' || !schema.type && (schema.properties || schema.required) && value !== null && typeof value === 'object' && !Array.isArray(value)) {
     if (value === null || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return [{ path, code: 'object_required' }];
     const keys = Reflect.ownKeys(value);
     for (const key of keys) {
-      if (typeof key !== 'string' || !Object.hasOwn(schema.properties, key)) { errors.push({ path, code: 'unknown_field' }); continue; }
+      if (typeof key !== 'string') { errors.push({ path, code: 'unknown_field' }); continue; }
+      if (!Object.hasOwn(schema.properties ?? {}, key)) { if (schema.additionalProperties === false) errors.push({ path, code: 'unknown_field' }); continue; }
       const property = Object.getOwnPropertyDescriptor(value, key);
       if (!Object.hasOwn(property, 'value')) { errors.push({ path: `${path}.${key}`, code: 'accessor_forbidden' }); continue; }
       errors.push(...schemaDiagnostics(property.value, schema.properties[key], `${path}.${key}`));
@@ -122,7 +253,7 @@ export const runCommandRequestDigest = input => digest(`agdf-run-command/1\0${ca
 export function operationContract(group, kind, { gate } = {}) {
   if (!RUN_COMMAND_GROUPS[group]?.includes(kind)) return { available: false, reason: 'command_group_unsupported' };
   return { schema_version: RUN_COMMAND_VERSION, available: true, group, kind, ...RUN_COMMAND_DESCRIPTORS[kind], payload_schema: payloadSchema(group, kind),
-    schema: strictObject({ ...envelope, command: strictObject({ kind: { const: kind }, payload: payloadSchema(group, kind) }) }), retry_class: 'inspect_original_operation_after_dispatch', assurance: 'cooperative_local',
+    schema: describeFields(strictObject({ ...envelope, command: strictObject({ kind: { const: kind }, payload: { ...payloadSchema(group, kind), description: RUN_COMMAND_DESCRIPTORS[kind].effects.join('; ') } }) })), result_schema: RUN_COMMAND_RESULT_SCHEMA, retry_class: 'inspect_original_operation_after_dispatch', assurance: 'cooperative_local',
     reference_limits: { input_bytes: RUN_COMMAND_LIMITS.input_bytes, source_file_bytes: 131072, result_bytes: RUN_COMMAND_LIMITS.result_bytes },
     internal_result_formats: kind === 'step.record' ? { 'UX Intent Definition': UX_DECISION_FORMAT,
       reviews: { declaration: '- decision: pass | revise | block | not_applicable', result_scope: 'actual current owner report; no generated judgement or approval' } } : undefined,

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-presentation-render.js

@@ -431,8 +431,8 @@ export function renderReviewableApproval(root, report, { runId, gate, revisionId
     german ? 'Antworte „Dokument lesen“, um diese Fassung vollständig im Chat zu lesen. Fragen und Änderungswünsche kannst du hier besprechen. Ohne deine Freigabe bleibt dieser Schritt offen.'
       : 'Reply “Read document” to read this complete version in Chat. Discuss questions and requested changes here. This step remains open until you approve.',
     pack.decisionCard.chatApprovalHint.replace('{gate}', gate),
-    `<details><summary>${german ? 'Details und Nachweise' : 'Details and evidence'}</summary>\n\n${summaryMarkdown}\n\n</details>`,
-    `<details><summary>${german ? 'Fassung und Quellen' : 'Version and sources'}</summary>\n\nRun: \`${runId}\` · ${pack.gateTitles[gate]} · Revision: \`${revisionId}\`\n\nSHA-256: \`${artefactDigest}\`\n\n</details>`];
+    `### ${german ? 'Details und Nachweise' : 'Details and evidence'}\n\n${summaryMarkdown}`,
+    `### ${german ? 'Fassung und Quellen' : 'Version and sources'}\n\nRun: \`${runId}\` · ${pack.gateTitles[gate]} · Revision: \`${revisionId}\`\n\nSHA-256: \`${artefactDigest}\``];
   return parts.every((part) => typeof part === "string" && part.trim())
     ? { markdown: parts.join("\n\n"), companion_markdown: [german
           ? `Die AGDF-Karte ist geöffnet. Du kannst dort „${qaAcceptance?.approve_label || 'Freigeben'}“ klicken oder hier \`Approval: ${gate}\` eingeben. Beide Wege entscheiden dieselbe vorgelegte Fassung einmal.`

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

@@ -409,7 +409,7 @@ function markdownCell(value) {
     .replaceAll("&", "&")
     .replaceAll("<", "&lt;")
     .replaceAll(">", "&gt;")
-    .replace(/\r?\n/g, "<br>");
+    .replace(/\r\n?|\n/g, " · ");
 }
 
 function localizedOperationalValue(value, pack, fallbackPack, fallbackLocale) {

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

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "c730aaa7e69a8c56e836bb01970854cab6ae480496733bb111fcd00f148ad4b0"
+  "digest": "c5e31f9ebf057b4fd18244e276f2262fe0fa6bc40d120ace72d69bdf421a41d1"
 }

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

@@ -59,6 +59,8 @@ Clean-review-specific output must make the primary solution, fallbacks, workarou
 Applicable findings must use `../../meta/contracts/quality.md` §Normalized Review Gaps. This skill
 must distinguish a missing upstream decision from implementation that violates an approved decision.
 
+Apply quality.md Proportionate Tests And Evidence and Verification Effectiveness And Completion when assessing reuse and parallel structures. Reject unnecessary duplicated proof and status-only finding closure; shared evidence preserves this review responsibility.
+
 ## Rules
 1. Clean primary solution before fallback.
 2. Root cause before symptom masking.

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

@@ -58,6 +58,8 @@ Code-review-specific output must make actual findings, missing review scope, evi
 Applicable findings must use `../../meta/contracts/quality.md` §Normalized Review Gaps. Concrete diff
 defects remain Code Review findings; missing upstream constraints route to their authoritative owner.
 
+Apply quality.md Proportionate Tests And Evidence and Verification Effectiveness And Completion to actual changed behavior: check requirement-derived expectations, meaningful defect detection and targeted re-verification of findings, including relevant side effects or justified alternatives.
+
 ## Rules
 1. Review the actual diff and impacted code, not intent alone.
 2. Findings require concrete evidence.

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

@@ -74,12 +74,11 @@ evidence into `pass`, or claim native qualification. Only a deliberate human dec
 new exact presentation can accept deviations through the existing approval owner. The technical
 QA result and open findings remain unchanged and accompany UAT and OR.
 
-When post-CD+Tests review evidence exists, present the Runtime Contract's derived Quality
-Readiness projection before the detailed QA report: Plan coverage, Solution integrity, Code
-quality and QA decision in that order. Name `qa-gate` as the sole decision owner, show one
-decisive reason and one permissible next action, and keep detailed reports as evidence links or
-on-demand detail. The projection is non-authorizing and must not replace the Run Status Card,
-Gate Transition Card or the durable QA report.
+For routine technical pass, use quality.md Quality Readiness Projection's concise result
+and report reference. At revise/block show its four dimensions in the canonical order,
+with the decisive source/reason and next permissible action. Explicit detail/status
+requests may show the full overview even at pass. This derived, non-authorizing output
+never replaces durable reports, complete gate material or deliberate human decisions.
 
 ## Resolved Target Run And Evidence Discovery
 
@@ -107,6 +106,8 @@ QA owns the Quality Readiness and QA decision only. It must not reconstruct or p
 Card, Gate Transition Card, native QA card or interactive QA card. Operational run status and gate
 approval orientation remain owned by gate-check and the Interaction Contract.
 
+Apply quality.md Proportionate Tests And Evidence and Verification Effectiveness And Completion. Assess evidence applicability and targeted finding re-verification; sufficient checking ends redundant collection, never required reviews or approvals. Missing proof and accepted deviations retain their original technical effect.
+
 ## Rules
 1. No QA pass without strong evidence.
 2. TP is the reference, not merely working code.
@@ -183,9 +184,9 @@ If Context Graph impact is relevant, include the fields from `../../meta/contrac
 
 ### Compact Chat Output
 
-At `pass`: one line — `QA: pass — <one-line summary>`. Reference the durable QA report
-path. Do not show the Quality Readiness projection or evidence inventory in chat.
-At `revise`/`block`: show the decisive dimension, reason and next action.
+Follow quality.md Quality Readiness Projection: routine `pass` is one concise line
+with the durable report reference; explicit detail requests may show the overview.
+At `revise`/`block`, show its four dimensions and the decisive source/reason/next action.
 
 ## Decision Guidance
 - `pass`: required TP tasks are done, evidence is strong, no blocking Brownfield or solution-integrity risk remains.

package/generated/plugins/agdf/skills/sd-definition/SKILL.md

@@ -8,7 +8,8 @@ description: "Use this skill for this scope: bound SD content. Boundary: content
 ## Runtime Contract
 
 Use the returned `continuation.runtime_contracts` after `skill_continuation`. If absent, load
-`../../meta/contracts/sd-definition.md` and `../../meta/contracts/gate-artifact-preparation.md`
+`../../meta/contracts/sd-definition.md`, `../../meta/contracts/gate-artifact-preparation.md`
+and `../../meta/contracts/quality.md`
 through the supplied contract reader or bundled files.
 Missing contract or invalid binding: stop. This skill owns SD content; gate-check owns readiness.
 

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

@@ -62,6 +62,8 @@ If `context_graph_required_action` is not `none`, the affected task is complete
 Applicable review gaps must use `../../meta/contracts/quality.md` §Normalized Review Gaps. This skill
 must not maintain its own type-to-route mapping.
 
+Verify scoped coverage, reuse applicability and remaining obligations under quality.md Proportionate Tests And Evidence and Verification Effectiveness And Completion. Reuse valid results without replacing this review assessment; a later gate alone requires no recollection.
+
 ## Rules
 1. The Task Plan is the reference, not plausible code.
 2. No assumptions without evidence.

package/generated/plugins/agdf/skills/tp-definition/SKILL.md

@@ -8,7 +8,8 @@ description: "Use this skill for this scope: bound TP content. Boundary: content
 ## Runtime Contract
 
 Use the returned `continuation.runtime_contracts` after `skill_continuation`. If absent, load
-`../../meta/contracts/tp-definition.md` and `../../meta/contracts/gate-artifact-preparation.md`
+`../../meta/contracts/tp-definition.md`, `../../meta/contracts/gate-artifact-preparation.md`
+and `../../meta/contracts/quality.md`
 through the supplied contract reader or bundled files.
 Missing contract or invalid binding: stop. This skill owns TP content; gate-check owns readiness.
 

package/generated/plugins/agdf/submission/openai/availability.md

@@ -1,6 +1,6 @@
 # Availability Decision Record
 
-- release: `0.20.1`
+- release: `0.20.2`
 - decision_state: `pending`
 - decision_owner: verified publisher
 - countries: not selected

package/generated/plugins/agdf/submission/openai/capability-matrix.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.20.1",
+  "releaseVersion": "0.20.2",
   "evidenceStates": [
     "common",
     "codex-specific",

package/generated/plugins/agdf/submission/openai/release-notes.md

@@ -1,4 +1,4 @@
-# AGDF 0.20.1 — Initial OpenAI Public Plugin Candidate
+# AGDF 0.20.2 — Initial OpenAI Public Plugin Candidate
 
 This candidate packages the canonical AGDF workflow skills for public discovery in ChatGPT and
 Codex. It helps users assess delivery fit, preserve explicit human approvals, inspect existing-system

package/generated/plugins/agdf/submission/openai/reviewer-cases.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.20.1",
+  "releaseVersion": "0.20.2",
   "cases": [
     {
       "id": "positive-proportional-fit",