gaia-framework 1.57.0 → 1.57.2

package/_gaia/lifecycle/workflows/5-deployment/release-plan/instructions.xml

@@ -1,33 +0,0 @@
-<workflow name="release-plan">
-<critical>
-  <mandate>Every release must have a defined deployment strategy</mandate>
-  <mandate>Staged rollout percentages must be explicit</mandate>
-  <mandate>Communication plan must be included</mandate>
-</critical>
-<step n="1" title="Release Scope">
-  <action>Define what's included: stories, features, bug fixes, breaking changes</action>
-  <action>Assign version number following semantic versioning</action>
-  <action>Identify release dependencies and ordering constraints</action>
-</step>
-<step n="2" title="Deployment Strategy">
-  <action>Select strategy: blue-green, canary, rolling, or big-bang</action>
-  <action>Justify strategy choice based on risk profile and infrastructure</action>
-  <action>Define success criteria for each deployment phase</action>
-</step>
-<step n="3" title="Staged Rollout">
-  <action>Define percentage targets: 1% → 10% → 50% → 100%</action>
-  <action>Set observation windows between stages</action>
-  <action>Define metrics to monitor at each stage</action>
-  <action>Specify abort criteria for each stage</action>
-</step>
-<step n="4" title="Communication Plan">
-  <action>Define stakeholder notification timeline</action>
-  <action>Prepare changelog and release notes</action>
-  <action>Plan user-facing communications if applicable</action>
-</step>
-<step n="5" title="Generate Output">
-  <template-output file="{implementation_artifacts}/release-plan-{version}.md">
-    Generate release plan with: scope, deployment strategy, staged rollout schedule, communication plan, and success criteria.
-  </template-output>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/5-deployment/release-plan/workflow.yaml

@@ -1,19 +0,0 @@
-name: release-plan
-description: 'Staged rollout and release strategy'
-module: lifecycle
-agent: devops
-config_resolved: "{installed_path}/.resolved/release-plan.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/5-deployment/release-plan"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  architecture:
-    whole: "{planning_artifacts}/architecture.md"
-    load_strategy: "FULL_LOAD"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/release-plan-{version}.md"

package/_gaia/lifecycle/workflows/5-deployment/rollback-plan/checklist.md

@@ -1,20 +0,0 @@
----
-title: 'Rollback Plan Validation'
-validation-target: 'Rollback plan document'
-required-inputs: []
----
-## Triggers
-- [ ] Rollback trigger criteria defined
-- [ ] Authority to initiate specified
-## Procedure
-- [ ] Step-by-step rollback documented
-- [ ] Expected duration estimated
-- [ ] Verification steps after rollback defined
-## Data
-- [ ] DB migration reversal plan exists
-- [ ] Non-reversible data identified with mitigation
-## Communication
-- [ ] Notification list defined
-- [ ] Incident response process documented
-## Output Verification
-- [ ] Rollback plan file generated

package/_gaia/lifecycle/workflows/5-deployment/rollback-plan/instructions.xml

@@ -1,33 +0,0 @@
-<workflow name="rollback-plan">
-<critical>
-  <mandate>Rollback must be executable without additional approvals during incident</mandate>
-  <mandate>Data rollback strategy must be explicitly defined</mandate>
-  <mandate>Communication plan must be included</mandate>
-</critical>
-<step n="1" title="Trigger Criteria">
-  <action>Define when to rollback: error rate threshold, latency spike, critical bug</action>
-  <action>Specify automated vs manual rollback triggers</action>
-  <action>Define who has authority to initiate rollback</action>
-</step>
-<step n="2" title="Rollback Procedure">
-  <action>Step-by-step rollback execution plan</action>
-  <action>Define rollback mechanism: redeploy previous version, traffic shift, feature flag</action>
-  <action>Specify expected rollback duration</action>
-  <action>Define verification steps after rollback</action>
-</step>
-<step n="3" title="Data Rollback">
-  <action>Define DB migration reversal plan</action>
-  <action>Specify data fix procedures for any data written by new version</action>
-  <action>Identify data that cannot be rolled back and mitigation plan</action>
-</step>
-<step n="4" title="Communication">
-  <action>Define who to notify during rollback: engineering, stakeholders, users</action>
-  <action>Specify incident response process and escalation path</action>
-  <action>Prepare status page and communication templates</action>
-</step>
-<step n="5" title="Generate Plan">
-  <template-output file="{implementation_artifacts}/rollback-plan-{version}.md">
-    Generate rollback plan with: trigger criteria, step-by-step procedure, data rollback strategy, communication plan, and post-rollback verification steps.
-  </template-output>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/5-deployment/rollback-plan/workflow.yaml

@@ -1,15 +0,0 @@
-name: rollback-plan
-description: 'Rollback trigger criteria and procedures'
-module: lifecycle
-agent: devops
-config_resolved: "{installed_path}/.resolved/rollback-plan.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/5-deployment/rollback-plan"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/rollback-plan-{version}.md"

package/_gaia/lifecycle/workflows/anytime/brownfield-onboarding/checklist.md

@@ -1,52 +0,0 @@
----
-title: 'Brownfield Onboarding Validation'
-validation-target: 'Brownfield onboarding output'
----
-## Step 1: Discovery
-- [ ] Existing project documented
-- [ ] Tech stack identified
-- [ ] Current architecture mapped
-- [ ] Capability flags detected (has_apis, has_events, has_external_deps, has_frontend)
-- [ ] Testing infrastructure assessed
-- [ ] CI/CD pipeline documented
-- [ ] Brownfield assessment generated at {planning_artifacts}/brownfield-assessment.md
-## Step 2: Parallel Documentation Subagents
-- [ ] Dependency map subagent completed — {planning_artifacts}/dependency-map.md exists
-- [ ] Dependency audit subagent completed — {test_artifacts}/dependency-audit-{date}.md exists
-- [ ] API documentation subagent completed (if has_apis) — {planning_artifacts}/api-documentation.md exists
-- [ ] UX design assessment subagent completed (if has_frontend) — {planning_artifacts}/ux-design.md exists
-- [ ] Event catalog subagent completed (if has_events) — {planning_artifacts}/event-catalog.md exists
-- [ ] All API docs use Swagger/OpenAPI format
-- [ ] All diagrams use Mermaid syntax
-## Step 3: NFR Assessment & Performance Test Plan
-- [ ] NFR assessment subagent completed — {test_artifacts}/nfr-assessment.md exists
-- [ ] NFR baseline summary table has real measured values (not placeholders)
-- [ ] Performance test plan created — {test_artifacts}/performance-test-plan-{date}.md exists
-- [ ] Performance budgets defined (P50/P95/P99) based on NFR baselines
-- [ ] Load test scenarios designed (gradual, spike, soak)
-- [ ] Frontend performance targets set if applicable (LCP, INP, CLS)
-- [ ] CI performance gates configured with pass/fail thresholds
-## Step 4: Gap Analysis PRD
-- [ ] If prior prd.md existed, user confirmed overwrite or alternate filename used
-- [ ] PRD created with gap-focused content only
-- [ ] NFR section includes current baseline and target from nfr-assessment.md
-- [ ] Upstream artifacts referenced (api-docs, event-catalog, dependency-map, ux-design)
-- [ ] Priority matrix maps each gap to priority/effort/impact
-## Step 5: Adversarial Review
-- [ ] Adversarial review subagent completed — {planning_artifacts}/adversarial-review-prd-{date}.md exists
-- [ ] Critical/high findings incorporated into PRD
-- [ ] "Review Findings Incorporated" section added to PRD
-## Step 6: Architecture & Phase 3 Handoff
-- [ ] Architecture subagent completed — {planning_artifacts}/architecture.md exists
-- [ ] User informed of remaining Phase 3 sequence: /gaia-review-api (optional) → /gaia-adversarial → /gaia-test-design → /gaia-test-framework (optional) → /gaia-create-epics → /gaia-threat-model → /gaia-infra-design → /gaia-trace → /gaia-ci-setup → /gaia-readiness-check
-## Output Verification
-- [ ] Project documentation exists at {planning_artifacts}/project-documentation.md
-- [ ] API documentation exists at {planning_artifacts}/api-documentation.md (if has_apis)
-- [ ] UX design exists at {planning_artifacts}/ux-design.md (if has_frontend)
-- [ ] Event catalog exists at {planning_artifacts}/event-catalog.md (if has_events)
-- [ ] Dependency map exists at {planning_artifacts}/dependency-map.md
-- [ ] NFR assessment exists at {test_artifacts}/nfr-assessment.md
-- [ ] Performance test plan exists at {test_artifacts}/performance-test-plan-*.md
-- [ ] PRD exists at {planning_artifacts}/prd.md
-- [ ] Architecture exists at {planning_artifacts}/architecture.md
-- [ ] Next step: /gaia-review-api (optional) → /gaia-adversarial → /gaia-test-design → /gaia-test-framework (optional) → /gaia-create-epics → /gaia-threat-model → /gaia-infra-design → /gaia-trace → /gaia-ci-setup → /gaia-readiness-check

package/_gaia/lifecycle/workflows/anytime/brownfield-onboarding/instructions.xml

@@ -1,122 +0,0 @@
-<workflow name="brownfield-onboarding">
-<critical>
-  <mandate>Document existing state before proposing changes</mandate>
-  <mandate>Stories should only cover gaps, not re-implement existing features</mandate>
-  <mandate>All diagrams must use Mermaid syntax — no ASCII art, no text descriptions of diagrams</mandate>
-  <mandate>All API documentation must use Swagger/OpenAPI format</mandate>
-  <mandate>Limit flow diagrams to 3-5 key flows to avoid output bloat</mandate>
-  <mandate>Subagent completion MUST NOT auto-advance the workflow. After all subagents return, pause for user review before proceeding.</mandate>
-</critical>
-
-<step n="1" title="Deep Project Discovery">
-  <action>Invoke document-project workflow to scan codebase</action>
-  <action>Capture: tech stack, architecture, existing features, code quality, conventions</action>
-  <action>API Detection: scan for route definitions, controllers, OpenAPI/Swagger specs. Set {has_apis} flag (true/false)</action>
-  <action>Event Detection: scan for Kafka, RabbitMQ, SNS-SQS, Redis pub-sub, NATS, or other messaging patterns. Set {has_events} flag (true/false)</action>
-  <action>Dependency Detection: scan for outbound HTTP clients, SDKs, service URLs, database connections. Set {has_external_deps} flag (true/false)</action>
-  <action>Frontend Detection: scan for React, Angular, Vue, Flutter, SwiftUI, UI frameworks, CSS/styling. Set {has_frontend} flag (true/false)</action>
-  <action>Testing infrastructure: identify test framework, coverage config, test count, test patterns</action>
-  <action>CI/CD: identify GitHub Actions, Jenkins, Docker, Terraform, or other pipeline files</action>
-  <action>Generate brownfield assessment: read {installed_path}/../../templates/brownfield-assessment-template.md — capture component inventory, technical debt, migration constraints, coexistence strategy, and adoption path. Output to {planning_artifacts}/brownfield-assessment.md</action>
-  <template-output file="{planning_artifacts}/project-documentation.md">
-    Generate enhanced project documentation following the project documentation conventions. Include all standard sections plus: detected capability flags (has_apis, has_events, has_external_deps, has_frontend), testing infrastructure summary, and CI/CD pipeline summary.
-  </template-output>
-</step>
-
-<step n="2" title="Parallel Documentation Subagents">
-  <action>Spawn subagents in parallel using the Agent tool with multiple calls in a single message. Only spawn subagents for detected capabilities.</action>
-  <action>If {has_apis}: spawn subagent — "Scan the codebase at {project-path} for API routes, controllers, and OpenAPI/Swagger specs. Read {installed_path}/../../templates/api-documentation-template.md for the output format. Check if an OpenAPI spec file already exists — if so, validate it against actual routes; if not, generate an OpenAPI 3.x spec from code. Document all endpoints (method, path, handler, auth, parameters, request/response schemas, error formats). Include a Mermaid API flow diagram. List undocumented endpoints as gaps. All API docs must use Swagger/OpenAPI format. Output to {planning_artifacts}/api-documentation.md"</action>
-  <action>If {has_frontend}: spawn subagent — "Scan the codebase at {project-path} for UI frameworks, components, design patterns, and styling. Read {installed_path}/../../templates/ux-design-assessment-template.md for the output format. Document existing UI patterns, navigation structure (Mermaid sitemap), interaction patterns, accessibility (WCAG compliance, ARIA, keyboard nav). Identify UX gaps — propose improvements for gaps only, not redesign of working patterns. Output to {planning_artifacts}/ux-design.md"</action>
-  <action>If {has_events}: spawn subagent — "Scan the codebase at {project-path} for messaging patterns (Kafka, RabbitMQ, SNS-SQS, Redis pub-sub, NATS). Read {installed_path}/../../templates/event-catalog-template.md for the output format. Document messaging infrastructure, produced/consumed events with schemas, external events, delivery guarantees (retry, DLQ, idempotency). Include Mermaid event flow diagrams for 2-3 key flows. Output to {planning_artifacts}/event-catalog.md"</action>
-  <action>Spawn subagent (always) — "Scan the codebase at {project-path} for external dependencies. Read {installed_path}/../../templates/dependency-map-template.md for the output format. Document external service dependencies (APIs consumed, auth, health checks), infrastructure dependencies (databases, caches, queues), key library dependencies (ORM, auth lib — check version currency and CVE risk). Create Mermaid dependency graph. Document contracts, SLAs, and fallback strategies. Identify dependency risks. Output to {planning_artifacts}/dependency-map.md. Then load {project-root}/_gaia/core/tasks/review-dependency-audit.xml, read its entire contents, and follow the flow steps EXACTLY to generate a dependency audit report."</action>
-  <action>Wait for all subagents to complete. Verify each expected output file exists: dependency-map.md at {planning_artifacts}/ (always), api-documentation.md at {planning_artifacts}/ (if has_apis), ux-design.md at {planning_artifacts}/ (if has_frontend), event-catalog.md at {planning_artifacts}/ (if has_events), dependency-audit-{date}.md at {test_artifacts}/ (always).</action>
-  <action>If any subagent failed to write its output file: the orchestrator MUST write the file on the subagent's behalf using the paths declared in workflow.yaml output.artifacts. Do NOT use hardcoded paths — read the workflow config to determine the correct output directory for each artifact. Specifically: dependency-audit goes to {test_artifacts}/, all other Step 2 artifacts go to {planning_artifacts}/.</action>
-  <template-output file="{planning_artifacts}/brownfield-subagent-summary.md">
-    After all subagents complete, summarize: which subagents ran, artifacts produced, file paths, and any errors. This checkpoint ensures user reviews subagent results before NFR assessment.
-  </template-output>
-</step>
-
-<step n="3" title="NFR Assessment &amp; Performance Test Plan">
-  <action>Spawn a subagent — "Analyze the codebase at {project-path} for non-functional requirements. Read {installed_path}/../../templates/nfr-assessment-template.md for the output format. Assess: code quality (linting, complexity, duplication), security posture (dependency vulnerabilities, secrets handling, auth quality — load security-basics skill section vulnerability-scanning if needed), performance (bundle size if frontend, query patterns, caching, resource management), accessibility (ARIA, semantic HTML, keyboard nav if frontend), test coverage (framework, count, coverage %, untested areas, quality), CI/CD (build pipeline, deploy strategy, environments, IaC). Create NFR Baseline Summary Table with measured values (not placeholders). Output to {test_artifacts}/nfr-assessment.md. Then create a performance test plan: load {project-root}/_gaia/testing/knowledge/performance/k6-patterns.md for load testing patterns. If {has_frontend}: also load {project-root}/_gaia/testing/knowledge/performance/lighthouse-ci.md. Define performance budgets (P50/P95/P99) based on NFR baselines, load test scenarios (gradual, spike, soak), backend profiling targets (slow queries, N+1, connection pools), CI performance gates. If {has_frontend}: define Core Web Vitals targets (LCP under 2.5s, INP under 200ms, CLS under 0.1). Output to {test_artifacts}/performance-test-plan-{date}.md"</action>
-  <action>When subagent returns: verify both {test_artifacts}/nfr-assessment.md and {test_artifacts}/performance-test-plan-{date}.md exist. If the subagent failed to write files, the orchestrator MUST write them to {test_artifacts}/ as declared in workflow.yaml output.artifacts — do NOT fall back to {planning_artifacts}/.</action>
-</step>
-
-<step n="4" title="Create PRD for Gaps">
-  <action>Read the PRD template from {installed_path}/../../templates/prd-template.md</action>
-  <action>Read upstream artifacts to inform gap analysis:</action>
-  <action>— nfr-assessment.md → NFR section gets real "Current Baseline" and "Target" columns</action>
-  <action>— api-documentation.md (if exists) → extract API gaps (undocumented endpoints, missing validation)</action>
-  <action>— event-catalog.md (if exists) → extract messaging gaps (missing DLQ, missing schemas)</action>
-  <action>— dependency-map.md → extract dependency risks (outdated versions, missing health checks)</action>
-  <action>— dependency-audit-{date}.md → extract critical/high findings as gap requirements (CVEs, outdated packages, license conflicts)</action>
-  <action>— ux-design.md (if exists) → extract UX gaps (accessibility violations, inconsistent patterns)</action>
-  <action>Invoke create-prd logic in brownfield mode: fill every section with gap-focused content only</action>
-  <action>Overview = existing project summary + what gaps this PRD addresses</action>
-  <action>Goals = gap closure goals only. Non-Goals = existing features that will NOT be re-implemented</action>
-  <action>User Stories = stories for gap features only, not existing functionality</action>
-  <action>Functional Requirements = gap requirements organized by priority</action>
-  <action>Non-Functional Requirements = NFR gaps with current baseline and target from {test_artifacts}/nfr-assessment.md</action>
-  <action>If {planning_artifacts}/prd.md already exists: WARN user — "A PRD already exists. Continuing will overwrite it with brownfield gap content. Choose: (a) overwrite, (b) save as prd-brownfield-gaps.md instead." If user chooses (b), adjust template-output path accordingly.</action>
-  <template-output file="{planning_artifacts}/prd.md">
-    Generate a PRD following the standard template structure. YAML frontmatter MUST include: mode: brownfield, baseline_version: {version from package.json or inferred}, focus: gap-filling. Add "Mode: Brownfield — gaps only" to the header. All sections must follow the template format but contain only gap-focused content. NFR section must include "Current Baseline" and "Target" columns with real values from {test_artifacts}/nfr-assessment.md. Include a Priority Matrix section mapping each gap to priority/effort/impact.
-  </template-output>
-</step>
-
-<step n="5" title="Adversarial Review &amp; PRD Refinement">
-  <action>Spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-adversarial.xml. Read its entire contents. Target: {planning_artifacts}/prd.md. Target label: prd. Follow the task instructions EXACTLY." This is required — findings will be incorporated back into the PRD.</action>
-  <action>When subagent returns: verify adversarial-review-prd-{date}.md exists in {planning_artifacts}/</action>
-  <action>Read {planning_artifacts}/adversarial-review-prd-{date}.md — extract critical and high severity findings</action>
-  <action>For each critical/high finding: add as a new requirement or refine an existing requirement in the PRD</action>
-  <action>Add a "## Review Findings Incorporated" section to the PRD listing each finding, its severity, and how it was addressed</action>
-  <template-output file="{planning_artifacts}/prd.md">
-    Update the PRD with adversarial review findings incorporated. Critical/high findings become new requirements or refine existing ones. Add "Review Findings Incorporated" section.
-  </template-output>
-</step>
-
-<step n="6" title="Architecture">
-  <action>Architecture is created using the Phase 3 workflow which auto-detects brownfield mode from the PRD "Mode: Brownfield" header set in step 4.</action>
-  <action>If {planning_artifacts}/architecture.md already exists: WARN user — "An architecture document already exists. Continuing will overwrite it with the brownfield version. Choose: (a) overwrite, (b) save as architecture-brownfield.md instead." If user chooses (b), instruct the subagent to output to {planning_artifacts}/architecture-brownfield.md.</action>
-  <action>Spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/engine/workflow.xml, then process {project-root}/_gaia/lifecycle/workflows/3-solutioning/create-architecture/workflow.yaml as workflow-config. Run in YOLO mode. Follow the workflow engine instructions EXACTLY." When subagent returns: verify the architecture file exists at the chosen path.</action>
-  <action>After architecture is generated: verify it has YAML frontmatter with mode: brownfield, baseline_version: {version}, and update_scope: [list of components being modified]. If these fields are missing, append them to the YAML frontmatter block.</action>
-  <action>The remaining Phase 3 sequence must be run after this workflow completes:
-  /gaia-review-api (optional, if APIs) → /gaia-adversarial → /gaia-test-design → /gaia-test-framework (optional) → /gaia-create-epics → /gaia-threat-model → /gaia-infra-design → /gaia-trace → /gaia-ci-setup → /gaia-readiness-check</action>
-</step>
-
-<step n="7" title="Bootstrap Val Ground Truth" optional="true">
-  <action>Check if Val is installed: verify {project-root}/_gaia/lifecycle/agents/validator.md exists AND {memory_path}/validator-sidecar/ directory exists</action>
-  <check if="validator.md not found OR validator-sidecar/ not found">Skip Step 7 silently — Val is not installed. Brownfield onboarding continues without ground truth bootstrap.</check>
-
-  <ask>Step 7: Bootstrap Val ground truth from brownfield assessment? [y/n]</ask>
-
-  <action>Check if /gaia-refresh-ground-truth workflow exists: look for {project-root}/_gaia/lifecycle/workflows/*/refresh-ground-truth/ directory</action>
-  <check if="refresh-ground-truth workflow directory not found">Val ground truth bootstrap skipped — refresh-ground-truth workflow not available. Run /gaia-refresh-ground-truth manually after E8-S9 is implemented. Brownfield onboarding completes successfully.</check>
-
-  <action>Invoke /gaia-refresh-ground-truth to scan the filesystem and populate framework inventory facts (workflows, agents, skills, commands) into ground-truth.md</action>
-  <invoke-workflow ref="refresh-ground-truth" mode="yolo" />
-
-  <action>Load brownfield-extraction section of ground-truth-management skill JIT from {project-root}/_gaia/lifecycle/skills/ground-truth-management.md</action>
-  <action>Read available brownfield artifacts and extract project-specific facts. For each artifact, check if the file exists before reading — skip missing artifacts without error:
-    — {planning_artifacts}/brownfield-assessment.md: extract tech stack, dependencies, file counts, project structure → file-inventory and variable-inventory entries
-    — {planning_artifacts}/project-documentation.md: extract architecture patterns, conventions, config values → structural-pattern and cross-reference entries
-    — {test_artifacts}/nfr-assessment.md (if present): extract performance targets, security requirements → variable-inventory entries</action>
-
-  <action>Write extracted project facts to {memory_path}/validator-sidecar/ground-truth.md. If ground-truth.md already exists with content: merge new facts with existing entries — add new facts, update changed facts, flag removed facts — never destructive overwrite. Follow merge semantics from ground-truth-management conflict-resolution section. If ground-truth.md is empty or new: write all extracted facts as initial seed entries with verification count = 1.</action>
-  <action>Report: "Seeded {N} ground-truth entries from brownfield artifacts + filesystem scan"</action>
-</step>
-
-<next-step command="/gaia-review-api">
-  Run the remaining Phase 3 sequence after this workflow:
-  1. /gaia-review-api — review API design against standards (optional, if APIs exist)
-  2. /gaia-adversarial — adversarial review of architecture
-  3. /gaia-test-design — create risk-based test plan (required before epics)
-  4. /gaia-test-framework — setup test framework (optional)
-  5. /gaia-create-epics — create epics and stories for gap requirements
-  6. /gaia-threat-model — security threat model
-  7. /gaia-infra-design — infrastructure design
-  8. /gaia-trace — traceability matrix
-  9. /gaia-ci-setup — CI pipeline setup
-  10. /gaia-readiness-check — implementation readiness validation
-
-  WARNING: If Phase 3 artifacts already exist from a prior greenfield setup (test-plan.md, epics-and-stories.md), running these workflows will overwrite them. Consider backing up existing artifacts or using the brownfield PRD path to generate separate brownfield-specific outputs.
-</next-step>
-</workflow>

package/_gaia/lifecycle/workflows/anytime/brownfield-onboarding/test-step7.sh

@@ -1,149 +0,0 @@
-#!/usr/bin/env bash
-# E8-S17 — Structural validation tests for Step 7 in brownfield instructions.xml
-# RED phase: All tests should FAIL because Step 7 does not exist yet.
-
-FILE="$(dirname "$0")/instructions.xml"
-PASS=0
-FAIL=0
-ERRORS=()
-
-count_matches() {
-  local pattern="$1"
-  local file="$2"
-  grep -c "$pattern" "$file" 2>/dev/null || printf "0"
-}
-
-count_matches_after_line() {
-  local pattern="$1"
-  local file="$2"
-  local start_line="$3"
-  if [ "$start_line" -gt 0 ] 2>/dev/null; then
-    tail -n +"$start_line" "$file" | grep -c "$pattern" 2>/dev/null || printf "0"
-  else
-    printf "0"
-  fi
-}
-
-assert() {
-  local desc="$1"
-  local actual="$2"
-  local expected="${3:-1}"
-  if [ "$actual" -ge "$expected" ] 2>/dev/null; then
-    PASS=$((PASS + 1))
-    echo "  PASS: $desc"
-  else
-    FAIL=$((FAIL + 1))
-    ERRORS+=("$desc")
-    echo "  FAIL: $desc"
-  fi
-}
-
-echo "=== E8-S17 Structural Tests ==="
-echo ""
-
-# Locate step lines
-step6_line=$(grep -n 'step n="6"' "$FILE" 2>/dev/null | head -1 | cut -d: -f1)
-step6_line=${step6_line:-0}
-step7_line=$(grep -n 'step n="7"' "$FILE" 2>/dev/null | head -1 | cut -d: -f1)
-step7_line=${step7_line:-0}
-
-# --- AC1: Step 7 exists after Step 6 ---
-echo "[AC1] Step 7 exists and is positioned after Step 6"
-
-assert "Step 7 XML block exists with n=\"7\"" "$(count_matches 'step n="7"' "$FILE")"
-assert "Step 7 has title 'Bootstrap Val Ground Truth'" "$(count_matches 'title="Bootstrap Val Ground Truth"' "$FILE")"
-
-if [ "$step7_line" -gt 0 ] && [ "$step6_line" -gt 0 ] && [ "$step7_line" -gt "$step6_line" ]; then
-  assert "Step 7 appears after Step 6 in file" 1
-else
-  assert "Step 7 appears after Step 6 in file" 0
-fi
-
-step7_optional=$(grep 'step n="7"' "$FILE" 2>/dev/null | grep -c 'optional="true"' || printf "0")
-assert "Step 7 is marked optional" "$step7_optional"
-
-for i in 1 2 3 4 5 6; do
-  assert "Step $i still exists" "$(count_matches "step n=\"$i\"" "$FILE")"
-done
-
-echo ""
-
-# --- AC2: User prompt with correct text ---
-echo "[AC2] User prompt for Step 7"
-assert "Ask tag contains 'Bootstrap Val ground truth from brownfield assessment'" \
-  "$(count_matches 'Bootstrap Val ground truth from brownfield assessment' "$FILE")"
-
-echo ""
-
-# --- AC3: Silent skip when Val not installed ---
-echo "[AC3] Silent skip when Val not installed"
-assert "Step 7 checks for validator.md existence" \
-  "$(count_matches_after_line 'validator.md' "$FILE" "$step7_line")"
-assert "Step 7 checks for validator-sidecar/ directory" \
-  "$(count_matches_after_line 'validator-sidecar' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- AC4: Graceful skip when refresh-ground-truth missing ---
-echo "[AC4] Graceful skip when refresh-ground-truth workflow missing"
-assert "Step 7 references refresh-ground-truth workflow" \
-  "$(count_matches_after_line 'refresh-ground-truth' "$FILE" "$step7_line")"
-assert "Step 7 has graceful skip message for missing refresh workflow" \
-  "$(count_matches_after_line 'refresh-ground-truth workflow not available' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- AC5: Invoke refresh-ground-truth ---
-echo "[AC5] Invoke refresh-ground-truth sub-workflow"
-assert "Step 7 has invoke-workflow for refresh-ground-truth" \
-  "$(count_matches_after_line 'invoke-workflow' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- AC6: Brownfield-specific artifact extraction ---
-echo "[AC6] Brownfield-specific artifact extraction"
-assert "Step 7 references brownfield-extraction skill section" \
-  "$(count_matches_after_line 'brownfield-extraction' "$FILE" "$step7_line")"
-assert "Step 7 reads brownfield-assessment.md" \
-  "$(count_matches_after_line 'brownfield-assessment.md' "$FILE" "$step7_line")"
-assert "Step 7 reads project-documentation.md" \
-  "$(count_matches_after_line 'project-documentation.md' "$FILE" "$step7_line")"
-assert "Step 7 reads nfr-assessment.md" \
-  "$(count_matches_after_line 'nfr-assessment.md' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- AC7: Handle missing artifacts gracefully ---
-echo "[AC7] Handle missing artifacts gracefully"
-assert "Step 7 has conditional checks for artifact existence" \
-  "$(count_matches_after_line 'if.*exists\|if.*available\|if.*present\|skip.*missing' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- AC8: Merge with existing ground truth ---
-echo "[AC8] Merge with existing ground truth (no destructive overwrite)"
-assert "Step 7 references merge semantics (not overwrite)" \
-  "$(count_matches_after_line 'merge\|never.*overwrite\|additive\|flag.*removed' "$FILE" "$step7_line")"
-assert "Step 7 references ground-truth.md output" \
-  "$(count_matches_after_line 'ground-truth.md' "$FILE" "$step7_line")"
-
-echo ""
-
-# --- XML well-formedness ---
-echo "[Structure] XML integrity"
-close_tags=$(count_matches '</step>' "$FILE")
-assert "XML has balanced step tags (7 closing tags for 7 steps)" "$close_tags" 7
-
-echo ""
-echo "=== Results: $PASS passed, $FAIL failed ==="
-
-if [ "$FAIL" -gt 0 ]; then
-  echo ""
-  echo "Failed tests:"
-  for err in "${ERRORS[@]}"; do
-    echo "  - $err"
-  done
-  exit 1
-fi
-
-exit 0

package/_gaia/lifecycle/workflows/anytime/brownfield-onboarding/workflow.yaml

@@ -1,33 +0,0 @@
-name: brownfield-onboarding
-description: 'Apply GAIA framework to an existing project with comprehensive developer knowledge base'
-module: lifecycle
-agent: orchestrator
-config_resolved: "{installed_path}/.resolved/brownfield-onboarding.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/anytime/brownfield-onboarding"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-quality_gates:
-  post_complete:
-    - check: "nfr_assessment_exists"
-      on_fail: "HALT: NFR assessment not found at {test_artifacts}/nfr-assessment.md."
-    - check: "performance_test_plan_exists"
-      on_fail: "HALT: Performance test plan not found at {test_artifacts}/. Run /gaia-perf-testing."
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/brownfield-onboarding.md"
-  artifacts:
-    - "{planning_artifacts}/project-documentation.md"
-    - "{planning_artifacts}/api-documentation.md"
-    - "{planning_artifacts}/ux-design.md"
-    - "{planning_artifacts}/event-catalog.md"
-    - "{planning_artifacts}/dependency-map.md"
-    - "{test_artifacts}/nfr-assessment.md"
-    - "{test_artifacts}/performance-test-plan-{date}.md"
-    - "{planning_artifacts}/prd.md"
-    - "{planning_artifacts}/architecture.md"
-    - "{planning_artifacts}/epics-and-stories.md"
-    - "{planning_artifacts}/brownfield-onboarding.md"

package/_gaia/lifecycle/workflows/anytime/document-project/checklist.md

@@ -1,11 +0,0 @@
----
-title: 'Project Documentation Validation'
-validation-target: 'Project documentation'
----
-## Coverage
-- [ ] Tech stack identified
-- [ ] Directory structure documented
-- [ ] Key files identified
-- [ ] Conventions documented
-## Output Verification
-- [ ] Output file exists at {planning_artifacts}/project-documentation.md

package/_gaia/lifecycle/workflows/anytime/document-project/instructions.xml

@@ -1,26 +0,0 @@
-<workflow name="document-project">
-<critical>
-  <mandate>Scan the actual project files — do not guess or assume</mandate>
-</critical>
-<step n="1" title="Scan Project">
-  <action>Identify source files, config files, existing documentation</action>
-  <action>Map directory structure</action>
-</step>
-<step n="2" title="Technology Detection">
-  <action>Identify tech stack from package.json, build files, configs</action>
-  <action>Detect frameworks, build tools, test frameworks</action>
-</step>
-<step n="3" title="Structure Mapping">
-  <action>Generate directory structure overview</action>
-  <action>Identify key entry points and modules</action>
-</step>
-<step n="4" title="Generate Documentation">
-  <action>Create comprehensive project documentation</action>
-  <action>Include: overview, tech stack, structure, conventions, key files</action>
-</step>
-<step n="5" title="Generate Output">
-  <template-output file="{planning_artifacts}/project-documentation.md">
-    Generate project documentation with: overview, technology stack, directory structure, conventions, key files, and entry points.
-  </template-output>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/anytime/document-project/workflow.yaml

@@ -1,15 +0,0 @@
-name: document-project
-description: 'Document an existing project for AI context'
-module: lifecycle
-agent: analyst
-config_resolved: "{installed_path}/.resolved/document-project.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/anytime/document-project"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/project-documentation.md"

package/_gaia/lifecycle/workflows/anytime/generate-project-context/checklist.md

@@ -1,11 +0,0 @@
----
-title: 'Project Context Validation'
-validation-target: 'Project context document'
----
-## Content
-- [ ] Project overview present
-- [ ] Tech stack documented
-- [ ] Conventions listed
-- [ ] AI-optimized rules included
-## Output Verification
-- [ ] Output file exists at {planning_artifacts}/project-context.md

package/_gaia/lifecycle/workflows/anytime/generate-project-context/instructions.xml

@@ -1,22 +0,0 @@
-<workflow name="generate-project-context">
-<critical>
-  <mandate>Output must be optimized for AI agent consumption</mandate>
-</critical>
-<step n="1" title="Scan Project">
-  <action>Read key files: package.json, README, config files</action>
-  <action>Identify project name, version, dependencies</action>
-</step>
-<step n="2" title="Distill Context">
-  <action>Extract: project name, tech stack, conventions, file structure</action>
-  <action>Identify coding standards, naming conventions</action>
-</step>
-<step n="3" title="Generate AI Rules">
-  <action>Create rules file optimized for AI agent consumption</action>
-  <action>Include: do/don't rules, file patterns, conventions</action>
-</step>
-<step n="4" title="Generate Output">
-  <template-output file="{planning_artifacts}/project-context.md">
-    Generate project context document optimized for AI agents with: project overview, tech stack, conventions, do/don't rules, key file patterns.
-  </template-output>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/anytime/generate-project-context/workflow.yaml

@@ -1,15 +0,0 @@
-name: generate-project-context
-description: 'Generate AI-optimized project context'
-module: lifecycle
-agent: analyst
-config_resolved: "{installed_path}/.resolved/generate-project-context.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/anytime/generate-project-context"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/project-context.md"

package/_gaia/lifecycle/workflows/anytime/memory-hygiene/checklist.md

@@ -1,24 +0,0 @@
----
-title: 'Memory Hygiene Validation'
-validation-target: 'Memory hygiene report'
----
-
-## Scan
-- [ ] All 9 sidecar directories enumerated
-- [ ] Empty sidecars identified and skipped
-- [ ] Session/creative logs (orchestrator, storyteller) skipped
-
-## Cross-Reference
-- [ ] Available reference artifacts loaded (architecture.md, prd.md, test-plan.md, etc.)
-- [ ] Each sidecar entry compared against its reference artifact
-- [ ] Each entry classified as ACTIVE, STALE, CONTRADICTED, or ORPHANED
-- [ ] Orphaned and renamed artifact references detected and reported
-
-## User Actions
-- [ ] All flagged entries presented to user with evidence
-- [ ] User confirmed action (Keep/Archive/Delete) for each flagged entry
-- [ ] Sidecar files updated per user choices
-- [ ] Sidecar headers and marker comments preserved after edits
-
-## Output
-- [ ] Report saved to {implementation_artifacts}/memory-hygiene-report-{date}.md