gaia-framework 1.57.0 → 1.57.2

package/_gaia/lifecycle/workflows/4-implementation/sprint-planning/instructions.xml

@@ -1,140 +0,0 @@
-<workflow name="sprint-planning">
-<critical>
-  <mandate>Use sprint state machine: backlog, validating, ready-for-dev, in-progress, invalid, review, done</mandate>
-  <mandate>Support multi-sprint via sprint_id tracking</mandate>
-  <mandate>Only stories with status 'ready-for-dev' are selectable for a sprint</mandate>
-</critical>
-<step n="1" title="Load Epics, Stories, Action Items, and Previous Retro">
-  <action>Read {implementation_artifacts}/action-items.yaml if it exists. Check for HIGH priority items open for 2+ sprints (escalation_count >= 2 AND priority == "high" AND status == "open").
-    If any found: HALT — "Cannot start sprint planning. {count} HIGH priority action item(s) have been open for {escalation_count}+ sprints:
-    {for each: A-{NNN}: {title} (open since {source_sprint}) → Run: /gaia-action-items A-{NNN}}
-    Resolve each item using the command shown above before re-running sprint planning."
-    For MEDIUM/LOW open items: display warning but do NOT halt: "Note: {count} action items still open (non-blocking)."</action>
-  <action>Read {planning_artifacts}/epics-and-stories.md</action>
-  <action>Parse all stories with their priorities, sizes, dependencies</action>
-  <action>Scan {implementation_artifacts}/ for individual story files matching {story_key}-*.md. For each file found, read its frontmatter Status field.</action>
-  <action>Classify stories into selectable and non-selectable:
-    - SELECTABLE: stories with individual files AND status = 'ready-for-dev'
-    - NOT SELECTABLE: stories without individual files → "Story {key} has no individual file — run /gaia-create-story {key} first."
-    - NOT SELECTABLE: stories with files but status ≠ 'ready-for-dev' → "Story {key} is in '{status}' status — must be 'ready-for-dev' to be selectable. Run /gaia-validate-story {key} first."
-  </action>
-  <action>Display the classification to the user: selectable stories table (Key | Title | Priority | Size | Risk | Status) and non-selectable stories with reasons.</action>
-  <action>Load most recent retro-{sprint_id}.md from {implementation_artifacts}/ if available</action>
-  <action>If retro found: extract open action items — carry forward as sprint constraints or tasks. Present to user: "Previous retro action items to carry forward:" with status of each.</action>
-</step>
-<step n="2" title="Optional: Memory Hygiene Check" optional="true">
-  <action>Check if any sidecar directories under {memory_path}/*-sidecar/ contain content beyond their template header</action>
-  <check if="any sidecars have content">
-    <ask>Agent memory sidecars contain decisions from previous sessions. Would you like to run memory hygiene? This spawns a subagent in a separate context. Recommended if architecture or requirement changes occurred since last sprint. (yes / skip)</ask>
-    <action>If yes: spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/engine/workflow.xml, then process {project-root}/_gaia/lifecycle/workflows/anytime/memory-hygiene/workflow.yaml as workflow-config. Run in YOLO mode. Follow the workflow engine instructions EXACTLY."</action>
-    <action>If skip: memory hygiene can be run anytime with /gaia-memory-hygiene</action>
-  </check>
-  <check if="no sidecars have content">
-    <ask>No agent memory sidecar data found. Would you like to run memory hygiene anyway? This is typically skipped for first sprints. (yes / skip)</ask>
-    <action>If yes: spawn subagent as above</action>
-    <action>If skip: continue to next step</action>
-  </check>
-</step>
-<step n="3" title="Sprint Scoping">
-  <ask>Sprint duration (1 week / 2 weeks / custom)?</ask>
-  <ask>Team velocity estimate (story points)?</ask>
-  <ask>Sprint number (for multi-sprint tracking)?</ask>
-</step>
-<step n="4" title="Story Selection">
-  <action>Read sizing_map from {project-root}/_gaia/_config/global.yaml. Use these canonical point values for T-shirt sizes (S/M/L/XL → points). Display the mapping to the user before selection.</action>
-  <action>Select stories for this sprint based on priority and dependencies — only from stories classified as SELECTABLE in Step 1 (status = 'ready-for-dev').</action>
-  <action>Ensure total size fits within velocity estimate using the sizing_map point values</action>
-  <action>Dependency blocking: for each candidate story, check its depends_on list. If any dependency story is NOT in 'done' status, the story CANNOT be included in this sprint. Display: "BLOCKED: Story {key} depends on {dep_key} (status: {dep_status}) — cannot be included until {dep_key} is done."</action>
-  <action>Priority surfacing: after story selection, check for P0 stories that are 'ready-for-dev' but were NOT selected. If any found, display: "WARNING: The following P0/critical stories are ready but not selected for this sprint:" followed by the list with their sizes. Ask user to confirm they intentionally excluded these high-priority stories.</action>
-  <action>If {test_artifacts}/test-plan.md exists: apply risk levels to story selection — buffer 20% for high-risk stories in velocity estimate</action>
-  <action>ATDD check (high-risk ONLY): for each story with risk = high, check if {test_artifacts}/atdd-{story_key}.md exists. If missing, add a sprint risk note: "HIGH-RISK story {key} has no ATDD file — run /gaia-atdd {key} before development." Do NOT flag medium or low risk stories — ATDD is required only for high-risk stories.</action>
-</step>
-<step n="5" title="Update Story Files">
-  <action>For each selected story that has an individual file in {implementation_artifacts}/: update the sprint_id field to "sprint-{N}"</action>
-  <action>For each selected story: invoke status-sync protocol to assign the sprint — keep status as 'ready-for-dev' (do NOT change to backlog). Stories remain ready-for-dev until /gaia-dev-story transitions them to in-progress.
-    <invoke-protocol ref="status-sync" story_key="{story_key}" new_status="ready-for-dev" sprint_id="sprint-{N}" source_workflow="sprint-planning" />
-    Note: sprint-status.yaml may not exist yet at this point (created in Step 8) — the protocol will skip the sprint-status.yaml update if the file doesn't exist.</action>
-  <action>Include all modified story files in the checkpoint files_touched with sha256 checksums</action>
-</step>
-<step n="6" title="Optional: Mobile Testing">
-  <ask>Would you like to create a mobile test plan? This spawns a subagent in a separate context. Recommended for mobile or responsive applications. (yes / skip)</ask>
-  <action>If yes: spawn a subagent using the Agent tool: "Load {project-root}/_gaia/core/engine/workflow.xml, then process {project-root}/_gaia/testing/workflows/mobile-testing/workflow.yaml as workflow-config. Run in YOLO mode. Follow the workflow engine instructions EXACTLY."</action>
-  <action>If skip: mobile testing can be set up anytime later with /gaia-mobile-testing</action>
-</step>
-<step n="7" title="Sprint Plan Generation">
-  <action>Create sprint plan with story assignments and execution order</action>
-  <action>Order by dependency resolution + priority</action>
-  <action>Generate a Sprint Burndown Estimate table showing projected points remaining per day based on wave/story completion schedule. Format: Day | Points Remaining | Stories Completing. This helps the team track expected progress and identify deviations early.</action>
-</step>
-<step n="8" title="Status Initialization">
-  <action>All selected stories remain in 'ready-for-dev' status (assigned to sprint but not yet started)</action>
-  <action>Generate sprint-status.yaml with standardized schema:
-    sprint_id: "sprint-{N}"
-    duration: "{1 week / 2 weeks / custom}"
-    velocity_capacity: {velocity estimate from Step 3}
-    team_size: {number of developers}
-    total_points: {sum of all selected story points}
-    capacity_utilization: "{total_points / velocity_capacity * 100}%"
-    started: "{date}"
-    end_date: "{date}"
-    stories:
-      - key: "{story-key}"
-        title: "{story title}"
-        status: "ready-for-dev"
-        points: {story points from sizing_map}
-        risk_level: "{high/medium/low}"
-        assignee: null
-        blocked_by: null
-        updated: "{date}"
-  </action>
-</step>
-<step n="9" title="Generate Output">
-  <template-output file="{implementation_artifacts}/{sprint_id}-plan.md">
-    Generate sprint plan document with: sprint goals, selected stories (ordered), velocity target, risk assessment, Sprint Burndown Estimate (points remaining per day), and a Testing Readiness section listing ONLY high-risk stories with their ATDD file status. Medium and low risk stories do NOT require ATDD and should NOT appear in the ATDD readiness checks.
-  </template-output>
-  <action>Write sprint-status.yaml to {implementation_artifacts}/sprint-status.yaml</action>
-</step>
-<step n="10" title="Val Validation">
-  <action>Invoke Val to validate the sprint plan. Val verifies:
-    (a) All selected story keys exist as story files with status 'ready-for-dev'
-    (b) Dependency ordering is correct — no story selected before its blocking dependency is 'done'
-    (c) Points math is correct — total selected points ≤ velocity capacity
-    (d) No duplicate story keys in the selection
-    (e) Sprint-status.yaml entries match the sprint plan document
-    If findings: SM auto-fixes (e.g., remove invalid stories, fix ordering), re-validates.
-    If Val fails or crashes: log warning and continue — validation is non-blocking for sprint planning.</action>
-  <invoke-workflow
-    target="{project-root}/_gaia/lifecycle/workflows/4-implementation/val-validate-artifact/workflow.yaml"
-    input_artifact="{implementation_artifacts}/{sprint_id}-plan.md"
-    on_error="warn_and_continue"
-    model_override="opus" />
-</step>
-<step n="11" title="Save to Val Memory">
-  <action>Auto-save sprint planning decisions to Val's memory sidecar (no user prompt required):
-
-  1. Append to {memory_path}/validator-sidecar/decision-log.md:
-     ### [YYYY-MM-DD] Sprint Planning: {sprint_id}
-
-     - **Agent:** validator
-     - **Workflow:** sprint-planning
-     - **Sprint:** {sprint_id}
-     - **Status:** recorded
-
-     Sprint {sprint_id} planned. Duration: {duration}. Velocity: {velocity_capacity} pts.
-     Stories selected: {count} ({total_points} pts, {utilization}% capacity).
-     Story keys: {comma-separated list}.
-     High-risk stories: {count} (ATDD: {verified/missing}).
-     Retro action items carried forward: {count or "none"}.
-
-  2. Replace body of {memory_path}/validator-sidecar/conversation-context.md (preserve header above first ---):
-     Last session: Sprint planning for {sprint_id}.
-     Date: {YYYY-MM-DD}. Stories: {count} ({total_points} pts). Velocity: {velocity_capacity}.
-
-  If {memory_path}/validator-sidecar/ directory or files don't exist, create them with standard headers.
-  If writing fails, log warning and continue — memory save is non-blocking.</action>
-</step>
-<next-step source="lifecycle-sequence.yaml">
-  <primary command="/gaia-dev-story">Start implementing the first story from the sprint</primary>
-  <alternative command="/gaia-sprint-status" context="To review current sprint state"/>
-</next-step>
-</workflow>

package/_gaia/lifecycle/workflows/4-implementation/sprint-planning/workflow.yaml

@@ -1,33 +0,0 @@
-name: sprint-planning
-description: 'Generate sprint plan from epics and stories'
-module: lifecycle
-agent: sm
-template_output_prompt: "auto"
-config_resolved: "{installed_path}/.resolved/sprint-planning.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/4-implementation/sprint-planning"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  epics:
-    whole: "{planning_artifacts}/epics-and-stories.md"
-    load_strategy: "FULL_LOAD"
-  previous_retro:
-    whole: "{implementation_artifacts}/retro-*.md"
-    load_strategy: "INDEX_GUIDED"
-  story_files:
-    whole: "{implementation_artifacts}/{story_key}-*.md"
-    load_strategy: "INDEX_GUIDED"
-quality_gates:
-  pre_start:
-    - check: "test_plan_exists"
-      on_fail: "WARN: Test plan not found at {test_artifacts}/test-plan.md. Sprint risk assessment will be incomplete. Consider running /gaia-test-design."
-tracking_system: "file-system"
-status_file: "{implementation_artifacts}/sprint-status.yaml"
-story_statuses: [backlog, validating, ready-for-dev, in-progress, invalid, review, done]
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/{sprint_id}-plan.md"

package/_gaia/lifecycle/workflows/4-implementation/sprint-status/checklist.md

@@ -1,18 +0,0 @@
----
-title: 'Sprint Status Validation'
-validation-target: 'Sprint status display'
----
-## Reconciliation
-- [ ] Each story's sprint-status.yaml entry compared with story file frontmatter
-- [ ] Divergent statuses corrected (story file wins)
-- [ ] Reconciliation changes logged
-- [ ] Reconciliation changes displayed to user before status display
-## Display
-- [ ] All stories shown with current status
-- [ ] Blocked stories highlighted
-- [ ] Progress percentage shown
-## Tech Debt
-- [ ] Tech debt summary shown (if dashboard exists)
-## Risks
-- [ ] At-risk stories identified
-- [ ] Mitigation suggestions provided

package/_gaia/lifecycle/workflows/4-implementation/sprint-status/instructions.xml

@@ -1,36 +0,0 @@
-<workflow name="sprint-status">
-<critical>
-  <mandate>Highlight blocked stories prominently with reason</mandate>
-  <mandate>Reconcile sprint-status.yaml with story file frontmatter before displaying — story files are the source of truth for story status</mandate>
-</critical>
-<step n="1" title="Load Sprint Status">
-  <action>Read {implementation_artifacts}/sprint-status.yaml</action>
-  <action>Parse all story entries with their statuses</action>
-</step>
-<step n="2" title="Reconcile With Story Files">
-  <action>For each story in sprint-status.yaml: read the story file matching {story_key}*.md in {implementation_artifacts}/. Read ONLY the YAML frontmatter (stop at closing ---) and the Review Gate table. The story file frontmatter is ALWAYS the source of truth — never rely solely on story-index.yaml which may be incomplete.</action>
-  <action>Compare the Status field in the story file frontmatter with the status in sprint-status.yaml</action>
-  <action>If they differ: the story file frontmatter is authoritative — update sprint-status.yaml to match</action>
-  <action>If a story file has all 6 Review Gate rows PASSED and status 'done' but sprint-status.yaml still shows 'review': update sprint-status.yaml to 'done'</action>
-  <action>Log any reconciliation changes: "Reconciled {story_key}: {old_status} → {new_status} (synced from story file)"</action>
-  <action>If any discrepancies were found and reconciled: write a reconciliation report to {implementation_artifacts}/sprint-reconciliation-{date}.md containing: reconciliation timestamp, total stories checked, each discrepancy (story key, old status, new status, source: "story file frontmatter"), and a summary line. If no discrepancies were found, skip writing — no report needed when everything is in sync.</action>
-  <action>After reconciliation: display a change summary to the user before proceeding — for each reconciled story show "{story_key}: {old_status} → {new_status}". If no changes were made, display "All statuses in sync — no reconciliation needed."</action>
-</step>
-<step n="3" title="Display Status">
-  <action>Format output with standard header: "## Sprint Status — {sprint_id} | {date}" followed by summary line: "Progress: {done}/{total} stories ({pct}%) | {points_done}/{total_points} points | Blocked: {blocked_count}"</action>
-  <action>Show stories grouped by status in a table</action>
-  <action>Highlight blocked stories with blocking reason</action>
-  <action>Show progress: done/total, percentage complete</action>
-  <action>If {implementation_artifacts}/tech-debt-dashboard.md exists: read summary metrics section only</action>
-  <action>Show debt summary line: "Tech Debt: {count} items ({fix_now} FIX NOW, {overdue} overdue)"</action>
-  <action>If any FIX NOW items are overdue: include in Step 4 risk flags</action>
-</step>
-<step n="4" title="Surface Risks">
-  <action>Identify at-risk stories: blocked, dependencies not met</action>
-  <action>Flag stories that may miss sprint deadline</action>
-  <action>Suggest mitigation actions</action>
-  <template-output file="{implementation_artifacts}/sprint-status.yaml">
-    Save reconciled sprint status with current story states, progress metrics, and risk flags.
-  </template-output>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/4-implementation/sprint-status/workflow.yaml

@@ -1,19 +0,0 @@
-name: sprint-status
-description: 'Show current sprint status and surface risks'
-module: lifecycle
-agent: sm
-config_resolved: "{installed_path}/.resolved/sprint-status.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/4-implementation/sprint-status"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-input_file_patterns:
-  status:
-    whole: "{implementation_artifacts}/sprint-status.yaml"
-    load_strategy: "FULL_LOAD"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/sprint-status.yaml"

package/_gaia/lifecycle/workflows/4-implementation/tech-debt-review/checklist.md

@@ -1,30 +0,0 @@
----
-title: 'Tech Debt Review Validation'
-validation-target: 'Tech debt dashboard'
----
-## Scan
-- [ ] All story files scanned for tech-debt findings
-- [ ] Sprint-status.yaml parsed for backlog debt stories
-- [ ] Previous dashboard loaded for trend comparison (if exists)
-## Classification
-- [ ] Every debt item assigned exactly one category (design/code/test/infrastructure)
-- [ ] Every debt item tagged with source (finding/triage/manual)
-## Scoring
-- [ ] Impact, effort, and risk-of-inaction scores assigned (1-5 each)
-- [ ] Debt Score computed: (Impact + Risk) - Effort
-- [ ] Priority mapped: FIX NOW (>=7) / PLAN NEXT (4-6) / TRACK (1-3)
-- [ ] Top 5 scores confirmed with user
-## Aging
-- [ ] Age calculated in sprints for every item
-- [ ] SLA thresholds applied (OVERDUE / escalated / review relevance)
-## Dashboard
-- [ ] Summary metrics table complete
-- [ ] Category breakdown table complete
-- [ ] Top 10 debt items listed with scores and actions
-- [ ] Overdue alerts shown for SLA-breaching items
-- [ ] Trend data included (or "First review" noted)
-## Recommendations
-- [ ] Actionable next steps provided with specific /gaia-* commands
-- [ ] Debt ratio assessed with sprint allocation recommendation
-## Output Verification
-- [ ] Dashboard file exists at {implementation_artifacts}/tech-debt-dashboard.md

package/_gaia/lifecycle/workflows/4-implementation/tech-debt-review/instructions.xml

@@ -1,147 +0,0 @@
-<workflow name="tech-debt-review">
-<critical>
-  <mandate>Read ONLY frontmatter + Findings section from story files — never load full content (token budget protection)</mandate>
-  <mandate>Every debt item must be classified, scored, and aged — none may be left unprocessed</mandate>
-  <mandate>Dashboard is a living document — overwrite on each run, preserve trend data from previous version</mandate>
-  <mandate>Each debt item gets a stable ID (TD-1, TD-2, ...) assigned in Step 2. This ID MUST be preserved across ALL subsequent steps — never renumber items when sorting or filtering.</mandate>
-  <mandate>For each triaged item, validate the target story status. Flag items where the target is done (STALE TARGET) or missing (UNASSIGNED).</mandate>
-</critical>
-<step n="1" title="Scan Debt Sources">
-  <action>If {implementation_artifacts}/tech-debt-dashboard.md exists: load it for trend comparison (previous totals, previous items list)</action>
-  <action>Read {implementation_artifacts}/sprint-status.yaml — identify current sprint_id and all stories with status 'backlog'</action>
-  <action>Scan story files in {implementation_artifacts}/ — for each .md file:</action>
-  <action>  1. Read YAML frontmatter (stop at closing ---) to get story key, status, sprint_id, type</action>
-  <action>  2. Scan for ## Findings section — collect rows where Type = 'tech-debt'</action>
-  <action>  3. Also collect findings of Type = 'bug' with Severity = 'medium' or 'low' that are NOT marked [TRIAGED] or [DISMISSED]</action>
-  <action>For each finding marked [TRIAGED → {target_key}], validate the target story:
-    1. Check if {implementation_artifacts}/{target_key}-*.md exists
-    2. If exists: read its frontmatter status field
-    3. Determine resolution status:
-       - Target status = 'backlog' or 'validating' or 'ready-for-dev' → QUEUED
-       - Target status = 'in-progress' → IN PROGRESS
-       - Target status = 'review' → IN REVIEW
-       - Target status = 'done' → STALE TARGET (story completed but debt still exists — finding was likely added after implementation)
-    4. If target file doesn't exist → UNASSIGNED
-    5. If target is not a valid story key (e.g., "cleanup", "later", free text) → UNASSIGNED</action>
-  <action>For each STALE TARGET item: verify whether the debt was actually resolved by the target story.
-    1. Read the finding description — identify what specific file, config, or pattern the debt refers to
-    2. Check the filesystem: does the issue still exist? (e.g., if finding says "duplicate file X", check if both copies still exist; if finding says "missing skill Y", check if it was created)
-    3. If the issue is RESOLVED (no longer exists in filesystem): mark as RESOLVED and exclude from classification/scoring
-    4. If the issue PERSISTS despite target story being done: keep as active debt with status STALE TARGET
-    5. Report: "{N} STALE TARGET items verified: {resolved_count} resolved (excluded), {persists_count} still active"</action>
-  <action>Separate items into two pools: (a) untriaged findings still in story files, (b) triaged debt stories already in backlog</action>
-  <action>If untriaged findings exist: include them in the analysis with Resolution Status = UNASSIGNED. Do NOT recommend running /gaia-triage-findings here — triage may have already run and these items fell through its filters. Flag them for Step 6 recommendations instead.</action>
-  <action>If no debt items found at all: inform user "No technical debt detected" and stop</action>
-</step>
-<step n="2" title="Classify Debt">
-  <action>Before assigning IDs, detect and merge duplicate findings that describe the same root cause:
-    1. Compare all items — two items are duplicates if they describe the same root cause:
-       - Same file/config/pattern referenced
-       - Same type of issue (e.g., "dual directories" from different source stories)
-       - One finding is a subset of another
-    2. For each group of duplicates: merge into a single item
-       - Use the most descriptive title
-       - Combine all source stories (e.g., "E8-S2, E8-S4")
-       - Keep the same target story
-       - Mark as "(merged from {count} findings)" in the Item column
-    3. Report: "Merged {N} duplicate findings into {M} items"</action>
-  <action>Assign each MERGED debt item a stable ID: TD-1, TD-2, TD-3, etc. IDs are assigned AFTER merging so they reflect the final deduplicated list. This ID stays with the item through ALL subsequent steps — never renumber.</action>
-  <action>Categorize each debt item into exactly one category:</action>
-  <action>  DESIGN — architectural shortcuts, missing abstractions, tight coupling, violation of design patterns</action>
-  <action>  CODE — code smells, duplication, excessive complexity, naming inconsistencies, SOLID violations</action>
-  <action>  TEST — missing tests, flaky tests, low coverage areas, manual-only testing</action>
-  <action>  INFRASTRUCTURE — CI/CD gaps, missing monitoring, manual deployment steps, environment drift</action>
-  <action>Tag each item with its source: 'finding' (from dev-story), 'triage' (backlog story from triage-findings), 'manual' (user-reported)</action>
-  <action>If any items have resolution status STALE TARGET or UNASSIGNED, present a warning block BEFORE the classification table:
-    ⚠ Target Validation Issues:
-    - TD-{N}: Target {key} is DONE — finding was likely added after implementation. Needs re-triage: create a new story or dismiss.
-    - TD-{N}: Target "{text}" — no valid story assigned. Needs triage.
-    Recommend: run /gaia-triage-findings to reassign these items.</action>
-  <action>Present classification table with ALL columns:
-    | ID | Item | Category | Source | Target Story | Resolution Status |
-    Resolution Status values: QUEUED, IN PROGRESS, IN REVIEW, STALE TARGET, UNASSIGNED</action>
-  <action>Present category summary table grouped by category with counts</action>
-</step>
-<step n="3" title="Score and Prioritize">
-  <action>For each debt item, assess three dimensions (1-5 scale):</action>
-  <action>  Impact — How much does this affect development velocity, reliability, or user experience? (1=minimal, 5=severe)</action>
-  <action>  Effort — How much work to resolve? (1=trivial fix, 2=few hours, 3=1 story, 4=multi-story, 5=epic-sized)</action>
-  <action>  Risk of Inaction — What happens if ignored for 3 more sprints? (1=nothing, 3=slows team, 5=production incident)</action>
-  <action>Calculate Debt Score = (Impact + Risk of Inaction) - Effort</action>
-  <action>Map to priority: Score >= 7 = FIX NOW, 4-6 = PLAN NEXT, 1-3 = TRACK</action>
-  <action>Sort all items by Debt Score descending. Add a Rank column for sorted position, but KEEP the original TD-{N} ID from Step 2.</action>
-  <action>Present the FULL scored table with all columns preserved:
-    | Rank | ID | Item | Category | Source | Target | Resolution | Impact | Effort | Risk | Score | Priority |</action>
-  <action if="yolo_mode">In YOLO mode: auto-confirm the recommended scores for all items — skip the user review prompt below.</action>
-  <ask>Review the top 5 scored items — confirm or adjust the scores</ask>
-</step>
-<step n="4" title="Calculate Aging">
-  <action>For each debt item, calculate age in sprints:</action>
-  <action>  - Triaged backlog stories: compare story creation sprint to current sprint_id</action>
-  <action>  - Untriaged findings: compare source story sprint_id to current sprint_id</action>
-  <action>  - If sprint_id not available: use file modification date as fallback</action>
-  <action>Apply SLA thresholds and escalate where needed:</action>
-  <action>  FIX NOW items older than 1 sprint → flag as OVERDUE</action>
-  <action>  PLAN NEXT items older than 3 sprints → auto-escalate to FIX NOW</action>
-  <action>  TRACK items older than 5 sprints → flag for relevance review (may be obsolete)</action>
-  <action>Build aging distribution: count items per age bucket (current sprint, 1-2 sprints, 3-4 sprints, 5+ sprints)</action>
-</step>
-<step n="5" title="Generate Dashboard">
-  <action>Load template from {project-root}/_gaia/lifecycle/templates/tech-debt-dashboard-template.md</action>
-  <action>Fill summary metrics: total count, FIX NOW / PLAN NEXT / TRACK counts, overdue count, debt ratio, STALE TARGET count, UNASSIGNED count</action>
-  <action>Fill category table: count and oldest item age per category</action>
-  <action>Fill aging histogram: ASCII bar chart showing items per age bucket</action>
-  <action>Fill top 10 table with ALL columns: ID, item description, category, source, target, resolution status, impact, effort, risk, score, age, priority, recommended action</action>
-  <action>Fill overdue alerts: list all OVERDUE and auto-escalated items with source and age</action>
-  <action>Fill target issues section: list all STALE TARGET and UNASSIGNED items with recommendation to re-triage</action>
-  <action>Fill trend section: compare current totals to previous dashboard (if exists), compute deltas</action>
-  <action>  If no previous dashboard: show "First review — no prior data" in trend section</action>
-  <template-output file="{implementation_artifacts}/tech-debt-dashboard.md">
-    Generate tech debt dashboard from template with all metrics, rankings, aging alerts, target validation issues, and trend data.
-  </template-output>
-</step>
-<step n="6" title="Recommend Actions">
-  <action>Based on dashboard findings, recommend specific next steps:</action>
-  <action>  If any STALE TARGET or UNASSIGNED items exist: "Run /gaia-triage-findings to reassign {count} items with invalid targets"</action>
-  <action>  If any FIX NOW + OVERDUE items exist: "Run /gaia-correct-course to inject these into the current sprint"</action>
-  <action>  If debt ratio > 30%: "Consider dedicating 20% of next sprint capacity to debt reduction"</action>
-  <action>  If TEST debt dominates: "Run /gaia-test-automate to address test coverage gaps"</action>
-  <action>  If DESIGN debt dominates: "Consider /gaia-change-request for architectural refactoring"</action>
-  <action>  If INFRASTRUCTURE debt dominates: "Run /gaia-ci-setup to close CI/CD gaps"</action>
-  <action>  If items were auto-escalated: "Review escalated items — aging has upgraded their priority"</action>
-  <action>Present the specific /gaia-* command chain for each top-priority item</action>
-  <action>For FIX NOW + OVERDUE items: write each to {implementation_artifacts}/action-items.yaml as an action item (if not already tracked):
-    type: "implementation", priority: "high", status: "open",
-    source_workflow: "tech-debt-review", source_sprint: {sprint_id},
-    title: "{debt item description}", related_stories: [{target story if exists}]
-    Check existing action items by title similarity to avoid duplicates.</action>
-</step>
-<step n="7" title="Save to Val Memory">
-  <action>Auto-save tech debt review decisions to Val's memory sidecar (no user prompt required):
-
-  1. Append to {memory_path}/validator-sidecar/decision-log.md:
-     ### [YYYY-MM-DD] Tech Debt Review: {total_count} items
-
-     - **Agent:** validator
-     - **Workflow:** tech-debt-review
-     - **Sprint:** {sprint_id}
-     - **Status:** recorded
-
-     Dashboard: {total_count} items. FIX NOW: {fix_now_count}. PLAN NEXT: {plan_next_count}. TRACK: {track_count}.
-     Overdue: {overdue_count}. Auto-escalated: {escalated_count}.
-     Stale targets: {stale_count}. Unassigned: {unassigned_count}.
-     Debt ratio: {ratio}%. Trend: {delta vs previous} ({up/down/stable}).
-     Top category: {dominant_category} ({count} items).
-     Top 3 FIX NOW items: {brief list with scores}.
-     Recommendations: {list of recommended /gaia-* commands}.
-
-  2. Replace body of {memory_path}/validator-sidecar/conversation-context.md (preserve header above first ---):
-     Last session: Tech debt review for {sprint_id}.
-     Date: {YYYY-MM-DD}. Items: {total_count}. FIX NOW: {fix_now_count}. Overdue: {overdue_count}.
-     Stale targets: {stale_count}. Unassigned: {unassigned_count}.
-     Debt ratio: {ratio}%. Trend: {up/down/stable}.
-
-  If _memory/validator-sidecar/ directory or files don't exist, create them with standard headers.
-  If writing fails, log warning and continue — memory save is non-blocking.</action>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/4-implementation/tech-debt-review/workflow.yaml

@@ -1,24 +0,0 @@
-name: tech-debt-review
-description: 'Aggregate, classify, and prioritize technical debt'
-module: lifecycle
-agent: sm
-template_output_prompt: "auto"
-config_resolved: "{installed_path}/.resolved/tech-debt-review.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/4-implementation/tech-debt-review"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-template: "{project-root}/_gaia/lifecycle/templates/tech-debt-dashboard-template.md"
-input_file_patterns:
-  status:
-    whole: "{implementation_artifacts}/sprint-status.yaml"
-    load_strategy: "FULL_LOAD"
-  stories:
-    pattern: "{implementation_artifacts}/*.md"
-    load_strategy: "FRONTMATTER_ONLY"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/tech-debt-dashboard.md"

package/_gaia/lifecycle/workflows/4-implementation/triage-findings/checklist.md

@@ -1,17 +0,0 @@
----
-title: 'Triage Findings Validation'
-validation-target: 'Triaged development findings'
----
-## Scan
-- [ ] All story files scanned for non-empty Findings tables
-- [ ] Only untriaged findings collected
-## Triage
-- [ ] Every finding has a triage decision (create story, add to existing, or dismiss)
-- [ ] Critical/high severity findings prioritized
-## Stories Created
-- [ ] New backlog stories follow story template format
-- [ ] New stories reference source story in Dependencies
-- [ ] sprint-status.yaml updated with new backlog entries
-## Marking
-- [ ] All processed findings marked as [TRIAGED → {key}] or [DISMISSED] in source story
-- [ ] No untriaged findings remain

package/_gaia/lifecycle/workflows/4-implementation/triage-findings/instructions.xml

@@ -1,124 +0,0 @@
-<workflow name="triage-findings">
-<critical>
-  <mandate>Every finding must be triaged — none may be left unprocessed</mandate>
-  <mandate>New stories created from findings must have status 'backlog'</mandate>
-  <mandate>Source story findings must be marked as triaged with the target story key or dismissed</mandate>
-  <mandate>New stories MUST be appended to epics-and-stories.md under the correct epic — the master planning artifact must stay in sync with story files</mandate>
-  <mandate>New story keys MUST use the next sequential number in the epic — scan existing stories to determine the last key. NEVER reuse an existing key.</mandate>
-  <mandate>New triaged stories MUST NOT be added to sprint-status.yaml — they are backlog items that get assigned to sprints via /gaia-sprint-plan or injected via /gaia-correct-course</mandate>
-</critical>
-<step n="1" title="Scan for Findings">
-  <action>Scan story files in {implementation_artifacts}/ for non-empty Findings tables</action>
-  <action>Collect all findings from ALL story files regardless of status — scan every .md file that has a non-empty Findings table. This ensures triage catches findings from stories in any status (backlog, validating, ready-for-dev, in-progress, invalid, review, done) so nothing is invisible to tech-debt-review later.</action>
-  <action>Skip findings already marked as [TRIAGED] or [DISMISSED]</action>
-  <action>If no untriaged findings found: inform user "No findings to triage" and stop</action>
-</step>
-<step n="2" title="Present Findings">
-  <action>Group findings by severity (critical first, then high, medium, low)</action>
-  <action>For each finding, show: source story key, type, severity, description, suggested action</action>
-  <action>Present to user for triage decisions</action>
-</step>
-<step n="3" title="Triage Each Finding">
-  <action>For each finding, generate a triage recommendation based on:
-    - **Severity:** CRITICAL or HIGH findings → recommend CREATE STORY (standalone fix needed)
-    - **Type:** 'tech-debt' and 'bug' findings → recommend CREATE STORY; 'improvement' findings → consider ADD TO EXISTING
-    - **Scope:** If the finding is closely related to an existing backlog story → recommend ADD TO EXISTING and list candidate backlog stories for the user to pick from
-    - **Relevance:** If the finding describes a temporary workaround that has since been resolved or the issue no longer applies → recommend DISMISS
-    Present the recommendation with reasoning for each finding.</action>
-  <action>For each CREATE STORY recommendation, also recommend a timing/urgency:
-    - **CRITICAL** severity (production bug, security vulnerability, data loss risk) → recommend **NOW**: "Inject into current sprint via /gaia-correct-course after triage completes"
-    - **HIGH** severity (blocking debt, significant bug) → recommend **NEXT SPRINT**: flag as priority P0 so /gaia-sprint-plan picks it up first
-    - **MEDIUM** severity → recommend **BACKLOG**: standard priority P1, pick up when capacity allows
-    - **LOW** severity → recommend **BACKLOG**: standard priority P2, no urgency
-    Present the timing recommendation alongside the triage decision.</action>
-  <action if="yolo_mode">In YOLO mode: auto-apply both the triage recommendation and the timing recommendation for each finding without prompting the user. Log each decision, reasoning, and timing.</action>
-  <action if="not yolo_mode">Present the recommendation, then let the user confirm or override for each finding:</action>
-  <action>  a. CREATE STORY — generate a new story file with status 'backlog', referencing the source story and finding. Use when: the finding represents a standalone piece of work (bug fix, tech debt cleanup, missing feature) that needs its own acceptance criteria and testing.
-    After choosing CREATE STORY, confirm timing: [n] Now (inject into sprint) | [s] Next sprint (P0) | [b] Backlog (standard priority)</action>
-  <action>  b. ADD TO EXISTING — append finding to an existing story's tasks. Use when: the finding is closely related to an existing backlog story and can be addressed as part of that work.
-    When presenting candidate stories: only show stories with status 'backlog', 'validating', 'ready-for-dev', or 'in-progress'.
-    EXCLUDE stories with status 'done' or 'review' — adding a finding to a completed story won't be worked on.
-    If user tries to pick a done story: warn "Story {key} is already done. Adding a finding to a completed story won't be worked on. Choose a different story or use CREATE STORY instead."</action>
-  <action>  c. DISMISS — finding is not actionable or already resolved. Use when: the finding was about a temporary state that no longer exists, the issue has been fixed by a subsequent change, or the risk is accepted.</action>
-</step>
-<step n="4" title="Create Backlog Stories">
-  <action>For each CREATE STORY decision, determine the correct story key:
-    1. Identify which epic the finding belongs to — use the source story's epic_key (e.g., if source is E1-S3, the epic is E1)
-    2. Scan {planning_artifacts}/epics-and-stories.md AND {implementation_artifacts}/ for ALL existing stories in that epic
-    3. Find the highest story number in that epic (e.g., if E1-S1 through E1-S7 exist, the highest is S7)
-    4. Assign the next sequential key: E1-S8
-    5. NEVER reuse an existing key — always increment from the highest found across both sources
-    6. Determine: title (from finding's suggested action), priority (NOW→P0, NEXT SPRINT→P0, BACKLOG→P1/P2), size estimate, risk level (CRITICAL/HIGH→high, MEDIUM→medium, LOW→low)</action>
-  <action>Update {planning_artifacts}/epics-and-stories.md BEFORE spawning create-story (create-story reads this file in its Step 1):
-    1. Read the file and find the epic section for the new story's epic (e.g., ## Epic 1: ...)
-    2. Append the new story entry at the END of that epic's story list — after the last existing story in that epic
-    3. Include: story key, title, priority, size estimate, risk level, and a note "(from triage: {source_story_key})"
-    4. Do NOT insert at the beginning or middle of the list — always append at the end
-    5. If the epic section has a stories table: add a new row at the bottom
-    6. If the epic section has a stories list: add a new item at the bottom</action>
-  <action>Spawn /gaia-create-story as a subagent for full story elaboration and Val validation.
-    Use the Agent tool to invoke the create-story workflow with the following prompt:
-
-    "Run /gaia-create-story {story_key} yolo
-
-    This story was created from a triage finding. Use this context for elaboration:
-    - **Source story:** {source_story_key} ({source_story_title})
-    - **Finding type:** {finding_type}
-    - **Finding severity:** {finding_severity}
-    - **Finding description:** {finding_description}
-    - **Suggested action:** {finding_suggested_action}
-    - **Priority:** {priority}
-    - **Risk level:** {risk_level}
-
-    The story entry has already been added to epics-and-stories.md. Proceed with story creation."
-
-    create-story will: load epics context, spawn Derek (PM) and Theo (Architect) for elaboration,
-    generate the full story file with all sections, run Val validation, and transition to ready-for-dev if validation passes.</action>
-  <action>After the create-story subagent returns:
-    - Verify the story file was created at {implementation_artifacts}/{story_key}-*.md
-    - If the subagent failed or the file does not exist: fall back to generating a minimal story file directly (same as the previous behavior) and warn "create-story subagent failed for {story_key} — created minimal story file. Run /gaia-create-story {story_key} manually to fully elaborate."
-    - Record the result (success with final status, or fallback) for the Step 6 summary</action>
-</step>
-<step n="5" title="Mark Findings as Triaged">
-  <action>In each source story's Findings table, update the processed findings:</action>
-  <action>  - CREATE STORY: append "[TRIAGED → {new_story_key}]" to the Finding column</action>
-  <action>  - ADD TO EXISTING: append "[TRIAGED → {existing_story_key}]" to the Finding column</action>
-  <action>  - DISMISS: append "[DISMISSED]" to the Finding column</action>
-</step>
-<step n="6" title="Summary and Recommendations">
-  <action>Present triage summary: total findings processed, stories created (with keys and priorities), items added to existing stories, dismissed</action>
-  <action>Confirm: "epics-and-stories.md updated with {N} new stories under their respective epics."</action>
-  <action>If any stories were marked as NOW (inject into current sprint):
-    Present: "⚠ {count} story(ies) recommended for immediate sprint injection: {list of story keys with titles}. Run /gaia-correct-course to inject them into the current sprint."
-    Write each NOW story to {implementation_artifacts}/action-items.yaml as an action item:
-    type: "implementation", priority: "high", status: "open", assignee: null,
-    source_workflow: "triage-findings", related_stories: [{story_key}]</action>
-  <action>If any stories were marked as NEXT SPRINT (P0):
-    Present: "{count} story(ies) flagged as P0 for next sprint planning: {list of story keys}. They will be prioritized in /gaia-sprint-plan."</action>
-</step>
-<step n="7" title="Save to Val Memory">
-  <action>Auto-save triage decisions to Val's memory sidecar (no user prompt required):
-
-  1. Append to {memory_path}/validator-sidecar/decision-log.md:
-     ### [YYYY-MM-DD] Triage: {N} findings processed
-
-     - **Agent:** validator
-     - **Workflow:** triage-findings
-     - **Status:** recorded
-     - **Related:** {comma-separated list of source story keys}
-
-     Triaged {N} findings. Created {X} new stories: {list of new_key (title)}.
-     Added {Y} to existing stories: {list of existing_key}.
-     Dismissed {Z}.
-     Timing: {count} NOW (inject), {count} NEXT SPRINT (P0), {count} BACKLOG.
-     Mapping: {new_key → source_key for each created story}
-
-  2. Replace body of {memory_path}/validator-sidecar/conversation-context.md (preserve header above first ---):
-     Last session: Triage of {N} findings from {source_count} stories.
-     Date: {YYYY-MM-DD}. Created: {X} stories. Added: {Y}. Dismissed: {Z}.
-     Urgent: {count} stories flagged for immediate sprint injection.
-
-  If _memory/validator-sidecar/ directory or files don't exist, create them with standard headers.
-  If writing fails, log warning and continue — memory save is non-blocking.</action>
-</step>
-</workflow>

package/_gaia/lifecycle/workflows/4-implementation/triage-findings/workflow.yaml

@@ -1,15 +0,0 @@
-name: triage-findings
-description: 'Triage development findings into backlog stories'
-module: lifecycle
-agent: sm
-config_resolved: "{installed_path}/.resolved/triage-findings.yaml"
-config_source: "{project-root}/_gaia/lifecycle/config.yaml"
-installed_path: "{project-root}/_gaia/lifecycle/workflows/4-implementation/triage-findings"
-instructions: "{installed_path}/instructions.xml"
-validation: "{installed_path}/checklist.md"
-on_error:
-  missing_file: "ask_user"
-  unresolved_variable: "halt"
-
-output:
-  primary: "{implementation_artifacts}/sprint-status.yaml"