nkdAgility
diff --git a/‎.agents/20-guardrails/workflow/testing-rules.md‎
Lines changed: 60 additions & 33 deletions b/‎.agents/20-guardrails/workflow/testing-rules.md‎
Lines changed: 60 additions & 33 deletions
diff --git a/‎.agents/skills/nkda-testdsl-feature-conversion/SKILL.md‎
Lines changed: 19 additions & 35 deletions b/‎.agents/skills/nkda-testdsl-feature-conversion/SKILL.md‎
Lines changed: 19 additions & 35 deletions
@@ -6,30 +6,53 @@ MSTest conventions, test naming, and organisation. See also: [coding-standards.m
 
 ## Test Priority Hierarchy
 
-| Priority | Category | Marker | Speed | Use |
-| --- | --- | --- | --- | --- |
-| 1 (highest) | Unit Tests | `[TestCategory("UnitTests")]` | < 50 ms | All logic, branching, transforms. No I/O, no DI. Single class/method in isolation. |
-| 2 | Domain Tests (Internal DSL + MSTest) | `[TestCategory("DomainTests")]` | < 500 ms | Business behaviour across collaborating domain objects via the internal DSL. |
-| 3 | Simulated System Tests | `[TestCategory("SystemTest_Simulated")]` | < 10 s | End-to-end with `Simulated` connector. No network. |
-| 3a | Smoke System Tests | `[TestCategory("SystemTest_Smoke")]` | < 30 s | Critical-path subset of system tests run on every PR. |
-| 4 (lowest) | Live System Tests | `[TestCategory("SystemTest")]`/`[TestCategory("SystemTest_Live")]` | < 60 s | Requires live ADO/TFS. Environment-gated. |
-
-### Distinguishing UnitTests from DomainTests
+> **Speed Budget is not a classifier.** A test's category is determined solely by its intent and makeup — what it exercises and what dependencies it uses. A test that exceeds its category's speed budget is non-compliant and must be fixed (e.g. inject a time abstraction, replace real delays with fakes) — not moved to a slower category to make the number fit.
 
-| Criterion | UnitTests | DomainTests |
-| --- | --- | --- |
-| Scope | Single class/method in isolation | Business behaviour across collaborating domain objects |
-| Dependencies | All dependencies mocked/stubbed | Uses real domain objects, DSL builders/runners/assertions |
-| DSL usage | No `DevOpsMigrationPlatform.Testing` usage | Uses the internal DSL library (builders, runners, assertions) |
-| Arrange style | Direct `new Foo()` + mock setup | Builder pattern (`A.WorkItem().WithField(...)`) |
-| Assert style | Assert on return value / state of one object | Assert on observable business outcome |
-| I/O | None | None (still in-process, no connectors) |
+Tests are grouped into two parent families that reflect the runtime requirement:
 
-**Rule:** If the test references `DevOpsMigrationPlatform.Testing` DSL infrastructure (builders, runners, or domain assertions), it is a `DomainTests` test. Otherwise it is a `UnitTests` test.
+- **`[TestCategory("CodeTest")]`** — runs entirely in-process. No system must be active. Covers priorities 1–3.
+- **`[TestCategory("SystemTest")]`** — requires the full system to be active. Covers priorities 4–6.
 
-**Principles:** Fast validation is the goal. Push tests downward (can it be a unit test?). Live tests are a last resort. Simulated replaces live where possible. CI gates run UnitTests + DomainTests by default.
+Every test carries **both** the specific category tag and its parent family tag.
 
-**Anti-patterns (instant reject):** Simulated/Live test for logic with no external dependency. Feature test with real I/O when mocks suffice. New Live test without proving lower level can't cover it. Feature/Simulated/Live outnumbering Unit + Domain tests.
+| Priority | Parent | Specific Marker | Intent & Makeup | Speed Budget |
+| --- | --- | --- | --- | --- |
+| 1 | `CodeTest` | `[TestCategory("UnitTests")]` | Single class in isolation. All deps mocked. No I/O, no real infrastructure. | < 50 ms |
+| 2 | `CodeTest` | `[TestCategory("DomainTests")]` | Business behaviour via the internal DSL. Real domain objects, no connectors or infrastructure. | < 500 ms |
+| 3 | `CodeTest` | `[TestCategory("IntegrationTests")]` | Real infrastructure components (e.g. retry policies, HTTP clients, serialisers) wired together in-process. No external network or connector. | < 30 s |
+| 4 | `SystemTest` | `[TestCategory("SystemTest_Smoke")]` | Critical-path subset of system tests run on every PR. | < 120 s |
+| 5 | `SystemTest` | `[TestCategory("SystemTest_Simulated")]` | End-to-end with the `Simulated` connector. No network. | < 60 s |
+| 6 | `SystemTest` | `[TestCategory("SystemTest_Live")]` | Requires live ADO/TFS. Environment-gated. | < 300 s |
+
+### Distinguishing categories
+
+| Criterion | UnitTests | DomainTests | IntegrationTests |
+| --- | --- | --- | --- |
+| Scope | Single class/method in isolation | Business behaviour across collaborating domain objects | Real infrastructure components wired together in-process |
+| Dependencies | All mocked/stubbed | Real domain objects via DSL builders/runners/assertions | Real library/framework components (e.g. Polly, HttpClient) — no external network |
+| DSL usage | No `DevOpsMigrationPlatform.Testing` usage | Uses the internal DSL library (builders, runners, assertions) | No DSL |
+| Arrange style | Direct `new Foo()` + mock setup | Builder pattern (`A.WorkItem().WithField(...)`) | Direct construction of real infrastructure components |
+| Assert style | Assert on return value / state of one object | Assert on observable business outcome | Assert on real component behaviour (retry count, response, serialised output) |
+| I/O | None | None | None (in-process only; no filesystem, no network) |
+| External connectivity | None | None | None |
+
+**Classification rules:**
+- If the test references `DevOpsMigrationPlatform.Testing` DSL infrastructure → `[TestCategory("CodeTest")]` + `[TestCategory("DomainTests")]`
+- If the test uses real library/framework components in-process with no external connectivity → `[TestCategory("CodeTest")]` + `[TestCategory("IntegrationTests")]`
+- If the test is a single isolated class with all deps mocked → `[TestCategory("CodeTest")]` + `[TestCategory("UnitTests")]`
+- If the test exercises a full end-to-end flow with the Simulated connector → `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Simulated")]`
+- If the test requires live ADO/TFS → `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Live")]`
+
+> **⛔ `SystemTest_Smoke` — OPERATOR-DESIGNATED ONLY.**
+> An agent MUST NOT add `[TestCategory("SystemTest_Smoke")]` to any test under any circumstances.
+> Smoke tests are a specific designated subset curated by a human operator. Only a human operator
+> can assign this category, in writing (e.g. PR comment or decision record). If you believe a test
+> belongs in the smoke suite, note it in your output summary for the operator to decide — do not
+> apply the tag yourself.
+
+**Principles:** Push tests downward — can it be a unit test? Live tests are a last resort. Simulated replaces live where possible. CI gates run `CodeTest` by default; `SystemTest` requires the full system active.
+
+**Anti-patterns (instant reject):** Integration/Simulated/Live test for logic that could be mocked. New Live test without proving lower level can't cover it. Integration/Simulated/Live outnumbering Unit + Domain tests. Agent-assigned `SystemTest_Smoke`.
 
 ---
 
@@ -40,23 +63,27 @@ MSTest conventions, test naming, and organisation. See also: [coding-standards.m
 
 Every time a test file is **created, edited, moved, or touched in any way**, every `[TestMethod]` and `[TestClass]` in that file MUST carry the correct `[TestCategory]` before the change is committed or reported as complete.
 
-| Condition | Required attribute |
+| Condition | Required attributes (both must be present) |
 | --- | --- |
-| Test uses `DevOpsMigrationPlatform.Testing` DSL | `[TestCategory("DomainTests")]` |
-| Test is isolated unit test (no DSL, no I/O) | `[TestCategory("UnitTests")]` |
-| Test uses `Simulated` connector end-to-end | `[TestCategory("SystemTest_Simulated")]` |
-| Test is a critical-path smoke subset | `[TestCategory("SystemTest_Smoke")]` |
-| Test targets live ADO/TFS | `[TestCategory("SystemTest")]` or `[TestCategory("SystemTest_Live")]` |
+| Test is isolated unit test (no DSL, no I/O, all deps mocked) | `[TestCategory("CodeTest")]` + `[TestCategory("UnitTests")]` |
+| Test uses `DevOpsMigrationPlatform.Testing` DSL | `[TestCategory("CodeTest")]` + `[TestCategory("DomainTests")]` |
+| Test uses real infrastructure components in-process, no external connectivity | `[TestCategory("CodeTest")]` + `[TestCategory("IntegrationTests")]` |
+| Test uses `Simulated` connector end-to-end | `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Simulated")]` |
+| Test targets live ADO/TFS | `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Live")]` |
+| ⛔ Smoke test (operator-designated only) | DO NOT assign — operator only |
+| Test uses `Simulated` connector end-to-end | `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Simulated")]` |
+| Test targets live ADO/TFS | `[TestCategory("SystemTest")]` + `[TestCategory("SystemTest_Live")]` |
 
 **Enforcement rules — all are blocking, none are optional:**
 
-1. **Missing tag on touch:** If any `[TestMethod]` or `[TestClass]` in a touched file lacks `[TestCategory]`, add the correct tag in the same edit. This applies to every method in the file, not just the method being modified.
-2. **Wrong tag on touch:** If a tag is incorrect (wrong category, old name), correct it in the same edit.
-3. **Delegation does not exempt:** If a sub-agent or delegated run added or modified a test, the calling agent is responsible for verifying tags before closing the task. "The delegated run didn't add it" is not a valid completion state.
-4. **No partial compliance:** Applying the tag to the new method while leaving existing uncategorised methods in the same file is non-compliant. Fix the whole file.
-5. **Category names are canonical:** Only the exact strings `UnitTests`, `DomainTests`, `SystemTest_Simulated`, `SystemTest_Smoke`, `SystemTest`, `SystemTest_Live` are valid. Any other value is non-compliant and must be corrected on contact.
-6. The `nkda-testdsl-*` skills must apply `[TestCategory("DomainTests")]` to all converted tests.
-7. The `nkda-testdsl-refactor` skill must verify and correct all category tags in any file it touches.
+1. **Missing tag on touch:** If any `[TestMethod]` or `[TestClass]` in a touched file lacks `[TestCategory]`, add the correct tags in the same edit. This applies to every method in the file, not just the method being modified.
+2. **Both tags required:** Every test must carry its parent family tag (`CodeTest` or `SystemTest`) AND its specific category tag. A test with only one of the two is non-compliant.
+3. **Wrong tag on touch:** If a tag is incorrect (wrong category, old name), correct it in the same edit.
+4. **Delegation does not exempt:** If a sub-agent or delegated run added or modified a test, the calling agent is responsible for verifying tags before closing the task. "The delegated run didn't add it" is not a valid completion state.
+5. **No partial compliance:** Applying the tag to the new method while leaving existing uncategorised methods in the same file is non-compliant. Fix the whole file.
+6. **Category names are canonical:** Only the exact strings `CodeTest`, `UnitTests`, `DomainTests`, `IntegrationTests`, `SystemTest`, `SystemTest_Smoke`, `SystemTest_Simulated`, `SystemTest_Live` are valid. Any other value is non-compliant and must be corrected on contact.
+7. The `nkda-testdsl-*` skills must apply `[TestCategory("CodeTest")]` + `[TestCategory("DomainTests")]` to all converted tests.
+8. The `nkda-testdsl-refactor` skill must verify and correct all category tags in any file it touches.
 
 **Checklist before marking any test-touching task complete:**
 
 
@@ -45,46 +45,30 @@ There is no executing baseline, so behaviour parity against prior tests is not a
 
 ## Scenario Retirement Gate
 
-- Scenario-level retirement is allowed during conversion, but only for scenarios whose mapped code-first tests are already passing.
-- If a scenario's mapped test is failing or unresolved, keep that scenario in the `.feature` file.
-- Record, per scenario row in `00-scenario-test-inventory.md`, whether it is retained or retired, with test evidence.
-- If all scenarios in a family have been retired, mark the `.feature` file as eligible for deletion; actual file deletion occurs only in verification after overall `PASS`.
+- A scenario is retired from the `.feature` file when its mapped DSL test is **passing**.
+- A scenario whose test is failing must have its production code fixed until the test passes — only then is it retired.
+- Record, per scenario row in `00-scenario-test-inventory.md`, whether it is retained or retired, with test evidence (`path:line`).
+- All scenarios must be retired by end of conversion. If all scenarios are retired, mark the `.feature` file as eligible for deletion; actual file deletion occurs only in verification after overall `PASS`.
 
-## Gap Logging
+## Completion Standard
 
-Any scenario that cannot be converted MUST be logged in `analysis/dsl-gaps-detected.md` before `04-conversion-summary.md` is finalised. Do not leave a retained scenario undocumented.
+Every scenario in the `.feature` file MUST result in a passing DSL test. There is no other acceptable outcome.
 
-For each retained scenario, append an entry using this format:
+Per the project guardrails (`definition-of-done.md`, `testing-rules.md`):
+- `[Ignore]` is banned. Never add it.
+- `Assert.Inconclusive` is banned. Never add it.
+- A failing test is not acceptable output — fix the production code until the test passes.
+- Retaining a scenario in the `.feature` file because the test is hard to write is not acceptable.
 
-```markdown
-## GAP-NNN: <family> — <scenario title>
-
-**File:** `<feature file path>`
-**Scenario:** `<scenario title>`
-**Family:** `<family>`
-**Wiring:** `<wired|miswired|unwired>`
-**Gap type:** `<gap-type from reference table>`
-**Detected:** `<ISO date>`
-**Status:** OPEN
-
-### Engineering detail
-
-<Specific, actionable description of why this scenario cannot be converted.
-Reference exact file paths and line numbers where relevant. State what
-would need to change to unblock conversion.>
-```
-
-Gap number (`NNN`) must be unique — scan `analysis/dsl-gaps-detected.md` for the highest existing number and increment.
+**If production code is missing: implement it** — following all guardrails (coding-standards.md, architecture-boundaries.md, DI wiring rules).
+**If a seam or interface is missing: create it** — following the canonical seam patterns in the guardrails.
+**If a DI binding is missing: add it** — register in the correct host startup extension.
+**If production behaviour conflicts with the scenario intent: fix the production behaviour** — the scenario describes the correct behaviour.
+**If a subprocess cannot be intercepted: introduce the abstraction** that makes it interceptable, then wire it through DI.
 
 ## Stop Conditions
 
-Stop and report if:
+Stop and report ONLY if:
 
-- behaviour parity cannot be shown for a `wired` family
-- for a `miswired`/`unwired` family, an assertion cannot be confirmed against observed production behaviour, or feature intent conflicts with actual behaviour
-- conversion requires unplanned production behaviour changes
-- failures cannot be resolved in scope
-- only pipeline-phase grouping (Inventory/Export/Import/Validate style) is available and business-focused grouping cannot be established
-- missing-step intent cannot be inferred with enough confidence to create a deterministic behaviour test
-- any scenario in `00-scenario-test-inventory.md` remains `unmatched` after conversion
-- converted tests are missing required tags or have non-compliant tags
+- a scenario's intent is genuinely ambiguous and cannot be resolved by reading the feature file, the DSL design, and the production code together — ask for clarification rather than guessing
+- converted tests are missing required tags or have non-compliant tags (fix the tags, then continue)