create-agdf 0.1.3 → 0.1.5

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

@@ -0,0 +1,116 @@
+---
+name: agdf-brownfield-analysis
+description: Use this skill before implementation in an existing codebase, especially for feature extensions, bug fixes, refactorings, or changes to existing modules. It analyzes existing artefacts, current coverage, reuse strategy, risks, and the minimal clean implementation path. Use it before CD+Tests.
+---
+
+# brownfield-analysis
+
+## Purpose
+Ensure implementation in an existing system is Brownfield-oriented, not Greenfield-style.
+
+The skill answers:
+
+- which existing artefacts matter
+- what already exists fully or partially
+- what can be reused, extended, or refactored
+- whether new artefacts are really needed
+- architecture, compatibility, migration, and regression impact
+- the minimal clean implementation path
+- whether Context Graph impact exists without automatically creating a node
+
+## Runtime Contract
+Use `../../meta/agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+Brownfield-specific output must make evidence, missing existing-system view, parallel-structure risk, reuse strategy, and the minimal next step visible.
+
+## Rules
+1. Brownfield first: understand the existing codebase before implementation.
+2. Reuse-before-create: prefer existing modules, services, components, tables, endpoints, tests, and configuration.
+3. Minimal clean slice: choose the smallest durable intervention, not merely the smallest technical diff.
+4. No silent parallel structures.
+5. Existing architecture, naming, error handling, logging, security, and test conventions are binding unless deviation is justified.
+6. What is not visibly evidenced does not count as existing.
+7. Async execute paths must not become a second product-policy decision point.
+8. Visible state ownership must be checked for chat, rendering, scrolling, recovery, and status problems.
+9. SoT/runtime/product-semantics drift must be named; if official behaviour must be decided first, recommend UR or equivalent product direction.
+10. Large UI surfaces and state hooks must be checked for mixed render, view-model, derived state, orchestration, persistence, and recovery ownership.
+11. Context Graph impact must be curated; it is not a review log or version index.
+12. Specification archive migrations must follow the archive index if present.
+
+## When To Use
+- before `CD+Tests`
+- before changes to an existing repository
+- bug fixes in existing modules
+- feature extensions in existing architecture
+- refactorings
+- unclear existing coverage
+- risk of new parallel structures
+- a TP is clear but its connection to the existing system is not
+
+## Inputs
+Use what is available:
+
+- Task Plan, `task_id`, `story_id`
+- project structure
+- affected files, modules, services, APIs, data models
+- existing tests
+- architecture notes from PRD or SD
+- repository conventions
+
+If inputs are missing, work only from observable evidence and mark gaps explicitly.
+
+## Workflow
+1. Identify affected tasks and scope.
+2. Find relevant existing artefacts.
+3. Assess current coverage before new implementation:
+   - `fully_done`
+   - `partially_done`
+   - `not_done`
+4. Choose reuse strategy:
+   - `extend`
+   - `refactor`
+   - `replace`
+   - `new`
+5. Assess change impact:
+   - files/modules
+   - interfaces
+   - data model/migrations
+   - backwards compatibility
+   - regression tests
+   - side effects
+6. Check parallel-structure risk.
+7. Check SoT/runtime/product-semantics drift.
+8. Check primary visible ownership for UI/status/recovery paths.
+9. Check UI monolith risk for large surfaces or central hooks.
+10. Check Context Graph impact according to `../../meta/agdf-runtime-contract.md`.
+11. Recommend the minimal clean implementation path.
+
+## Output
+Use a concise structure:
+
+```text
+## Brownfield Analysis
+- decision: pass | revise | block | not_applicable
+- scope:
+- evidence:
+- missing_evidence:
+- current_coverage:
+- reuse_strategy:
+- risks:
+- context_graph_impact:
+- required_next_step:
+```
+
+## Pass / Revise / Block Guidance
+- `pass`: existing owners are understood, reuse path is clear, and no blocking drift or parallel structure risk remains.
+- `revise`: relevant evidence, tests, ownership, or reuse path is incomplete.
+- `block`: implementation would create a second SoT, second owner, unresolved product semantics, or hard unmitigated risk.
+
+## Forbidden
+This skill must not:
+
+- propose a Greenfield replacement without evidence
+- silently accept overlapping ownership
+- convert product-semantics drift into a mere refactor
+- create Context Graph nodes automatically
+- treat archive links as active current specification signals

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

@@ -0,0 +1,23 @@
+## NAME
+
+`agdf-brownfield-analysis` - brownfield analysis
+
+## SYNOPSIS
+
+`/agdf-brownfield-analysis` [`--help`|`-h`]
+
+## DESCRIPTION
+
+Ensures implementation in an existing system is Brownfield-oriented rather than Greenfield-style. Analyzes existing artefacts, current coverage, reuse strategy, risks, and the minimal clean implementation path.
+
+## EXAMPLES
+
+Trigger the skill:
+
+```text
+> /agdf-brownfield-analysis
+```
+
+## SEE ALSO
+
+See the full SKILL.md for detailed workflow, output format, and decision logic.

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

@@ -0,0 +1,100 @@
+---
+name: agdf-clean-implementation-review
+description: Use this skill to determine whether an implementation is a clean primary solution or whether fallbacks, workarounds, guards, defaults, shims, or parallel structures have made it unnecessarily complex. Use it after code changes, before QA, or whenever symptom treatment is suspected.
+---
+
+# clean-implementation-review
+
+## Purpose
+Evaluate implementation integrity.
+
+This skill answers:
+
+- was the task solved with a clean primary solution
+- was the root cause fixed or only masked
+- were unnecessary fallbacks, workarounds, guards, defaults, or shims introduced
+- were unnecessary parallel structures introduced
+- does the solution fit the existing architecture
+- is it maintainable or workaround-heavy
+
+## Runtime Contract
+Use `../../meta/agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+Clean-review-specific output must make the primary solution, fallbacks, workarounds, parallel structures, exit criteria, and next cleanup/review step visible.
+
+## Rules
+1. Clean primary solution before fallback.
+2. Root cause before symptom masking.
+3. Fallbacks are exceptions, not target architecture.
+4. Every retained fallback needs rationale, target state, and exit condition.
+5. No silent parallel structures.
+6. Brownfield fit is mandatory.
+7. Maintainability matters; "works somehow" is not enough.
+8. Async execute paths must not decide product rules again.
+9. Shared finalization or merge rules belong in one owner.
+
+## When To Use
+- after `CD+Tests`
+- before QA
+- when a solution contains many guards, defaults, or special paths
+- when wrappers or helper layers were introduced
+- when symptom treatment is suspected
+- when fallback, retry, or compatibility-shim logic was added
+- when code works but the architecture looks questionable
+
+## Inputs
+Use what is available:
+
+- Task Plan
+- Code Deliverables
+- changed files
+- tests and test results
+- `agdf-code-review` or Code Review Report
+- QA Report
+- Brownfield Analysis findings
+- PRD or SD architecture notes
+
+If evidence is missing, mark it explicitly.
+
+## Workflow
+1. Understand the intended change.
+2. Identify the primary implementation path.
+3. Identify fallbacks, guards, defaults, shims, retries, wrappers, and catch-all branches.
+4. Decide whether each is justified.
+5. Check for parallel ownership.
+6. Check Brownfield fit.
+7. Assess whether the implementation fixes the root cause.
+8. Assign a decision:
+   - `pass`
+   - `revise`
+   - `block`
+   - `not_applicable`
+
+## Output
+Use this compact structure:
+
+```text
+## Clean Implementation Review
+- decision:
+- primary_solution:
+- evidence:
+- fallbacks_retained:
+- workaround_or_shim_risk:
+- parallel_structure_risk:
+- brownfield_fit:
+- missing_evidence:
+- required_next_step:
+```
+
+## Pass / Revise / Block Guidance
+- `pass`: primary solution is clean, tested, and integrated with existing owners.
+- `revise`: solution works but contains avoidable fallback, unclear ownership, or missing evidence.
+- `block`: solution creates a second SoT, a second owner, unbounded fallback, or masks unresolved product semantics.
+
+## Forbidden
+This skill must not:
+
+- accept fallback-heavy logic as target architecture
+- hide unjustified workarounds
+- treat green tests as proof of solution integrity
+- decide final QA

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

@@ -0,0 +1,23 @@
+## NAME
+
+`agdf-clean-implementation-review` - clean implementation review
+
+## SYNOPSIS
+
+`/agdf-clean-implementation-review` [`--help`|`-h`]
+
+## DESCRIPTION
+
+Evaluates solution integrity: whether the implementation is a clean primary solution or has become unnecessarily complex through fallbacks, workarounds, guards, defaults, shims, or parallel structures.
+
+## EXAMPLES
+
+Trigger the skill:
+
+```text
+> /agdf-clean-implementation-review
+```
+
+## SEE ALSO
+
+See the full SKILL.md for detailed workflow, output format, and decision logic.

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

@@ -0,0 +1,94 @@
+---
+name: agdf-code-review
+description: Use this skill after code changes and before QA to produce the mandatory Code Review Report for correctness, regression, security, and maintainability findings in the actual diff. It standardizes the CR step without replacing TP review, clean review, or QA.
+---
+
+# code-review
+
+## Purpose
+Produce the mandatory Code Review Report (CR) for a relevant run.
+
+It answers:
+
+- whether the changed code shows functional defects, security issues, regression risks, or maintainability problems that matter
+- whether findings are blocking, revisable, or advisory
+- which concrete evidence in files, diffs, tests, or runtime observations supports each finding
+- which issues must be fixed before QA
+- whether Brownfield, TP, or clean-review follow-up remains open
+
+## Runtime Contract
+Use `../../meta/agdf-runtime-contract.md` for Quality Contract output, Context Graph fields, gate terms, and non-duplication rules.
+
+Code-review-specific output must make actual findings, missing review scope, evidence strength, and the next required step visible.
+
+## Rules
+1. Review the actual diff and impacted code, not intent alone.
+2. Findings require concrete evidence.
+3. Prioritize correctness, safety, data integrity, compatibility, and maintainability over style.
+4. Do not generate style-only noise.
+5. Missing review scope or evidence must stay visible.
+6. Brownfield owners and existing conventions are binding unless deviation is justified.
+7. Distinguish blocking defects from fixable review findings.
+8. CR does not grant QA pass.
+
+## When To Use
+- after `CD+Tests`
+- before `QA`
+- when code changes exist
+- when multiple agents or contributors touched the same area
+- when a commit-near change needs explicit review evidence
+
+## Inputs
+Use what is available:
+
+- changed files and diff
+- affected neighbouring code
+- test/build results
+- Brownfield Analysis
+- Task Plan and TP Review
+- Clean Implementation Review
+- runtime or UI evidence
+- known risks or follow-up decisions
+
+If no code changes are present, do not invent a CR result.
+
+## Workflow
+1. Inspect the changed files and directly impacted neighbours.
+2. Check correctness, edge cases, and error paths.
+3. Check security, data handling, and state ownership risks.
+4. Check regression and compatibility risks.
+5. Check maintainability only where it creates real defect or change-risk exposure.
+6. Classify the overall result:
+   - `pass`
+   - `revise`
+   - `block`
+   - `not_applicable`
+7. Set exactly one required next step.
+
+## Output
+Use this compact structure:
+
+```text
+## Code Review
+- decision: pass | revise | block | not_applicable
+- findings:
+  - [severity] file/path - issue - evidence
+- missing_evidence:
+- risks:
+- required_next_step:
+```
+
+## Decision Guidance
+- `pass`: no meaningful review finding remains evident in reviewed scope.
+- `revise`: fixable correctness, regression, or maintainability issues remain.
+- `block`: a hard defect, security risk, data-integrity risk, or unresolved critical uncertainty remains.
+- `not_applicable`: no code changes were present for review.
+
+## Forbidden
+This skill must not:
+
+- decide final QA
+- accept a green build as sufficient review evidence
+- hide missing review scope
+- generate style-only findings
+- duplicate TP Review or QA as if they were the same step

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

@@ -0,0 +1,23 @@
+## NAME
+
+`agdf-code-review` - code review
+
+## SYNOPSIS
+
+`/agdf-code-review` [`--help`|`-h`]
+
+## DESCRIPTION
+
+Produces the mandatory Code Review Report for changed code and focuses on correctness, regression, security, and other materially relevant findings before QA.
+
+## EXAMPLES
+
+Trigger the skill:
+
+```text
+> /agdf-code-review
+```
+
+## SEE ALSO
+
+See the full SKILL.md for workflow, output format, and review boundaries.

package/generated/plugins/agdf/skills/agdf-delivery-closeout/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: agdf-delivery-closeout
+description: Use this skill for the final delivery handoff after QA, OR, or UAT when a run should move toward commit, push, or PR. It standardizes commit-ready summaries, UAT-gated commit offers, and the next delivery step without replacing QA or OR decisions.
+---
+
+# delivery-closeout
+
+## Purpose
+Standardize the operational delivery closeout.
+
+It answers:
+
+- what operational delivery status applies after QA, OR, or UAT
+- whether a commit-ready Git summary should be provided
+- whether a commit should be actively offered after `Approval: UAT`
+- which next delivery step makes sense: commit, push, PR, rollout, or none
+- whether evidence-based technical follow-up remains useful
+- whether Context Graph follow-up from OR/QA remains open
+
+This skill does not replace `agdf-qa-gate`, `agdf-release-or`, user approvals, or gate decisions.
+
+## Runtime Contract
+Use `../../meta/agdf-runtime-contract.md` for closeout discipline, gate terms, Context Graph fields, and non-duplication rules.
+
+## Rules
+1. Delivery follows gate clarity.
+2. Never perform commit, push, or PR automatically.
+3. Use one handoff format:
+   - `Commit title`
+   - `Commit body`
+   - optional `Migration/Rollout note`
+4. `Approval: UAT` unlocks an active commit offer when code changes exist.
+5. No commit handoff for runs without code changes.
+6. Always include exactly one next step and one quality outlook.
+
+## When To Use
+- after `QA pass` with code changes
+- after OR when delivery handoff should be clean
+- after `Approval: UAT`
+- when the user asks for commit, push, or PR handoff
+
+Do not use as a substitute for `agdf-qa-gate`, `agdf-release-or`, or `agdf-gate-check`.
+
+## Inputs
+Use what is available:
+
+- QA Report
+- OR
+- current gate status
+- whether code changes exist
+- existing commit-ready summary
+- rollout or migration notes
+- open technical risks or documentation gaps
+- Context Graph impact from OR/QA/review
+
+If code-change status is unclear, do not claim a commit handoff.
+
+## Workflow
+1. Classify the closeout:
+   - `qa_pass_with_code`
+   - `qa_pass_without_code`
+   - `uat_approved_with_code`
+   - `uat_approved_without_code`
+   - `non_delivery_closeout`
+2. Derive Git handoff only when code changes exist.
+3. Set exactly one next delivery step:
+   - offer commit
+   - offer push
+   - offer PR
+   - no further delivery step
+   - run QA/review
+   - obtain UAT/approval
+   - perform documentation follow-up
+4. Set quality outlook:
+   - no further technical follow-up
+   - more tests
+   - refactoring
+   - documentation sharpening
+   - monitoring/runtime verification
+5. If `Approval: UAT` exists and code changes were delivered, actively offer the commit but do not run it.
+
+## Output
+For code-changing runs:
+
+```text
+Delivery status:
+Next step:
+Quality outlook:
+Commit title:
+Commit body:
+Migration/Rollout note:
+```
+
+For non-code runs:
+
+```text
+Delivery status:
+Next step:
+Quality outlook:
+```
+
+## Forbidden
+This skill must not:
+
+- decide QA pass
+- replace OR
+- execute commit, push, or PR
+- invent a commit handoff for non-code runs
+- imply new gate approvals

package/generated/plugins/agdf/skills/agdf-delivery-closeout/help.md

@@ -0,0 +1,23 @@
+## NAME
+
+`agdf-delivery-closeout` - delivery closeout
+
+## SYNOPSIS
+
+`/agdf-delivery-closeout` [`--help`|`-h`]
+
+## DESCRIPTION
+
+Standardizes the operational delivery closeout for a run with a commit-ready Git summary, UAT-gated commit offer, and next delivery step.
+
+## EXAMPLES
+
+Trigger the skill:
+
+```text
+> /agdf-delivery-closeout
+```
+
+## SEE ALSO
+
+See the full SKILL.md for detailed workflow, output format, and decision logic.

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

@@ -0,0 +1,92 @@
+---
+name: agdf-gate-check
+description: Use this skill when the active gate is unclear, when a later-gate artefact is requested, when an exact approval may be missing, or when the next permissible step must be determined. Use it before creating formal artefacts in Structured Delivery and whenever implicit consent might be mistaken for approval.
+---
+
+# gate-check
+
+## Purpose
+Determine the earliest blocking user approval gate and derive:
+
+- the active or blocking gate
+- whether the process is open or blocked
+- currently allowed outputs
+- currently forbidden outputs
+- the exact missing approval
+- the next permissible step
+
+This skill must not create later artefacts such as PRD, SD, TP, CD, CR, QA, or UAT when the gate does not allow them.
+
+## Runtime Contract
+Use `../../meta/agdf-runtime-contract.md` for gate terms, closeout discipline, and non-duplication rules.
+
+## Rules
+1. Fail closed when a required approval or artefact status is missing.
+2. The earliest blocking gate wins.
+3. A user approval is valid only as `Approval: <GateName>`.
+4. Treat `Freigabe: <GateName>` as a legacy alias only when reviewing older German runs.
+5. Implicit consent is not approval.
+6. Do not preview later artefacts while a gate blocks.
+7. Internal process steps are not user approval gates.
+8. OR-lite is allowed if it does not leak blocked content.
+9. SoT/runtime/product-semantics drift can trigger an early product gate, usually `UR`.
+
+## Gate Order
+User gates:
+
+`UR -> PRD -> SD -> TP -> QA -> UAT`
+
+Internal mandatory steps:
+
+`Brownfield Analysis -> CD+Tests -> CR -> OR`
+
+## When To Use
+- Structured Delivery before first artefact creation
+- unclear current gate
+- user says "continue" or similar without exact approval
+- code or a later-gate artefact is requested
+- implementation permission is unclear
+- QA, UAT, or release permission is unclear
+
+Not required for simple Quick Tasks without new product scope and without formal artefacts.
+
+## Inputs
+Use what is available:
+
+- current user request
+- existing exact approvals
+- status of UR, PRD, SD, TP
+- Brownfield Analysis status
+- CD+Tests, CR, QA, UAT status
+- signs of documentation/runtime/product-semantics drift
+
+If a status is not explicit, do not assume it is satisfied.
+
+## Workflow
+1. Check exact approvals.
+2. Check artefact status.
+3. Determine the earliest blocking user gate or internal mandatory step.
+4. Derive allowed and forbidden outputs.
+5. Name the exact missing approval, if any.
+6. If consent was only implicit, say it is not yet approval and provide the exact formula.
+
+## Output
+Keep the result short and operational:
+
+- **Current gate:** `<GateName or internal step>`
+- **Status:** `open | blocked`
+- **Allowed:** `<allowed outputs>`
+- **Forbidden:** `<forbidden outputs>`
+- **Missing approval:** `Approval: <GateName> | none`
+- **Next step:** `<single permissible next step>`
+
+## Forbidden
+This skill must not:
+
+- create PRD before UR approval
+- create SD before PRD approval
+- create TP while earlier gates block
+- perform full Brownfield Analysis unless explicitly requested
+- provide implementation snippets while implementation is gated
+- present QA or UAT as passed without evidence
+- present release as allowed without QA pass and UAT approval where required

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

@@ -0,0 +1,23 @@
+## NAME
+
+`agdf-gate-check` - gate check
+
+## SYNOPSIS
+
+`/agdf-gate-check` [`--help`|`-h`]
+
+## DESCRIPTION
+
+Determines the earliest blocking user approval gate and derives which artefacts are allowed or forbidden, whether an exact approval is missing, and which next step is permissible.
+
+## EXAMPLES
+
+Trigger the skill:
+
+```text
+> /agdf-gate-check
+```
+
+## SEE ALSO
+
+See the full SKILL.md for detailed workflow, output format, and decision logic.