create-agdf 0.14.5 → 0.20.0

package/generated/submissions/openai/agdf/meta/contracts/task-target-resolution.md

@@ -2,19 +2,71 @@
 
 ## Purpose And Ordering
 
-Resolve the user's primary work target before repository activation, Scope Classification, mode
-selection or gate evaluation. Repository governance is downstream of the task target; the current
-working directory, an inspected repository or a source mentioned as evidence must never become the
-work target by accident.
+After positive Request Activation, resolve the user's primary work target before repository
+activation, Scope Classification, mode selection or gate evaluation for routes that require a
+target. Repository governance is downstream of the task target; the current working directory, an
+inspected repository or a source mentioned as evidence must never become the work target by
+accident. Silent Request Activation abstention and targetless catalog routes do not invoke this
+contract.
 
-The canonical order is:
+The canonical order after Request Activation selected a target-bound route is:
 
 1. resolve or revalidate the task target;
 2. derive the governance target from that resolved target;
 3. activate repository-local AGDF control only for that governance target;
 4. then apply read-only orientation, Scope Classification, mode selection and gate evaluation.
 
-If task-target resolution is unresolved, steps 2–4 and every mutation are forbidden.
+If task-target resolution is unresolved, steps 2–4 and every mutation are forbidden. The unresolved
+result is terminal for the current response and overrides continuation, missing-control, fresh-UR
+and approval branches. Prior chat artefacts, runs and approvals remain candidate context only; they
+must not produce a conditional gate result until one target is resolved.
+
+## Direct Skill Invocation Preflight
+
+After the already-loaded Request Activation guard has positively selected a direct, target-bound
+skill route, every canonical AGDF skill invocation starts with this preflight before skill-specific
+input discovery, repository inspection, run selection, gate evaluation, quality evaluation or
+mutation. This applies equally when a user invokes a skill explicitly and when the agent router
+selected it. Automatic selection alone is not positive activation; on silent abstention this
+preflight is not run.
+
+1. Determine the current conversation language for presentation. A German user turn or an ongoing
+   German conversation uses `de`; an unsupported language falls back to the complete English locale
+   pack through the Interaction Contract.
+2. Resolve or revalidate the primary target under Target Authority Precedence. When an exact-version
+   surface-local validator is available, use one of the existing `target-check --json` forms below.
+3. Validate the normalized Resolution Result. Do not infer missing fields from cwd, chat storage,
+   an inspected repository, a prior run or evidence sources.
+4. If `resolution_state` is `unresolved`, consume `task_target_orientation.markdown` verbatim from
+   the Interaction Contract, request only the normalized `next_action` in the same presentation
+   language and stop the current skill invocation. This is a terminal pre-decision outcome: do not
+   inspect repository control state, select a run, evaluate a gate or quality decision, produce the
+   skill's normal output, or mutate files.
+5. If `resolution_state` is `resolved`, use only its `governance_target` for downstream repository,
+   run, gate and evidence access. Revalidate after an explicit target change and before every
+   mutation or gate decision.
+
+The resolved `presentation_language` remains binding for the complete user-facing interaction:
+target orientation, clarification and subsequent skill-owned chat output must not mix locale packs.
+Durable artefacts, machine fields, task identifiers and exact approval values retain their canonical
+language as defined by the Interaction Contract.
+
+Context-only form when no reliable target is selected:
+
+```bash
+node <surface-local-agdf> target-check --json --language <current-chat-language> --working-directory <absolute-path>
+```
+
+Selected-target form:
+
+```bash
+node <surface-local-agdf> target-check --json --language <current-chat-language> --target-source <explicit_target|continued_target|current_repository> --primary-target <absolute-path> --working-directory <absolute-path>
+```
+
+The two forms are validation paths, not permission to invent a target or contact a registry. If no
+exact-version surface-local validator exists, continue agent-natively only as far as the observable
+evidence permits and report machine validation as unavailable. Do not install or resolve a remote
+runtime during ordinary skill invocation.
 
 ## Resolution Result
 
@@ -22,17 +74,19 @@ Use one normalized result:
 
 - `resolution_state`: `resolved | unresolved`
 - `reason_code`: `explicit_target | continued_target | multiple_plausible_targets |
-  target_content_mismatch | target_unavailable | no_reliable_target`
+  target_content_mismatch | target_unavailable | no_reliable_target | target_source_invalid`
 - `primary_target`: exactly one requested work object when resolved, otherwise empty
 - `evidence_sources`: zero or more mentioned or inspected sources that do not gain mutation authority
 - `working_directory`: execution context only, never target authority by itself
 - `governance_target`: the repository whose control state applies to the primary target, otherwise empty
 - `target_changed`: whether an explicit new target replaced the previously confirmed target
 - `next_action`: required clarification, supply or retry action when unresolved
+- `input_error`: present only for invalid target-selection input; contains the canonical `field` and
+  `allowed_values` without echoing the rejected value
 
 A resolved result requires a non-empty `primary_target` and a reason code of `explicit_target` or
 `continued_target`. An unresolved result requires an empty `primary_target`, an empty
-`governance_target`, one of the four unresolved reason codes and a non-empty `next_action`.
+`governance_target`, one of the five unresolved reason codes and a non-empty `next_action`.
 Contradictory or incomplete results fail closed.
 
 ## Target Authority Precedence
@@ -94,7 +148,7 @@ Never silently expand scope to make the request fit a different project.
 ## Presentation Boundary
 
 `contracts/interaction.md` owns the visible, non-authorizing Task Target Orientation.
-`create-agdf/lib/interaction-presentation.js` owns its rendering. The renderer projects a normalized
+`packages/core/lib/interaction-presentation.js` owns its rendering. The renderer projects a normalized
 result; it must not resolve targets, derive governance or become a state store.
 
 Show orientation when target/context separation is material, when the target changes, or when the

package/generated/submissions/openai/agdf/meta/contracts/tp-definition.md

@@ -0,0 +1,81 @@
+# AGDF Runtime Contract — TP Definition
+
+Use only a bound skill_continuation with phase tp_definition. This is the semantic Task/Test
+Plan author, never a gate, writer, approval or implementation authority.
+
+## Binding and content
+
+Use the returned target/run/revision, destination, exact approved PRD/SD and analytical sources,
+resolved languages and installed plugin-owned template_path. Missing/unsafe templates stop before
+writing; repository scaffold copies are no fallback. Unbound invocation uses the existing scope
+inventory, then revision-bound gate-check intake. Ambient runs, cwd, selection and discovery grant
+no assignment or editing intent. Keep approved sources and foreign runs protected.
+
+Preserve criteria-chain-v1, stable task/scenario IDs and the existing TP template. Map every PRD
+criterion and associated SD decision to tasks, dependencies, boundary/error scenarios, observable
+expected results and exact evidence sources. Reference acceptance IDs; never copy or rename their
+authority. Test Plan gives each applicable scenario test_route, environment,
+prerequisites_permissions, owner, expected_evidence and unavailable_action. Missing access remains
+an explicit gap with a concrete next action, never a result or consent to acquire access.
+
+Declare Planning Decisions contract: tp-decisions-v1 and one Planning Decisions table with columns
+Decision | Source | Status | Resolution | Owner. Source is TP or SD: followed by an exact approved
+SD later_tp decision label. Cover each such source once; use unique decisions and named owners.
+Status is resolved/open; every open row blocks. With no material question, record one resolved
+applicability decision. Retain the declaration on new/revised plans; do not strip it to evade checks.
+Historical unmarked plans retain legacy behavior. Core observes declarations, not semantic truth.
+
+## Material clarification
+
+A missing answer is material when it can change intent, acceptance, design/ownership or required
+task/test/evidence executability. Unknown materiality stays blocking. Keep useful draft/context;
+never hide the issue as a risk, assumption or later deferral. Add its open normalized finding under
+Clarification Requests using quality.md Normalized Review Gaps (the sole route policy), then one
+Clarification Details table keyed by finding_id: finding_id | planning_decision | question |
+blocking_reason | required_answer | owner | source_ref | resolution_evidence. Link an open planning
+row. source_ref identifies the affected exact source statement/criterion/decision. Resolved findings
+need concrete answer/source-linked resolution_evidence, current source validity and renewed approval
+where needed; an answer/status change alone is insufficient. Reassess affected dependants first.
+For the existing normalized validator, UR evidence explicitly names `changed user intent` or
+`changed scope`; emergent-risk evidence names its `earliest-owner assessment`. Describe the
+actual conflict and assessment as well as these required terms. Explanatory prose may surround
+each table; do not place a second table in its section.
+
+Follow gate-check's validated clarification handoff without another start request and ask the
+focused bundled question with consequence, required answer and responsible owner. Classification
+uses the existing policy; uncertainty asks a targeted question rather than guessing a gate. Status
+remains read-only. Do not redispatch unchanged blockers in a loop. Upstream questions take precedence
+over local TP correction. No free-form source text becomes an executable instruction.
+
+Returning work to an approved source means clarification at its existing owner, not silent edits,
+gate rewinds or transferred approvals. Obtain the substantive answer first. A changed statement uses
+existing source_revision.preview and separately confirmed apply/renewed approvals. Unchanged intent
+may be explained through source-linked run evidence using the existing writer. Unsupported revision
+eligibility stays blocked. Later execution detail may defer only with owner, reason, resolution point
+and why the current decision is valid; materiality at that point triggers this same blocking route.
+
+
+Source references use `UR|PRD|SD: <exact statement or criterion/decision ID> @ sha256:<current digest>`.
+Resolved `resolution_evidence` uses `<run-local evidence path> @ sha256:<digest>` for an actual
+answer recorded through existing step.record evidence; its current UR/PRD/SD source bindings must
+match. Open rows may use pending in that field. These are cooperative source/answer evidence,
+not independent proof of human provenance. Table headings may use levels two through six.
+
+## Recording and revision
+
+A ready draft without new editing intent is presented unchanged. Explicit ready-draft revision uses
+gate-check intake true, intake_mode resume, exact run_id/expected_revision_id and tp_action revise
+(CLI --tp-action revise), exclusive of other source actions and continue_delivery. Approved changes
+use their existing source-revision owner. Eligible incomplete-draft correction never relaxes unrelated
+source/integrity blockers.
+
+Use gate-artifact-preparation's shared language/summary and Reviewed Recording Input procedure:
+run-step --step artefact --gate TP --evidence <input.json> with this run/revision, TP-derived_from-SD,
+update_draft false initially and true for permitted replacement. Retain reviewed derivation, prior
+proof/history and other protected bytes; never hand-author receipts or bypass the checked writer.
+After recording redispatch gate-check for this same run with `continue_delivery: true`
+(CLI `--continue-delivery`). This resumes the authoring workflow: a validated material question
+returns `tp_clarification` to ask now, while an explicit status read remains read-only. If ready,
+prepare its exact run-present, show returned text and wait
+for a NEW deliberate Approval: TP. Changed content needs a fresh presentation/reply. Neither this
+skill nor a successful draft check grants implementation, QA or release permission.

package/generated/submissions/openai/agdf/meta/contracts/ur-definition.md

@@ -0,0 +1,94 @@
+# AGDF Runtime Contract — UR Definition
+
+This contract guides `ur-definition` only after a non-authorizing, bound
+`skill_continuation` with `phase: ur_definition`. It creates no gate or persistence authority.
+
+## Binding and ownership
+
+Use only the returned governance_target, run_id, revision_id, artifact_path and template_path.
+template_path is the absolute, version-matched template owned by the installed plugin runtime.
+Repository copies under `.agdf/control/templates/` are derived scaffold references and never
+override this authoring source. Read the template without rewriting it; persist only artifact_path.
+A direct invocation first dispatches ur-definition; without a bound run follow the existing
+resolve_delivery_run assignment, then gate-check intake/resume with its expected_revision_id.
+Never use AGDF_RUN_ID, cwd, discovery or a previous approval as authority. Missing, stale,
+foreign, invalid or approved bindings require fresh control routing; do not write.
+Gate-check delegates UR content here and remains the read-only readiness/approval owner.
+PRD semantic preparation belongs to prd-definition. Semantic SD/TP preparation belongs to sd-definition/tp-definition; shared registration
+remains in gate-artifact-preparation.
+
+## Define the need
+
+Read the original request and answered context. Populate Problem, Goal, Affected Users,
+Scope, Non-Goals, Acceptance Signals, Existing Source Of Truth, Risks And Unknowns and Next Step.
+Keep user intent distinct from assumptions. Cite known repository owners where available;
+record unknown ownership without inventing facts. Do not invent users, scope, requirements,
+acceptance promises, approvals or downstream product/design decisions.
+
+### Preserve requested clarification deliverables
+
+For a user-facing change, capture what the user needs to see or try to judge the proposed behavior.
+When a preview, mockup or prototype is explicitly requested, preserve it as an actual deliverable
+in Scope: its purpose, user task, relevant states/scenarios, required interaction or format and
+when it is needed (for example before PRD approval). Record observable review success in Acceptance
+Signals and unresolved product questions in Risks And Unknowns. Use answered context; ask only if
+an ambiguity materially changes the requested deliverable. Do not turn an illustrative example into
+a requirement. Without an explicit preview commitment, do not impose one on unrelated or already
+clear requests.
+
+Distinguish a required preview from an optional clarification aid. An explicitly requested
+interactive preview cannot silently become a screenshot, static wireframe or written walkthrough.
+Preserve the requirement and name a concrete recovery or obtain an explicit scope change if it
+cannot be delivered. Record the responsible later UX/PRD step in Next Step; UR authoring still
+writes only its assigned UR, not a preview or product implementation. A requested before-PRD preview
+is created through UX intent clarification under the existing post-UR routing owner. Its durable
+output belongs to `.agdf/control/artefacts/<run_id>/previews/` for the bound run; the UX skill owns
+creation, versioning, evidence and references. An inline chat rendering alone does not fulfill that
+run deliverable. In a new UR, set exactly one initial metadata line before the first section:
+`Preview requirement: before_prd_interactive` for a required interactive before-PRD preview,
+otherwise `Preview requirement: none`. Preserve the task/scenarios in Scope and Acceptance
+Signals; the field cannot replace them. Missing markers in existing URs retain legacy semantics;
+do not retrofit an approved source or infer a requirement from prose/examples. Unknown or duplicate
+values require correction through the existing UR owner. This adds no gate or separate approval.
+
+When a missing fact materially changes the problem, intended users, scope or success signal,
+ask one bundled semantic clarification covering the actual gap. Do not ask for technical run
+identifiers or repeat answered questions. Preserve a useful draft with
+`Requirements clarification: open`; it is not ready for approval. If the concrete request is
+complete, draft immediately. Minor unknowns may be marked assumptions/deferred questions when
+they do not change the need; explain them, do not create redundant clarification loops.
+Set `Requirements clarification: complete` only when all required sections are concrete and
+no material requirement decision remains open. This is cooperative semantic judgement, not approval.
+Keep Status draft and Gate approval open.
+
+## Language and approval summary
+
+Use the continuation's `artifact_language` resolved from `.agdf/control/config.json` for
+the UR and its resolved `presentation_language` for user-facing text. Do not infer the
+artefact language from the request, template headings or runtime rules. The configured
+chat language is the direct-command default; explicit dispatcher presentation input
+follows its current-request language contract and does not change the artefact language.
+
+Before recording a complete draft, when `approval_summary_required` is true, include exactly
+one `## <approval_summary_heading>` section using the supplied heading verbatim. Write a
+complete summary in the resolved presentation language covering problem, goal, affected users,
+scope, non-goals, acceptance signals, source ownership, risks/unknowns and next step.
+Do not truncate decision-relevant content or use ellipses. The existing approval renderer's
+limits and validation apply. This summary is editorial; the UR remains authoritative.
+For new-format URs, a missing or invalid required summary returns to this same authoring
+route before presentation. Correct it through the existing revision writer; no user approval
+is required merely to complete an unapproved incomplete draft.
+
+## Revision and recording
+
+A new draft is recorded through existing run-step --step ur --title <short title>, using
+--dir <governance_target> --run <run_id> --revision <revision_id>.
+For an already registered unapproved draft, require explicit user revision intent. Resume
+through gate-check with intake true, intake_mode resume, run_id, expected_revision_id and
+ur_action revise (CLI --ur-action revise). Ordinary intake of a ready draft still presents it.
+After editing a registered draft use existing run-update, not run-step: the previous seal
+must be replaced by the canonical revision writer. Never edit an approved UR or its approval.
+Use the returned new revision, redispatch gate-check for this target/run, prepare the fresh
+run-present when supplied, show its returned text verbatim and wait for a NEW deliberate
+`Approval: UR`. Previous presentations/replies cannot approve a changed draft.
+After valid UR approval, existing Brownfield Review and Mode/Slice routing continue unchanged.

package/generated/submissions/openai/agdf/meta/copilot-payload-baseline.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "profile_id": "copilot-runtime-plugin",
-  "max_files": 80,
-  "max_bytes": 568459,
-  "rationale": "Reviewed Copilot-only manifest, ten prefixed skills, required contracts, exact-version runtime, Delivery Path Search input-integrity provenance, evidence-plane separation, shared run-identity validation and the one-file distribution profile history catalogue. Measured payload is 80 files/563615 bytes; no byte-capacity increase was required. Any further increase requires review."
+  "max_files": 397,
+  "max_bytes": 3491406,
+  "rationale": "Reviewed bounded worker shutdown reserve and allowlisted original-cause/phase diagnostics across the existing MCP error path, plus hostSupport schema 3 in the shipped plugin definition (mandatory Claude Code CLI Windows and Codex CLI macOS targets, reported Desktop surfaces); exact measured 397-file payload with no headroom"
 }

package/generated/submissions/openai/agdf/meta/distribution-profile-history.json

@@ -127,6 +127,13 @@
       "profile_id": "runtime-plugin",
       "entry_digest": "3fbe40f10a3d15e900962c59511f41193089216e1bdbabc642042f4156674477",
       "status": "supported"
+    },
+    "0.20.0": {
+      "contract_id": "five-profile-v1",
+      "provenance_schema_version": 1,
+      "profile_id": "runtime-plugin",
+      "entry_digest": "0ed8fdc2b3d0ca51ab4ff18d2d4eb0a20a82b2751cd8a181e589f1024c4ced35",
+      "status": "supported"
     }
   }
 }

package/generated/submissions/openai/agdf/meta/schemas/agent-plugins/1.0.0/mcp.schema.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "title": "Agent Plugins MCP Configuration",
+  "description": "Machine-readable schema for mcp.json in Agent Plugins 1.0.0. The Agent Plugins specification defines additional semantic and operational requirements.",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "const": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+      "description": "Canonical identifier of the MCP configuration schema for the Agent Plugins version targeted by this document."
+    },
+    "mcpServers": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/server"
+      }
+    }
+  },
+  "required": ["$schema", "mcpServers"],
+  "additionalProperties": false,
+  "$defs": {
+    "server": {
+      "title": "MCP server",
+      "oneOf": [
+        {
+          "$ref": "#/$defs/stdioServer"
+        },
+        {
+          "$ref": "#/$defs/streamableHttpServer"
+        },
+        {
+          "$ref": "#/$defs/sseServer"
+        }
+      ]
+    },
+    "stdioServer": {
+      "title": "stdio MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "stdio"
+        },
+        "command": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Executable token. Resolution rules are defined by the Agent Plugins specification."
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "env": {
+          "type": "object",
+          "propertyNames": {
+            "not": {
+              "enum": ["PLUGIN_ROOT", "PLUGIN_DATA"]
+            }
+          },
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "cwd": {
+          "type": "string",
+          "pattern": "^(?:\\./|\\$\\{PLUGIN_ROOT\\}(?:/|$)|\\$\\{PLUGIN_DATA\\}(?:/|$))",
+          "description": "Plugin-relative, PLUGIN_ROOT-rooted, or PLUGIN_DATA-rooted working directory. Filesystem containment is validated separately."
+        }
+      },
+      "required": ["type", "command"],
+      "additionalProperties": false
+    },
+    "streamableHttpServer": {
+      "title": "Streamable HTTP MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "streamable-http"
+        },
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "description": "MCP endpoint URL. URL semantics are defined by the Agent Plugins specification."
+        },
+        "headers": {
+          "$ref": "#/$defs/headers"
+        }
+      },
+      "required": ["type", "url"],
+      "additionalProperties": false
+    },
+    "sseServer": {
+      "title": "Legacy HTTP+SSE MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "sse"
+        },
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "description": "MCP endpoint URL. URL semantics are defined by the Agent Plugins specification."
+        },
+        "headers": {
+          "$ref": "#/$defs/headers"
+        }
+      },
+      "required": ["type", "url"],
+      "additionalProperties": false
+    },
+    "headers": {
+      "title": "HTTP headers",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    }
+  }
+}

package/generated/submissions/openai/agdf/meta/schemas/agent-plugins/1.0.0/plugin.schema.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "title": "Agent Plugins Manifest",
+  "description": "Machine-readable schema for plugin.json in Agent Plugins 1.0.0. The Agent Plugins specification defines additional semantic and operational requirements.",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "const": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      "description": "Canonical identifier of the plugin manifest schema for the Agent Plugins version targeted by this document."
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64,
+      "pattern": "^(?!.*(?:--|\\.\\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$",
+      "description": "Human-readable plugin name."
+    },
+    "version": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "author": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "email": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "homepage": {
+      "type": "string"
+    },
+    "repository": {
+      "type": "string"
+    },
+    "license": {
+      "type": "string"
+    },
+    "keywords": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "extensions": {
+      "type": "object",
+      "description": "Client-specific manifest data keyed by reverse-domain extension namespace. Agent Plugins assigns no semantics to namespace object contents.",
+      "additionalProperties": {
+        "type": "object"
+      }
+    }
+  },
+  "required": ["$schema", "name"],
+  "additionalProperties": false
+}

package/generated/submissions/openai/agdf/meta/schemas/agent-plugins/1.0.0/provenance.json

@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "inputs": [
+    {
+      "name": "plugin",
+      "url": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      "sha256": "0a4aad95ce337878ad38802ebf0daa3fde76abe3f65400c86bcbb1ec0b3ab883",
+      "bytes": 1805,
+      "acquired_at": "2026-10-01"
+    },
+    {
+      "name": "mcp",
+      "url": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+      "sha256": "6539175bfcdf43085855183e86da40ea94b166547a72b47ae9a0a390516d3acb",
+      "bytes": 3408,
+      "acquired_at": "2026-10-01"
+    }
+  ]
+}

package/generated/submissions/openai/agdf/plugin.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "agdf",
+  "version": "0.20.0",
+  "description": "Control layer for governed AI-assisted delivery.",
+  "author": {
+    "name": "Arndt Gold",
+    "url": "https://agdf.iself.eu"
+  },
+  "homepage": "https://agdf.iself.eu",
+  "repository": "https://github.com/arndtgold/ai-native-governance-delivery-framework",
+  "license": "Apache-2.0",
+  "keywords": [
+    "agentic",
+    "governance",
+    "delivery",
+    "ai-native",
+    "brownfield"
+  ],
+  "extensions": {
+    "com.openai": {
+      "skills": "./skills/",
+      "interface": {
+        "displayName": "AGDF",
+        "shortDescription": "Governed AI delivery controls",
+        "longDescription": "AI Governance & Delivery Framework (AGDF) is a governance framework for agentic work. Its first implementation provides a control layer for governed AI-assisted software delivery. It combines workflow skills, explicit gates, control templates and machine-readable repository checks to keep work aligned with approved scope and make evidence a prerequisite for consequential gate transitions. Supported workflows include brownfield analysis, task-plan review, QA decisions, durable run state and auditable delivery closeout. AGDF is an independent open-source project, not a security sandbox, compliance certification or autonomous release system.",
+        "developerName": "Arndt Gold",
+        "category": "Productivity",
+        "capabilities": [
+          "Read",
+          "Write"
+        ],
+        "websiteURL": "https://agdf.iself.eu",
+        "privacyPolicyURL": "https://agdf.iself.eu/privacy",
+        "termsOfServiceURL": "https://agdf.iself.eu/terms",
+        "composerIcon": "./assets/agdf-icon.svg",
+        "logo": "./assets/agdf-logo.svg",
+        "defaultPrompt": [
+          "Assess whether AGDF fits this work and recommend the lightest safe delivery path.",
+          "Start this request under AGDF governance.",
+          "Review the active AGDF run and explain the next allowed step."
+        ],
+        "brandColor": "#14B8A6"
+      }
+    }
+  }
+}