create-agdf 0.2.8 → 0.3.0

package/generated/.opencode/agents/agdf-qa-gate.md

@@ -0,0 +1,116 @@
+---
+description: final QA decision
+mode: subagent
+---
+
+---
+name: agdf-qa-gate
+description: Use this skill before any QA decision to determine whether implementation can be classified as pass, revise, or block based on TP coverage, Brownfield fit, solution integrity, evidence, and open blockers. Use it after CD+Tests, after reviews, and before UAT or release decisions.
+---
+
+# qa-gate
+
+## Purpose
+Make the formal QA gate decision.
+
+This skill is the only final QA decision point for `pass | revise | block`.
+
+It answers:
+
+- whether `QA pass` is allowed
+- whether the implementation must be revised
+- whether a hard blocker remains
+- whether relevant TP tasks are sufficiently verified
+- whether P0/P1 tasks are complete
+- whether Brownfield fit is sufficient
+- whether solution integrity is sufficient
+- whether blockers, critical risks, or missing evidence remain
+
+## Runtime Contract
+Use `../agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+QA-specific `decision` is exactly `pass | revise | block`.
+`pass` is allowed only when TP coverage, Brownfield fit, solution integrity, and relevant documentation/Context Graph impact are sufficiently evidenced.
+`sot_drift` must not pass silently as a warning.
+
+## Rules
+1. No QA pass without strong evidence.
+2. TP is the reference, not merely working code.
+3. P0/P1 gaps block `pass`.
+4. Brownfield fit is mandatory.
+5. UI surface integrity is mandatory for UI-impacting changes.
+6. Solution integrity is mandatory.
+7. Always output exactly one decision: `pass`, `revise`, or `block`.
+8. Open risks, missing tests, partial TP coverage, or side effects must be visible.
+
+## When To Use
+- after `CD+Tests`
+- after `agdf-code-review`
+- after `agdf-task-plan-review`
+- after `agdf-clean-implementation-review`
+- before UAT
+- before any claim that implementation is done, releasable, or QA-ready
+- when evidence from Brownfield, TP, or clean-review skills exists
+
+Important:
+
+- `CD+Tests` is implementation and test status only.
+- Without review evidence and TP coverage, `QA pass` is not allowed.
+
+## Inputs
+Use what is available:
+
+- approved TP and TP Review
+- Brownfield Analysis
+- Clean Implementation Review
+- `agdf-code-review` or Code Review Report
+- test/build results
+- documentation impact review
+- runtime or UI evidence
+- known blockers and risks
+
+If evidence is missing, lower the decision accordingly.
+
+## Workflow
+1. Confirm the relevant gate context.
+2. Verify TP coverage.
+3. Verify P0/P1 completion.
+4. Verify Brownfield fit.
+5. Verify solution integrity.
+6. Verify tests and evidence strength.
+7. Verify documentation and Context Graph impact if relevant.
+8. Decide:
+   - `pass`
+   - `revise`
+   - `block`
+9. State the single required next step.
+
+## Output
+Use this shape:
+
+```text
+## QA Gate
+- decision: pass | revise | block
+- evidence:
+- missing_evidence:
+- risks:
+- required_next_step:
+- impact_codes:
+```
+
+If Context Graph impact is relevant, include the fields from `../agdf-runtime-contract.md`.
+
+## Decision Guidance
+- `pass`: required TP tasks are done, evidence is strong, no blocking Brownfield or solution-integrity risk remains.
+- `revise`: implementation is plausible but missing evidence, partial tasks, UX gaps, or fixable integrity issues remain.
+- `block`: hard prerequisite, approval, product semantics, security/compliance, SoT drift, or critical behaviour is unresolved.
+
+## Forbidden
+This skill must not:
+
+- grant QA pass from a green build alone
+- hide partial task completion
+- replace UAT
+- treat missing reviews as completed
+- downgrade SoT drift to harmless warning
+

package/generated/.opencode/agents/agdf-release-or.md

@@ -0,0 +1,130 @@
+---
+description: auditable closeout for every relevant run
+mode: subagent
+---
+
+---
+name: agdf-release-or
+description: Use this skill at the end of every relevant run to produce a compact, auditable Orchestration Report. It summarizes gate status, delivered and intentionally not delivered work, TP coverage, Brownfield fit, solution integrity, open risks, and the next permissible step.
+---
+
+# release-or
+
+## Purpose
+Produce the Orchestration Report (OR) as the mandatory closeout for a relevant run.
+
+It reports:
+
+- current user gate
+- whether the run is `pass`, `revise`, `block`, or not yet QA-decided
+- what was delivered
+- what was intentionally not delivered
+- missing approvals
+- TP coverage status
+- Brownfield fit
+- solution integrity
+- documentation impact
+- Context Graph impact
+- open risks, blockers, retained fallbacks, and exit criteria
+- next permissible step
+- whether further quality follow-up or a separate delivery closeout is useful
+
+## Runtime Contract
+Use `../agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+OR-specific output must make gate status, delivered and intentionally not delivered content, missing approvals, missing evidence, risks, retained fallbacks, and the next permissible step visible.
+When `.agdf/control/` is present, persist or link the OR under `.agdf/control/artefacts/<key>/OR.md` and reference it from `AGDF_RUN.md` or `MASTER_BACKLOG.md` when it is steering-relevant.
+Use the Runtime Contract definition of `Relevant Run` to decide whether OR is mandatory or whether a Quick Task mini-closeout is enough.
+
+## Rules
+1. OR is always allowed and mandatory for relevant runs as defined in the Runtime Contract.
+2. OR is an audit report, not a blocking gate.
+3. Do not leak artefacts from blocked later gates.
+4. Use OR-lite when early gates block.
+5. Use OR-full only within the allowed scope.
+6. Report status, not marketing language.
+7. Name missing approvals, partial implementation, risks, fallbacks, Brownfield issues, and open defects.
+8. Retained fallbacks require visible exit criteria and cleanup path.
+9. End with the immediately permissible next step.
+10. `CD+Tests` is not completion.
+
+## When To Use
+- at the end of every relevant run
+- after artefact creation
+- when a gate blocks
+- after `CD+Tests`
+- after `agdf-code-review`
+- after QA
+- after UAT
+- whenever a compact audit closeout is needed
+
+Do not force OR onto a pure explanation, read-only inspection, small review, or local debugging step that produces no durable state change and no gate consequence.
+
+## Inputs
+Use what is available:
+
+- current gate
+- existing approvals
+- artefacts created in this run
+- intentionally not delivered content
+- Task Plan
+- `agdf-task-plan-review`
+- `agdf-brownfield-analysis`
+- `agdf-clean-implementation-review`
+- `agdf-code-review`
+- QA Report
+- UAT Report
+- documentation impact review
+- Context Graph impact
+- known risks, defects, fallbacks, and open questions
+- test/build status and relevant metrics
+
+If information is missing, state the gap instead of guessing.
+
+## Workflow
+1. Determine the current gate and earliest blocker.
+2. Determine report depth:
+   - `OR-lite`: gate status, allowed/forbidden outputs, missing approval, next step
+   - `OR-full`: also delivered artefacts, TP coverage, Brownfield fit, solution integrity, risks, fallbacks, QA/UAT status
+3. Record the selected `Report mode` and durable OR target or link when `.agdf/control/` exists.
+4. Record delivered vs intentionally not delivered content.
+5. Summarize TP coverage if a TP exists.
+6. Summarize Brownfield fit and solution integrity if reviewed.
+7. Summarize tests and verification.
+8. Summarize documentation and Context Graph impact if relevant.
+9. Name retained fallbacks and exit criteria.
+10. Set exactly one next permissible step.
+11. Set exactly one quality outlook.
+12. State whether `agdf-delivery-closeout` is the next operational handoff step when code changes exist and the delivery state allows it.
+
+## Output
+Use a compact structure:
+
+```text
+## OR
+- gate:
+- report_mode:
+- artefact:
+- status:
+- delivered:
+- intentionally_not_delivered:
+- evidence:
+- missing_evidence:
+- risks:
+- retained_fallbacks:
+- required_next_step:
+- quality_outlook:
+```
+
+When Context Graph impact is relevant, include the fields from `../agdf-runtime-contract.md`.
+
+## Forbidden
+This skill must not:
+
+- decide QA in place of `agdf-qa-gate`
+- call `CD+Tests` complete, QA-ready, or release-ready
+- hide missing approvals
+- provide later-gate content while an earlier gate blocks
+- produce the operative commit/PR handoff owned by `agdf-delivery-closeout`
+- execute commit, push, or PR actions
+

package/generated/.opencode/agents/agdf-task-plan-review.md

@@ -0,0 +1,121 @@
+---
+description: after implementation and before QA, verify TP coverage
+mode: subagent
+---
+
+---
+name: agdf-task-plan-review
+description: Use this skill after code changes and before QA to verify whether the approved Task Plan was actually fulfilled. It checks each task_id against implementation, acceptance criteria, tests, visible evidence, and deviations, and provides TP coverage for QA.
+---
+
+# task-plan-review
+
+## Purpose
+Verify whether implementation actually satisfies the approved Task Plan.
+
+For each relevant task, this skill determines:
+
+- whether the task is fully, partially, or not completed
+- which acceptance criteria are done, partial, missing, or not verifiable
+- which files, tests, runtime evidence, or UI evidence support the finding
+- evidence strength
+- which gaps must be handed to `agdf-qa-gate`
+
+This skill provides TP coverage. It is not the final QA decision.
+
+## Runtime Contract
+Use `../agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+TP-specific output must evaluate every relevant `task_id` with completion status, AC coverage, evidence, missing evidence, and QA-relevant gaps.
+If `context_graph_required_action` is not `none`, the affected task is complete only if follow-up, evidence, or an intentionally open gap is visible.
+
+## Rules
+1. The Task Plan is the reference, not plausible code.
+2. No assumptions without evidence.
+3. Evaluate each relevant `task_id` individually.
+4. `fully_done` requires strong evidence.
+5. A green build alone does not prove TP completion.
+6. UI/state/render/recovery tasks need visible evidence, not only code.
+7. Partial implementation must be marked `partially_done`.
+8. P0/P1 gaps must be handed to QA.
+9. Out-of-scope changes must be reported.
+10. When evidence is unclear, fail closed to at least `partially_done`.
+
+## Clarifications
+### TP Slice Before Target State
+If the TP explicitly defines a preparatory, additive, or limited slice, evaluate that exact scope.
+`fully_done` is allowed for a completed slice even if the larger target state remains open.
+
+### Missing Priorities
+If no priorities are defined, do not invent them. Mark the gap and treat QA relevance conservatively.
+
+### Missing Acceptance Criteria
+If ACs are unclear, derive only obvious expectations from title, goal, and scope. Mark AC basis as incomplete and lower evidence confidence as needed.
+
+## When To Use
+- after `CD+Tests`
+- before `QA`
+- when TP completion is unclear
+- when the user asks for TP fulfilment
+- when UI/state/runtime invariants are affected
+- when several agents or work steps touched the same TP
+
+## Inputs
+Use what is available:
+
+- Task Plan
+- `task_id`, `story_id`, priorities
+- acceptance criteria or success goals
+- changed files
+- tests and test results
+- build results
+- runtime/UI evidence
+- known deviations and scope decisions
+
+If TP or relevant tasks are missing, do not claim reliable TP coverage.
+
+## Output
+Use this compact structure:
+
+```text
+## TP Coverage
+| task_id | status | evidence | missing_evidence | QA impact |
+|---|---|---|---|---|
+
+## Summary
+- fully_done:
+- partially_done:
+- not_done:
+- out_of_scope_changes:
+- risks:
+- required_next_step:
+```
+
+Completion status:
+
+- `fully_done`
+- `partially_done`
+- `not_done`
+
+AC status:
+
+- `done`
+- `partial`
+- `missing`
+- `not_verifiable`
+
+Evidence confidence:
+
+- `high`
+- `medium`
+- `low`
+
+## Forbidden
+This skill must not:
+
+- decide final QA
+- mark tasks fully done from code existence alone
+- hide partial work
+- upgrade missing evidence into confidence
+- reinterpret the TP scope
+

package/generated/opencode.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "create-agdf"
+  ],
+  "instructions": [
+    ".opencode/AGDF.md"
+  ],
+  "permission": {
+    "edit": "ask",
+    "bash": "ask"
+  }
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Codex-first workflow skills for gated, auditable AI-assisted software delivery.",
   "author": {
     "name": "AI-native Governance & Delivery Framework",
@@ -20,6 +20,8 @@
     "category": "Productivity",
     "capabilities": ["Read", "Write"],
     "websiteURL": "https://agdf.iself.eu",
+    "composerIcon": "./assets/agdf-icon.svg",
+    "logo": "./assets/agdf-logo.svg",
     "defaultPrompt": [
       "Run an AGDF gate check for this request.",
       "Create an AGDF control scaffold for this repository.",

package/generated/plugins/agdf/assets/agdf-icon.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="AGDF">
+  <defs>
+    <linearGradient id="agdf-bg" x1="10" y1="6" x2="54" y2="58" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#0F766E"/>
+      <stop offset="1" stop-color="#2563EB"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="14" fill="#06131F"/>
+  <rect x="4" y="4" width="56" height="56" rx="12" fill="url(#agdf-bg)"/>
+  <path d="M32 10.5 50 21v22L32 53.5 14 43V21L32 10.5Z" fill="none" stroke="#ECFEFF" stroke-width="5" stroke-linejoin="round"/>
+  <path d="M32 21v13m0 0-10 6m10-6 10 6" fill="none" stroke="#ECFEFF" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="32" cy="21" r="5.3" fill="#ECFEFF"/>
+  <circle cx="32" cy="34" r="5.6" fill="#ECFEFF"/>
+  <circle cx="22" cy="40" r="5.3" fill="#ECFEFF"/>
+  <circle cx="42" cy="40" r="5.3" fill="#ECFEFF"/>
+</svg>

package/generated/plugins/agdf/assets/agdf-logo.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" role="img" aria-label="AGDF">
+  <defs>
+    <linearGradient id="agdf-logo-bg" x1="80" y1="48" x2="432" y2="464" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#0F766E"/>
+      <stop offset="1" stop-color="#2563EB"/>
+    </linearGradient>
+  </defs>
+  <rect width="512" height="512" rx="112" fill="#06131F"/>
+  <rect x="32" y="32" width="448" height="448" rx="96" fill="url(#agdf-logo-bg)"/>
+  <path d="M256 84 400 168v176L256 428 112 344V168L256 84Z" fill="none" stroke="#ECFEFF" stroke-width="40" stroke-linejoin="round"/>
+  <path d="M256 168v104m0 0-80 48m80-48 80 48" fill="none" stroke="#ECFEFF" stroke-width="32" stroke-linecap="round" stroke-linejoin="round"/>
+  <circle cx="256" cy="168" r="42" fill="#ECFEFF"/>
+  <circle cx="256" cy="272" r="45" fill="#ECFEFF"/>
+  <circle cx="176" cy="320" r="42" fill="#ECFEFF"/>
+  <circle cx="336" cy="320" r="42" fill="#ECFEFF"/>
+</svg>

package/generated/plugins/agdf/control/README.md

@@ -49,21 +49,21 @@ Keep these files small and reviewable. They are control artefacts, not a second
 Create the live files with:
 
 ```bash
-npm create agdf@latest -- init
+npx --yes agdf@latest init
 ```
 
 If only the project language preference is missing or should change after plugin installation, write just the config file:
 
 ```bash
-npm create agdf@latest -- config --language en
+npx --yes agdf@latest config --language en
 ```
 
 Then check whether the live state is actionable:
 
 ```bash
-npm create agdf@latest -- doctor
-npx --yes create-agdf@latest doctor --json
-npx --yes create-agdf@latest gate-check --json
+npx --yes agdf@latest doctor
+npx --yes agdf@latest doctor --json
+npx --yes agdf@latest gate-check --json
 ```
 
 `doctor` does not replace agent judgment. It catches basic control failures: missing live files, missing current gate, missing next allowed action, empty evidence, empty backlog pointer, empty source-of-truth registry, duplicate active SoT rows and invalid quality contracts.

package/generated/plugins/agdf/hooks/session-start.sh

@@ -8,7 +8,7 @@ ROUTER="${META_DIR}/agdf-agent-router.md"
 CONSTITUTION="${META_DIR}/agdf-constitution.md"
 CONFIG_PATH="${PWD}/.agdf/control/config.json"
 
-CONFIG_HINT="Project config: .agdf/control/config.json not found. Use npm create agdf@latest -- config --language de|en to persist the project language."
+CONFIG_HINT="Project config: .agdf/control/config.json not found. Use npx --yes agdf@latest config --language de|en to persist the project language."
 if [[ -f "${CONFIG_PATH}" ]]; then
   CONFIG_HINT="$(CONFIG_PATH="${CONFIG_PATH}" node <<'NODE' 2>/dev/null || true
 const fs = require("node:fs");
@@ -20,7 +20,7 @@ try {
   const runtime = config.runtime_language || "en";
   console.log(`Project config: .agdf/control/config.json (artefacts=${artefacts}, chat=${chat}, runtime=${runtime}).`);
 } catch {
-  console.log("Project config: .agdf/control/config.json exists but is not valid JSON. Run npm create agdf@latest -- doctor.");
+  console.log("Project config: .agdf/control/config.json exists but is not valid JSON. Run npx --yes agdf@latest doctor.");
 }
 NODE
 )"

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

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "AI-native Governance & Delivery Framework",
   "description": "Codex-first workflow skills for gated, auditable AI-assisted software delivery.",
@@ -22,6 +22,8 @@
     "skills": "./skills/",
     "skillPrefix": "",
     "agentRouter": "meta/agdf-agent-router.md",
+    "composerIcon": "./assets/agdf-icon.svg",
+    "logo": "./assets/agdf-logo.svg",
     "capabilities": ["Read", "Write"],
     "defaultPrompt": [
       "Run an AGDF gate check for this request.",
@@ -39,6 +41,16 @@
     "skillPrefix": "agdf-",
     "runtimeContractFileName": "agdf-runtime-contract.md"
   },
+  "opencode": {
+    "skillPrefix": "agdf-",
+    "runtimeContractFileName": "agdf-runtime-contract.md",
+    "instructionsFileName": "AGDF.md",
+    "npmPackage": "create-agdf",
+    "permissions": {
+      "edit": "ask",
+      "bash": "ask"
+    }
+  },
   "skillSet": [
     {
       "slug": "brownfield-analysis",

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

@@ -41,10 +41,10 @@ Use `init` only when the user explicitly asks for durable AGDF control state, th
 Use the executable control path when a machine-readable check is requested, when the gate state is ambiguous, when CI or PR evidence is needed, or when a repository-local automation needs JSON output:
 
 ```bash
-npm create agdf@latest -- init
-npx --yes create-agdf@latest doctor --json
-npx --yes create-agdf@latest gate-check --json
-npx --yes create-agdf@latest delivery-map --json
+npx --yes agdf@latest init
+npx --yes agdf@latest doctor --json
+npx --yes agdf@latest gate-check --json
+npx --yes agdf@latest delivery-map --json
 ```
 
 `init` creates the control scaffold. `doctor` checks whether `.agdf/control/` is actionable. `gate-check` consumes that result and `AGDF_RUN.md` to report the operative process decision: `open | blocked`, current gate, blocking reason, missing approval, allowed outputs, forbidden outputs, next allowed action and evidence references.

package/opencode-plugin.js

@@ -0,0 +1,33 @@
+export const AGDFPlugin = async ({ directory, client }) => {
+  const controlDir = `${directory}/.agdf/control`;
+
+  return {
+    event: async ({ event }) => {
+      if (event?.type === "session.created") {
+        await client.app.log({
+          body: {
+            service: "agdf",
+            level: "info",
+            message: "AGDF OpenCode surface active",
+            extra: { controlDir },
+          },
+        });
+      }
+    },
+
+    "shell.env": async (_input, output) => {
+      output.env.AGDF_CONTROL_DIR = controlDir;
+    },
+
+    "experimental.session.compacting": async (_input, output) => {
+      output.context.push([
+        "## AGDF Runtime Reminder",
+        "Use `.opencode/AGDF.md`, `.opencode/agents/` and `.agdf/control/` as the AGDF source for this OpenCode session.",
+        "For new build/change intent or unclear approval, route first to `agdf-gate-check` before later artefacts or implementation.",
+        "Use `npx --yes agdf@latest gate-check --json` only as deterministic proof, not as a replacement for AGDF judgement.",
+      ].join("\n"));
+    },
+  };
+};
+
+export default AGDFPlugin;

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "create-agdf",
-  "version": "0.2.8",
-  "description": "Bootstrap AGDF repository-local plugin files, Copilot instructions, skills, control files and machine-readable checks.",
+  "version": "0.3.0",
+  "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
     "bin",
     "generated",
+    "opencode-plugin.js",
     "README.md",
     "NOTICE"
   ],
+  "exports": {
+    ".": "./opencode-plugin.js",
+    "./cli": "./bin/create-agdf.js",
+    "./opencode-plugin": "./opencode-plugin.js"
+  },
   "bin": {
     "create-agdf": "./bin/create-agdf.js"
   },
@@ -23,6 +29,7 @@
     "copilot",
     "claude-code",
     "codex",
+    "opencode",
     "control",
     "scaffold",
     "bootstrap"