harness-everything 0.2.2 → 0.4.0

package/plugins/harness-everything/skills/tdd/guides/tests.md

@@ -0,0 +1,61 @@
+# Good and Bad Tests
+
+## Good Tests
+
+**Integration-style**: Test through real interfaces, not mocks of internal parts.
+
+```typescript
+// GOOD: Tests observable behavior
+test("user can checkout with valid cart", async () => {
+  const cart = createCart();
+  cart.add(product);
+  const result = await checkout(cart, paymentMethod);
+  expect(result.status).toBe("confirmed");
+});
+```
+
+Characteristics:
+
+- Tests behavior users/callers care about
+- Uses public API only
+- Survives internal refactors
+- Describes WHAT, not HOW
+- One logical assertion per test
+
+## Bad Tests
+
+**Implementation-detail tests**: Coupled to internal structure.
+
+```typescript
+// BAD: Tests implementation details
+test("checkout calls paymentService.process", async () => {
+  const mockPayment = jest.mock(paymentService);
+  await checkout(cart, payment);
+  expect(mockPayment.process).toHaveBeenCalledWith(cart.total);
+});
+```
+
+Red flags:
+
+- Mocking internal collaborators
+- Testing private methods
+- Asserting on call counts/order
+- Test breaks when refactoring without behavior change
+- Test name describes HOW not WHAT
+- Verifying through external means instead of interface
+
+```typescript
+// BAD: Bypasses interface to verify
+test("createUser saves to database", async () => {
+  await createUser({ name: "Alice" });
+  const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]);
+  expect(row).toBeDefined();
+});
+
+// GOOD: Verifies through interface
+test("createUser makes user retrievable", async () => {
+  const user = await createUser({ name: "Alice" });
+  const retrieved = await getUser(user.id);
+  expect(retrieved.name).toBe("Alice");
+});
+```

package/plugins/harness-everything/skills/tdd/references/core-discipline.md

@@ -0,0 +1,51 @@
+# TDD — Core Discipline (Full Detail)
+
+## Process & TDD Execution Flow
+
+Follow the decision matrix below when conducting TDD:
+
+```mermaid
+flowchart TD
+    Start[Trigger: Tier 2 Feature / Bugfix Task] --> Red[1. RED: Write Failing Unit/Integration Test]
+    Red --> TestRunner{Run Project Test Runner}
+
+    TestRunner -- Tests Fail as Expected --> Green[2. GREEN: Write Minimal Code to Pass]
+    TestRunner -- Tests Unexpectedly Pass --> FixTest[Fix Test Logic / Assertions] --> Red
+
+    Green --> CheckPass{Re-run Test Runner}
+    CheckPass -- Tests Pass --> Refactor[3. REFACTOR: Clean Code & Verify Alignments]
+    CheckPass -- Tests Fail (> 3 Retries) --> ZoomOut[Trigger zoom-out Circuit Breaker]
+
+    Refactor --> VerifyFinal[Re-run Tests & Mark Todo Complete]
+    VerifyFinal --> Done[TDD Cycle Complete]
+```
+
+When this skill is loaded, you MUST suppress the urge to write implementation code directly, and strictly follow these three phases.
+
+For public behavior, RED/GREEN evidence is necessary but not sufficient. Apply the machine-verifiable matrix, source-conformance policy, determinism comparison, and mandatory gates in `quality-model.md` before completion.
+
+**Evidence Assertion (Law of Evidence Assertion - 證據斷言定律)**:
+During each TDD phase (RED, GREEN, REFACTOR), you MUST present actual terminal test execution logs showing the exact test failure or pass. Claiming progress or success based on "assumed" passes is strictly PROHIBITED; you must assert outcomes with hard, objective evidence.
+
+### 1. RED (Write a Failing Test)
+- **Action**: Before implementing the requested feature or Bug fix, write the corresponding Unit Test or Integration Test in the test folder.
+- **Validation**: Run the test to **ensure the test fails** (this proves the test actually covers unimplemented functionality, rather than being a fake test).
+- **Note**: If the test passes immediately, it means your test is wrong or the Bug doesn't actually exist. You must fix the test.
+
+### 2. GREEN (Implement Minimal Code to Pass Test)
+- **Action**: Switch to the implementation code and write the "minimum amount of code just enough to pass the test". Do not over-engineer or consider future extensibility at this stage.
+- **Validation**: Run the test to ensure it passes.
+
+### 3. REFACTOR (Refactor and Optimize)
+
+**Code-Doc Alignment (Law of Code-Documentation Alignment - 程式碼與文件對齊定律)**:
+In the REFACTOR phase, you MUST verify that the implemented code actually aligns with the documented contracts and doesn't contain hardcoded mocking to "finesse" or cheat the tests. Use the `todo-driven-workflow` checklist items to audit that your implementation aligns 100% with the requirement specifications.
+
+- **Action**: Under the safety net of passing tests, begin optimizing the code.
+- Checks: Is the naming clear? Is there duplicated code? Can performance be improved? Does it comply with the project's Clean Code standards?
+- **Validation**: After every modification, re-run the tests to ensure refactoring hasn't broken the original functionality.
+
+## Circuit Breaker Defense
+If during a TDD cycle you get stuck in the **GREEN phase**, and 3 consecutive implementation attempts fail to pass the test:
+- **Trigger Condition Met**: You might have hit the reasoning ceiling, or the initial test logic (RED) was written incorrectly.
+- **Mandatory Action**: Stop guessing blindly. Immediately abort the TDD process and call the `zoom-out` skill: fact-check the assumption behind each failing attempt — including whether the RED test itself encodes the wrong expectation — and resume on a fresh diagnosis. Bring the human in only if the reflection surfaces a genuine decision (e.g., the test contradicts the requirement).

package/plugins/harness-everything/skills/tdd/references/integration-testing.md

@@ -0,0 +1,13 @@
+# Integration Testing Profile
+
+Use `testProfile: "integration"` when behavior crosses a process, filesystem, database, network, queue, subprocess, or service boundary.
+
+## Required evidence
+
+- Derive every expectation from the exact authoritative section, or record `INFERRED` and its basis.
+- Exercise positive and negative boundary contracts, complete request/input validation, response/output schema and values, declared errors, cleanup/rollback, and applicable malformed or unsupported inputs.
+- Run identical input at least twice from clean equivalent state.
+- Compare exit status, error category, output, created/changed/deleted files, persistent state, events, logs, and external calls. Preserve specified ordering.
+- Treat every mismatch as failure. Normalize only an `output.*` or `sideEffects.*` field whose variability is explicitly permitted by a cited authoritative section.
+
+Use the narrowest real boundary that proves the contract. Do not replace the boundary with a mock and still call the result integration evidence. See [interface design](../guides/interface-design.md) and [deep-module guidance](../guides/deep-modules.md).

package/plugins/harness-everything/skills/tdd/references/quality-model.md

@@ -0,0 +1,68 @@
+# TDD Scoring Standard
+
+This model turns each source requirement into auditable evidence. The authoritative source remains the contract even when it appears wrong. Record a suspected documentation problem as `SOURCE_DEFECT`; record disagreement between traced sources as `SOURCE_CONFLICT`. Never reinterpret either into a passing implementation. If no authoritative source exists, use `INFERRED` and state the inference basis.
+
+## Profile contract
+
+Every requirement declares exactly one `testProfile`: `unit` or `integration`. The selected profile defines which case classes are applicable; the common scoring and source rules do not make every test use identical evidence.
+
+- `unit`: follow `unit-testing.md`. Integration determinism is N/A with a written reason.
+- `integration`: follow `integration-testing.md`. Determinism is mandatory and cannot be declared N/A.
+
+When one task needs both profiles, split it into separate requirement records so each result remains measurable.
+
+## Workflow
+
+1. Give every source requirement a stable `requirementId`, select its `testProfile`, and record the exact source path and section.
+2. Use that profile to declare each applicable equivalence partition, field check, error path, and unexpected-input class before implementation.
+3. RED: execute the source-backed tests and retain their evidence location.
+4. GREEN/REFACTOR: update each check to `PASS`, `FAIL`, `SKIPPED`, or reasoned `N/A`.
+5. For integration behavior, run identical input in clean equivalent state at least twice. Record exit status, error category, output, files, persistent state, events, logs, and external calls.
+6. Run the gate and retain its JSON report:
+
+```bash
+npm run tdd:quality -- evidence.json --output tdd-quality-report.json
+```
+
+Exit `0` is PASS, `1` is a valid FAIL report, and `2` is malformed input or CLI usage failure. Schemas are in `tdd/schemas/`; start from `tdd/fixtures/pass-evidence.json`.
+
+## Common evidence dimensions
+
+| Dimension | Declarations and evidence |
+| --- | --- |
+| Positive parameters | One executed case per supported parameter class, enum, or equivalence partition |
+| Negative parameters | One executed case per rejected partition or constraint |
+| Input completeness | `required`, `optional`, `omitted`, `empty`, `null`, `min`, `max`, `boundary` |
+| Output completeness | `value`, `type`, `schema`, `required-field`, `prohibited-extra-field`, `side-effect` |
+| Error handling | `error-type`, `error-code`, `message`, `state-cleanup`, `rollback`, `no-unintended-output` |
+| Unexpected input | `malformed`, `unknown`, `extra`, `unsupported`, `out-of-range`, `duplicate`, `wrong-type` |
+| Determinism | At least two matching runs with identical input and complete output/side-effect records |
+| Source traceability | Every source has an exact path/section, or is explicitly `INFERRED` with a basis |
+
+For an applicable dimension, every fixed class must appear. The selected profile decides applicability. Mark an inapplicable dimension or check `N/A` with a written reason; omission is a schema/gate failure. Skipped and flaky tests remain visible and fail the gate.
+
+## Scoring and mandatory gates
+
+The evaluator derives raw counts and percentages from individual checks; evidence cannot supply or override an aggregate score.
+
+```text
+dimension_percentage = passed_checks / required_checks * 100
+weighted_points = sum(dimension_percentage * canonical_weight)
+quality_score = weighted_points / sum(applicable_weights)
+```
+
+Canonical weights are positive 0.15, negative 0.15, input 0.15, output 0.15, errors 0.15, unexpected 0.10, determinism 0.10, and traceability 0.05. Integration normally applies all weights. Unit excludes reasoned-N/A dimensions and renormalizes the remaining canonical weights; it never invents replacement weights. Reports publish `weights`, `weightedPoints`, `applicableWeight`, every dimension's raw counts/percentage, and the final score so the calculation is reproducible.
+
+A report passes only at 100% and when every applicable dimension executed, every source is traced, no mismatch/conflict exists, input/output/error checks are complete, integration ran at least twice with equivalent normalized results, and no skipped/flaky test exists. `SOURCE_DEFECT` is reported independently and does not excuse `NON_CONFORMANT`.
+
+## Agent self-check
+
+1. Copy `tdd/fixtures/pass-evidence.json` and select `unit` or `integration` per requirement.
+2. Replace fixture checks with real case IDs and test evidence; use explicit reasoned N/A instead of deleting inapplicable classes.
+3. Run `npm run tdd:quality -- <evidence.json> --output <report.json>`.
+4. Inspect each requirement score, dimension percentage, mandatory gate, skip/N/A list, and structural error.
+5. Accept the tests only when exit code is 0, every requirement and aggregate result is `PASS`, and every score is 100. Exit 1 means valid but inadequate evidence; exit 2 means the input cannot be evaluated.
+
+## Deterministic comparison
+
+Object key order is canonicalized; array order remains significant. The same-input rule is strict. A normalization may target only `output.*` or `sideEffects.*`, must exist in every run, and must name the exact authoritative source section that permits volatility. The rule and ignored path remain in the report. Any other mismatch fails.

package/plugins/harness-everything/skills/tdd/references/unit-testing.md

@@ -0,0 +1,15 @@
+# Unit Testing Profile
+
+Use `testProfile: "unit"` when the behavior remains inside one process and has no real filesystem, database, network, queue, subprocess, or service boundary.
+
+## Required evidence
+
+- Derive expected behavior from the exact authoritative section, or record `INFERRED` and its basis.
+- Cover every supported and rejected equivalence partition exposed by the unit.
+- Validate applicable required/optional/omitted/empty/null/min/max/boundary inputs.
+- Assert output value, type, schema/shape, required and prohibited fields, and absence of side effects where applicable.
+- Test each declared error type/code/message and cleanup guarantee; mark a whole dimension N/A only when the unit has no such contract.
+- Cover malformed, unknown, extra, unsupported, out-of-range, duplicate, and wrong-type inputs only where the unit accepts that input class. Record reasoned N/A for the rest.
+- Mark integration determinism N/A with a reason. Ordinary repeatability remains the project test runner's responsibility.
+
+Test observable behavior through the public interface. Use [tests guidance](../guides/tests.md) and [mocking guidance](../guides/mocking.md); isolate external boundaries instead of selecting this profile for code that actually crosses them.

package/plugins/harness-everything/skills/tdd/schemas/quality-evidence.schema.json

@@ -0,0 +1,211 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/dyphn1/Harness-everything/tdd/schemas/quality-evidence.schema.json",
+  "title": "Harness TDD quality evidence",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "requirements"],
+  "properties": {
+    "schemaVersion": { "const": "1.0.0" },
+    "requirements": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/requirement" }
+    }
+  },
+  "$defs": {
+    "source": {
+      "type": "object",
+      "required": ["type", "status"],
+      "properties": {
+        "type": { "type": "string", "minLength": 1 },
+        "status": { "enum": ["AUTHORITATIVE", "INFERRED"] },
+        "path": { "type": "string", "minLength": 1 },
+        "section": { "type": "string", "minLength": 1 },
+        "inferenceBasis": { "type": "string", "minLength": 1 }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "status": { "const": "AUTHORITATIVE" } } },
+          "then": {
+            "required": ["path", "section"],
+            "properties": {
+              "path": { "type": "string", "minLength": 1 },
+              "section": { "type": "string", "minLength": 1 }
+            }
+          },
+          "else": {
+            "required": ["inferenceBasis"],
+            "properties": { "inferenceBasis": { "type": "string", "minLength": 1 } }
+          }
+        }
+      ],
+      "additionalProperties": false
+    },
+    "check": {
+      "type": "object",
+      "required": ["id", "class", "status"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "class": { "type": "string", "minLength": 1 },
+        "status": { "enum": ["PASS", "FAIL", "SKIPPED", "N/A"] },
+        "evidence": { "type": "string", "minLength": 1 },
+        "reason": { "type": "string", "minLength": 1 }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "status": { "const": "N/A" } } },
+          "then": {
+            "required": ["reason"],
+            "properties": { "reason": { "type": "string", "minLength": 1 } }
+          },
+          "else": {
+            "required": ["evidence"],
+            "properties": { "evidence": { "type": "string", "minLength": 1 } }
+          }
+        }
+      ],
+      "additionalProperties": false
+    },
+    "checkDimension": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["applicable", "checks"],
+          "properties": {
+            "applicable": { "const": true },
+            "checks": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/check" } }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["applicable", "reason"],
+          "properties": {
+            "applicable": { "const": false },
+            "reason": { "type": "string", "minLength": 1 }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "sideEffects": {
+      "type": "object",
+      "required": ["createdFiles", "changedFiles", "deletedFiles", "persistentState", "events", "logs", "externalCalls"],
+      "properties": {
+        "createdFiles": { "type": "array" },
+        "changedFiles": { "type": "array" },
+        "deletedFiles": { "type": "array" },
+        "persistentState": {},
+        "events": { "type": "array" },
+        "logs": { "type": "array" },
+        "externalCalls": { "type": "array" }
+      },
+      "additionalProperties": false
+    },
+    "run": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "input", "exitStatus", "errorCategory", "output", "sideEffects"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "input": {},
+        "exitStatus": { "type": "integer" },
+        "errorCategory": { "type": ["string", "null"] },
+        "output": {},
+        "sideEffects": { "$ref": "#/$defs/sideEffects" }
+      }
+    },
+    "normalization": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["path", "rule", "sourceSection"],
+      "properties": {
+        "path": { "type": "string", "pattern": "^(output|sideEffects)\\." },
+        "rule": { "type": "string", "minLength": 1 },
+        "sourceSection": { "type": "string", "minLength": 1 }
+      }
+    },
+    "determinism": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["applicable", "runs", "normalizations"],
+          "properties": {
+            "applicable": { "const": true },
+            "runs": { "type": "array", "minItems": 2, "items": { "$ref": "#/$defs/run" } },
+            "normalizations": { "type": "array", "items": { "$ref": "#/$defs/normalization" } }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["applicable", "reason"],
+          "properties": {
+            "applicable": { "const": false },
+            "reason": { "type": "string", "minLength": 1 }
+          }
+        }
+      ]
+    },
+    "requirement": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["requirementId", "testProfile", "source", "sourceConformance", "sourceValidity", "dimensions", "skippedTests", "naDeclarations"],
+      "properties": {
+        "requirementId": { "type": "string", "minLength": 1 },
+        "testProfile": { "enum": ["unit", "integration"] },
+        "source": { "$ref": "#/$defs/source" },
+        "additionalSources": { "type": "array", "items": { "$ref": "#/$defs/source" } },
+        "sourceConformance": { "enum": ["PASS", "NON_CONFORMANT"] },
+        "sourceValidity": { "enum": ["VALID", "SOURCE_DEFECT", "SOURCE_CONFLICT"] },
+        "sourceNotes": { "type": "string", "minLength": 1 },
+        "skippedTests": { "type": "array" },
+        "flakyTests": { "type": "array" },
+        "naDeclarations": { "type": "array" },
+        "dimensions": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["positiveParameters", "negativeParameters", "inputCompleteness", "outputCompleteness", "errorHandling", "unexpectedInput", "determinism", "sourceTraceability"],
+          "properties": {
+            "positiveParameters": { "$ref": "#/$defs/checkDimension" },
+            "negativeParameters": { "$ref": "#/$defs/checkDimension" },
+            "inputCompleteness": { "$ref": "#/$defs/checkDimension" },
+            "outputCompleteness": { "$ref": "#/$defs/checkDimension" },
+            "errorHandling": { "$ref": "#/$defs/checkDimension" },
+            "unexpectedInput": { "$ref": "#/$defs/checkDimension" },
+            "determinism": { "$ref": "#/$defs/determinism" },
+            "sourceTraceability": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["applicable"],
+              "properties": { "applicable": { "const": true } }
+            }
+          }
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "required": ["testProfile"],
+            "properties": { "testProfile": { "const": "integration" } }
+          },
+          "then": {
+            "properties": {
+              "dimensions": {
+                "type": "object",
+                "properties": {
+                  "determinism": {
+                    "type": "object",
+                    "properties": { "applicable": { "const": true } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+}

package/plugins/harness-everything/skills/tdd/schemas/quality-report.schema.json

@@ -0,0 +1,110 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/dyphn1/Harness-everything/tdd/schemas/quality-report.schema.json",
+  "title": "Harness TDD quality report",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "requirements", "dimensions", "mandatoryGates", "skippedTests", "naDeclarations", "scoring", "score", "result", "errors"],
+  "properties": {
+    "schemaVersion": { "const": "1.0.0" },
+    "requirements": { "type": "array", "items": { "$ref": "#/$defs/requirementResult" } },
+    "dimensions": { "$ref": "#/$defs/dimensions" },
+    "mandatoryGates": { "$ref": "#/$defs/gates" },
+    "skippedTests": { "type": "array" },
+    "naDeclarations": { "type": "array" },
+    "scoring": { "$ref": "#/$defs/scoring" },
+    "score": { "type": "number", "minimum": 0, "maximum": 100 },
+    "result": { "enum": ["PASS", "FAIL"] },
+    "errors": { "type": "array", "items": { "type": "string" } }
+  },
+  "$defs": {
+    "count": {
+      "type": "object",
+      "required": ["applicable", "passed", "required", "percentage"],
+      "properties": {
+        "applicable": { "type": "boolean" },
+        "passed": { "type": "integer", "minimum": 0 },
+        "required": { "type": "integer", "minimum": 0 },
+        "percentage": { "type": ["number", "null"], "minimum": 0, "maximum": 100 }
+      }
+    },
+    "dimensions": {
+      "type": "object",
+      "required": ["positiveParameters", "negativeParameters", "inputCompleteness", "outputCompleteness", "errorHandling", "unexpectedInput", "determinism", "sourceTraceability"],
+      "properties": {
+        "positiveParameters": { "$ref": "#/$defs/count" },
+        "negativeParameters": { "$ref": "#/$defs/count" },
+        "inputCompleteness": { "$ref": "#/$defs/count" },
+        "outputCompleteness": { "$ref": "#/$defs/count" },
+        "errorHandling": { "$ref": "#/$defs/count" },
+        "unexpectedInput": { "$ref": "#/$defs/count" },
+        "determinism": { "$ref": "#/$defs/count" },
+        "sourceTraceability": { "$ref": "#/$defs/count" }
+      }
+    },
+    "gates": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["applicableDimensionsExecuted", "sourceTraceabilityComplete", "noSourceMismatch", "noSourceConflict", "allRequiredInputOutputValidated", "allDeclaredErrorPathsTested", "integrationRepeated", "deterministicOutputs", "noSkippedOrFlakyTests", "qualityScoreComplete"],
+      "properties": {
+        "applicableDimensionsExecuted": { "type": "boolean" },
+        "sourceTraceabilityComplete": { "type": "boolean" },
+        "noSourceMismatch": { "type": "boolean" },
+        "noSourceConflict": { "type": "boolean" },
+        "allRequiredInputOutputValidated": { "type": "boolean" },
+        "allDeclaredErrorPathsTested": { "type": "boolean" },
+        "integrationRepeated": { "type": "boolean" },
+        "deterministicOutputs": { "type": "boolean" },
+        "noSkippedOrFlakyTests": { "type": "boolean" },
+        "qualityScoreComplete": { "type": "boolean" }
+      }
+    },
+    "scoring": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["weights", "method", "weightedPoints", "applicableWeight", "requiredScore"],
+      "properties": {
+        "weights": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["positiveParameters", "negativeParameters", "inputCompleteness", "outputCompleteness", "errorHandling", "unexpectedInput", "determinism", "sourceTraceability"],
+          "properties": {
+            "positiveParameters": { "const": 0.15 },
+            "negativeParameters": { "const": 0.15 },
+            "inputCompleteness": { "const": 0.15 },
+            "outputCompleteness": { "const": 0.15 },
+            "errorHandling": { "const": 0.15 },
+            "unexpectedInput": { "const": 0.10 },
+            "determinism": { "const": 0.10 },
+            "sourceTraceability": { "const": 0.05 }
+          }
+        },
+        "method": { "const": "weightedPoints / applicableWeight" },
+        "weightedPoints": { "type": "number", "minimum": 0, "maximum": 100 },
+        "applicableWeight": { "type": "number", "exclusiveMinimum": 0, "maximum": 1 },
+        "requiredScore": { "const": 100 }
+      }
+    },
+    "requirementResult": {
+      "type": "object",
+      "required": ["requirementId", "testProfile", "source", "additionalSources", "sourceConformance", "sourceValidity", "dimensions", "skippedTests", "flakyTests", "naDeclarations", "mandatoryGates", "scoring", "score", "result"],
+      "properties": {
+        "requirementId": { "type": ["string", "null"] },
+        "testProfile": { "enum": ["unit", "integration", null] },
+        "source": { "type": "object" },
+        "additionalSources": { "type": "array" },
+        "sourceConformance": { "enum": ["PASS", "NON_CONFORMANT", null] },
+        "sourceValidity": { "enum": ["VALID", "SOURCE_DEFECT", "SOURCE_CONFLICT", null] },
+        "sourceNotes": { "type": "string" },
+        "dimensions": { "$ref": "#/$defs/dimensions" },
+        "skippedTests": { "type": "array" },
+        "flakyTests": { "type": "array" },
+        "naDeclarations": { "type": "array" },
+        "mandatoryGates": { "$ref": "#/$defs/gates" },
+        "scoring": { "$ref": "#/$defs/scoring" },
+        "score": { "type": "number", "minimum": 0, "maximum": 100 },
+        "result": { "enum": ["PASS", "FAIL"] }
+      }
+    }
+  }
+}