gswd 1.0.0 → 1.1.0

package/dist/tests/bootstrap.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bootstrap module tests — policy engine, resume gate, interrupt handler, auto decision summary,
+ * and runBootstrap orchestrator
+ */
+export {};

package/dist/tests/bootstrap.test.js

@@ -0,0 +1,611 @@
+"use strict";
+/**
+ * Bootstrap module tests — policy engine, resume gate, interrupt handler, auto decision summary,
+ * and runBootstrap orchestrator
+ */
+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 bootstrap_js_1 = require("../lib/bootstrap.js");
+const state_js_1 = require("../lib/state.js");
+const config_js_1 = require("../lib/config.js");
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-bootstrap-'));
+}
+function makeConfig(overrides) {
+    return { ...config_js_1.GSWD_CONFIG_DEFAULTS, ...overrides, auto: { ...config_js_1.GSWD_CONFIG_DEFAULTS.auto, ...overrides?.auto } };
+}
+// ─── checkPolicy ────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('checkPolicy', () => {
+    (0, node_test_1.it)('returns shouldInterrupt:false when no violations', () => {
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: '',
+            decisionsContent: '',
+            nfrContent: '',
+        });
+        assert.strictEqual(result.shouldInterrupt, false);
+        assert.strictEqual(result.reasons.length, 0);
+    });
+    (0, node_test_1.it)('detects paid integrations not pre-approved', () => {
+        const intContent = `## Integrations
+
+### I-001: Stripe
+Payment processing for subscriptions.
+**Cost:** $50/month
+**Auth:** API key required
+**Status:** approved
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: intContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, true);
+        assert.ok(result.reasons.some(r => r.includes('I-001')));
+    });
+    (0, node_test_1.it)('ignores free integrations ($0)', () => {
+        const intContent = `## Integrations
+
+### I-001: SendGrid Free Tier
+Email sending service.
+**Cost:** $0/month
+**Status:** approved
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: intContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, false);
+    });
+    (0, node_test_1.it)('skips paid integration check when pre-approved', () => {
+        const intContent = `## Integrations
+
+### I-001: Stripe
+Payment processing.
+**Cost:** $50/month
+**Status:** approved
+`;
+        const config = makeConfig({ auto: { ...config_js_1.GSWD_CONFIG_DEFAULTS.auto, preapproved_integrations: ['I-001'] } });
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config,
+            integrationsContent: intContent,
+        });
+        // Should not interrupt because I-001 is pre-approved
+        const stripeReasons = result.reasons.filter(r => r.includes('I-001') && r.includes('pre-approval'));
+        assert.strictEqual(stripeReasons.length, 0);
+    });
+    (0, node_test_1.it)('detects credential requirements', () => {
+        const intContent = `## Integrations
+
+### I-002: Twilio
+SMS messaging service.
+**Auth:** API key required
+**Cost:** $25/month
+**Status:** approved
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: intContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, true);
+        assert.ok(result.reasons.some(r => r.includes('credential') || r.includes('I-002')));
+    });
+    (0, node_test_1.it)('detects conflicting requirements', () => {
+        const decisionsContent = `## Frozen Decisions
+
+1. **Auth model:** no accounts — anonymous usage only
+2. **Data store:** local storage
+`;
+        const intContent = `## Integrations
+
+### I-001: Stripe
+Payment processing for subscriptions.
+**Cost:** $50/month
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: intContent,
+            decisionsContent: decisionsContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, true);
+        assert.ok(result.reasons.some(r => r.toLowerCase().includes('conflict')));
+    });
+    (0, node_test_1.it)('detects security posture mismatch', () => {
+        const nfrContent = `## Non-Functional Requirements
+
+### NFR-001: HIPAA Compliance
+All patient health data must be encrypted at rest and in transit.
+HIPAA compliance is mandatory for healthcare use case.
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            nfrContent: nfrContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, true);
+        assert.ok(result.reasons.some(r => r.toLowerCase().includes('security') || r.toLowerCase().includes('hipaa')));
+    });
+    (0, node_test_1.it)('combines multiple reasons', () => {
+        const intContent = `## Integrations
+
+### I-001: Stripe
+Payment processing.
+**Cost:** $50/month
+**Auth:** API key required
+
+### I-002: Twilio
+SMS service.
+**Cost:** $25/month
+**Auth:** OAuth secret required
+`;
+        const result = (0, bootstrap_js_1.checkPolicy)({
+            config: makeConfig(),
+            integrationsContent: intContent,
+        });
+        assert.strictEqual(result.shouldInterrupt, true);
+        assert.ok(result.reasons.length >= 2, `Expected 2+ reasons, got ${result.reasons.length}`);
+    });
+});
+// ─── validateStageArtifacts ─────────────────────────────────────────────────
+(0, node_test_1.describe)('validateStageArtifacts', () => {
+    (0, node_test_1.it)('returns complete:true when all artifacts exist', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            // Create all imagine artifacts
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.imagine) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'imagine');
+            assert.strictEqual(result.complete, true);
+            assert.strictEqual(result.missing.length, 0);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns complete:false with missing files listed', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            // Create only 3 of 5 imagine artifacts
+            const imagineFiles = bootstrap_js_1.STAGE_ARTIFACTS.imagine;
+            for (let i = 0; i < 3; i++) {
+                fs.writeFileSync(path.join(tmpDir, imagineFiles[i]), 'content');
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'imagine');
+            assert.strictEqual(result.complete, false);
+            assert.strictEqual(result.missing.length, 2);
+            assert.ok(result.missing.includes(imagineFiles[3]));
+            assert.ok(result.missing.includes(imagineFiles[4]));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns complete:false for empty files (size 0)', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const imagineFiles = bootstrap_js_1.STAGE_ARTIFACTS.imagine;
+            // Create all but make one empty
+            for (let i = 0; i < imagineFiles.length; i++) {
+                if (i === 0) {
+                    fs.writeFileSync(path.join(tmpDir, imagineFiles[i]), '');
+                }
+                else {
+                    fs.writeFileSync(path.join(tmpDir, imagineFiles[i]), 'content');
+                }
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'imagine');
+            assert.strictEqual(result.complete, false);
+            assert.ok(result.missing.includes(imagineFiles[0]));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('validates specify stage (5 files)', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.specify) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'specify');
+            assert.strictEqual(result.complete, true);
+            assert.strictEqual(result.missing.length, 0);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('validates audit stage (1 file)', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.audit) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'audit');
+            assert.strictEqual(result.complete, true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('validates compile stage (4 files)', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.compile) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.validateStageArtifacts)(tmpDir, 'compile');
+            assert.strictEqual(result.complete, true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+// ─── shouldSkipStage ────────────────────────────────────────────────────────
+(0, node_test_1.describe)('shouldSkipStage', () => {
+    (0, node_test_1.it)('returns false when resume is false', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            const state = (0, state_js_1.initState)(gswdDir, 'test');
+            state.stage_status.imagine = 'done';
+            // Create all imagine artifacts
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.imagine) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.shouldSkipStage)('imagine', state, tmpDir, false);
+            assert.strictEqual(result, false);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns false when stage status is not done/pass', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            const state = (0, state_js_1.initState)(gswdDir, 'test');
+            state.stage_status.imagine = 'in_progress';
+            const result = (0, bootstrap_js_1.shouldSkipStage)('imagine', state, tmpDir, true);
+            assert.strictEqual(result, false);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns true when resume=true, status=done, all artifacts present', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            const state = (0, state_js_1.initState)(gswdDir, 'test');
+            state.stage_status.imagine = 'done';
+            for (const f of bootstrap_js_1.STAGE_ARTIFACTS.imagine) {
+                fs.writeFileSync(path.join(tmpDir, f), 'content');
+            }
+            const result = (0, bootstrap_js_1.shouldSkipStage)('imagine', state, tmpDir, true);
+            assert.strictEqual(result, true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns false when resume=true, status=done, but artifact missing (RESM-03)', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            const state = (0, state_js_1.initState)(gswdDir, 'test');
+            state.stage_status.imagine = 'done';
+            // Only create some artifacts, not all
+            fs.writeFileSync(path.join(tmpDir, 'IMAGINE.md'), 'content');
+            fs.writeFileSync(path.join(tmpDir, 'ICP.md'), 'content');
+            const result = (0, bootstrap_js_1.shouldSkipStage)('imagine', state, tmpDir, true);
+            assert.strictEqual(result, false);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('handles audit stage with pass status', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            const state = (0, state_js_1.initState)(gswdDir, 'test');
+            state.stage_status.audit = 'pass';
+            fs.writeFileSync(path.join(tmpDir, 'AUDIT.md'), 'content');
+            const result = (0, bootstrap_js_1.shouldSkipStage)('audit', state, tmpDir, true);
+            assert.strictEqual(result, true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+// ─── handleInterrupt ────────────────────────────────────────────────────────
+(0, node_test_1.describe)('handleInterrupt', () => {
+    (0, node_test_1.it)('writes reasons to state.auto.interrupt_reasons', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            (0, state_js_1.initState)(gswdDir, 'test');
+            const statePath = path.join(gswdDir, 'STATE.json');
+            const result = (0, bootstrap_js_1.handleInterrupt)(['Paid integration I-001 requires approval', 'Credentials needed for I-002'], statePath, ['imagine'], ['IMAGINE.md'], [], 0);
+            const state = (0, state_js_1.readState)(statePath);
+            assert.ok(state);
+            assert.ok(state.auto.interrupt_reasons.length >= 2);
+            assert.ok(state.auto.interrupt_reasons.some(r => r.includes('I-001')));
+            assert.ok(state.auto.interrupt_reasons.some(r => r.includes('I-002')));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.it)('returns BootstrapResult with status interrupted', () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const gswdDir = path.join(tmpDir, 'gswd');
+            fs.mkdirSync(gswdDir, { recursive: true });
+            (0, state_js_1.initState)(gswdDir, 'test');
+            const statePath = path.join(gswdDir, 'STATE.json');
+            const result = (0, bootstrap_js_1.handleInterrupt)(['Some reason'], statePath, ['imagine'], ['IMAGINE.md'], [], 0);
+            assert.strictEqual(result.status, 'interrupted');
+            assert.deepStrictEqual(result.interruptReasons, ['Some reason']);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+// ─── renderAutoDecisionSummary ──────────────────────────────────────────────
+(0, node_test_1.describe)('renderAutoDecisionSummary', () => {
+    (0, node_test_1.it)('returns empty string for no decisions', () => {
+        const result = (0, bootstrap_js_1.renderAutoDecisionSummary)([]);
+        assert.strictEqual(result, '');
+    });
+    (0, node_test_1.it)('formats decisions with type, chosen, rationale', () => {
+        const decisions = [
+            { type: 'direction', chosen: 'Direction 1: MVP', rationale: 'Highest score', recorded_at: '2026-01-01T00:00:00.000Z' },
+            { type: 'icp', chosen: 'Solo developers', rationale: 'Best pain score', recorded_at: '2026-01-01T00:00:00.000Z' },
+        ];
+        const result = (0, bootstrap_js_1.renderAutoDecisionSummary)(decisions);
+        assert.ok(result.includes('direction'));
+        assert.ok(result.includes('Direction 1: MVP'));
+        assert.ok(result.includes('icp'));
+        assert.ok(result.includes('Solo developers'));
+    });
+});
+// ─── runBootstrap ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('runBootstrap', () => {
+    (0, node_test_1.it)('returns failed when no ideaFilePath in auto mode', async () => {
+        const result = await (0, bootstrap_js_1.runBootstrap)({ auto: true });
+        assert.strictEqual(result.status, 'failed');
+        assert.ok(result.error?.includes('idea'));
+    });
+    (0, node_test_1.it)('returns failed when ideaFilePath does not exist', async () => {
+        const tmpDir = makeTmpDir();
+        try {
+            const result = await (0, bootstrap_js_1.runBootstrap)({
+                auto: true,
+                ideaFilePath: path.join(tmpDir, 'nonexistent-idea.md'),
+                planningDir: tmpDir,
+                configPath: path.join(tmpDir, 'config.json'),
+                skipResearch: true,
+            });
+            // Should fail because the idea file doesn't exist
+            assert.strictEqual(result.status, 'failed');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+// ─── e2e: bootstrap --auto @idea.md ─────────────────────────────────────────
+/**
+ * Helper: create a complete tmpDir environment for e2e bootstrap testing.
+ * Sets up: planningDir, gswd/STATE.json, config.json, templates, idea.md.
+ */
+function makeBootstrapEnv() {
+    const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-e2e-bootstrap-'));
+    const planningDir = path.join(rootDir, '.planning');
+    fs.mkdirSync(planningDir, { recursive: true });
+    // Config
+    const configPath = path.join(planningDir, 'config.json');
+    const config = {
+        gswd: {
+            mode: 'balanced',
+            strict_gates: true,
+            max_parallel_agents: 4,
+            external_research: false,
+            integration_budget_usd_month: 0,
+            doc_verbosity: 'standard',
+            phase_style: 'thin',
+            auto: {
+                policy: 'balanced',
+                allow_paid_integrations_under_budget: false,
+                default_auth_model: 'passwordless-email',
+                default_data_store: 'sqlite',
+                default_stack: 'Next.js + TypeScript',
+                preapproved_integrations: [],
+            },
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    // Templates (specify needs these)
+    const templatesDir = path.join(rootDir, 'templates', 'gswd');
+    fs.mkdirSync(templatesDir, { recursive: true });
+    fs.writeFileSync(path.join(templatesDir, 'SPEC.template.md'), `# Specification\n\n## Roles & Permissions\n\n<!-- GSWD:CONTENT:ROLES -->\n\n## Functional Requirements\n\n<!-- GSWD:CONTENT:FRS -->\n\n## Acceptance Criteria\n\n<!-- GSWD:CONTENT:ACCEPTANCE -->\n\n## Traceability\n\n<!-- GSWD:CONTENT:TRACEABILITY -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    fs.writeFileSync(path.join(templatesDir, 'JOURNEYS.template.md'), `# User Journeys\n\n## Journeys\n\n<!-- GSWD:CONTENT:JOURNEYS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    fs.writeFileSync(path.join(templatesDir, 'NFR.template.md'), `# Non-Functional Requirements\n\n## Non-Functional Requirements\n\n<!-- GSWD:CONTENT:NFRS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    fs.writeFileSync(path.join(templatesDir, 'ARCHITECTURE.template.md'), `# Architecture\n\n## Architecture\n\n### Components\n\n<!-- GSWD:CONTENT:COMPONENTS -->\n\n### Data Model\n\n<!-- GSWD:CONTENT:DATA_MODEL -->\n\n### Ownership Boundaries\n\n<!-- GSWD:CONTENT:OWNERSHIP -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    fs.writeFileSync(path.join(templatesDir, 'INTEGRATIONS.template.md'), `# External Integrations\n\n## Integrations\n\n<!-- GSWD:CONTENT:INTEGRATIONS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    // Idea fixture (use the real fixture)
+    const ideaFilePath = path.resolve(__dirname, 'fixtures/bootstrap/idea.md');
+    return {
+        rootDir,
+        planningDir,
+        configPath,
+        ideaFilePath,
+        cleanup: () => {
+            try {
+                fs.rmSync(rootDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        },
+    };
+}
+(0, node_test_1.describe)('e2e: bootstrap --auto @idea.md', () => {
+    (0, node_test_1.it)('runs full pipeline and produces done state (TEST-05)', async () => {
+        const env = makeBootstrapEnv();
+        try {
+            const result = await (0, bootstrap_js_1.runBootstrap)({
+                ideaFilePath: env.ideaFilePath,
+                auto: true,
+                skipResearch: true,
+                planningDir: env.planningDir,
+                configPath: env.configPath,
+                // No spawnFn — specify uses skipAgents=true
+            });
+            // Pipeline completed
+            assert.strictEqual(result.status, 'done', `Expected done but got ${result.status}: ${result.error}`);
+            // State verification
+            const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+            const finalState = (0, state_js_1.readState)(statePath);
+            assert.ok(finalState, 'STATE.json must be readable');
+            assert.strictEqual(finalState.stage, 'done', 'state.stage must be done (Pitfall 8)');
+            assert.strictEqual(finalState.stage_status.audit, 'pass', 'audit must have passed');
+            assert.strictEqual(finalState.stage_status.compile, 'done', 'compile must be done');
+            // Contract docs exist
+            const contractDocs = ['PROJECT.md', 'REQUIREMENTS.md', 'ROADMAP.md', 'STATE.md'];
+            for (const doc of contractDocs) {
+                assert.ok(fs.existsSync(path.join(env.planningDir, doc)), `${doc} must exist in planningDir`);
+            }
+            // All 4 stages completed
+            assert.strictEqual(result.stagesCompleted.length, 4, 'All 4 stages must complete');
+            assert.ok(result.stagesCompleted.includes('imagine'));
+            assert.ok(result.stagesCompleted.includes('specify'));
+            assert.ok(result.stagesCompleted.includes('audit'));
+            assert.ok(result.stagesCompleted.includes('compile'));
+        }
+        finally {
+            env.cleanup();
+        }
+    });
+    (0, node_test_1.it)('records auto decisions in state when auto mode', async () => {
+        const env = makeBootstrapEnv();
+        try {
+            const result = await (0, bootstrap_js_1.runBootstrap)({
+                ideaFilePath: env.ideaFilePath,
+                auto: true,
+                skipResearch: true,
+                planningDir: env.planningDir,
+                configPath: env.configPath,
+            });
+            assert.strictEqual(result.status, 'done');
+            const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+            const finalState = (0, state_js_1.readState)(statePath);
+            assert.ok(finalState);
+            assert.ok(finalState.auto.decisions, 'auto.decisions must exist');
+            assert.ok(finalState.auto.decisions.length > 0, 'at least one auto decision recorded');
+            assert.strictEqual(finalState.auto.enabled, true, 'auto.enabled must be true');
+        }
+        finally {
+            env.cleanup();
+        }
+    });
+    (0, node_test_1.it)('produces imagine and specify artifacts', async () => {
+        const env = makeBootstrapEnv();
+        try {
+            const result = await (0, bootstrap_js_1.runBootstrap)({
+                ideaFilePath: env.ideaFilePath,
+                auto: true,
+                skipResearch: true,
+                planningDir: env.planningDir,
+                configPath: env.configPath,
+            });
+            assert.strictEqual(result.status, 'done');
+            // Imagine artifacts
+            assert.ok(fs.existsSync(path.join(env.planningDir, 'DECISIONS.md')), 'DECISIONS.md must exist');
+            assert.ok(fs.existsSync(path.join(env.planningDir, 'IMAGINE.md')), 'IMAGINE.md must exist');
+            // Specify artifacts
+            assert.ok(fs.existsSync(path.join(env.planningDir, 'SPEC.md')), 'SPEC.md must exist');
+            assert.ok(fs.existsSync(path.join(env.planningDir, 'JOURNEYS.md')), 'JOURNEYS.md must exist');
+            // Audit report
+            assert.ok(fs.existsSync(path.join(env.planningDir, 'AUDIT.md')), 'AUDIT.md must exist');
+        }
+        finally {
+            env.cleanup();
+        }
+    });
+    (0, node_test_1.it)('resume skips completed stages', async () => {
+        const env = makeBootstrapEnv();
+        try {
+            // First run
+            const result1 = await (0, bootstrap_js_1.runBootstrap)({
+                ideaFilePath: env.ideaFilePath,
+                auto: true,
+                skipResearch: true,
+                planningDir: env.planningDir,
+                configPath: env.configPath,
+            });
+            assert.strictEqual(result1.status, 'done');
+            // Second run with resume=true
+            const result2 = await (0, bootstrap_js_1.runBootstrap)({
+                ideaFilePath: env.ideaFilePath,
+                auto: true,
+                resume: true,
+                skipResearch: true,
+                planningDir: env.planningDir,
+                configPath: env.configPath,
+            });
+            assert.strictEqual(result2.status, 'done');
+            // All stages should be in completed list (via skip)
+            assert.strictEqual(result2.stagesCompleted.length, 4);
+        }
+        finally {
+            env.cleanup();
+        }
+    });
+});

package/dist/tests/compile.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compile module tests — spec bundle parsing, sort helpers, and 4 document generators
+ */
+export {};