Migrate platform feature families from Reqnroll to MSTest DSL + fix CLI tests (#125)

## Summary

- Migrated all 34 platform feature families from Reqnroll/Gherkin BDD to
internal MSTest DSL (C# code-first unit tests), retiring all `.feature`
files
- Fixed NuGet package version conflicts introduced during migration
(bumped `Microsoft.Extensions.*`, `System.*`, `Microsoft.Bcl.*` to
10.0.8, removed stale `VersionOverride` attributes)
- Fixed 3 failing CLI execution tests that were testing against a
non-existent `discovery inventory` command — updated to use the real
`queue` command with out-of-process execution
- Cleaned up all orphaned `.feature.cs` Reqnroll code-behind files
- Added explicit three-gate commit rule to DSL migration skills
(scenario tests → full build → full test suite must all pass before
commit)

## Test plan

- [ ] All 1,494 unit tests pass across 10 test assemblies (verified
locally: 0 failures)
- [ ] CLI tests: all 38 pass including the 3 previously-blocked
CliCommandExecutionTests
- [ ] `dotnet build` succeeds with no errors (warnings only)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: MrHinsh

.agents/configure.ps1

@@ -162,6 +162,7 @@ Ensure-Symlink '.claude\skills'   '..\.agents\skills'
 Ensure-Symlink '.claude\agents'   '..\.agents\agents'
 Ensure-Symlink '.claude\commands' '..\.agents\commands'
 Ensure-Symlink '.claude\prompts'  '..\.agents\prompts'
+Ensure-Symlink '.claude\workflows'  '..\.agents\workflows'
 
 # -- .github symlinks --------------------------------------------------------
 Write-Host ""

.agents/skills/nkda-testdsl-autonomous/SKILL.md

@@ -85,18 +85,24 @@ Run `nkda-testdsl-refactor` → produce `05-refactor-summary.md`.
 
 Run `nkda-testdsl-verification` → produce `06-verification.md`.
 
-- Run converted/affected tests first.
+**Verification gate — ALL of the following must pass before ANY commit:**
+
+1. **Scenario unit tests pass** — run `dotnet test <test-project> --filter "FullyQualifiedName~<TestClass>"` for each new or modified test class. Every mapped test must be green.
+2. **Full solution build passes** — run `dotnet build` from the repo root. Zero errors. A build failure is a hard blocker — fix it before proceeding, do not commit around it.
+3. **Full unit test suite passes** — run `dotnet test` from the repo root. Every test in every project must pass. A failure in ANY test project, even one unrelated to this family, must be investigated and fixed before committing.
+
+**Do not commit if any of these three gates fail.** Fix the failure first.
+
 - Verify every retired scenario has a mapped passing test with `path:line` evidence.
-- If all scenarios are retired and tests are green, run the full repository test suite.
-- If verification returns `PASS`:
+- If all three gates pass:
   - Delete the `.feature` file.
   - Delete any generated `.feature.cs` and legacy `*Steps.cs` scoped to wiring state.
   - **Commit all changes** with message: `migrate: <family-name> feature → DSL`.
 - If verification returns `BLOCKED` or `FAIL`:
   - Retain the `.feature` file (with only unconverted scenarios remaining).
   - Record the reason in `06-verification.md`.
   - **Append every retained scenario as an entry in `analysis/dsl-gaps-detected.md`** with the gap-type, family, file path, scenario title, wiring state, and specific engineering detail. Do not leave a scenario retained without a gap entry.
-  - **Commit partial progress** (retired scenarios removed, new tests added, gap entries written) with message: `migrate(partial): <family-name> <N> scenarios retired`.
+  - Only commit partial progress once gates 1–3 above are satisfied for the work done so far: `migrate(partial): <family-name> <N> scenarios retired`.
 
 ### Step 11 — Report and stop
 

.agents/skills/nkda-testdsl-verification/SKILL.md

@@ -27,11 +27,14 @@ description: Use when conversion and refactor are done and parity, artefact remo
 
 ## Required Test Execution Order
 
-1. Run the converted/affected feature-family tests first.
+1. Run the converted/affected feature-family tests first (`dotnet test <project> --filter "FullyQualifiedName~<TestClass>"`). Every mapped test must be green before proceeding.
 2. Score any intent-derived tests with test-validity dimensions and reject `WASTE` or `LOW VALUE` tests.
 3. Confirm scenario inventory coverage and tag compliance are complete.
-4. If and only if tests are green, validity gate passes, and inventory/tag checks pass, run the full repository test suite.
-5. Record commands, outcomes, validity scores, and inventory/tag verdict in `06-verification.md`.
+4. Run `dotnet build` from the repo root. If the build fails, return `FAIL` immediately — do not proceed. Investigate and fix any break, including NuGet version conflicts or compilation errors introduced by this or prior migrations.
+5. If and only if the build succeeds, tests are green, validity gate passes, and inventory/tag checks pass, run `dotnet test` from the repo root (the full unit test suite across all projects).
+6. Record commands, outcomes, build result, validity scores, and inventory/tag verdict in `06-verification.md`.
+
+**A commit must never be made unless all three — scenario tests green, full build green, full test suite green — are confirmed in that order.**
 
 ## Artefact Deletion Gate
 

.agents/workflows/nkda-testdsl-workflow.js

@@ -0,0 +1,313 @@
+export const meta = {
+  name: 'nkda-testdsl-workflow',
+  description: 'Migrate Reqnroll feature families to internal DSL — enumerate all files, process each sequentially through the full phase pipeline',
+  phases: [
+    { title: 'Enumerate', detail: 'Discover all .feature files and filter already-PASS families' },
+    { title: 'Assessment', detail: 'Run nkda-testdsl-feature-assessment for the current family' },
+    { title: 'DSL Design', detail: 'Run nkda-testdsl-dsl-design for the current family' },
+    { title: 'Extraction', detail: 'Run nkda-testdsl-extraction for the current family' },
+    { title: 'Conversion', detail: 'Run nkda-testdsl-feature-conversion for the current family' },
+    { title: 'Refactor', detail: 'Run nkda-testdsl-refactor for the current family' },
+    { title: 'Verification', detail: 'Run nkda-testdsl-verification and commit for the current family' },
+  ],
+}
+
+// args: feature family name, folder path, or feature file path.
+// If omitted, defaults to the canonical feature folder.
+const scope = args || 'features/platform'
+
+// ---------------------------------------------------------------------------
+// Phase: Enumerate
+// ---------------------------------------------------------------------------
+phase('Enumerate')
+
+const ENUMERATE_SCHEMA = {
+  type: 'object',
+  properties: {
+    files: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          featureFilePath: { type: 'string' },
+          familyName: { type: 'string' },
+          alreadyPassed: { type: 'boolean' },
+        },
+        required: ['featureFilePath', 'familyName', 'alreadyPassed'],
+      },
+    },
+  },
+  required: ['files'],
+}
+
+const enumResult = await agent(
+  `You are enumerating Reqnroll .feature files for migration scope: "${scope}".
+
+Tasks:
+1. Find all .feature files under the scope path (or the single file if a file path was given).
+2. For each file, derive the family name (the .feature filename without extension, or use folder-based naming if multiple files share a folder).
+3. For each family, check whether .output/nkda-testdsl/<family-name>/06-verification.md exists AND contains a PASS verdict. If both conditions are true, set alreadyPassed=true.
+4. Return every file including already-passed ones so the workflow can report them.
+
+Return a structured list.`,
+  { label: 'enumerate:scope', phase: 'Enumerate', schema: ENUMERATE_SCHEMA }
+)
+
+if (!enumResult || enumResult.files.length === 0) {
+  log('No .feature files found in scope. Nothing to do.')
+} else {
+  const pending = enumResult.files.filter(f => !f.alreadyPassed)
+  const skipped = enumResult.files.filter(f => f.alreadyPassed)
+
+  if (skipped.length > 0) {
+    log(`Skipping ${skipped.length} already-PASS families: ${skipped.map(f => f.familyName).join(', ')}`)
+  }
+
+  if (pending.length === 0) {
+    log('All families already have PASS verdicts. Nothing to migrate.')
+  } else {
+    log(`Processing ${pending.length} families sequentially: ${pending.map(f => f.familyName).join(', ')}`)
+
+    // ---------------------------------------------------------------------------
+    // Sequential loop: one family fully completes (all phases + commit) before
+    // the next starts. This is required because:
+    //   - all families share tests/DevOpsMigrationPlatform.Testing
+    //   - only one dotnet test run can execute at a time
+    //   - git commits must be sequential
+    // ---------------------------------------------------------------------------
+
+    const PHASE_SCHEMA = {
+      type: 'object',
+      properties: {
+        familyName: { type: 'string' },
+        status: { type: 'string', enum: ['ok', 'blocked', 'failed'] },
+        outputFile: { type: 'string' },
+        summary: { type: 'string' },
+      },
+      required: ['familyName', 'status', 'outputFile', 'summary'],
+    }
+
+    const VERIFICATION_SCHEMA = {
+      type: 'object',
+      properties: {
+        familyName: { type: 'string' },
+        verdict: { type: 'string', enum: ['PASS', 'BLOCKED', 'FAIL'] },
+        migratedScenarios: { type: 'array', items: { type: 'string' } },
+        blockedScenarios: { type: 'array', items: { type: 'string' } },
+        failedScenarios: { type: 'array', items: { type: 'string' } },
+        wiringState: { type: 'string' },
+        commitSha: { type: 'string' },
+        commitMessage: { type: 'string' },
+        summary: { type: 'string' },
+      },
+      required: ['familyName', 'verdict', 'migratedScenarios', 'blockedScenarios', 'failedScenarios', 'wiringState', 'summary'],
+    }
+
+    const results = []
+
+    for (const file of pending) {
+      log(`Starting family: ${file.familyName} (${file.featureFilePath})`)
+      let blocked = false
+      let blockReason = ''
+
+      // --- Phase: Assessment ---
+      phase('Assessment')
+      const assessment = await agent(
+        `Run the nkda-testdsl-feature-assessment skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-feature-assessment/SKILL.md.
+Produce:
+- .output/nkda-testdsl/${file.familyName}/00-scenario-test-inventory.md
+- .output/nkda-testdsl/${file.familyName}/01-feature-assessment.md
+
+Return structured output.`,
+        { label: `assessment:${file.familyName}`, schema: PHASE_SCHEMA }
+      )
+      if (!assessment || assessment.status === 'failed') {
+        blocked = true
+        blockReason = assessment?.summary || 'Assessment failed'
+      }
+
+      // --- Phase: DSL Design ---
+      if (!blocked) {
+        phase('DSL Design')
+        const dslDesign = await agent(
+          `Run the nkda-testdsl-dsl-design skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Consume .output/nkda-testdsl/${file.familyName}/01-feature-assessment.md.
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-dsl-design/SKILL.md.
+Produce .output/nkda-testdsl/${file.familyName}/02-dsl-design.md.
+
+Return structured output.`,
+          { label: `dsl-design:${file.familyName}`, schema: PHASE_SCHEMA }
+        )
+        if (!dslDesign || dslDesign.status === 'failed') {
+          blocked = true
+          blockReason = dslDesign?.summary || 'DSL Design failed'
+        }
+      }
+
+      // --- Phase: Extraction ---
+      if (!blocked) {
+        phase('Extraction')
+        const extraction = await agent(
+          `Run the nkda-testdsl-extraction skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Consume .output/nkda-testdsl/${file.familyName}/02-dsl-design.md.
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-extraction/SKILL.md.
+
+Bootstrap tests/DevOpsMigrationPlatform.Testing if it does not exist — this is never a blocker.
+Purge orphaned generated Features/*.feature.cs files in the target test project before extraction.
+Produce .output/nkda-testdsl/${file.familyName}/03-extraction-summary.md.
+
+Return structured output.`,
+          { label: `extraction:${file.familyName}`, schema: PHASE_SCHEMA }
+        )
+        if (!extraction || extraction.status === 'failed') {
+          blocked = true
+          blockReason = extraction?.summary || 'Extraction failed'
+        }
+      }
+
+      // --- Phase: Conversion ---
+      if (!blocked) {
+        phase('Conversion')
+        const conversion = await agent(
+          `Run the nkda-testdsl-feature-conversion skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Consume:
+- .output/nkda-testdsl/${file.familyName}/01-feature-assessment.md
+- .output/nkda-testdsl/${file.familyName}/02-dsl-design.md
+
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-feature-conversion/SKILL.md.
+
+For each scenario:
+- Build and run its mapped test.
+- If the test passes: retire the scenario from the .feature file (remove that scenario block).
+- If the test fails: retain the scenario in the .feature file.
+- Every new or modified test method must carry [TestCategory("UnitTest")] immediately above [TestMethod].
+- Check the existing test corpus before building any test; map to pre-existing, extend partial-existing, build only to-build.
+- For missing-step scenarios with no pre-existing coverage, generate intent-derived tests.
+
+Produce .output/nkda-testdsl/${file.familyName}/04-conversion-summary.md.
+
+Return structured output.`,
+          { label: `conversion:${file.familyName}`, schema: PHASE_SCHEMA }
+        )
+        if (!conversion || conversion.status === 'failed') {
+          blocked = true
+          blockReason = conversion?.summary || 'Conversion failed'
+        }
+      }
+
+      // --- Phase: Refactor ---
+      if (!blocked) {
+        phase('Refactor')
+        const refactor = await agent(
+          `Run the nkda-testdsl-refactor skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-refactor/SKILL.md.
+Produce .output/nkda-testdsl/${file.familyName}/05-refactor-summary.md.
+
+Return structured output.`,
+          { label: `refactor:${file.familyName}`, schema: PHASE_SCHEMA }
+        )
+        if (!refactor || refactor.status === 'failed') {
+          blocked = true
+          blockReason = refactor?.summary || 'Refactor failed'
+        }
+      }
+
+      // --- Phase: Verification + Commit ---
+      phase('Verification')
+      let verificationResult
+      if (blocked) {
+        verificationResult = {
+          familyName: file.familyName,
+          verdict: 'BLOCKED',
+          migratedScenarios: [],
+          blockedScenarios: [],
+          failedScenarios: [],
+          wiringState: 'unknown',
+          commitSha: '',
+          commitMessage: '',
+          summary: blockReason,
+        }
+      } else {
+        verificationResult = await agent(
+          `Run the nkda-testdsl-verification skill for feature family "${file.familyName}".
+Feature file: ${file.featureFilePath}
+
+Follow the skill exactly as written in .agents/skills/nkda-testdsl-verification/SKILL.md.
+
+Required test execution order:
+1. Run converted/affected feature-family tests first.
+2. Verify every retired scenario has a mapped passing test with path:line evidence.
+3. If all scenarios are retired and tests are green, run the full repository test suite.
+
+If verification returns PASS:
+- Delete the .feature file.
+- Delete any generated .feature.cs and legacy *Steps.cs scoped to wiring state.
+- Commit all changes with message: migrate: ${file.familyName} feature → DSL
+
+If verification returns BLOCKED or FAIL:
+- Retain the .feature file (with only unconverted scenarios remaining).
+- Append every retained scenario as an entry in analysis/dsl-gaps-detected.md.
+- Commit partial progress with message: migrate(partial): ${file.familyName} <N> scenarios retired
+
+Produce .output/nkda-testdsl/${file.familyName}/06-verification.md.
+
+Return structured output including the verdict, lists of migrated/blocked/failed scenarios, wiring state, and commit SHA.`,
+          { label: `verification:${file.familyName}`, schema: VERIFICATION_SCHEMA }
+        )
+      }
+
+      results.push(verificationResult)
+      log(`Completed family: ${file.familyName} — ${verificationResult?.verdict ?? 'unknown'}`)
+    }
+
+    // ---------------------------------------------------------------------------
+    // Terminal report
+    // ---------------------------------------------------------------------------
+    const verified = results.filter(Boolean)
+
+    for (const r of verified) {
+      const terminalStatus =
+        r.verdict === 'PASS'
+          ? (r.migratedScenarios?.length > 0 ? 'converted' : 'already-adapted')
+          : r.verdict === 'BLOCKED'
+          ? 'blocked'
+          : 'failed'
+
+      log(`
+**\`${r.familyName}\` — \`${terminalStatus}\`**
+
+| | Count |
+|---|---|
+| ✅ Migrated & committed | ${r.migratedScenarios?.length ?? 0} |
+| 🚧 Blocked (gap) | ${r.blockedScenarios?.length ?? 0} |
+| ⚠️ Failed | ${r.failedScenarios?.length ?? 0} |
+| Total | ${(r.migratedScenarios?.length ?? 0) + (r.blockedScenarios?.length ?? 0) + (r.failedScenarios?.length ?? 0)} |
+
+**Migrated:**
+${(r.migratedScenarios ?? []).map(s => `- ${s} ✅`).join('\n') || '- (none)'}
+
+**Blocked:**
+${(r.blockedScenarios ?? []).map(s => `- ${s}`).join('\n') || '- (none)'}
+
+**Failed:**
+${(r.failedScenarios ?? []).map(s => `- ${s}`).join('\n') || '- (none)'}
+
+**Wiring state:** \`${r.wiringState}\`
+**Commit:** \`${r.commitSha || 'none'}\` — ${r.commitMessage || r.summary}
+`)
+    }
+
+    return { processed: verified.length, results: verified }
+  }
+}

.claude/prompts

@@ -0,0 +1 @@
+../.agents/prompts

.claude/workflows

@@ -0,0 +1 @@
+../.agents/workflows