maestro-flow 0.3.10 → 0.3.12

package/.codex/skills/quality-test-gen/SKILL.md

@@ -5,14 +5,46 @@ argument-hint: "[-y|--yes] [-c|--concurrency N] [--continue] \"<phase> [--type u
 allowed-tools: spawn_agents_on_csv, Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
 ---
 
-## Auto Mode
-
-When `--yes` or `-y`: Auto-confirm test plan, skip interactive validation, use defaults for framework detection.
+<purpose>
+Wave-based test generation using `spawn_agents_on_csv`. Each source file/module gets an independent agent that classifies, plans, and writes tests using RED-GREEN methodology. All agents run in a single parallel wave.
 
-# Maestro Test Gen (CSV Wave)
+**Core workflow**: Discover Infrastructure -> Identify Gaps -> Classify Files -> Decompose to CSV -> Parallel Test Gen -> Aggregate Results
 
-## Usage
+```
++---------------------------------------------------------------------------+
+|                  TEST GENERATION CSV WAVE WORKFLOW                         |
++---------------------------------------------------------------------------+
+|                                                                           |
+|  Phase 1: Gap Analysis -> CSV                                             |
+|     +-- Resolve phase directory from arguments                            |
+|     +-- Discover test infrastructure (framework, patterns, conventions)   |
+|     +-- Identify gaps from verification.json + coverage-report.json       |
+|     +-- Classify changed files into unit/integration/e2e/skip             |
+|     +-- Apply --type filter if set                                        |
+|     +-- Generate tasks.csv with one row per source file                   |
+|     +-- User validates test plan breakdown (skip if -y)                   |
+|                                                                           |
+|  Phase 2: Wave Execution Engine                                           |
+|     +-- Wave 1: Test Generation (independent parallel)                    |
+|     |   +-- Each agent generates tests for its assigned source file       |
+|     |   +-- RED phase: write failing test targeting real behavior          |
+|     |   +-- GREEN assessment: check if source already satisfies           |
+|     |   +-- Discoveries shared via board (test patterns, fixtures)        |
+|     |   +-- Results: tests_created + coverage_delta per source file       |
+|     +-- discoveries.ndjson shared across all agents (append-only)         |
+|                                                                           |
+|  Phase 3: Results Aggregation                                             |
+|     +-- Export results.csv + test-gen-report.json                         |
+|     +-- Run full test suite to verify no regressions                      |
+|     +-- Generate context.md with all findings                             |
+|     +-- Update validation.json with new coverage status                   |
+|     +-- Display summary with next steps                                   |
+|                                                                           |
++---------------------------------------------------------------------------+
+```
+</purpose>
 
+<context>
 ```bash
 $quality-test-gen "3"
 $quality-test-gen -c 4 "3 --type unit"
@@ -25,53 +57,13 @@ $quality-test-gen --continue "test-gen-phase3-20260318"
 - `-c, --concurrency N`: Max concurrent agents within the wave (default: 6)
 - `--continue`: Resume existing session
 
+When `--yes` or `-y`: Auto-confirm test plan, skip interactive validation, use defaults for framework detection.
+
 **Output Directory**: `.workflow/.csv-wave/{session-id}/`
 **Core Output**: `tasks.csv` (master state) + `results.csv` (final) + `discoveries.ndjson` (shared exploration) + `context.md` (human-readable report) + `test-gen-report.json` (structured output for downstream)
+</context>
 
----
-
-## Overview
-
-Wave-based test generation using `spawn_agents_on_csv`. Each source file/module gets an independent agent that classifies, plans, and writes tests using RED-GREEN methodology. All agents run in a single parallel wave.
-
-**Core workflow**: Discover Infrastructure → Identify Gaps → Classify Files → Decompose to CSV → Parallel Test Gen → Aggregate Results
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                  TEST GENERATION CSV WAVE WORKFLOW                       │
-├─────────────────────────────────────────────────────────────────────────┤
-│                                                                          │
-│  Phase 1: Gap Analysis → CSV                                             │
-│     ├─ Resolve phase directory from arguments                            │
-│     ├─ Discover test infrastructure (framework, patterns, conventions)   │
-│     ├─ Identify gaps from verification.json + coverage-report.json       │
-│     ├─ Classify changed files into unit/integration/e2e/skip             │
-│     ├─ Apply --type filter if set                                        │
-│     ├─ Generate tasks.csv with one row per source file                   │
-│     └─ User validates test plan breakdown (skip if -y)                   │
-│                                                                          │
-│  Phase 2: Wave Execution Engine                                          │
-│     ├─ Wave 1: Test Generation (independent parallel)                    │
-│     │   ├─ Each agent generates tests for its assigned source file       │
-│     │   ├─ RED phase: write failing test targeting real behavior          │
-│     │   ├─ GREEN assessment: check if source already satisfies           │
-│     │   ├─ Discoveries shared via board (test patterns, fixtures)        │
-│     │   └─ Results: tests_created + coverage_delta per source file       │
-│     └─ discoveries.ndjson shared across all agents (append-only)         │
-│                                                                          │
-│  Phase 3: Results Aggregation                                            │
-│     ├─ Export results.csv + test-gen-report.json                         │
-│     ├─ Run full test suite to verify no regressions                      │
-│     ├─ Generate context.md with all findings                             │
-│     ├─ Update validation.json with new coverage status                   │
-│     └─ Display summary with next steps                                   │
-│                                                                          │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## CSV Schema
+<csv_schema>
 
 ### tasks.csv (Master State)
 
@@ -96,8 +88,8 @@ id,title,description,source_file,test_type,test_framework,deps,context_from,wave
 | `test_framework` | Input | Detected or specified framework: jest/vitest/pytest/mocha/playwright/cypress |
 | `deps` | Input | Semicolon-separated dependency task IDs (empty for independent parallel) |
 | `context_from` | Input | Semicolon-separated task IDs whose findings this task needs (empty for wave 1) |
-| `wave` | Computed | Wave number (always 1 — independent parallel topology) |
-| `status` | Output | `pending` → `completed` / `failed` / `skipped` |
+| `wave` | Computed | Wave number (always 1 -- independent parallel topology) |
+| `status` | Output | `pending` -> `completed` / `failed` / `skipped` |
 | `findings` | Output | Key findings summary: bugs discovered, patterns used (max 500 chars) |
 | `tests_created` | Output | Semicolon-separated paths to generated test files |
 | `coverage_delta` | Output | Coverage improvement estimate: `+N%` or `N new cases` |
@@ -107,36 +99,43 @@ id,title,description,source_file,test_type,test_framework,deps,context_from,wave
 
 Each wave generates `wave-{N}.csv` with extra `prev_context` column (empty for wave 1).
 
----
-
-## Output Artifacts
+### Output Artifacts
 
 | File | Purpose | Lifecycle |
 |------|---------|-----------|
-| `tasks.csv` | Master state — all tasks with status/findings | Updated after wave completes |
+| `tasks.csv` | Master state -- all tasks with status/findings | Updated after wave completes |
 | `wave-{N}.csv` | Per-wave input (temporary) | Created before wave, deleted after |
 | `results.csv` | Final export of all task results | Created in Phase 3 |
 | `discoveries.ndjson` | Shared exploration board | Append-only, carries across agents |
 | `context.md` | Human-readable test generation report | Created in Phase 3 |
 | `test-gen-report.json` | Structured output for downstream commands | Created in Phase 3 |
 
----
-
-## Session Structure
+### Session Structure
 
 ```
 .workflow/.csv-wave/test-gen-{phase}-{date}/
-├── tasks.csv
-├── results.csv
-├── discoveries.ndjson
-├── context.md
-├── test-gen-report.json
-└── wave-{N}.csv (temporary)
++-- tasks.csv
++-- results.csv
++-- discoveries.ndjson
++-- context.md
++-- test-gen-report.json
++-- wave-{N}.csv (temporary)
 ```
+</csv_schema>
 
----
+<invariants>
+1. **Start Immediately**: First action is session initialization, then Phase 1
+2. **Single Wave**: All test generation agents run in one parallel wave (independent topology)
+3. **CSV is Source of Truth**: Master tasks.csv holds all state
+4. **RED-GREEN Methodology**: Write failing test first, then assess -- never write trivially passing tests
+5. **Tests Expose, Not Fix**: Failing tests document bugs; source code changes are NOT permitted
+6. **Discovery Board is Append-Only**: Never clear, modify, or recreate discoveries.ndjson
+7. **Follow Existing Patterns**: Generated tests must match project's test conventions (imports, structure, assertions)
+8. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
+9. **DO NOT STOP**: Continuous execution until all agents complete and results are aggregated
+</invariants>
 
-## Implementation
+<execution>
 
 ### Session Initialization
 
@@ -165,15 +164,13 @@ const sessionFolder = `.workflow/.csv-wave/${sessionId}`
 Bash(`mkdir -p ${sessionFolder}`)
 ```
 
----
-
-### Phase 1: Gap Analysis → CSV
+### Phase 1: Gap Analysis -> CSV
 
 **Objective**: Discover test infrastructure, identify coverage gaps, classify files, generate tasks.csv.
 
 **Decomposition Rules**:
 
-1. **Phase resolution**: Resolve `{phaseArg}` to `.workflow/phases/{NN}-{slug}/`
+1. **Phase resolution**: Resolve `{phaseArg}` via artifact registry in `state.json` to `.workflow/scratch/{type}-{slug}-{date}/`; legacy fallback to `.workflow/phases/{NN}-{slug}/`
 
 2. **Test infrastructure discovery**:
    - Find config files: `jest.config.*`, `vitest.config.*`, `pytest.ini`, `.mocharc.*`
@@ -210,12 +207,10 @@ Bash(`mkdir -p ${sessionFolder}`)
 
 7. **CSV generation**: One row per source file (skip category excluded).
 
-**Wave computation**: Single wave — all tasks are independent parallel (wave = 1).
+**Wave computation**: Single wave -- all tasks are independent parallel (wave = 1).
 
 **User validation**: Display test plan breakdown (skip if AUTO_YES).
 
----
-
 ### Phase 2: Wave Execution Engine
 
 **Objective**: Execute test generation agents in parallel via spawn_agents_on_csv.
@@ -262,12 +257,10 @@ Each agent receives:
 - Gap references (requirement IDs, descriptions)
 - RED-GREEN methodology rules:
   1. **RED**: Write test that fails if behavior is broken (not trivially passing)
-  2. **Verify RED**: Run test — if passes, strengthen; if fails with expected error, good
+  2. **Verify RED**: Run test -- if passes, strengthen; if fails with expected error, good
   3. **GREEN assessment**: If source satisfies, gap was missing test; if fails, record as bug discovery
 - Discovery board protocol for sharing test patterns and fixtures
-- Instruction to NOT fix source code — failing tests are valuable bug documentation
-
----
+- Instruction to NOT fix source code -- failing tests are valuable bug documentation
 
 ### Phase 3: Results Aggregation
 
@@ -332,7 +325,7 @@ Each agent receives:
 6. Generate `context.md`:
 
 ```markdown
-# Test Generation Report — Phase {phase}
+# Test Generation Report -- Phase {phase}
 
 ## Summary
 - Framework: {framework}
@@ -359,13 +352,13 @@ Each agent receives:
 - Existing tests broken: {N} (regressions)
 
 ## Bugs Discovered
-{list of failing tests with descriptions — NOT fixed, documented only}
+{list of failing tests with descriptions -- NOT fixed, documented only}
 
 ## Next Steps
 {suggested_next_command}
 ```
 
-7. Update `validation.json` gaps: change MISSING → COVERED for gaps that now have tests.
+7. Update `validation.json` gaps: change MISSING -> COVERED for gaps that now have tests.
 
 8. Copy `test-gen-report.json` to phase `.tests/` directory.
 
@@ -380,11 +373,9 @@ Each agent receives:
 | Regressions found | `quality-debug` immediately |
 | Coverage still low | Run again with `--type` for uncovered layers |
 
----
-
-## Shared Discovery Board Protocol
+### Shared Discovery Board Protocol
 
-### Standard Discovery Types
+#### Standard Discovery Types
 
 | Type | Dedup Key | Data Schema | Description |
 |------|-----------|-------------|-------------|
@@ -394,7 +385,7 @@ Each agent receives:
 | `blocker` | `data.issue` | `{issue, severity, impact}` | Blocking issue found |
 | `tech_stack` | singleton | `{framework, language, tools[]}` | Technology stack info |
 
-### Domain Discovery Types
+#### Domain Discovery Types
 
 | Type | Dedup Key | Data Schema | Description |
 |------|-----------|-------------|-------------|
@@ -403,7 +394,7 @@ Each agent receives:
 | `mock_strategy` | `data.module` | `{module, strategy, file}` | How a dependency is mocked |
 | `bug_discovered` | `data.location` | `{location, test_file, description, severity}` | Bug found via failing test |
 
-### Protocol
+#### Protocol
 
 1. **Read** `{session_folder}/discoveries.ndjson` before own test generation
 2. **Skip covered**: If discovery of same type + dedup key exists, skip
@@ -414,34 +405,32 @@ Each agent receives:
 ```bash
 echo '{"ts":"<ISO>","worker":"{id}","type":"test_pattern","data":{"name":"api-endpoint-test","file":"src/api/__tests__/users.test.ts","framework":"vitest","description":"supertest + vitest pattern for REST endpoints"}}' >> {session_folder}/discoveries.ndjson
 ```
+</execution>
 
----
-
-## Error Handling
+<error_codes>
 
 | Error | Resolution |
 |-------|------------|
 | Phase directory not found | Abort with error: "Phase {N} not found" |
-| No verification results found | Abort with error: "No verification results — run maestro-verify first" |
+| No verification results found | Abort with error: "No verification results -- run maestro-verify first" |
 | No test framework detected | Abort with error: "No test framework detected (E003)" |
-| No gaps identified | Info: "No coverage gaps found — phase fully tested" |
+| No gaps identified | Info: "No coverage gaps found -- phase fully tested" |
 | Agent timeout | Mark as failed, continue with remaining agents |
 | Test file write conflict | Agent checks for existing test, extends rather than overwrites |
 | CSV parse error | Validate format, show line number |
 | discoveries.ndjson corrupt | Ignore malformed lines |
 | Continue mode: no session found | List available sessions |
 | Regression detected in existing tests | Flag as blocker (W002), do not fix source code |
-
----
-
-## Core Rules
-
-1. **Start Immediately**: First action is session initialization, then Phase 1
-2. **Single Wave**: All test generation agents run in one parallel wave (independent topology)
-3. **CSV is Source of Truth**: Master tasks.csv holds all state
-4. **RED-GREEN Methodology**: Write failing test first, then assess — never write trivially passing tests
-5. **Tests Expose, Not Fix**: Failing tests document bugs; source code changes are NOT permitted
-6. **Discovery Board is Append-Only**: Never clear, modify, or recreate discoveries.ndjson
-7. **Follow Existing Patterns**: Generated tests must match project's test conventions (imports, structure, assertions)
-8. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
-9. **DO NOT STOP**: Continuous execution until all agents complete and results are aggregated
+</error_codes>
+
+<success_criteria>
+- [ ] Session folder created with valid tasks.csv
+- [ ] All test generation agents executed in parallel (single wave)
+- [ ] Test files created following project conventions
+- [ ] RED-GREEN methodology applied (no trivially passing tests)
+- [ ] test-gen-report.json produced with classification and results
+- [ ] context.md produced with test generation report
+- [ ] Full test suite run to verify no regressions
+- [ ] validation.json gaps updated for covered items
+- [ ] discoveries.ndjson append-only throughout
+</success_criteria>

package/.codex/skills/spec-add/SKILL.md

@@ -1,31 +1,44 @@
 ---
 name: spec-add
-description: Add a spec entry (bug, pattern, decision, or rule) to the appropriate specs file
-argument-hint: "<type> <content>"
+description: Add a spec entry to the appropriate specs file by category
+argument-hint: "<category> <content>"
 allowed-tools: Read, Write, Bash, Glob, Grep
 ---
 
-# Spec Add
-
-## Usage
+<purpose>
+Add a spec entry using `<spec-entry>` closed-tag format. Each category maps 1:1 to a single target file.
 
 ```bash
-$spec-add "pattern Always use named exports for utility functions"
-$spec-add "bug Off-by-one in pagination when page=0"
-$spec-add "decision Use Zod for runtime validation over io-ts"
-$spec-add "rule All API endpoints must return structured error objects"
+$spec-add "coding Always use named exports for utility functions"
+$spec-add "learning Off-by-one in pagination when page=0"
+$spec-add "arch Use Zod for runtime validation over io-ts"
+$spec-add "quality All API endpoints must return structured error objects"
 ```
 
-**Arguments**: `<type> <content>` where type is one of: bug, pattern, decision, rule, debug, test, review, validation.
+**Valid categories**: coding, arch, quality, debug, test, review, learning.
+</purpose>
 
----
+<context>
+$ARGUMENTS — `<category> <content>` where category selects the target file.
+
+**Category-to-file mapping (1:1, same as spec-load):**
+| Category | Target file |
+|----------|------------|
+| `coding` | `coding-conventions.md` |
+| `arch` | `architecture-constraints.md` |
+| `quality` | `quality-rules.md` |
+| `debug` | `debug-notes.md` |
+| `test` | `test-conventions.md` |
+| `review` | `review-standards.md` |
+| `learning` | `learnings.md` |
+</context>
 
-## Implementation
+<execution>
 
 ### Step 1: Parse Input
 
-Extract type (first token) and content (remainder) from arguments.
-- Validate type is one of: bug, pattern, decision, rule, debug, test, review, validation (E003 if invalid)
+Extract category (first token) and content (remainder) from arguments.
+- Validate category is one of: coding, arch, quality, debug, test, review, learning (E003 if invalid)
 - Validate content is non-empty (E001 if missing)
 
 ### Step 2: Validate Specs Directory
@@ -36,44 +49,50 @@ test -d .workflow/specs || exit 1  # E002: not initialized
 
 ### Step 3: Route to File
 
-| Type | Primary File | Secondary Update |
-|------|-------------|-----------------|
-| `bug` | `learnings.md` | -- |
-| `pattern` | `learnings.md` | `coding-conventions.md` |
-| `decision` | `learnings.md` | `architecture-constraints.md` |
-| `rule` | `learnings.md` | `quality-rules.md` |
-| `debug` | `learnings.md` | `debug-notes.md` |
-| `test` | `learnings.md` | `test-conventions.md` |
-| `review` | `learnings.md` | `review-standards.md` |
-| `validation` | `learnings.md` | `validation-rules.md` |
+Resolve target file from category-to-file mapping table. If the target file does not exist, create it with a basic header.
 
-### Step 4: Append Entry
+### Step 4: Extract Keywords
 
-Append timestamped entry to `.workflow/specs/learnings.md` using the unified `[type] [date]` format:
+Auto-extract 3-5 relevant keywords from the content. Keywords should be:
+- Lowercase, no spaces (use hyphens for multi-word)
+- Domain-specific terms that would help future lookup
+- Avoid generic words (code, file, function, etc.)
 
-```markdown
-### [{type}] [{YYYY-MM-DD}] {first line of content}
+### Step 5: Write Entry
 
-{content}
-```
+Append `<spec-entry>` closed-tag block to target file:
 
-Example: `### [bug] [2026-03-21] Off-by-one in pagination when page=0`
+```markdown
+<spec-entry category="{category}" keywords="{kw1},{kw2},{kw3}" date="{YYYY-MM-DD}">
 
-If type has a secondary file, also update that file with the new convention/rule/decision.
+### {title extracted from content}
 
-### Step 5: Confirm
+{content}
 
-```
-Added [{type}] to learnings.md
-{Secondary file updated if applicable}
+</spec-entry>
 ```
 
----
+### Step 6: Confirm
 
-## Error Handling
+```
+Added [{category}] to {target_file}
+Keywords: {kw1}, {kw2}, {kw3}
+Verify: /spec-load --keyword {kw1}
+```
+</execution>
 
+<error_codes>
 | Code | Severity | Description |
 |------|----------|-------------|
 | E001 | fatal | Category and content are both required |
 | E002 | fatal | `.workflow/specs/` not initialized -- run `Skill({ skill: "spec-setup" })` first |
-| E003 | fatal | Invalid category -- must be one of: bug, pattern, decision, rule, debug, test, review, validation |
+| E003 | fatal | Invalid category -- must be one of: coding, arch, quality, debug, test, review, learning |
+</error_codes>
+
+<success_criteria>
+- [ ] Category and content parsed and validated
+- [ ] Keywords auto-extracted from content (3-5 terms)
+- [ ] Entry written in `<spec-entry>` closed-tag format with keywords attribute
+- [ ] Entry appended to correct target file
+- [ ] Confirmation displayed with keywords and verify command
+</success_criteria>

package/.codex/skills/spec-load/SKILL.md

@@ -1,26 +1,41 @@
 ---
 name: spec-load
 description: Load relevant specs for current context, optionally filtered by category or keyword
-argument-hint: "[--category <type>] [keyword]"
+argument-hint: "[--category <type>] [--keyword <word>]"
 allowed-tools: Read, Bash, Glob, Grep
 ---
 
-# Spec Load
+<purpose>
+Load relevant specs filtered by category (file-level) and/or keyword (entry-level via `<spec-entry>` tags).
+</purpose>
 
-## Usage
+<context>
+$ARGUMENTS — optional category filter and keyword.
 
 ```bash
 $spec-load
-$spec-load "--category execution"
-$spec-load "authentication"
-$spec-load "--category debug error handling"
+$spec-load "--category coding"
+$spec-load "--keyword auth"
+$spec-load "--category coding --keyword naming"
 ```
 
-**Flags**: `--category <type>` filters by spec category. Optional keyword searches within loaded files.
+**Category-to-file mapping (1:1, same as spec-add):**
 
----
+| Category | File loaded |
+|----------|------------|
+| `coding` | `coding-conventions.md` |
+| `arch` | `architecture-constraints.md` |
+| `quality` | `quality-rules.md` |
+| `debug` | `debug-notes.md` |
+| `test` | `test-conventions.md` |
+| `review` | `review-standards.md` |
+| `learning` | `learnings.md` |
+| `all` (default) | All spec files |
 
-## Implementation
+**Keyword filtering**: When `--keyword` is provided, only entries with matching keyword in their `<spec-entry keywords="...">` attribute are returned. Legacy entries (heading format) are filtered by text grep.
+</context>
+
+<execution>
 
 ### Step 1: Validate Specs Directory
 
@@ -30,46 +45,36 @@ test -d .workflow/specs || exit 1  # E001: not initialized
 
 ### Step 2: Parse Arguments
 
-Extract optional `--category` flag and keyword from arguments.
-
-**Category-to-file mapping:**
-
-| Category | Files Loaded |
-|----------|-------------|
-| `general` | `learnings.md` |
-| `planning` | `architecture-constraints.md` |
-| `execution` | `coding-conventions.md`, `quality-rules.md` |
-| `debug` | `debug-notes.md` |
-| `test` | `test-conventions.md` |
-| `review` | `review-standards.md` |
-| `validation` | `validation-rules.md` |
-| `all` (default) | All spec files |
-
-### Step 3: Load Files
+Extract optional `--category` and `--keyword` flags from arguments.
 
-Read the spec files matching the category filter.
-If no files exist for the category, fall back to loading all specs.
+### Step 3: Load via CLI
 
-### Step 4: Apply Keyword Filter
+```bash
+maestro spec load [--category <cat>] [--keyword <word>]
+```
 
-If a keyword is provided, search within loaded files for matching sections using grep.
-Return only matching sections with file:line references.
-If no matches found, show all content in the category (W001).
+If CLI unavailable, read files directly and apply keyword filter.
 
-### Step 5: Display Results
+### Step 4: Display Results
 
 ```
-=== SPECS: {category} ===
-{For each file}
---- {filename} ---
-{content or matching sections}
+=== SPECS: {category} {keyword ? "keyword=" + keyword : ""} ===
+--- {filename} ({category}) ---
+{matched entry content (tags stripped)}
 ```
+</execution>
 
----
-
-## Error Handling
-
+<error_codes>
 | Code | Severity | Description |
 |------|----------|-------------|
 | E001 | fatal | `.workflow/specs/` not initialized -- run `Skill({ skill: "spec-setup" })` first |
 | W001 | warning | No matching specs for keyword -- showing all in category |
+</error_codes>
+
+<success_criteria>
+- [ ] `.workflow/specs/` directory validated
+- [ ] Category and keyword parsed from arguments
+- [ ] Files loaded per category mapping
+- [ ] Keyword filtering applied at entry level (via `<spec-entry>` keywords)
+- [ ] Results displayed with file references and stripped tags
+</success_criteria>