gswd 1.0.0 → 1.1.0

package/dist/tests/audit.test.js

@@ -0,0 +1,1579 @@
+"use strict";
+/**
+ * Audit module tests — coverage matrix, checks, report generation, auto-fix, gate
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const audit_js_1 = require("../lib/audit.js");
+const parse_js_1 = require("../lib/parse.js");
+const state_js_1 = require("../lib/state.js");
+// ─── Test Fixtures ──────────────────────────────────────────────────────────
+const MINIMAL_JOURNEYS = `## Journeys
+
+### J-001: Onboarding
+User onboards to the system.
+References FR-001 and FR-002.
+
+#### Acceptance Tests
+- User can complete onboarding flow
+- User sees welcome message after onboarding
+
+### J-002: Core Action
+User performs the core action.
+References FR-003.
+Uses I-001 for external data.
+
+#### Acceptance Tests
+- User can perform core action successfully
+`;
+const MINIMAL_SPEC = `## Roles & Permissions
+Admin role only.
+
+## Functional Requirements
+
+### FR-001: Create account
+**Scope:** v1
+**Priority:** P0
+
+### FR-002: Set profile
+**Scope:** v1
+**Priority:** P1
+
+### FR-003: Perform action
+**Scope:** v1
+**Priority:** P0
+
+### FR-004: View history
+**Scope:** v2
+**Priority:** P2
+
+## Acceptance Criteria
+All tests must pass.
+`;
+const MINIMAL_NFR = `## Non-Functional Requirements
+
+### NFR-001: Response time
+Response time under 200ms.
+`;
+const MINIMAL_INTEGRATIONS = `## Integrations
+
+### I-001: External API
+**Status:** approved
+**Fallback:** None needed
+`;
+// ─── extractArtifactIds ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('extractArtifactIds', () => {
+    (0, node_test_1.it)('extracts J-001 from journey heading content', () => {
+        const result = (0, audit_js_1.extractArtifactIds)('### J-001: Onboarding');
+        assert.strictEqual(result.journeyIds.length, 1);
+        assert.strictEqual(result.journeyIds[0].id, 'J-001');
+    });
+    (0, node_test_1.it)('extracts FR-001, FR-002 from spec content with mixed IDs', () => {
+        const result = (0, audit_js_1.extractArtifactIds)('FR-001 and FR-002 with J-001');
+        assert.strictEqual(result.frIds.length, 2);
+        assert.strictEqual(result.frIds[0].id, 'FR-001');
+        assert.strictEqual(result.frIds[1].id, 'FR-002');
+        assert.strictEqual(result.journeyIds.length, 1);
+    });
+    (0, node_test_1.it)('returns empty arrays for empty content', () => {
+        const result = (0, audit_js_1.extractArtifactIds)('');
+        assert.strictEqual(result.journeyIds.length, 0);
+        assert.strictEqual(result.frIds.length, 0);
+        assert.strictEqual(result.nfrIds.length, 0);
+        assert.strictEqual(result.integrationIds.length, 0);
+    });
+    (0, node_test_1.it)('handles content with no IDs', () => {
+        const result = (0, audit_js_1.extractArtifactIds)('This has no IDs at all.');
+        assert.strictEqual(result.journeyIds.length, 0);
+        assert.strictEqual(result.frIds.length, 0);
+    });
+    (0, node_test_1.it)('extracts NFR and I IDs correctly', () => {
+        const result = (0, audit_js_1.extractArtifactIds)('NFR-001 and I-002');
+        assert.strictEqual(result.nfrIds.length, 1);
+        assert.strictEqual(result.nfrIds[0].id, 'NFR-001');
+        assert.strictEqual(result.integrationIds.length, 1);
+        assert.strictEqual(result.integrationIds[0].id, 'I-002');
+    });
+});
+// ─── parseJourneySections ───────────────────────────────────────────────────
+(0, node_test_1.describe)('parseJourneySections', () => {
+    (0, node_test_1.it)('splits 2 journeys into 2 sections', () => {
+        const content = `## Journeys
+### J-001: First
+Content of first journey.
+### J-002: Second
+Content of second journey.`;
+        const sections = (0, audit_js_1.parseJourneySections)(content);
+        assert.strictEqual(sections.size, 2);
+        assert.ok(sections.has('J-001'));
+        assert.ok(sections.has('J-002'));
+    });
+    (0, node_test_1.it)('each section contains only content between headings', () => {
+        const content = `### J-001: First
+First content here.
+### J-002: Second
+Second content here.`;
+        const sections = (0, audit_js_1.parseJourneySections)(content);
+        assert.ok(sections.get('J-001').includes('First content'));
+        assert.ok(!sections.get('J-001').includes('Second content'));
+        assert.ok(sections.get('J-002').includes('Second content'));
+    });
+    (0, node_test_1.it)('returns empty map for content without journey headings', () => {
+        const sections = (0, audit_js_1.parseJourneySections)('No journeys here.');
+        assert.strictEqual(sections.size, 0);
+    });
+    (0, node_test_1.it)('returns empty map for empty string', () => {
+        const sections = (0, audit_js_1.parseJourneySections)('');
+        assert.strictEqual(sections.size, 0);
+    });
+});
+// ─── parseFRScope ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('parseFRScope', () => {
+    (0, node_test_1.it)('extracts "v1" scope from "**Scope:** v1" pattern', () => {
+        const content = `### FR-001: Test\n**Scope:** v1\n**Priority:** P0`;
+        const scopes = (0, audit_js_1.parseFRScope)(content);
+        assert.strictEqual(scopes.get('FR-001'), 'v1');
+    });
+    (0, node_test_1.it)('extracts "v2" from "Scope: v2" pattern', () => {
+        const content = `### FR-001: Test\nScope: v2\nPriority: P2`;
+        const scopes = (0, audit_js_1.parseFRScope)(content);
+        assert.strictEqual(scopes.get('FR-001'), 'v2');
+    });
+    (0, node_test_1.it)('extracts "out" scope correctly', () => {
+        const content = `### FR-001: Test\n**Scope:** out`;
+        const scopes = (0, audit_js_1.parseFRScope)(content);
+        assert.strictEqual(scopes.get('FR-001'), 'out');
+    });
+    (0, node_test_1.it)('defaults to "v1" when scope not found', () => {
+        const content = `### FR-001: Test\nNo scope line here.`;
+        const scopes = (0, audit_js_1.parseFRScope)(content);
+        assert.strictEqual(scopes.get('FR-001'), 'v1');
+    });
+    (0, node_test_1.it)('handles multiple FRs with different scopes', () => {
+        const content = `### FR-001: A\n**Scope:** v1\n### FR-002: B\n**Scope:** v2`;
+        const scopes = (0, audit_js_1.parseFRScope)(content);
+        assert.strictEqual(scopes.get('FR-001'), 'v1');
+        assert.strictEqual(scopes.get('FR-002'), 'v2');
+    });
+});
+// ─── parseIntegrationStatus ─────────────────────────────────────────────────
+(0, node_test_1.describe)('parseIntegrationStatus', () => {
+    (0, node_test_1.it)('parses "approved" status correctly', () => {
+        const content = `### I-001: API\n**Status:** approved`;
+        const statuses = (0, audit_js_1.parseIntegrationStatus)(content);
+        assert.strictEqual(statuses.get('I-001').status, 'approved');
+    });
+    (0, node_test_1.it)('parses "deferred" status with fallback present -> hasFallback: true', () => {
+        const content = `### I-001: API\n**Status:** deferred\n**Fallback:** Use local mode`;
+        const statuses = (0, audit_js_1.parseIntegrationStatus)(content);
+        assert.strictEqual(statuses.get('I-001').status, 'deferred');
+        assert.strictEqual(statuses.get('I-001').hasFallback, true);
+    });
+    (0, node_test_1.it)('parses "rejected" status correctly', () => {
+        const content = `### I-001: API\n**Status:** rejected`;
+        const statuses = (0, audit_js_1.parseIntegrationStatus)(content);
+        assert.strictEqual(statuses.get('I-001').status, 'rejected');
+    });
+    (0, node_test_1.it)('missing fallback -> hasFallback: false', () => {
+        const content = `### I-001: API\n**Status:** deferred`;
+        const statuses = (0, audit_js_1.parseIntegrationStatus)(content);
+        assert.strictEqual(statuses.get('I-001').hasFallback, false);
+    });
+    (0, node_test_1.it)('handles empty content', () => {
+        const statuses = (0, audit_js_1.parseIntegrationStatus)('');
+        assert.strictEqual(statuses.size, 0);
+    });
+});
+// ─── buildCoverageMatrix ────────────────────────────────────────────────────
+(0, node_test_1.describe)('buildCoverageMatrix', () => {
+    (0, node_test_1.it)('matrix journeyToFRs populated from journey sections', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.ok(matrix.journeyToFRs.has('J-001'));
+        const j1FRs = matrix.journeyToFRs.get('J-001');
+        assert.ok(j1FRs.has('FR-001'));
+        assert.ok(j1FRs.has('FR-002'));
+    });
+    (0, node_test_1.it)('matrix frToJourneys is reverse of journeyToFRs', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const fr1Journeys = matrix.frToJourneys.get('FR-001');
+        assert.ok(fr1Journeys);
+        assert.ok(fr1Journeys.has('J-001'));
+    });
+    (0, node_test_1.it)('matrix journeyToTests populated from acceptance test sections', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const j1Tests = matrix.journeyToTests.get('J-001');
+        assert.ok(j1Tests);
+        assert.ok(j1Tests.length >= 1);
+    });
+    (0, node_test_1.it)('matrix integrationStatus populated from INTEGRATIONS.md', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.ok(matrix.integrationStatus.has('I-001'));
+        assert.strictEqual(matrix.integrationStatus.get('I-001').status, 'approved');
+    });
+    (0, node_test_1.it)('matrix frScopes populated from SPEC.md', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        assert.strictEqual(matrix.frScopes.get('FR-001'), 'v1');
+        assert.strictEqual(matrix.frScopes.get('FR-004'), 'v2');
+    });
+    (0, node_test_1.it)('allJourneyIds contains all journeys found', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys: MINIMAL_JOURNEYS });
+        assert.ok(matrix.allJourneyIds.includes('J-001'));
+        assert.ok(matrix.allJourneyIds.includes('J-002'));
+    });
+    (0, node_test_1.it)('handles empty files gracefully', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({});
+        assert.strictEqual(matrix.allJourneyIds.length, 0);
+        assert.strictEqual(matrix.allFRIds.length, 0);
+    });
+});
+// ─── checkJourneyFRCoverage ─────────────────────────────────────────────────
+(0, node_test_1.describe)('checkJourneyFRCoverage', () => {
+    (0, node_test_1.it)('journey with FRs passes', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const result = (0, audit_js_1.checkJourneyFRCoverage)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('journey with zero FRs fails with correct finding', () => {
+        const journeys = `## Journeys\n### J-001: Empty\nNo FR references here.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const result = (0, audit_js_1.checkJourneyFRCoverage)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.strictEqual(result.findings[0].id, 'J-001');
+        assert.ok(result.findings[0].issue.includes('no functional requirements'));
+    });
+    (0, node_test_1.it)('multiple journeys: one passing, one failing', () => {
+        const journeys = `## Journeys
+### J-001: Good
+References FR-001.
+#### Acceptance Tests
+- test
+### J-002: Bad
+No refs here.
+#### Acceptance Tests
+- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const result = (0, audit_js_1.checkJourneyFRCoverage)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.strictEqual(result.findings.length, 1);
+        assert.strictEqual(result.findings[0].id, 'J-002');
+    });
+});
+// ─── checkJourneyTestCoverage ───────────────────────────────────────────────
+(0, node_test_1.describe)('checkJourneyTestCoverage', () => {
+    (0, node_test_1.it)('journey with acceptance test passes', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+        });
+        const result = (0, audit_js_1.checkJourneyTestCoverage)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('journey with empty tests fails', () => {
+        const journeys = `## Journeys\n### J-001: No Tests\nReferences FR-001.\n#### Acceptance Tests\n`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const result = (0, audit_js_1.checkJourneyTestCoverage)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.strictEqual(result.findings[0].id, 'J-001');
+    });
+    (0, node_test_1.it)('journey without acceptance tests section fails', () => {
+        const journeys = `## Journeys\n### J-001: Missing Section\nReferences FR-001.\nNo test section at all.`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const result = (0, audit_js_1.checkJourneyTestCoverage)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.strictEqual(result.findings[0].id, 'J-001');
+        assert.ok(result.findings[0].issue.includes('no acceptance tests'));
+    });
+});
+// ─── checkOrphanV1FRs ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('checkOrphanV1FRs', () => {
+    (0, node_test_1.it)('v1 FR referenced by a journey passes', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const result = (0, audit_js_1.checkOrphanV1FRs)(matrix);
+        // FR-001, FR-002, FR-003 are all v1 and referenced by journeys
+        // FR-004 is v2 so should be skipped
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('v1 FR NOT referenced by any journey fails (orphan detection)', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-001: Orphan\n**Scope:** v1\n## Acceptance Criteria\n`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: `## Journeys\n### J-001: Test\nNo FR refs.\n#### Acceptance Tests\n- test`,
+            spec,
+        });
+        const result = (0, audit_js_1.checkOrphanV1FRs)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.findings.some((f) => f.id === 'FR-001'));
+        assert.ok(result.findings[0].issue.includes('v1 FR not referenced'));
+    });
+    (0, node_test_1.it)('v2 FR not referenced by any journey still passes (scope filter works)', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-001: V2 Feature\n**Scope:** v2\n## Acceptance Criteria\n`;
+        const journeys = `## Journeys\n### J-001: Test\nNo FR refs.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys, spec });
+        const result = (0, audit_js_1.checkOrphanV1FRs)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('out-of-scope FR not referenced passes', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-001: Out\n**Scope:** out\n## Acceptance Criteria\n`;
+        const journeys = `## Journeys\n### J-001: Test\nNo FR refs.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys, spec });
+        const result = (0, audit_js_1.checkOrphanV1FRs)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+});
+// ─── checkIntegrationApproval ───────────────────────────────────────────────
+(0, node_test_1.describe)('checkIntegrationApproval', () => {
+    (0, node_test_1.it)('approved integration passes', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const result = (0, audit_js_1.checkIntegrationApproval)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('deferred integration WITH fallback passes', () => {
+        const integrations = `## Integrations\n### I-001: API\n**Status:** deferred\n**Fallback:** Use local data`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            integrations,
+        });
+        const result = (0, audit_js_1.checkIntegrationApproval)(matrix);
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('deferred integration WITHOUT fallback fails', () => {
+        const integrations = `## Integrations\n### I-001: API\n**Status:** deferred`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            integrations,
+        });
+        const result = (0, audit_js_1.checkIntegrationApproval)(matrix);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.findings.some((f) => f.id === 'I-001'));
+    });
+    (0, node_test_1.it)('rejected integration fails', () => {
+        const integrations = `## Integrations\n### I-001: API\n**Status:** rejected`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            integrations,
+        });
+        const result = (0, audit_js_1.checkIntegrationApproval)(matrix);
+        assert.strictEqual(result.passed, false);
+    });
+    (0, node_test_1.it)('integration not referenced by any journey is not checked', () => {
+        const integrations = `## Integrations\n### I-099: Unused\n**Status:** rejected`;
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys, integrations });
+        const result = (0, audit_js_1.checkIntegrationApproval)(matrix);
+        assert.strictEqual(result.passed, true); // I-099 not referenced, not checked
+    });
+});
+// ─── checkRequiredHeadings ──────────────────────────────────────────────────
+(0, node_test_1.describe)('checkRequiredHeadings', () => {
+    (0, node_test_1.it)('all headings present passes', () => {
+        const result = (0, audit_js_1.checkRequiredHeadings)({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+            'DECISIONS.md': `## Frozen Decisions\n## Success Metrics\n## Out of Scope\n## Risks & Mitigations\n## Open Questions`,
+        });
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('missing heading in JOURNEYS.md fails with specific heading', () => {
+        const result = (0, audit_js_1.checkRequiredHeadings)({
+            'JOURNEYS.md': 'No headings here',
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.findings.some((f) => f.id === 'JOURNEYS.md'));
+    });
+    (0, node_test_1.it)('missing heading in SPEC.md fails', () => {
+        const result = (0, audit_js_1.checkRequiredHeadings)({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': 'Only some content',
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.findings.some((f) => f.id === 'SPEC.md'));
+    });
+    (0, node_test_1.it)('unknown file type with no required headings is not checked', () => {
+        const result = (0, audit_js_1.checkRequiredHeadings)({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+            'UNKNOWN.md': 'whatever',
+        });
+        // Should not fail just because UNKNOWN.md has no required headings
+        // Only required files from REQUIRED_HEADINGS are checked
+        assert.strictEqual(result.passed, true);
+    });
+    (0, node_test_1.it)('empty file content produces finding', () => {
+        const result = (0, audit_js_1.checkRequiredHeadings)({
+            'JOURNEYS.md': '',
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.findings.some((f) => f.id === 'JOURNEYS.md' && f.issue.includes('missing or empty')));
+    });
+});
+// ─── runAudit ───────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('runAudit', () => {
+    (0, node_test_1.it)('full passing spec bundle returns passed: true', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, true);
+        assert.strictEqual(result.summary.failed, 0);
+    });
+    (0, node_test_1.it)('spec bundle with orphan v1 FR returns passed: false', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-001: Used\n**Scope:** v1\n### FR-002: Used\n**Scope:** v1\n### FR-003: Used\n**Scope:** v1\n### FR-099: Orphan\n**Scope:** v1\n## Acceptance Criteria\n`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        // Find the orphan check
+        const orphanCheck = result.checks.find((c) => c.check === 'orphan_v1_frs');
+        assert.ok(orphanCheck);
+        assert.strictEqual(orphanCheck.passed, false);
+        assert.ok(orphanCheck.findings.some((f) => f.id === 'FR-099'));
+    });
+    (0, node_test_1.it)('summary counts are accurate', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.summary.total_checks, 5);
+        assert.strictEqual(result.summary.passed + result.summary.failed, result.summary.total_checks);
+    });
+    (0, node_test_1.it)('empty/missing files produce appropriate findings', () => {
+        const result = (0, audit_js_1.runAudit)({});
+        assert.strictEqual(result.passed, false);
+        // Required headings check should fail for missing files
+        const headingCheck = result.checks.find((c) => c.check === 'required_headings');
+        assert.ok(headingCheck);
+        assert.strictEqual(headingCheck.passed, false);
+    });
+    (0, node_test_1.it)('check results have correct check names', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const checkNames = result.checks.map((c) => c.check);
+        assert.ok(checkNames.includes('journey_fr_coverage'));
+        assert.ok(checkNames.includes('journey_test_coverage'));
+        assert.ok(checkNames.includes('orphan_v1_frs'));
+        assert.ok(checkNames.includes('integration_approval'));
+        assert.ok(checkNames.includes('required_headings'));
+    });
+});
+// ─── Integration: journey without tests ─────────────────────────────────────
+(0, node_test_1.describe)('integration: journey without tests (TEST-02)', () => {
+    (0, node_test_1.it)('journeys content with no acceptance tests section produces FAIL', () => {
+        const journeys = `## Journeys\n### J-001: No Tests\nReferences FR-001.\nNo test section.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        const testCheck = result.checks.find((c) => c.check === 'journey_test_coverage');
+        assert.ok(testCheck);
+        assert.strictEqual(testCheck.passed, false);
+    });
+    (0, node_test_1.it)('journeys content with acceptance tests section produces PASS for that check', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const testCheck = result.checks.find((c) => c.check === 'journey_test_coverage');
+        assert.ok(testCheck);
+        assert.strictEqual(testCheck.passed, true);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Plan 04-02: Report Generation, Auto-Fix, Hard Gate
+// ═══════════════════════════════════════════════════════════════════════════════
+// ─── Helper: create tmp STATE.json ──────────────────────────────────────────
+function createTestStateDir(overrides) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-gate-'));
+    const statePath = path.join(dir, 'STATE.json');
+    const state = (0, state_js_1.createDefaultState)('test-project');
+    if (overrides?.audit) {
+        state.stage_status.audit = overrides.audit;
+    }
+    if (overrides?.stage) {
+        state.stage = overrides.stage;
+    }
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    return {
+        dir,
+        statePath,
+        cleanup: () => fs.rmSync(dir, { recursive: true, force: true }),
+    };
+}
+// ─── formatCoverageMatrixTable ──────────────────────────────────────────────
+(0, node_test_1.describe)('formatCoverageMatrixTable', () => {
+    (0, node_test_1.it)('produces table with correct headers', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const table = (0, audit_js_1.formatCoverageMatrixTable)(matrix);
+        assert.ok(table.includes('| Journey |'));
+        assert.ok(table.includes('| Linked FRs |'));
+        assert.ok(table.includes('| Acceptance Tests |'));
+        assert.ok(table.includes('| Status |'));
+    });
+    (0, node_test_1.it)('journey with FRs shows FR IDs comma-separated', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const table = (0, audit_js_1.formatCoverageMatrixTable)(matrix);
+        // J-001 has FR-001 and FR-002
+        assert.ok(table.includes('FR-001, FR-002'));
+    });
+    (0, node_test_1.it)('journey with no FRs shows "(none)"', () => {
+        const journeys = `## Journeys\n### J-001: Empty\nNo FR refs here.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const table = (0, audit_js_1.formatCoverageMatrixTable)(matrix);
+        assert.ok(table.includes('(none)'));
+    });
+    (0, node_test_1.it)('test count shown correctly', () => {
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+        });
+        const table = (0, audit_js_1.formatCoverageMatrixTable)(matrix);
+        // J-001 has 2 tests
+        assert.ok(table.includes('2 tests'));
+        // J-002 has 1 test
+        assert.ok(table.includes('1 test'));
+    });
+    (0, node_test_1.it)('sorted by journey ID', () => {
+        const journeys = `## Journeys\n### J-002: Second\nFR-002.\n#### Acceptance Tests\n- test\n### J-001: First\nFR-001.\n#### Acceptance Tests\n- test`;
+        const matrix = (0, audit_js_1.buildCoverageMatrix)({ journeys });
+        const table = (0, audit_js_1.formatCoverageMatrixTable)(matrix);
+        const j1Pos = table.indexOf('J-001');
+        const j2Pos = table.indexOf('J-002');
+        assert.ok(j1Pos < j2Pos, 'J-001 should appear before J-002');
+    });
+});
+// ─── formatCheckSection ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('formatCheckSection', () => {
+    (0, node_test_1.it)('passing check shows "PASS"', () => {
+        const result = { check: 'journey_fr_coverage', passed: true, findings: [] };
+        const section = (0, audit_js_1.formatCheckSection)(result);
+        assert.ok(section.includes('PASS'));
+        assert.ok(section.includes('Journey FR Coverage'));
+    });
+    (0, node_test_1.it)('failing check shows "FAIL" with checkbox items', () => {
+        const result = {
+            check: 'journey_fr_coverage',
+            passed: false,
+            findings: [
+                { id: 'J-003', issue: 'Journey references no FRs', fix: 'Add FR refs', severity: 'error' },
+            ],
+        };
+        const section = (0, audit_js_1.formatCheckSection)(result);
+        assert.ok(section.includes('FAIL'));
+        assert.ok(section.includes('- [ ]'));
+        assert.ok(section.includes('**J-003**'));
+    });
+    (0, node_test_1.it)('each finding has ID in bold and fix instruction', () => {
+        const result = {
+            check: 'orphan_v1_frs',
+            passed: false,
+            findings: [
+                { id: 'FR-099', issue: 'orphan FR', fix: 'Add reference to FR-099', severity: 'error' },
+            ],
+        };
+        const section = (0, audit_js_1.formatCheckSection)(result);
+        assert.ok(section.includes('**FR-099**'));
+        assert.ok(section.includes('Fix: Add reference to FR-099'));
+    });
+});
+// ─── generateAuditReport ────────────────────────────────────────────────────
+(0, node_test_1.describe)('generateAuditReport', () => {
+    (0, node_test_1.it)('PASS result includes "Result: PASS" header', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('**Result:** PASS'));
+    });
+    (0, node_test_1.it)('FAIL result includes "Result: FAIL" header', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: `## Journeys\n### J-001: Bad\nNo FR refs.\n`,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('**Result:** FAIL'));
+    });
+    (0, node_test_1.it)('coverage matrix table included', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('## Coverage Matrix'));
+        assert.ok(report.includes('| Journey |'));
+    });
+    (0, node_test_1.it)('coverage statistics table included', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('## Coverage Statistics'));
+        assert.ok(report.includes('| Journeys |'));
+        assert.ok(report.includes('| Functional Requirements |'));
+    });
+    (0, node_test_1.it)('check sections present for all checks', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('## Check Results'));
+        assert.ok(report.includes('### Journey FR Coverage'));
+        assert.ok(report.includes('### Journey Test Coverage'));
+        assert.ok(report.includes('### Orphan v1 FRs'));
+        assert.ok(report.includes('### Integration Approval'));
+        assert.ok(report.includes('### Required Headings'));
+    });
+    (0, node_test_1.it)('FAIL result includes actionable checklist section', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: `## Journeys\n### J-001: Bad\nNo FR refs.\n`,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('## Actionable Checklist'));
+        assert.ok(report.includes('- [ ]'));
+    });
+    (0, node_test_1.it)('PASS result does NOT include actionable checklist', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(!report.includes('## Actionable Checklist'));
+    });
+    (0, node_test_1.it)('summary counts are accurate', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        assert.ok(report.includes('5/5 checks passed'));
+        assert.ok(report.includes('0 issue(s) found'));
+    });
+});
+// ─── applyAutoFix — allowed changes ─────────────────────────────────────────
+(0, node_test_1.describe)('applyAutoFix — allowed changes', () => {
+    (0, node_test_1.it)('adds stub acceptance test to journey missing tests', () => {
+        const journeys = `## Journeys\n### J-001: Onboarding\nReferences FR-001.\nNo tests section.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        assert.ok(fixResult.applied.length > 0);
+        assert.ok(fixResult.applied.some((c) => c.change.includes('stub acceptance test')));
+    });
+    (0, node_test_1.it)('stub test contains journey ID', () => {
+        const journeys = `## Journeys\n### J-001: Onboarding\nReferences FR-001.\nNo tests.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        const updatedJourneys = fixResult.updatedFiles.get('JOURNEYS.md') || '';
+        assert.ok(updatedJourneys.includes('J-001'));
+        assert.ok(updatedJourneys.includes('Acceptance Tests'));
+    });
+    (0, node_test_1.it)('adds fallback stub for unapproved integration', () => {
+        const integrations = `## Integrations\n### I-001: External API\n**Status:** deferred`;
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001 and uses I-001.\n#### Acceptance Tests\n- test`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': integrations,
+        });
+        assert.ok(fixResult.applied.some((c) => c.change.includes('fallback')));
+        const updatedInt = fixResult.updatedFiles.get('INTEGRATIONS.md') || '';
+        assert.ok(updatedInt.includes('**Fallback:**'));
+    });
+    (0, node_test_1.it)('returns the change in applied[] with human-readable description', () => {
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001.\nNo tests.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        for (const change of fixResult.applied) {
+            assert.ok(change.file.length > 0);
+            assert.ok(change.change.length > 0);
+            assert.ok(change.finding);
+        }
+    });
+});
+// ─── applyAutoFix — prohibited changes ──────────────────────────────────────
+(0, node_test_1.describe)('applyAutoFix — prohibited changes', () => {
+    (0, node_test_1.it)('does NOT create new FRs (orphan FR finding goes to skipped[])', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-099: Orphan\n**Scope:** v1\n## Acceptance Criteria\n`;
+        const journeys = `## Journeys\n### J-001: Test\nNo FR refs.\n#### Acceptance Tests\n- test`;
+        const result = (0, audit_js_1.runAudit)({ journeys, spec, nfr: MINIMAL_NFR, integrations: MINIMAL_INTEGRATIONS });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': spec,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        // Orphan FR finding should be in skipped
+        assert.ok(fixResult.skipped.some((f) => f.id === 'FR-099'));
+    });
+    (0, node_test_1.it)('does NOT create new journeys (journey_fr_coverage finding goes to skipped[])', () => {
+        const journeys = `## Journeys\n### J-001: Empty\nNo FR refs.\n#### Acceptance Tests\n- test`;
+        const result = (0, audit_js_1.runAudit)({ journeys, spec: MINIMAL_SPEC, nfr: MINIMAL_NFR, integrations: MINIMAL_INTEGRATIONS });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        // Journey FR coverage finding should be in skipped
+        assert.ok(fixResult.skipped.some((f) => f.id === 'J-001'));
+    });
+    (0, node_test_1.it)('does NOT approve paid integrations (adds fallback instead)', () => {
+        const integrations = `## Integrations\n### I-001: Paid API\n**Status:** deferred`;
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001. Uses I-001.\n#### Acceptance Tests\n- test`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': integrations,
+        });
+        const updatedInt = fixResult.updatedFiles.get('INTEGRATIONS.md') || '';
+        // Should NOT change status to approved
+        assert.ok(!updatedInt.includes('**Status:** approved'));
+        // Should add fallback instead
+        assert.ok(updatedInt.includes('**Fallback:**'));
+    });
+    (0, node_test_1.it)('skipped findings include the original finding object', () => {
+        const spec = `## Roles & Permissions\n## Functional Requirements\n### FR-099: Orphan\n**Scope:** v1\n## Acceptance Criteria\n`;
+        const journeys = `## Journeys\n### J-001: Test\nNo FR refs.\n#### Acceptance Tests\n- test`;
+        const result = (0, audit_js_1.runAudit)({ journeys, spec, nfr: MINIMAL_NFR, integrations: MINIMAL_INTEGRATIONS });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': spec,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        for (const finding of fixResult.skipped) {
+            assert.ok(finding.id);
+            assert.ok(finding.issue);
+            assert.ok(finding.fix);
+        }
+    });
+});
+// ─── applyAutoFix — surgical principle ──────────────────────────────────────
+(0, node_test_1.describe)('applyAutoFix — surgical principle', () => {
+    (0, node_test_1.it)('original file content preserved except for additions', () => {
+        const journeys = `## Journeys\n### J-001: Onboarding\nReferences FR-001.\nOriginal content here.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        const updated = fixResult.updatedFiles.get('JOURNEYS.md') || '';
+        // Original content is still there
+        assert.ok(updated.includes('Original content here.'));
+        assert.ok(updated.includes('### J-001: Onboarding'));
+    });
+    (0, node_test_1.it)('changes are appended, not replacing existing content', () => {
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001.\nExisting text.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        const updated = fixResult.updatedFiles.get('JOURNEYS.md') || '';
+        // Existing text preserved AND new content added
+        assert.ok(updated.includes('Existing text.'));
+        assert.ok(updated.length > journeys.length);
+    });
+    (0, node_test_1.it)('updated file content in updatedFiles map', () => {
+        const journeys = `## Journeys\n### J-001: Test\nReferences FR-001.\nNo tests.`;
+        const result = (0, audit_js_1.runAudit)({
+            journeys,
+            spec: `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        const fixResult = (0, audit_js_1.applyAutoFix)(result, {
+            'JOURNEYS.md': journeys,
+            'SPEC.md': `## Roles & Permissions\n## Functional Requirements\n### FR-001: A\n**Scope:** v1\n## Acceptance Criteria\n`,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        assert.ok(fixResult.updatedFiles instanceof Map);
+        assert.ok(fixResult.updatedFiles.has('JOURNEYS.md'));
+    });
+});
+// ─── checkAuditGate ─────────────────────────────────────────────────────────
+(0, node_test_1.describe)('checkAuditGate', () => {
+    (0, node_test_1.it)('returns true when stage_status.audit is "pass"', () => {
+        const { statePath, cleanup } = createTestStateDir({ audit: 'pass' });
+        try {
+            assert.strictEqual((0, audit_js_1.checkAuditGate)(statePath), true);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns false when stage_status.audit is "fail"', () => {
+        const { statePath, cleanup } = createTestStateDir({ audit: 'fail' });
+        try {
+            assert.strictEqual((0, audit_js_1.checkAuditGate)(statePath), false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns false when stage_status.audit is "not_started"', () => {
+        const { statePath, cleanup } = createTestStateDir({ audit: 'not_started' });
+        try {
+            assert.strictEqual((0, audit_js_1.checkAuditGate)(statePath), false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns false when stage_status.audit is "in_progress"', () => {
+        const { statePath, cleanup } = createTestStateDir({ audit: 'in_progress' });
+        try {
+            assert.strictEqual((0, audit_js_1.checkAuditGate)(statePath), false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns false when STATE.json does not exist (fail-closed)', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-gate-'));
+        try {
+            assert.strictEqual((0, audit_js_1.checkAuditGate)(path.join(tmpDir, 'nonexistent.json')), false);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+// ─── updateAuditState ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('updateAuditState', () => {
+    (0, node_test_1.it)('sets stage_status.audit to "pass" when passed=true', () => {
+        const { statePath, cleanup } = createTestStateDir();
+        try {
+            (0, audit_js_1.updateAuditState)(statePath, true);
+            const content = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(content.stage_status.audit, 'pass');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('sets stage_status.audit to "fail" when passed=false', () => {
+        const { statePath, cleanup } = createTestStateDir();
+        try {
+            (0, audit_js_1.updateAuditState)(statePath, false);
+            const content = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(content.stage_status.audit, 'fail');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('updates stage field to "audit" on pass', () => {
+        const { statePath, cleanup } = createTestStateDir();
+        try {
+            (0, audit_js_1.updateAuditState)(statePath, true);
+            const content = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(content.stage, 'audit');
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Plan 04-03: Workflow Orchestrator
+// ═══════════════════════════════════════════════════════════════════════════════
+// ─── Helper: create tmp planning dir with fixture files ──────────────────────
+function createTestPlanningDir(fixtures) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-test-'));
+    const gswdDir = path.join(dir, 'gswd');
+    fs.mkdirSync(gswdDir, { recursive: true });
+    // Write fixture files
+    for (const [name, content] of Object.entries(fixtures)) {
+        fs.writeFileSync(path.join(dir, name), content, 'utf-8');
+    }
+    // Create default STATE.json
+    const statePath = path.join(gswdDir, 'STATE.json');
+    const state = (0, state_js_1.createDefaultState)('test-project');
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    return {
+        dir,
+        statePath,
+        cleanup: () => fs.rmSync(dir, { recursive: true, force: true }),
+    };
+}
+// ─── readArtifactFiles ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('readArtifactFiles', () => {
+    (0, node_test_1.it)('reads all 4 required artifact files from directory', () => {
+        const { dir, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const files = (0, audit_js_1.readArtifactFiles)(dir);
+            assert.ok(files.journeys.length > 0);
+            assert.ok(files.spec.length > 0);
+            assert.ok(files.nfr.length > 0);
+            assert.ok(files.integrations.length > 0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('missing file returns empty string (not error)', () => {
+        const { dir, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            // SPEC.md, NFR.md, INTEGRATIONS.md not created
+        });
+        try {
+            const files = (0, audit_js_1.readArtifactFiles)(dir);
+            assert.strictEqual(files.spec, '');
+            assert.strictEqual(files.nfr, '');
+            assert.strictEqual(files.integrations, '');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns correct content for each file', () => {
+        const { dir, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+        });
+        try {
+            const files = (0, audit_js_1.readArtifactFiles)(dir);
+            assert.strictEqual(files.journeys, MINIMAL_JOURNEYS);
+            assert.strictEqual(files.spec, MINIMAL_SPEC);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── writeAuditReport ────────────────────────────────────────────────────────
+(0, node_test_1.describe)('writeAuditReport', () => {
+    (0, node_test_1.it)('writes AUDIT.md to specified directory', () => {
+        const { dir, cleanup } = createTestPlanningDir({});
+        try {
+            (0, audit_js_1.writeAuditReport)(dir, '# Audit Report\n**Result:** PASS');
+            assert.ok(fs.existsSync(path.join(dir, 'AUDIT.md')));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('file content matches input', () => {
+        const { dir, cleanup } = createTestPlanningDir({});
+        const content = '# Audit Report\n**Result:** PASS\nSome details.';
+        try {
+            (0, audit_js_1.writeAuditReport)(dir, content);
+            const written = fs.readFileSync(path.join(dir, 'AUDIT.md'), 'utf-8');
+            assert.strictEqual(written, content);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('returns correct path', () => {
+        const { dir, cleanup } = createTestPlanningDir({});
+        try {
+            const returned = (0, audit_js_1.writeAuditReport)(dir, '# Report');
+            assert.strictEqual(returned, path.join(dir, 'AUDIT.md'));
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── runAuditWorkflow — passing ──────────────────────────────────────────────
+(0, node_test_1.describe)('runAuditWorkflow — passing', () => {
+    (0, node_test_1.it)('full passing spec bundle -> passed: true', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.strictEqual(result.passed, true);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('AUDIT.md written to planning dir', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.ok(fs.existsSync(path.join(dir, 'AUDIT.md')));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('STATE.json updated to audit: "pass"', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(state.stage_status.audit, 'pass');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('autoFixCycles: 0 when passing without auto-fix', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.strictEqual(result.autoFixCycles, 0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── runAuditWorkflow — failing without auto-fix ─────────────────────────────
+(0, node_test_1.describe)('runAuditWorkflow — failing without auto-fix', () => {
+    (0, node_test_1.it)('spec with orphan FR -> passed: false', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.strictEqual(result.passed, false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('AUDIT.md written with FAIL report', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const auditMd = fs.readFileSync(path.join(dir, 'AUDIT.md'), 'utf-8');
+            assert.ok(auditMd.includes('**Result:** FAIL'));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('STATE.json updated to audit: "fail"', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(state.stage_status.audit, 'fail');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('autoFixCycles: 0 when failing without auto-fix', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.strictEqual(result.autoFixCycles, 0);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── runAuditWorkflow — auto-fix success ─────────────────────────────────────
+(0, node_test_1.describe)('runAuditWorkflow — auto-fix success', () => {
+    (0, node_test_1.it)('spec with missing test + autoFix: true -> passes after auto-fix', () => {
+        // Journey without acceptance tests (fixable by auto-fix)
+        const journeysNoTests = `## Journeys\n\n### J-001: Onboarding\nReferences FR-001 and FR-002.\n\n### J-002: Core Action\nReferences FR-003.\nUses I-001.\n\n#### Acceptance Tests\n- User can perform core action successfully\n`;
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': journeysNoTests,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath, autoFix: true });
+            // After auto-fix adds stub test, J-001 should have acceptance test
+            assert.strictEqual(result.autoFixCycles, 1);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('autoFixChanges contains the stub addition', () => {
+        const journeysNoTests = `## Journeys\n\n### J-001: Onboarding\nReferences FR-001 and FR-002.\n\n### J-002: Core Action\nReferences FR-003.\nUses I-001.\n\n#### Acceptance Tests\n- User can perform core action successfully\n`;
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': journeysNoTests,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath, autoFix: true });
+            assert.ok(result.autoFixChanges.length > 0);
+            assert.ok(result.autoFixChanges.some((c) => c.change.includes('stub acceptance test')));
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── runAuditWorkflow — auto-fix exhausted ───────────────────────────────────
+(0, node_test_1.describe)('runAuditWorkflow — auto-fix exhausted', () => {
+    (0, node_test_1.it)('unfixable issue (orphan FR) + autoFix: true -> still FAIL after max cycles', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({
+                planningDir: dir,
+                statePath,
+                autoFix: true,
+                maxCycles: 2,
+            });
+            assert.strictEqual(result.passed, false);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('auto-fix cycles reach maxCycles when issue is not fixable', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            const result = (0, audit_js_1.runAuditWorkflow)({
+                planningDir: dir,
+                statePath,
+                autoFix: true,
+                maxCycles: 2,
+            });
+            assert.strictEqual(result.autoFixCycles, 2);
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── State transitions ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('State transitions', () => {
+    (0, node_test_1.it)('state goes from not_started to in_progress during audit (checkpoint)', () => {
+        // We verify this via the final state (in_progress is transient)
+        // After completion, state should be pass or fail, not in_progress
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            // Before workflow, state is not_started
+            const before = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(before.stage_status.audit, 'not_started');
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            // After workflow, state has transitioned
+            const after = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.ok(['pass', 'fail'].includes(after.stage_status.audit));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('state goes from in_progress to pass on successful audit', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(state.stage_status.audit, 'pass');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('state goes from in_progress to fail on failed audit', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': specWithOrphan,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.strictEqual(state.stage_status.audit, 'fail');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('checkpoint written with workflow: "gswd/audit-spec"', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.ok(state.last_checkpoint);
+            assert.strictEqual(state.last_checkpoint.workflow, 'gswd/audit-spec');
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── getAuditableFileTypes ────────────────────────────────────────────────────
+(0, node_test_1.describe)('getAuditableFileTypes', () => {
+    (0, node_test_1.it)('returns array of 4 file names', () => {
+        const types = (0, audit_js_1.getAuditableFileTypes)();
+        assert.strictEqual(types.length, 4);
+    });
+    (0, node_test_1.it)('includes JOURNEYS.md, SPEC.md, NFR.md, INTEGRATIONS.md', () => {
+        const types = (0, audit_js_1.getAuditableFileTypes)();
+        assert.ok(types.includes('JOURNEYS.md'));
+        assert.ok(types.includes('SPEC.md'));
+        assert.ok(types.includes('NFR.md'));
+        assert.ok(types.includes('INTEGRATIONS.md'));
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════════
+// Plan 04-03 Task 2: AUDIT.md template and heading validation
+// ═══════════════════════════════════════════════════════════════════════════════
+// ─── End-to-end integration test ────────────────────────────────────────────
+(0, node_test_1.describe)('End-to-end integration: full spec bundle to AUDIT.md', () => {
+    (0, node_test_1.it)('runAuditWorkflow with minimal complete spec bundle writes AUDIT.md', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            assert.ok(fs.existsSync(path.join(dir, 'AUDIT.md')));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('generated AUDIT.md content passes heading validation for AUDIT.md type', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const auditMd = fs.readFileSync(path.join(dir, 'AUDIT.md'), 'utf-8');
+            const validation = (0, parse_js_1.validateHeadings)(auditMd, 'AUDIT.md');
+            assert.strictEqual(validation.valid, true, `Missing headings: ${validation.missing.join(', ')}`);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    (0, node_test_1.it)('STATE.json updated after workflow completes', () => {
+        const { dir, statePath, cleanup } = createTestPlanningDir({
+            'JOURNEYS.md': MINIMAL_JOURNEYS,
+            'SPEC.md': MINIMAL_SPEC,
+            'NFR.md': MINIMAL_NFR,
+            'INTEGRATIONS.md': MINIMAL_INTEGRATIONS,
+        });
+        try {
+            (0, audit_js_1.runAuditWorkflow)({ planningDir: dir, statePath });
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            assert.ok(['pass', 'fail'].includes(state.stage_status.audit));
+        }
+        finally {
+            cleanup();
+        }
+    });
+});
+// ─── AUDIT.md heading validation ────────────────────────────────────────────
+(0, node_test_1.describe)('AUDIT.md heading validation (self-consistency)', () => {
+    (0, node_test_1.it)('generated AUDIT.md from PASS result passes validateHeadings for AUDIT.md', () => {
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, true);
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        const validation = (0, parse_js_1.validateHeadings)(report, 'AUDIT.md');
+        assert.strictEqual(validation.valid, true, `Missing headings in PASS report: ${validation.missing.join(', ')}`);
+    });
+    (0, node_test_1.it)('generated AUDIT.md from FAIL result also passes validateHeadings for AUDIT.md', () => {
+        const specWithOrphan = MINIMAL_SPEC.replace('## Acceptance Criteria', '### FR-099: Orphan\n**Scope:** v1\n\n## Acceptance Criteria');
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: specWithOrphan,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+        });
+        assert.strictEqual(result.passed, false);
+        const report = (0, audit_js_1.generateAuditReport)(result);
+        const validation = (0, parse_js_1.validateHeadings)(report, 'AUDIT.md');
+        assert.strictEqual(validation.valid, true, `Missing headings in FAIL report: ${validation.missing.join(', ')}`);
+    });
+});
+// ─── Phase 8: AUDT-05 ARCHITECTURE.md heading check ─────────────────────────
+(0, node_test_1.describe)('Phase 8: AUDT-05 ARCHITECTURE.md heading check', () => {
+    (0, node_test_1.it)('ARCHITECTURE.md with missing headings fails required heading check', () => {
+        // Content has ## Architecture but is missing ### Components and ### Data Model
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+            architecture: '## Architecture\n\nIncomplete content — missing required subsections.',
+        });
+        // Should have a heading-related finding for ARCHITECTURE.md
+        const headingCheck = result.checks.find((c) => c.check === 'required_headings');
+        assert.ok(headingCheck, 'Required headings check should exist');
+        const archFindings = headingCheck.findings.filter((f) => f.id === 'ARCHITECTURE.md');
+        assert.ok(archFindings.length > 0, 'Should report missing ARCHITECTURE.md headings');
+        // Confirm the specific missing heading is identified
+        const findingText = archFindings.map((f) => f.issue).join(' ');
+        assert.ok(findingText.includes('Components') || findingText.includes('Data Model'), `Should identify missing Components or Data Model heading, got: ${findingText}`);
+    });
+    (0, node_test_1.it)('ARCHITECTURE.md with all required headings passes heading check', () => {
+        const validArch = '## Architecture\n\n### Components\n\n#### C-001: Core\n**Responsibility:** Main logic\n\n### Data Model\n\nEntities here.\n';
+        const result = (0, audit_js_1.runAudit)({
+            journeys: MINIMAL_JOURNEYS,
+            spec: MINIMAL_SPEC,
+            nfr: MINIMAL_NFR,
+            integrations: MINIMAL_INTEGRATIONS,
+            architecture: validArch,
+        });
+        const headingCheck = result.checks.find((c) => c.check === 'required_headings');
+        assert.ok(headingCheck, 'Required headings check should exist');
+        // No ARCHITECTURE.md findings when headings are valid
+        const archFindings = headingCheck.findings.filter((f) => f.id === 'ARCHITECTURE.md');
+        assert.strictEqual(archFindings.length, 0, 'Valid ARCHITECTURE.md should produce no heading findings');
+    });
+});