gaia-framework 1.57.0 → 1.57.2

package/_gaia/lifecycle/workflows/3-solutioning/create-architecture/instructions.xml

@@ -1,100 +0,0 @@
-<workflow name="create-architecture">
-<critical>
-  <mandate>Record every significant decision as an ADR in architect-sidecar</mandate>
-  <mandate>PRD must exist before starting architecture</mandate>
-  <mandate>Every technical decision must connect to business value</mandate>
-</critical>
-<step n="1" title="Load Upstream Artifacts">
-  <action>Read {planning_artifacts}/prd.md — extract requirements</action>
-  <action>GATE: verify prd.md contains a "## Review Findings Incorporated" section. If missing, HALT — run /gaia-create-prd first to complete adversarial review and PRD refinement.</action>
-  <action>Read {planning_artifacts}/ux-design.md if available — extract UI requirements</action>
-  <action>Check for brownfield artifacts: {planning_artifacts}/brownfield-assessment.md and {planning_artifacts}/project-documentation.md. If either exists, load them — these contain existing codebase analysis that must inform architecture decisions even if the PRD is not in brownfield mode.</action>
-  <action>Check for {planning_artifacts}/threat-model.md. If it exists, load it — identified threats and mitigations must inform the security architecture in Step 7.</action>
-</step>
-<step n="2" title="Detect Mode">
-  <action>Check {planning_artifacts}/prd.md header for "Mode: Brownfield"</action>
-  <check if="brownfield mode detected">
-    Set {mode} = brownfield. Read brownfield-architecture-template.md from {installed_path}/../../templates/.
-    Also read for cross-references: {planning_artifacts}/api-documentation.md, {planning_artifacts}/event-catalog.md, {planning_artifacts}/dependency-map.md (skip any that don't exist).
-  </check>
-  <check if="no brownfield header">
-    Set {mode} = greenfield. Read architecture-template.md from {installed_path}/../../templates/.
-  </check>
-</step>
-<step n="3" title="Technology Selection">
-  <action>Greenfield: select tech stack with rationale for each choice. Consider: team expertise, scalability needs, ecosystem maturity.</action>
-  <action>Brownfield: discover existing tech stack from project-documentation.md and code scan. Mark ADR status as "Existing" for discovered decisions.</action>
-  <action>If brownfield artifacts were loaded in Step 1: reference the existing tech stack, constraints, and integration points from project-documentation.md and brownfield-assessment.md when evaluating technology choices. Prefer compatibility with the existing stack unless a change is justified by PRD requirements.</action>
-  <action>Record decision as ADR in {memory_path}/architect-sidecar/architecture-decisions.md</action>
-  <ask>Here is the recommended technology stack with rationale for each choice. Please review — confirm to proceed or request changes before I design the full architecture. [confirm / revise]</ask>
-</step>
-<step n="4" title="System Architecture">
-  <action>Greenfield: define component diagram and service boundaries. Describe communication patterns. Record architectural style as ADR.</action>
-  <action>Brownfield: document as-is architecture with Mermaid diagrams:</action>
-  <action>— System context diagram (C4 Level 1) using Mermaid C4 syntax</action>
-  <action>— Container diagram (C4 Level 2) using Mermaid C4 syntax</action>
-  <action>— 3-5 sequence diagrams for key system flows using Mermaid sequence diagram syntax</action>
-  <action>— Data flow diagram using Mermaid flowchart syntax</action>
-  <action>Brownfield: document target architecture for gaps identified in the PRD</action>
-  <action>Brownfield: create as-is vs target delta table</action>
-</step>
-<step n="5" title="Data Architecture">
-  <action>Design database schema and data model</action>
-  <action>Define data flow between components</action>
-  <action>Specify data storage, caching, and replication strategies</action>
-</step>
-<step n="6" title="API Design">
-  <action>Define API endpoint overview</action>
-  <action>Specify authentication and authorization strategy</action>
-  <action>Document API versioning approach</action>
-</step>
-<step n="7" title="Infrastructure &amp; Cross-Cutting Concerns">
-  <action>Define deployment topology and environments (dev, staging, prod)</action>
-  <action>Specify hosting, containerization, and orchestration choices</action>
-  <action>Define monitoring and logging strategy</action>
-  <action>Define security architecture: if threat-model.md was loaded, cross-reference identified threats and map each critical/high threat to an architectural mitigation (authentication strategy, authorization model, data encryption at rest and in transit, audit logging, input validation). If no threat model exists, prompt user for key security requirements.</action>
-  <action>Brownfield: document security architecture, cross-cutting concerns with current state and gaps</action>
-  <action>Brownfield: define migration strategy from as-is to target architecture</action>
-  <action>Brownfield: cross-reference api-documentation.md, event-catalog.md, dependency-map.md in the Integration Architecture section</action>
-</step>
-<step n="8" title="Architecture Decision Records">
-  <action>Review all decisions made in steps 3-7</action>
-  <action>Ensure each significant decision is recorded as ADR</action>
-  <action>Each ADR MUST follow this template: ### ADR-{NNN}: {Title} — **Date:** {YYYY-MM-DD} — **Status:** Proposed | Accepted | Deprecated | Superseded | Existing (brownfield) — **Context:** What is the issue or requirement driving this decision? — **Decision:** What was decided and why this option was chosen over alternatives? — **Alternatives Considered:** What other options were evaluated? — **Consequences:** What are the positive and negative implications? — **Addresses:** {FR/NFR IDs this decision satisfies}</action>
-  <action>Brownfield: mark existing decisions as status "Existing", new gap-related decisions as "Proposed"</action>
-  <action>For each ADR: add an "Addresses" field listing the FR/NFR IDs it satisfies (e.g., "Addresses: FR-003, NFR-002")</action>
-  <action>Append all ADRs to {memory_path}/architect-sidecar/architecture-decisions.md</action>
-  <action>Generate a "Decision → Requirement Mapping" table mapping each ADR to the FR/NFR IDs it addresses. Flag any FR/NFR from the PRD with no corresponding ADR as a coverage gap.</action>
-</step>
-<step n="9" title="Generate Output">
-  <template-output file="{planning_artifacts}/architecture.md">
-    Greenfield: generate architecture document with: technology stack, system architecture, data architecture, API design, infrastructure plan, ADR references, and Decision → Requirement Mapping table.
-    Brownfield: generate architecture document following brownfield-architecture-template. Must include: C4 Level 1 and Level 2 Mermaid diagrams, 3-5 Mermaid sequence diagrams for key flows, Mermaid data flow diagram, as-is/target delta table, migration strategy, and cross-references to api-documentation.md, event-catalog.md, and dependency-map.md.
-  </template-output>
-</step>
-<step n="10" title="Optional: API Design Review">
-  <ask>Would you like to review the API design against REST standards? This spawns a subagent in a separate context. Recommended if your architecture includes APIs. (yes / skip)</ask>
-  <action>If yes: spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-api-design.xml. Read its entire contents. Target: {planning_artifacts}/architecture.md. Follow the flow steps EXACTLY. Generate API design findings report."</action>
-  <action>If skip: API review can be run anytime later with /gaia-review-api</action>
-</step>
-<step n="11" title="Adversarial Review">
-  <action>Spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-adversarial.xml. Read its entire contents. Target: {planning_artifacts}/architecture.md. Target label: architecture. Follow the task instructions EXACTLY." This is required — findings will be incorporated back into the architecture document.</action>
-  <action>When subagent returns: verify adversarial-review-architecture-{date}.md exists in {planning_artifacts}/</action>
-</step>
-<step n="12" title="Incorporate Adversarial Findings">
-  <action>Read {planning_artifacts}/adversarial-review-architecture-{date}.md — extract critical and high severity findings relevant to architecture</action>
-  <action>For each critical/high finding: update the architecture — add missing components, revise decisions, strengthen security/scalability, update ADRs</action>
-  <action>Add a "## Review Findings Incorporated" section to the architecture document listing each finding, its severity, and how it was addressed</action>
-  <template-output file="{planning_artifacts}/architecture.md">
-    Update the architecture document with adversarial review findings incorporated. Critical/high findings lead to architecture revisions. Add "Review Findings Incorporated" section.
-  </template-output>
-</step>
-<next-step source="lifecycle-sequence.yaml">
-  <primary command="/gaia-review-api">Review API design against standards (optional, if APIs exist — otherwise skip to /gaia-adversarial)</primary>
-  <primary command="/gaia-adversarial">Adversarial review of architecture</primary>
-  <primary command="/gaia-test-design">Create risk-based test plan (required before creating epics)</primary>
-  <primary command="/gaia-test-framework">Setup test framework (optional)</primary>
-  <parallel command="/gaia-threat-model">Create security threat model (can run in parallel)</parallel>
-  <parallel command="/gaia-infra-design">Design infrastructure (can run in parallel)</parallel>
-</next-step>
-</workflow>

package/_gaia/lifecycle/workflows/3-solutioning/create-architecture/workflow.yaml

@@ -1,41 +0,0 @@
-name: create-architecture
-description: 'Create architecture and solution design'
-module: lifecycle
-agent: architect
-config_resolved: "{installed_path}/.resolved/create-architecture.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/3-solutioning/create-architecture"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  prd:
-    whole: "{planning_artifacts}/prd.md"
-    load_strategy: "FULL_LOAD"
-  ux:
-    whole: "{planning_artifacts}/ux-design.md"
-    load_strategy: "FULL_LOAD"
-  technical_research:
-    whole: "{planning_artifacts}/technical-research.md"
-    load_strategy: "FULL_LOAD"
-  brownfield_assessment:
-    whole: "{planning_artifacts}/brownfield-assessment.md"
-    load_strategy: "FULL_LOAD"
-  project_documentation:
-    whole: "{planning_artifacts}/project-documentation.md"
-    load_strategy: "INDEX_GUIDED"
-  threat_model:
-    whole: "{planning_artifacts}/threat-model.md"
-    load_strategy: "INDEX_GUIDED"
-quality_gates:
-  pre_start:
-    - check: "prd_exists"
-      on_fail: "HALT: Run /gaia-create-prd first — PRD required before architecture"
-  post_complete:
-    - check: "test_plan_recommended"
-      on_fail: "RECOMMEND: Architecture complete. Run /gaia-test-design next to create the test plan before creating epics."
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/architecture.md"

package/_gaia/lifecycle/workflows/3-solutioning/create-epics-stories/checklist.md

@@ -1,30 +0,0 @@
----
-title: 'Epics and Stories Validation'
-validation-target: 'Epics and stories document'
-required-inputs:
-  - '{planning_artifacts}/prd.md'
-  - '{planning_artifacts}/architecture.md'
-  - '{test_artifacts}/test-plan.md'
----
-## Gates
-- [ ] Architecture has "Review Findings Incorporated" section (hard gate — required before epics)
-## Epics
-- [ ] Epics group related features logically
-- [ ] Each epic has description and goal
-## Stories
-- [ ] Each story has acceptance criteria
-- [ ] Each story has size estimate
-- [ ] Each story follows user story format
-## Dependencies
-- [ ] depends_on declared for each story
-- [ ] blocks declared for each story
-- [ ] No circular dependencies
-## Test Integration
-- [ ] test-plan.md read and risk levels extracted
-- [ ] Each story has risk_level field (high/medium/low)
-- [ ] High-risk stories include ATDD reminder in Dev Notes
-## Priority
-- [ ] Stories ordered by dependency + priority
-- [ ] Priority labels assigned (P0/P1/P2)
-## Output Verification
-- [ ] Output file exists at {planning_artifacts}/epics-and-stories.md

package/_gaia/lifecycle/workflows/3-solutioning/create-epics-stories/instructions.xml

@@ -1,86 +0,0 @@
-<workflow name="create-epics-stories">
-<critical>
-  <mandate>Architecture must exist before creating epics</mandate>
-  <mandate>Every story must have depends_on and blocks declarations</mandate>
-  <mandate>Stories must be ordered by dependency topology + business priority</mandate>
-</critical>
-<step n="1" title="Load PRD, Architecture, and UX Design">
-  <action>Read {planning_artifacts}/prd.md — extract functional requirements</action>
-  <action>Read {planning_artifacts}/architecture.md — extract technical components</action>
-  <action>Read {planning_artifacts}/ux-design.md if available — extract UI flows, component hierarchy, interaction patterns, and accessibility requirements. Set {has_ux_design} flag.</action>
-  <action>GATE: verify architecture.md contains a "## Review Findings Incorporated" section. If missing, HALT — run /gaia-create-arch first to complete adversarial review and architecture refinement.</action>
-</step>
-<step n="2" title="Detect Mode">
-  <action>Check {planning_artifacts}/prd.md header for "Mode: Brownfield"</action>
-  <check if="brownfield mode detected">
-    Set {mode} = brownfield. Stories must cover gap requirements ONLY — do NOT create stories for existing implemented features.
-  </check>
-  <check if="no brownfield header">
-    Set {mode} = greenfield. Create stories for all features from the PRD.
-  </check>
-</step>
-<step n="3" title="Define Epics">
-  <action>Group related features into logical epics</action>
-  <action>Each epic: name, description, goal, success criteria</action>
-  <action>Brownfield: epics should focus on gap closure — not existing functionality</action>
-</step>
-<step n="4" title="Break Into Stories">
-  <action>For each epic, create user stories</action>
-  <action>Each story needs: title, description, acceptance criteria, size estimate (S/M/L/XL)</action>
-  <action>Use format: "As a [user], I want to [action] so that [benefit]"</action>
-  <action>Brownfield: stories must trace to PRD gap requirement IDs. Do NOT create stories for existing implemented features.</action>
-  <action>If {has_ux_design}: frontend stories MUST reference specific UX flows, components, and interaction patterns from ux-design.md. Include relevant screen names, navigation paths, and accessibility requirements in acceptance criteria.</action>
-</step>
-<step n="5" title="Apply Test-Plan Risk Levels">
-  <action>Read {test_artifacts}/test-plan.md — extract risk assessment: high-risk areas (revenue-critical, security-sensitive, complex logic)</action>
-  <action>For each story: if it touches a high-risk component, set risk_level: high. Otherwise medium or low.</action>
-  <action>High-risk stories: add to Dev Notes: "Risk: HIGH — run /gaia-atdd before /gaia-dev-story"</action>
-</step>
-<step n="6" title="Declare Dependencies">
-  <action>For each story, declare depends_on: [story-ids] and blocks: [story-ids]</action>
-  <action>Ensure no circular dependencies</action>
-</step>
-<step n="7" title="Priority Ordering">
-  <action>Sort stories by: dependency topology first, then business priority</action>
-  <action>Assign priority: P0 (must-have), P1 (should-have), P2 (nice-to-have)</action>
-</step>
-<step n="8" title="Generate Output">
-  <template-output file="{planning_artifacts}/epics-and-stories.md">
-    Generate epics and stories document. Each story formatted as:
-    ### Story {epic-N}-{story-N}: {Title}
-    - Epic: {epic name}
-    - Priority: {P0/P1/P2}
-    - Size: {S/M/L/XL}
-    - Risk: {high/medium/low}
-    - Depends on: [{story-ids}]
-    - Blocks: [{story-ids}]
-    - Acceptance Criteria:
-      - AC1: {criteria}
-  </template-output>
-</step>
-<step n="9" title="Brownfield: Generate Onboarding Knowledge Base" optional="true" condition="{mode} == brownfield">
-  <action>Skip this step if {mode} is greenfield.</action>
-  <action>Read the brownfield onboarding template from {installed_path}/../../templates/brownfield-onboarding-template.md</action>
-  <action>Generate onboarding doc as a knowledge base index linking to ALL artifacts: project-documentation.md, api-documentation.md (if exists), ux-design.md (if exists), event-catalog.md (if exists), dependency-map.md, nfr-assessment.md, performance-test-plan-{date}.md, prd.md, architecture.md, epics-and-stories.md</action>
-  <action>Include: quick-start guide, project overview, architecture overview, API reference, UX patterns (if frontend), event architecture (if events), dependencies, NFR baselines, performance test plan, gap analysis, stories, conventions, key files</action>
-  <action>Skip sections for optional artifacts that were not generated</action>
-  <action>Include a "Reading Order for New Developers" section at the end</action>
-  <template-output file="{planning_artifacts}/brownfield-onboarding.md">
-    Generate developer knowledge base following the brownfield-onboarding-template. Link to every artifact produced by the brownfield workflow. Skip sections for artifacts that were not generated (optional steps that were skipped). Include quick-start, architecture summary, conventions, key files, and reading order.
-  </template-output>
-</step>
-<step n="10" title="Optional: Edge Case Analysis">
-  <ask>Would you like to hunt for edge cases in the stories? This spawns a subagent in a separate context. Recommended to catch gaps before sprint planning. (yes / skip)</ask>
-  <action>If yes: spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-edge-case-hunter.xml. Read its entire contents. Target: {planning_artifacts}/epics-and-stories.md. Follow the task instructions EXACTLY."</action>
-  <action>If skip: edge case analysis can be run anytime later with /gaia-edge-cases</action>
-</step>
-<step n="11" title="Optional: Adversarial Review">
-  <ask>Would you like to run an adversarial review on the epics and stories? This spawns a subagent in a separate context. Recommended before sprint planning. (yes / skip)</ask>
-  <action>If yes: spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-adversarial.xml. Read its entire contents. Target: {planning_artifacts}/epics-and-stories.md. Target label: epics. Follow the task instructions EXACTLY."</action>
-  <action>If skip: adversarial review can be run anytime later with /gaia-adversarial</action>
-</step>
-<next-step source="lifecycle-sequence.yaml">
-  <primary command="/gaia-atdd">Generate acceptance tests for high-risk stories</primary>
-  <alternative command="/gaia-threat-model" context="If threat modeling not yet done"/>
-</next-step>
-</workflow>

package/_gaia/lifecycle/workflows/3-solutioning/create-epics-stories/workflow.yaml

@@ -1,34 +0,0 @@
-name: create-epics-stories
-description: 'Break requirements into epics and user stories'
-module: lifecycle
-agent: pm
-config_resolved: "{installed_path}/.resolved/create-epics-stories.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/3-solutioning/create-epics-stories"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  prd:
-    whole: "{planning_artifacts}/prd.md"
-    load_strategy: "FULL_LOAD"
-  architecture:
-    whole: "{planning_artifacts}/architecture.md"
-    load_strategy: "FULL_LOAD"
-  test_plan:
-    whole: "{test_artifacts}/test-plan.md"
-    load_strategy: "FULL_LOAD"
-  ux_design:
-    whole: "{planning_artifacts}/ux-design.md"
-    load_strategy: "FULL_LOAD"
-quality_gates:
-  pre_start:
-    - check: "architecture_exists"
-      on_fail: "HALT: Run /gaia-create-arch first — architecture doc required before creating epics"
-    - check: "test_plan_exists"
-      on_fail: "HALT: Test plan not found. Run /gaia-test-design first — test risk levels inform story sizing and ATDD decisions."
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/epics-and-stories.md"

package/_gaia/lifecycle/workflows/3-solutioning/edit-architecture/checklist.md

@@ -1,24 +0,0 @@
----
-title: 'Architecture Edit Validation'
-validation-target: 'Edited Architecture'
----
-## Edit Quality
-- [ ] Requested changes applied correctly
-- [ ] Unchanged sections preserved exactly
-- [ ] Architecture version incremented
-- [ ] Consistency maintained across sections
-## ADR Quality
-- [ ] New ADR(s) created with auto-incremented ID
-- [ ] Superseded ADRs marked with status update
-- [ ] Addresses field maps to FR/NFR IDs
-## Version History
-- [ ] Version note added with date, reason, driver, and CR ID (if applicable)
-## Review Gate
-- [ ] Adversarial review completed OR explicitly skipped for minor edits
-- [ ] "Review Findings Incorporated" section updated (if review ran)
-## Cascade Assessment
-- [ ] Impact classified for: epics/stories, test plan, infrastructure, traceability
-- [ ] Next steps communicated to user
-## Output Verification
-- [ ] Output file saved to {planning_artifacts}/architecture.md
-- [ ] Changes recorded in architect-sidecar memory

package/_gaia/lifecycle/workflows/3-solutioning/edit-architecture/instructions.xml

@@ -1,91 +0,0 @@
-<workflow name="edit-architecture">
-<critical>
-  <mandate>Preserve existing content not being changed — no silent drops, reorders, or modifications</mandate>
-  <mandate>Record every significant decision as a new ADR with auto-incremented ID</mandate>
-  <mandate>Add version note documenting what changed, why, and the CR/reference</mandate>
-</critical>
-<step n="1" title="Load Existing Architecture">
-  <action>Read {planning_artifacts}/architecture.md in full</action>
-  <action>Count existing ADRs in Section 2 (Architecture Decisions) — note highest ADR ID for auto-increment</action>
-  <action>Identify existing Version History entries — note last version number for auto-increment</action>
-  <action>Display current structure summary to user: section headers, ADR count, current version</action>
-</step>
-<step n="2" title="Capture Change Scope">
-  <check if="triggered_by_change_request">Inherit CR ID, technical_impact, and change_description from the triggering workflow context. Skip user questions — proceed directly to scope confirmation.</check>
-  <check if="triggered_by_adversarial_review">Load adversarial review findings as the change scope. Set driver = "adversarial-review". Skip user questions — proceed directly to scope confirmation.</check>
-  <ask>What sections need to change? (List affected architecture sections)</ask>
-  <ask>What is the change? (Describe the modification)</ask>
-  <ask>Why is this change needed? (Driver: change request / technical discovery / adversarial finding / PRD edit cascade)</ask>
-  <ask>Is this linked to a change request or other reference? If so, provide the CR ID or reference.</ask>
-  <action>Record: sections_affected, change_description, driver, cr_id</action>
-  <action>Classify change scope: MINOR (section update, config change) / SIGNIFICANT (new component, API change, data model change) / BREAKING (architectural shift, tech stack change)</action>
-  <action>Confirm scope of changes with user before proceeding</action>
-</step>
-<step n="3" title="Apply Targeted Edits">
-  <action>For each affected section: present current content, propose edits, wait for user confirmation or modification</action>
-  <action>Preserve all unchanged sections exactly as-is — no reordering, no reformatting, no content loss</action>
-  <action>Validate consistency between edited sections and remaining unchanged sections</action>
-  <action>If edits affect component-to-requirement traceability: verify Addresses fields remain accurate</action>
-</step>
-<step n="4" title="Record ADRs">
-  <action>For each significant decision in the edit: create a new ADR entry</action>
-  <action>Auto-increment ADR ID from highest existing (e.g., if ADR-5 exists, new ADR is ADR-6)</action>
-  <action>ADR template:
-    ### ADR-{id}: {Decision Title}
-    - **Status:** Active
-    - **Context:** {Why this decision was needed}
-    - **Decision:** {What was decided}
-    - **Consequences:** {Trade-offs and implications}
-    - **Addresses:** {FR-* / NFR-* IDs this decision addresses}
-  </action>
-  <action>If superseding an existing ADR: set old ADR status to "Superseded by ADR-{new_id}" and add "Supersedes: ADR-{old_id}" to the new entry</action>
-  <action>Auto-increment architecture version: minor bump (e.g., v1.0 → v1.1, v1.3 → v1.4)</action>
-</step>
-<step n="5" title="Add Version Note">
-  <action>Append a new row to the Version History table:
-    | {date} | {change summary} | {driver} | {CR ID or reference} |
-  </action>
-  <action>If no Version History section exists, create one:
-    ## Version History
-    | Date | Change | Reason | CR/Reference |
-    |------|--------|--------|-------------|
-    | {date} | {change summary} | {driver} | {CR ID or reference} |
-  </action>
-</step>
-<step n="6" title="Save and Review Gate">
-  <action>Generate a diff summary showing exactly what changed (sections modified, ADRs added/superseded, version bump)</action>
-  <template-output file="{planning_artifacts}/architecture.md">
-    Save updated architecture document with all edits applied, new ADRs appended, version incremented, and version note added.
-  </template-output>
-  <check if="change_scope == SIGNIFICANT OR change_scope == BREAKING">
-    <action>Adversarial review is REQUIRED for SIGNIFICANT/BREAKING changes.</action>
-    <action>Spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/tasks/review-adversarial.xml. Read its entire contents. Target: {planning_artifacts}/architecture.md. Target label: architecture. Follow the task instructions EXACTLY. Focus review on changed sections: {sections_affected}."</action>
-    <action>When subagent returns: verify adversarial-review-architecture-{date}.md exists.</action>
-    <action>Read findings — extract critical and high severity items.</action>
-    <action>For each critical/high finding: incorporate into architecture document.</action>
-    <action>Update "Review Findings Incorporated" section — append new entries with amendment date.</action>
-    <template-output file="{planning_artifacts}/architecture.md">
-      Update architecture with adversarial review findings incorporated. Append to existing "Review Findings Incorporated" section with amendment date.
-    </template-output>
-  </check>
-  <check if="change_scope == MINOR">
-    <ask>The architecture has been updated with MINOR changes. Would you like to run an adversarial review? (yes / skip for minor edits)</ask>
-    <action>If yes: spawn subagent as above, incorporate findings.</action>
-    <action>If skip: mark "Review Findings Incorporated" as "Incremental edit — adversarial review skipped (minor change)"</action>
-  </check>
-</step>
-<step n="7" title="Cascade Impact Analysis">
-  <action>Classify cascade impact on downstream artifacts:</action>
-  <action>
-    | Downstream Artifact    | Impact | Recommended Action |
-    |------------------------|--------|--------------------|
-    | Epics and Stories       | {NONE/MINOR/SIGNIFICANT} | {/gaia-add-stories or manual update} |
-    | Test Plan               | {NONE/MINOR/SIGNIFICANT} | {/gaia-test-design} |
-    | Infrastructure Design   | {NONE/MINOR/SIGNIFICANT} | {/gaia-infra-design or manual update} |
-    | Traceability Matrix     | {NONE/MINOR/SIGNIFICANT} | {/gaia-trace} |
-  </action>
-  <action>For each artifact with impact > NONE: recommend the appropriate update workflow</action>
-  <action>Report cascade assessment to user with recommended next command(s)</action>
-  <action>Record all architecture changes and new ADRs in Theo's memory sidecar: {memory_path}/architect-sidecar/architecture-decisions.md</action>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/3-solutioning/edit-architecture/workflow.yaml

@@ -1,32 +0,0 @@
-name: edit-architecture
-description: 'Edit an existing architecture document'
-module: lifecycle
-agent: architect
-config_resolved: "{installed_path}/.resolved/edit-architecture.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/3-solutioning/edit-architecture"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  architecture:
-    whole: "{planning_artifacts}/architecture.md"
-    load_strategy: "FULL_LOAD"
-  prd:
-    whole: "{planning_artifacts}/prd.md"
-    load_strategy: "SELECTIVE_LOAD"
-  epics_and_stories:
-    whole: "{planning_artifacts}/epics-and-stories.md"
-    load_strategy: "SELECTIVE_LOAD"
-quality_gates:
-  pre_start:
-    - check: "architecture_exists"
-      on_fail: "HALT: No architecture.md found. Run /gaia-create-arch first."
-  post_complete:
-    - check: "cascade_significant"
-      on_fail: "RECOMMEND: Cascade impact is SIGNIFICANT — run /gaia-create-epics to update stories and /gaia-test-design to update test plan."
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{planning_artifacts}/architecture.md"

package/_gaia/lifecycle/workflows/3-solutioning/implementation-readiness/checklist.md

@@ -1,66 +0,0 @@
----
-title: 'Implementation Readiness Check'
-validation-target: 'Readiness gate report'
----
-## Artifacts
-- [ ] PRD exists and is complete
-- [ ] UX Design exists and is complete
-- [ ] Architecture exists and is complete
-- [ ] Epics/Stories exist and are complete
-## Consistency
-- [ ] Stories trace to PRD requirements
-- [ ] Architecture covers all features
-- [ ] prd.md contains "Review Findings Incorporated" section
-- [ ] architecture.md contains "Review Findings Incorporated" section
-## Cross-Artifact Contradictions
-- [ ] Architecture decisions checked against threat model security requirements (if threat-model.md exists)
-- [ ] Architecture topology checked against infrastructure deployment topology (if infrastructure-design.md exists)
-- [ ] Story component references verified against architecture component inventory
-- [ ] PRD NFR targets verified against architecture design decisions
-- [ ] Critical/high security requirements verified against story acceptance criteria (if threat-model.md exists)
-- [ ] Auth strategy alignment verified across PRD, architecture, and threat model
-- [ ] contradiction_check field present in gate report YAML frontmatter
-- [ ] All BLOCKING contradictions listed in blocking_issues
-- [ ] Contradictions table included in report body
-## TEA Readiness
-- [ ] Technical: team expertise evaluated against chosen stack, learning curve assessed
-- [ ] Estimation: stories use numeric points (not just T-shirt sizes), no oversized stories (>13 pts)
-- [ ] Architecture: all ADRs resolved (none Proposed), adversarial findings incorporated, threat model reviewed
-- [ ] Testing: acceptance criteria testable, NFR targets quantified
-## Test Infrastructure
-- [ ] test-plan.md exists at {test_artifacts}/test-plan.md
-- [ ] traceability-matrix.md covers all PRD requirements
-- [ ] ci-setup.md has enforced quality gates (not advisory-only)
-- [ ] Gate report includes test_plan_exists, traceability_complete, ci_gates_enforced
-## Security
-- [ ] Security requirements documented
-- [ ] Auth strategy defined
-- [ ] Compliance timeline estimated (GDPR, PCI-DSS if applicable)
-- [ ] No P0 compliance stories in Post-MVP epics (or flagged as WARNING)
-## Operational Readiness
-- [ ] Rollback procedure documented and feasible
-- [ ] Observability stack defined (logging, metrics, alerting)
-- [ ] Release strategy defined and infrastructure supports it
-- [ ] Gate report includes rollback_feasible, observability_ready, release_strategy_defined
-## Brownfield Completeness (if brownfield-onboarding.md exists)
-- [ ] dependency-map.md exists with Mermaid dependency graph
-- [ ] nfr-assessment.md exists at {test_artifacts}/nfr-assessment.md with real baseline values
-- [ ] api-documentation.md exists with OpenAPI spec (if APIs detected)
-- [ ] event-catalog.md exists with event tables (if events detected)
-- [ ] ux-design.md exists with accessibility assessment (if frontend detected)
-- [ ] architecture.md has as-is/target sections with Mermaid diagrams
-- [ ] PRD NFR section references nfr-assessment.md baselines
-- [ ] brownfield-onboarding.md links to all generated artifacts
-- [ ] dependency-audit-{date}.md exists in planning-artifacts
-## Report
-- [ ] Machine-readable YAML frontmatter present
-- [ ] date field present in YAML
-- [ ] checks_passed aggregate (e.g., "7/8") in YAML
-- [ ] critical_blockers count in YAML
-- [ ] PASS/FAIL status clear
-- [ ] Section names use standard schema (completeness, consistency, contradictions, tea_readiness, test_infrastructure, security_readiness, operational_readiness, brownfield_completeness)
-- [ ] Values use PASS/FAIL (not boolean true/false), brownfield uses N/A when skipped
-- [ ] contradictions_found and contradictions_blocking counts in frontmatter
-- [ ] Blocking issues listed if FAIL
-## Output Verification
-- [ ] Output file exists at {planning_artifacts}/readiness-report.md