gswd 1.0.1 → 1.1.0

package/dist/tests/specify.test.js

@@ -0,0 +1,544 @@
+"use strict";
+/**
+ * Tests for GSWD Specify Workflow Orchestrator
+ *
+ * Integration-level tests using skipAgents mode and temp directories.
+ * Covers: full workflow, artifact generation, auto mode, ID validation,
+ * state management, error handling.
+ * Minimum 15 test cases per Plan 03-05.
+ */
+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 path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const specify_js_1 = require("../lib/specify.js");
+const state_js_1 = require("../lib/state.js");
+const config_js_1 = require("../lib/config.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+/** Create a temporary test environment with initialized state + config + DECISIONS.md */
+function createTestEnv() {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-specify-test-'));
+    const planningDir = tmpDir;
+    const gswdDir = path.join(planningDir, 'gswd');
+    fs.mkdirSync(gswdDir, { recursive: true });
+    // Initialize STATE.json with imagine:done
+    const state = (0, state_js_1.createDefaultState)('test-project');
+    state.stage = 'imagine';
+    state.stage_status.imagine = 'done';
+    const statePath = path.join(gswdDir, 'STATE.json');
+    (0, state_js_1.safeWriteJson)(statePath, state);
+    // Initialize config.json
+    const configPath = path.join(planningDir, 'config.json');
+    (0, config_js_1.mergeGswdConfig)(configPath);
+    // Create DECISIONS.md (required for specify stage)
+    const decisionsContent = `# Decisions
+
+## Frozen Decisions
+- **ICP:** Solo SaaS founders
+- **Problem Statement:** Founders skip specs, leading to rework
+- **Product Direction:** CLI Spec Generator
+- **Wedge / Entry Point:** 3-question intake
+- **Differentiator:** AI agents do PM research
+- **Target User:** Technical solo founders
+- **Timing Rationale:** LLMs now understand product requirements
+- **MVP Boundary:** Imagine stage only
+
+## Success Metrics
+- Activation rate
+- Week-1 retention
+
+## Out of Scope
+- Multi-user collaboration
+- Paid integrations
+
+## Risks & Mitigations
+- Risk: AI specs may be too generic
+- Risk: Solo founders may not pay
+- Risk: LLM quality degrades
+- Risk: Manual spec habit hard to break
+- Risk: Competitors add spec features
+
+## Open Questions
+- None at this time
+`;
+    (0, state_js_1.safeWriteFile)(path.join(planningDir, 'DECISIONS.md'), decisionsContent);
+    // Create IMAGINE.md (optional but nice to have)
+    (0, state_js_1.safeWriteFile)(path.join(planningDir, 'IMAGINE.md'), '# Imagine\n\n## Vision\nA CLI spec generator for solo founders.\n');
+    // Create templates directory with proper templates
+    const templatesDir = path.join(tmpDir, 'templates', 'gswd');
+    fs.mkdirSync(templatesDir, { recursive: true });
+    (0, state_js_1.safeWriteFile)(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`);
+    (0, state_js_1.safeWriteFile)(path.join(templatesDir, 'JOURNEYS.template.md'), `# User Journeys\n\n## Journeys\n\n<!-- GSWD:CONTENT:JOURNEYS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    (0, state_js_1.safeWriteFile)(path.join(templatesDir, 'NFR.template.md'), `# Non-Functional Requirements\n\n## Non-Functional Requirements\n\n<!-- GSWD:CONTENT:NFRS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    (0, state_js_1.safeWriteFile)(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`);
+    (0, state_js_1.safeWriteFile)(path.join(templatesDir, 'INTEGRATIONS.template.md'), `# External Integrations\n\n## Integrations\n\n<!-- GSWD:CONTENT:INTEGRATIONS -->\n\n<!-- GSWD:COMPLETE -->\n`);
+    return {
+        planningDir,
+        configPath,
+        templatesDir,
+        cleanup: () => {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        },
+    };
+}
+// ─── Workflow Sequence ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('Specify workflow sequence', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('runSpecify with skipAgents produces all 5 artifacts', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.strictEqual(result.status, 'complete', `Expected complete but got errors: ${result.errors?.join(', ')}`);
+        assert.strictEqual(result.artifacts.length, 5, 'Should write 5 artifacts');
+    });
+    (0, node_test_1.it)('workflow produces 6 journeys', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.strictEqual(result.journeyCount, 6);
+    });
+    (0, node_test_1.it)('workflow extracts FRs from journeys', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.ok(result.frCount > 0, 'Should have extracted FRs');
+    });
+    (0, node_test_1.it)('workflow generates NFRs', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.ok(result.nfrCount > 0, 'Should have generated NFRs');
+    });
+});
+// ─── Artifact Generation ────────────────────────────────────────────────────
+(0, node_test_1.describe)('Artifact generation', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('SPEC.md exists and has required headings', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const specPath = path.join(env.planningDir, 'SPEC.md');
+        assert.ok(fs.existsSync(specPath), 'SPEC.md should exist');
+        const content = fs.readFileSync(specPath, 'utf-8');
+        assert.ok(content.includes('## Roles & Permissions'), 'Should have Roles heading');
+        assert.ok(content.includes('## Functional Requirements'), 'Should have FR heading');
+        assert.ok(content.includes('## Acceptance Criteria'), 'Should have Acceptance heading');
+    });
+    (0, node_test_1.it)('JOURNEYS.md exists and has journey entries', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const journeysPath = path.join(env.planningDir, 'JOURNEYS.md');
+        assert.ok(fs.existsSync(journeysPath), 'JOURNEYS.md should exist');
+        const content = fs.readFileSync(journeysPath, 'utf-8');
+        assert.ok(content.includes('## Journeys'), 'Should have Journeys heading');
+        assert.ok(content.includes('### J-001'), 'Should have at least J-001');
+        assert.ok(content.includes('### J-006'), 'Should have J-006 (6 journeys)');
+    });
+    (0, node_test_1.it)('NFR.md exists and has NFR content', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const nfrPath = path.join(env.planningDir, 'NFR.md');
+        assert.ok(fs.existsSync(nfrPath), 'NFR.md should exist');
+        const content = fs.readFileSync(nfrPath, 'utf-8');
+        assert.ok(content.includes('## Non-Functional Requirements'), 'Should have NFR heading');
+        assert.ok(content.includes('### Security'), 'Should have Security category');
+        assert.ok(content.includes('### Performance'), 'Should have Performance category');
+    });
+    (0, node_test_1.it)('ARCHITECTURE.md exists and has required sub-headings', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const archPath = path.join(env.planningDir, 'ARCHITECTURE.md');
+        assert.ok(fs.existsSync(archPath), 'ARCHITECTURE.md should exist');
+        const content = fs.readFileSync(archPath, 'utf-8');
+        assert.ok(content.includes('### Components'), 'Should have Components heading');
+        assert.ok(content.includes('### Data Model'), 'Should have Data Model heading');
+        assert.ok(content.includes('### Ownership Boundaries'), 'Should have Ownership heading');
+    });
+    (0, node_test_1.it)('INTEGRATIONS.md exists and has Integrations heading', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const intPath = path.join(env.planningDir, 'INTEGRATIONS.md');
+        assert.ok(fs.existsSync(intPath), 'INTEGRATIONS.md should exist');
+        const content = fs.readFileSync(intPath, 'utf-8');
+        assert.ok(content.includes('## Integrations'), 'Should have Integrations heading');
+    });
+});
+// ─── ID Validation ──────────────────────────────────────────────────────────
+(0, node_test_1.describe)('ID validation', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('JOURNEYS.md IDs match J-XXX format', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const content = fs.readFileSync(path.join(env.planningDir, 'JOURNEYS.md'), 'utf-8');
+        const journeyIds = content.match(/### J-\d{3}/g) || [];
+        assert.ok(journeyIds.length >= 6, `Should have 6+ J-XXX IDs, found ${journeyIds.length}`);
+    });
+    (0, node_test_1.it)('SPEC.md contains FR-XXX format IDs', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const content = fs.readFileSync(path.join(env.planningDir, 'SPEC.md'), 'utf-8');
+        const frIds = content.match(/FR-\d{3}/g) || [];
+        assert.ok(frIds.length > 0, 'SPEC.md should contain FR IDs');
+    });
+    (0, node_test_1.it)('NFR.md contains NFR-XXX format IDs', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const content = fs.readFileSync(path.join(env.planningDir, 'NFR.md'), 'utf-8');
+        const nfrIds = content.match(/NFR-\d{3}/g) || [];
+        assert.ok(nfrIds.length > 0, 'NFR.md should contain NFR IDs');
+    });
+});
+// ─── State Management ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('State management', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('STATE.json specify status is done after success', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        assert.strictEqual(state.stage_status.specify, 'done');
+    });
+    (0, node_test_1.it)('STATE.json NOT updated to done on missing DECISIONS.md', async () => {
+        // Remove DECISIONS.md
+        fs.unlinkSync(path.join(env.planningDir, 'DECISIONS.md'));
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.strictEqual(result.status, 'failed');
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        assert.notStrictEqual(state.stage_status.specify, 'done');
+    });
+});
+// ─── Auto Mode ──────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('Auto mode', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('auto mode uses default single admin role', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const specContent = fs.readFileSync(path.join(env.planningDir, 'SPEC.md'), 'utf-8');
+        assert.ok(specContent.includes('admin'), 'SPEC.md should include admin role');
+    });
+});
+// ─── Error Handling ─────────────────────────────────────────────────────────
+(0, node_test_1.describe)('Error handling', () => {
+    (0, node_test_1.it)('missing DECISIONS.md produces clear error', async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-specify-nodata-'));
+        const gswdDir = path.join(tmpDir, 'gswd');
+        fs.mkdirSync(gswdDir, { recursive: true });
+        const state = (0, state_js_1.createDefaultState)('test');
+        state.stage_status.imagine = 'done';
+        (0, state_js_1.safeWriteJson)(path.join(gswdDir, 'STATE.json'), state);
+        (0, config_js_1.mergeGswdConfig)(path.join(tmpDir, 'config.json'));
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: tmpDir,
+            configPath: path.join(tmpDir, 'config.json'),
+        });
+        assert.strictEqual(result.status, 'failed');
+        assert.ok(result.errors?.some((e) => e.includes('DECISIONS.md')), 'Error should mention DECISIONS.md');
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    });
+    (0, node_test_1.it)('missing STATE.json produces clear error', async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-specify-nostate-'));
+        fs.mkdirSync(path.join(tmpDir, 'gswd'), { recursive: true });
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: tmpDir,
+            configPath: path.join(tmpDir, 'config.json'),
+        });
+        assert.strictEqual(result.status, 'failed');
+        assert.ok(result.errors?.some((e) => e.includes('STATE.json')), 'Error should mention STATE.json');
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    });
+});
+// ─── Cross-references ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('Cross-references', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('SPEC.md traceability table references journey IDs', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const specContent = fs.readFileSync(path.join(env.planningDir, 'SPEC.md'), 'utf-8');
+        assert.ok(specContent.includes('## Traceability'), 'Should have Traceability section');
+        assert.ok(specContent.includes('J-001'), 'Traceability should reference J-001');
+    });
+});
+// ─── Phase 8 Plan 02: FNDN-05 ID Allocation Regression Tests ─────────────────
+(0, node_test_1.describe)('Phase 8: FNDN-05 ID allocation', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('runSpecify with spawnFn writes id_registry to STATE.json', async () => {
+        // spawnFn that returns minimal agent output to avoid crashes
+        const spawnFn = async (_prompt) => {
+            return '## Journeys\n\n### J-001: Default Journey\nUser does something.\n\n#### Acceptance Tests\n- Test passes\n';
+        };
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: false,
+            spawnFn,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        // Read STATE.json and verify id_registry exists with allocated ranges
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        assert.ok(fs.existsSync(statePath), 'STATE.json must exist');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        assert.ok(state.id_registry, 'id_registry should exist in STATE.json after spawnFn run');
+        assert.ok(state.id_registry.allocated_ranges, 'allocated_ranges should exist');
+        // J range should be allocated (journey-mapper)
+        assert.ok(state.id_registry.allocated_ranges['J'], 'J range should be allocated for journey-mapper');
+        assert.ok(state.id_registry.allocated_ranges['J'].length > 0, 'J range should have at least one entry');
+    });
+    (0, node_test_1.it)('runSpecify with skipAgents=true does NOT call allocateIdRange', async () => {
+        await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        // STATE.json should exist but have no id_registry (skipAgents=true skips allocation)
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        assert.ok(fs.existsSync(statePath), 'STATE.json must exist');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        // id_registry should not exist or have no allocated ranges
+        if (state.id_registry && state.id_registry.allocated_ranges) {
+            const totalRanges = Object.values(state.id_registry.allocated_ranges)
+                .reduce((sum, arr) => sum + arr.length, 0);
+            assert.strictEqual(totalRanges, 0, 'No ranges should be allocated when skipAgents=true');
+        }
+        // Passing either way — no id_registry is the expected state
+    });
+});
+// ─── Phase 8: Integration Fixes Regression Tests ─────────────────────────────
+(0, node_test_1.describe)('Phase 8: Integration fixes', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('providedArchitecture without providedIntegrations does not crash', async () => {
+        // This tests the code path where providedArchitecture is set but
+        // providedIntegrations is absent and skipAgents is false and spawnFn is absent.
+        // Before fix: integrationsContent was undefined, causing runtime crash.
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: false,
+            providedArchitecture: '## Architecture\n\n### C-001: App Core\n**Responsibility:** Core logic\n---\n### Data Model\n---\n### Ownership',
+            // providedIntegrations intentionally absent
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        // Should complete without throwing — integrationsContent initialised to default
+        assert.ok(result.status !== 'failed' || !result.errors?.some(e => e.includes('undefined')), 'Should not have undefined-related errors');
+        const intPath = path.join(env.planningDir, 'INTEGRATIONS.md');
+        assert.ok(fs.existsSync(intPath), 'INTEGRATIONS.md should exist even without providedIntegrations');
+    });
+    (0, node_test_1.it)('validateIntegration is called on content with I-XXX IDs', async () => {
+        // Provide integration content with a valid I-001 integration
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            providedIntegrations: '## Integrations\n\n### I-001: Stripe\n**Status:** approved\n**Fallback:** None\n',
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        // Should complete — valid integration produces no validation errors
+        const integrationErrors = result.errors?.filter(e => e.toLowerCase().includes('integration')) || [];
+        assert.strictEqual(integrationErrors.length, 0, 'Valid integration should produce no validation errors');
+    });
+    (0, node_test_1.it)('deferred with fallback integration passes validateIntegration without error', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            providedIntegrations: '## Integrations\n\n### I-001: Stripe\n**Status:** deferred with fallback\n**Fallback:** Use manual invoicing\n',
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        const integrationErrors = result.errors?.filter(e => e.toLowerCase().includes('integration') || e.toLowerCase().includes('invalid status')) || [];
+        assert.strictEqual(integrationErrors.length, 0, `Deferred with fallback integration should produce no validation errors, got: ${integrationErrors.join(', ')}`);
+    });
+    (0, node_test_1.it)('default journeys path still works when no agent content available', async () => {
+        const result = await (0, specify_js_1.runSpecify)({
+            auto: true,
+            skipAgents: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            templatesDir: env.templatesDir,
+        });
+        assert.ok(result.status === 'complete' || result.status === 'success', 'Should complete with default journeys');
+        const jPath = path.join(env.planningDir, 'JOURNEYS.md');
+        assert.ok(fs.existsSync(jPath), 'JOURNEYS.md should exist with default journeys');
+        const content = fs.readFileSync(jPath, 'utf-8');
+        assert.ok(content.includes('J-001'), 'Default journeys should contain J-001');
+    });
+});

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

@@ -0,0 +1,4 @@
+/**
+ * State module tests — atomic writes, STATE.json CRUD, idempotent init, ID registry
+ */
+export {};