gswd 1.0.0 → 1.1.0

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

@@ -0,0 +1,4 @@
+/**
+ * Config module tests — merge under gswd key, preserve existing keys, idempotent
+ */
+export {};

package/dist/tests/config.test.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Config module tests — merge under gswd key, preserve existing keys, idempotent
+ */
+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 config_js_1 = require("../lib/config.js");
+let tmpDir;
+(0, node_test_1.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-config-test-'));
+});
+(0, node_test_1.afterEach)(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// ─── readConfig ──────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('readConfig', () => {
+    (0, node_test_1.it)('returns empty object for missing file', () => {
+        const result = (0, config_js_1.readConfig)(path.join(tmpDir, 'nonexistent.json'));
+        assert.deepStrictEqual(result, {});
+    });
+    (0, node_test_1.it)('returns parsed JSON for valid file', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({ model_profile: 'balanced' }));
+        const result = (0, config_js_1.readConfig)(configPath);
+        assert.strictEqual(result.model_profile, 'balanced');
+    });
+    (0, node_test_1.it)('returns empty object for invalid JSON', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, 'not json');
+        assert.deepStrictEqual((0, config_js_1.readConfig)(configPath), {});
+    });
+    (0, node_test_1.it)('returns empty object for JSON array', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, '[1,2,3]');
+        assert.deepStrictEqual((0, config_js_1.readConfig)(configPath), {});
+    });
+});
+// ─── mergeGswdConfig ─────────────────────────────────────────────────────────
+(0, node_test_1.describe)('mergeGswdConfig', () => {
+    (0, node_test_1.it)('creates gswd key with defaults when config has no gswd key', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({ model_profile: 'balanced' }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.ok(config.gswd);
+        assert.strictEqual(config.gswd.mode, 'balanced');
+        assert.strictEqual(config.gswd.strict_gates, true);
+        assert.strictEqual(config.gswd.max_parallel_agents, 4);
+    });
+    (0, node_test_1.it)('preserves existing non-gswd keys (model_profile, commit_docs, etc.)', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            model_profile: 'balanced',
+            commit_docs: true,
+            research: true,
+        }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.model_profile, 'balanced');
+        assert.strictEqual(config.commit_docs, true);
+        assert.strictEqual(config.research, true);
+        assert.ok(config.gswd); // gswd also exists
+    });
+    (0, node_test_1.it)('deep merges: user gswd values override defaults', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            gswd: {
+                mode: 'strict',
+                max_parallel_agents: 2,
+            }
+        }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.gswd.mode, 'strict'); // user value preserved
+        assert.strictEqual(config.gswd.max_parallel_agents, 2); // user value preserved
+        assert.strictEqual(config.gswd.strict_gates, true); // default filled in
+    });
+    (0, node_test_1.it)('fills missing defaults in partial gswd config', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            gswd: { mode: 'strict' }
+        }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.gswd.mode, 'strict');
+        assert.strictEqual(config.gswd.phase_style, 'thin'); // default
+        assert.strictEqual(config.gswd.external_research, true); // default
+    });
+    (0, node_test_1.it)('idempotent: merging twice produces identical output', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({ model_profile: 'balanced' }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const first = fs.readFileSync(configPath, 'utf-8');
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const second = fs.readFileSync(configPath, 'utf-8');
+        assert.strictEqual(first, second);
+    });
+    (0, node_test_1.it)('handles nested auto config merge correctly', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            gswd: {
+                auto: {
+                    policy: 'aggressive',
+                    default_stack: 'python_django',
+                }
+            }
+        }));
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.gswd.auto.policy, 'aggressive'); // user
+        assert.strictEqual(config.gswd.auto.default_stack, 'python_django'); // user
+        assert.strictEqual(config.gswd.auto.default_auth_model, 'passwordless_email'); // default
+        assert.deepStrictEqual(config.gswd.auto.preapproved_integrations, []); // default
+    });
+    (0, node_test_1.it)('creates config.json from scratch when file does not exist', () => {
+        const configPath = path.join(tmpDir, 'new-config.json');
+        (0, config_js_1.mergeGswdConfig)(configPath);
+        assert.ok(fs.existsSync(configPath));
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.ok(config.gswd);
+        assert.strictEqual(config.gswd.mode, 'balanced');
+    });
+    (0, node_test_1.it)('applies overrides on top of defaults', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, '{}');
+        (0, config_js_1.mergeGswdConfig)(configPath, { mode: 'strict', max_parallel_agents: 8 });
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        assert.strictEqual(config.gswd.mode, 'strict');
+        assert.strictEqual(config.gswd.max_parallel_agents, 8);
+    });
+});
+// ─── getGswdConfig ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('getGswdConfig', () => {
+    (0, node_test_1.it)('returns defaults when no gswd key exists', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({ model_profile: 'balanced' }));
+        const gswdConfig = (0, config_js_1.getGswdConfig)(configPath);
+        assert.strictEqual(gswdConfig.mode, config_js_1.GSWD_CONFIG_DEFAULTS.mode);
+        assert.strictEqual(gswdConfig.strict_gates, config_js_1.GSWD_CONFIG_DEFAULTS.strict_gates);
+    });
+    (0, node_test_1.it)('returns merged config when partial gswd key exists', () => {
+        const configPath = path.join(tmpDir, 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            gswd: { mode: 'strict' }
+        }));
+        const gswdConfig = (0, config_js_1.getGswdConfig)(configPath);
+        assert.strictEqual(gswdConfig.mode, 'strict'); // from file
+        assert.strictEqual(gswdConfig.phase_style, 'thin'); // from defaults
+    });
+    (0, node_test_1.it)('returns defaults for missing config file', () => {
+        const gswdConfig = (0, config_js_1.getGswdConfig)(path.join(tmpDir, 'missing.json'));
+        assert.deepStrictEqual(gswdConfig, config_js_1.GSWD_CONFIG_DEFAULTS);
+    });
+});

package/dist/tests/imagine-agents.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for GSWD Imagine Agents Module
+ *
+ * Covers: IMAGINE_AGENTS constant, buildAgentPrompt, orchestrateAgents (batching, failures)
+ */
+export {};

package/dist/tests/imagine-agents.test.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Tests for GSWD Imagine Agents Module
+ *
+ * Covers: IMAGINE_AGENTS constant, buildAgentPrompt, orchestrateAgents (batching, failures)
+ */
+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 imagine_agents_js_1 = require("../lib/imagine-agents.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+const TEST_BRIEF = {
+    vision: 'A CLI tool that turns ideas into execution-grade specs',
+    target_user: 'Solo founders building SaaS products',
+    why_now: 'LLMs can now understand product requirements deeply',
+    raw_themes: ['CLI', 'specifications', 'automation', 'SaaS'],
+    source: 'intake',
+};
+/** Mock spawn function that returns agent name as content */
+function mockSpawnFn(prompt) {
+    // Extract agent name from prompt for identification
+    const nameMatch = prompt.match(/name:\s*(\S+)/);
+    const name = nameMatch ? nameMatch[1] : 'unknown';
+    return Promise.resolve(`## Output from ${name}\n\nContent here.`);
+}
+/** Mock spawn function that fails for specific agents */
+function failingSpawnFn(failAgents) {
+    return (prompt) => {
+        for (const name of failAgents) {
+            if (prompt.includes(name)) {
+                return Promise.reject(new Error(`Agent ${name} failed`));
+            }
+        }
+        return Promise.resolve('## Success\n\nContent here.');
+    };
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('IMAGINE_AGENTS constant', () => {
+    (0, node_test_1.it)('has exactly 5 agents', () => {
+        assert.strictEqual(imagine_agents_js_1.IMAGINE_AGENTS.length, 5);
+    });
+    (0, node_test_1.it)('all agent names match GSWD_SPEC file names', () => {
+        const expectedNames = [
+            'market-researcher',
+            'icp-persona',
+            'positioning',
+            'brainstorm-alternatives',
+            'devils-advocate',
+        ];
+        const actualNames = imagine_agents_js_1.IMAGINE_AGENTS.map(a => a.name);
+        assert.deepStrictEqual(actualNames, expectedNames);
+    });
+    (0, node_test_1.it)('each has non-empty definitionPath, outputArtifact, requiredHeadings', () => {
+        for (const agent of imagine_agents_js_1.IMAGINE_AGENTS) {
+            assert.ok(agent.definitionPath.length > 0, `${agent.name} should have definitionPath`);
+            assert.ok(agent.outputArtifact.length > 0, `${agent.name} should have outputArtifact`);
+            assert.ok(agent.requiredHeadings.length > 0, `${agent.name} should have requiredHeadings`);
+        }
+    });
+});
+(0, node_test_1.describe)('buildAgentPrompt', () => {
+    (0, node_test_1.it)('includes StarterBrief as JSON in starter_brief tags', () => {
+        const agent = imagine_agents_js_1.IMAGINE_AGENTS[0];
+        const prompt = (0, imagine_agents_js_1.buildAgentPrompt)(agent, TEST_BRIEF);
+        assert.ok(prompt.includes('<starter_brief>'), 'Should include starter_brief tags');
+        assert.ok(prompt.includes(TEST_BRIEF.vision), 'Should include brief vision');
+        assert.ok(prompt.includes('</starter_brief>'), 'Should close starter_brief tags');
+    });
+    (0, node_test_1.it)('mentions required headings', () => {
+        const agent = imagine_agents_js_1.IMAGINE_AGENTS[0]; // market-researcher
+        const prompt = (0, imagine_agents_js_1.buildAgentPrompt)(agent, TEST_BRIEF);
+        assert.ok(prompt.includes('## Market Overview'), 'Should mention required headings');
+        assert.ok(prompt.includes('## Competitors'), 'Should mention required headings');
+    });
+    (0, node_test_1.it)('includes agent definition content', () => {
+        const agent = imagine_agents_js_1.IMAGINE_AGENTS[0]; // market-researcher
+        const prompt = (0, imagine_agents_js_1.buildAgentPrompt)(agent, TEST_BRIEF);
+        // Agent definition file should be included (it exists on disk)
+        assert.ok(prompt.includes('market') || prompt.includes('Market') || prompt.includes('researcher'), 'Should include content from agent definition');
+    });
+});
+(0, node_test_1.describe)('orchestrateAgents', () => {
+    (0, node_test_1.it)('with maxParallel=5, all agents spawn in 1 batch', async () => {
+        const callOrder = [];
+        const trackingSpawn = async (prompt) => {
+            const nameMatch = prompt.match(/name:\s*(\S+)/);
+            callOrder.push(nameMatch ? nameMatch[1] : 'unknown');
+            return '## Output\nContent';
+        };
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 5, TEST_BRIEF, trackingSpawn);
+        assert.strictEqual(results.length, 5);
+        assert.strictEqual(results.filter(r => r.status === 'complete').length, 5);
+    });
+    (0, node_test_1.it)('with maxParallel=4, agents spawn in 2 batches (4 then 1)', async () => {
+        let batchCount = 0;
+        let currentBatchSize = 0;
+        const batchSizes = [];
+        const batchTrackingSpawn = async () => {
+            currentBatchSize++;
+            // Small delay to ensure batch tracking works
+            await new Promise(resolve => setTimeout(resolve, 1));
+            return '## Output\nContent';
+        };
+        // We need to track batches differently — count calls between sequential awaits
+        // Since orchestrateAgents uses Promise.all per batch, we can track via the results
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 4, TEST_BRIEF, batchTrackingSpawn);
+        assert.strictEqual(results.length, 5, 'Should have 5 results');
+        assert.strictEqual(results.filter(r => r.status === 'complete').length, 5);
+    });
+    (0, node_test_1.it)('with maxParallel=2, agents spawn in 3 batches (2, 2, 1)', async () => {
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 2, TEST_BRIEF, mockSpawnFn);
+        assert.strictEqual(results.length, 5, 'Should have 5 results');
+        assert.strictEqual(results.filter(r => r.status === 'complete').length, 5);
+    });
+    (0, node_test_1.it)('failed spawnFn marks agent as failed, does not crash orchestration', async () => {
+        const failSpawn = failingSpawnFn(['devils-advocate']);
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 5, TEST_BRIEF, failSpawn);
+        assert.strictEqual(results.length, 5, 'Should still have 5 results');
+        const failed = results.filter(r => r.status === 'failed');
+        assert.strictEqual(failed.length, 1, 'Should have 1 failure');
+        assert.strictEqual(failed[0].agent, 'devils-advocate');
+        assert.ok(failed[0].error, 'Failed result should have error message');
+        const complete = results.filter(r => r.status === 'complete');
+        assert.strictEqual(complete.length, 4, 'Should have 4 successes');
+    });
+    (0, node_test_1.it)('mixed results (some complete, some failed) all returned', async () => {
+        const failSpawn = failingSpawnFn(['market-researcher', 'positioning']);
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 5, TEST_BRIEF, failSpawn);
+        assert.strictEqual(results.length, 5);
+        assert.strictEqual(results.filter(r => r.status === 'complete').length, 3);
+        assert.strictEqual(results.filter(r => r.status === 'failed').length, 2);
+    });
+    (0, node_test_1.it)('batch ordering is preserved (agents run in definition order)', async () => {
+        const order = [];
+        const orderTrackingSpawn = async (prompt) => {
+            const nameMatch = prompt.match(/name:\s*(\S+)/);
+            order.push(nameMatch ? nameMatch[1] : 'unknown');
+            return '## Output\nContent';
+        };
+        const results = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, 1, TEST_BRIEF, orderTrackingSpawn);
+        // With maxParallel=1, agents run sequentially in definition order
+        const resultOrder = results.map(r => r.agent);
+        const expectedOrder = imagine_agents_js_1.IMAGINE_AGENTS.map(a => a.name);
+        assert.deepStrictEqual(resultOrder, expectedOrder);
+    });
+});

package/dist/tests/imagine-gate.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for GSWD Imagine Gate Module
+ *
+ * Covers: countListItems, validateDecisionGate (passing, heading failures, count failures, combined)
+ */
+export {};

package/dist/tests/imagine-gate.test.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * Tests for GSWD Imagine Gate Module
+ *
+ * Covers: countListItems, validateDecisionGate (passing, heading failures, count failures, combined)
+ */
+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 imagine_gate_js_1 = require("../lib/imagine-gate.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+/** Full valid DECISIONS.md with all 5 sections and sufficient counts */
+const VALID_DECISIONS = `# Decisions
+
+## Frozen Decisions
+
+- ICP: Solo founders building SaaS products
+- Problem: Founders build before they think
+- Wedge: CLI-first spec generator
+- MVP: Four-stage pipeline (Imagine, Specify, Audit, Compile)
+- Auth: Passwordless email
+- Stack: Node.js + TypeScript
+- Data store: SQLite for v1
+- Success metric: Compile produces deterministic output
+- Distribution: Open source CLI tool
+- Pricing: Free for v1
+
+## Success Metrics
+
+- 80% of users complete the full pipeline on first run
+- Compile produces byte-identical output across runs
+
+## Out of Scope
+
+- Web UI / dashboard
+- Real-time collaborative editing
+- Automatic GitHub/Jira ticket creation
+- Cost/timeline estimation
+
+## Risks & Mitigations
+
+- Risk: LLM output non-determinism — Mitigation: Compile uses zero LLM calls
+- Risk: Agent parallelism limits — Mitigation: Configurable max_parallel_agents
+- Risk: Incomplete specs pass audit — Mitigation: Strict coverage matrix
+- Risk: State corruption on crash — Mitigation: Atomic write pattern
+- Risk: Spec format drift — Mitigation: Required heading enforcement
+- Risk: Users skip stages — Mitigation: Hard gates between stages
+
+## Open Questions
+
+- What is the optimal max_parallel_agents default?
+- Should we support custom auto policies?
+`;
+/** Minimal valid: exactly 8 frozen decisions, 1 metric, 5 risks, 1 out-of-scope */
+const MINIMAL_VALID = `# Decisions
+
+## Frozen Decisions
+
+- Decision one
+- Decision two
+- Decision three
+- Decision four
+- Decision five
+- Decision six
+- Decision seven
+- Decision eight
+
+## Success Metrics
+
+- One metric
+
+## Out of Scope
+
+- One exclusion
+
+## Risks & Mitigations
+
+- Risk one
+- Risk two
+- Risk three
+- Risk four
+- Risk five
+
+## Open Questions
+
+`;
+/** Maximum metrics (3) — still valid */
+const MAX_METRICS = MINIMAL_VALID.replace('- One metric', '- Metric one\n- Metric two\n- Metric three');
+// ─── Tests ───────────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('countListItems', () => {
+    (0, node_test_1.it)('counts bullet items (- prefix)', () => {
+        const content = '- item one\n- item two\n- item three';
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(content), 3);
+    });
+    (0, node_test_1.it)('counts numbered items (1. prefix)', () => {
+        const content = '1. first\n2. second\n3. third';
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(content), 3);
+    });
+    (0, node_test_1.it)('counts sub-heading items (### prefix)', () => {
+        const content = '### Decision A\nDetails...\n### Decision B\nMore details...';
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(content), 2);
+    });
+    (0, node_test_1.it)('returns 0 for empty string', () => {
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(''), 0);
+    });
+    (0, node_test_1.it)('returns 0 for null/undefined', () => {
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(null), 0);
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(undefined), 0);
+    });
+    (0, node_test_1.it)('handles mixed list styles in same section', () => {
+        const content = '- bullet one\n1. numbered one\n### heading one\n* star bullet';
+        assert.strictEqual((0, imagine_gate_js_1.countListItems)(content), 4);
+    });
+});
+(0, node_test_1.describe)('validateDecisionGate — passing', () => {
+    (0, node_test_1.it)('full valid DECISIONS.md passes', () => {
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(VALID_DECISIONS);
+        assert.strictEqual(result.passed, true);
+        assert.deepStrictEqual(result.missing_sections, []);
+        assert.deepStrictEqual(result.insufficient_counts, []);
+        assert.ok(result.summary.includes('PASS'));
+    });
+    (0, node_test_1.it)('minimal valid (exactly 8 decisions, 1 metric, 5 risks, 1 out-of-scope) passes', () => {
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(MINIMAL_VALID);
+        assert.strictEqual(result.passed, true);
+        assert.deepStrictEqual(result.missing_sections, []);
+        assert.deepStrictEqual(result.insufficient_counts, []);
+    });
+    (0, node_test_1.it)('maximum metrics (exactly 3) passes', () => {
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(MAX_METRICS);
+        assert.strictEqual(result.passed, true);
+    });
+});
+(0, node_test_1.describe)('validateDecisionGate — heading failures', () => {
+    (0, node_test_1.it)('missing ## Frozen Decisions heading fails', () => {
+        const content = VALID_DECISIONS.replace('## Frozen Decisions', '## Decisions Made');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.missing_sections.includes('## Frozen Decisions'));
+    });
+    (0, node_test_1.it)('missing ## Success Metrics heading fails', () => {
+        const content = VALID_DECISIONS.replace('## Success Metrics', '## Metrics');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.missing_sections.includes('## Success Metrics'));
+    });
+    (0, node_test_1.it)('missing all headings fails with all 5 in missing_sections', () => {
+        const content = '# Some Document\n\nJust plain text with no required headings.';
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        assert.strictEqual(result.missing_sections.length, 5);
+        assert.ok(result.missing_sections.includes('## Frozen Decisions'));
+        assert.ok(result.missing_sections.includes('## Success Metrics'));
+        assert.ok(result.missing_sections.includes('## Out of Scope'));
+        assert.ok(result.missing_sections.includes('## Risks & Mitigations'));
+        assert.ok(result.missing_sections.includes('## Open Questions'));
+    });
+    (0, node_test_1.it)('missing ## Open Questions heading fails (section must exist even if empty)', () => {
+        const content = VALID_DECISIONS.replace('## Open Questions', '## Questions');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.missing_sections.includes('## Open Questions'));
+    });
+});
+(0, node_test_1.describe)('validateDecisionGate — count failures', () => {
+    (0, node_test_1.it)('only 7 frozen decisions fails (need >= 8)', () => {
+        // Remove one decision from MINIMAL_VALID
+        const content = MINIMAL_VALID.replace('- Decision eight\n', '');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        const frozenIssue = result.insufficient_counts.find(c => c.section === 'Frozen Decisions');
+        assert.ok(frozenIssue, 'Should have Frozen Decisions issue');
+        assert.strictEqual(frozenIssue.actual, 7);
+        assert.strictEqual(frozenIssue.required, 8);
+    });
+    (0, node_test_1.it)('0 success metrics fails (need >= 1)', () => {
+        const content = MINIMAL_VALID.replace('- One metric\n', '');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        const metricsIssue = result.insufficient_counts.find(c => c.section === 'Success Metrics');
+        assert.ok(metricsIssue, 'Should have Success Metrics issue');
+        assert.strictEqual(metricsIssue.actual, 0);
+        assert.ok(metricsIssue.constraint === '1-3');
+    });
+    (0, node_test_1.it)('4 success metrics fails (need <= 3)', () => {
+        const content = MINIMAL_VALID.replace('- One metric', '- Metric one\n- Metric two\n- Metric three\n- Metric four');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        const metricsIssue = result.insufficient_counts.find(c => c.section === 'Success Metrics');
+        assert.ok(metricsIssue, 'Should have Success Metrics issue');
+        assert.strictEqual(metricsIssue.actual, 4);
+        assert.ok(metricsIssue.constraint === '1-3');
+    });
+    (0, node_test_1.it)('only 4 risks fails (need >= 5)', () => {
+        const content = MINIMAL_VALID.replace('- Risk five\n', '');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        const risksIssue = result.insufficient_counts.find(c => c.section === 'Risks & Mitigations');
+        assert.ok(risksIssue, 'Should have Risks & Mitigations issue');
+        assert.strictEqual(risksIssue.actual, 4);
+        assert.strictEqual(risksIssue.required, 5);
+    });
+    (0, node_test_1.it)('empty Out of Scope section fails (need >= 1 item)', () => {
+        const content = MINIMAL_VALID.replace('- One exclusion\n', '');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        const scopeIssue = result.insufficient_counts.find(c => c.section === 'Out of Scope');
+        assert.ok(scopeIssue, 'Should have Out of Scope issue');
+        assert.strictEqual(scopeIssue.actual, 0);
+        assert.strictEqual(scopeIssue.required, 1);
+    });
+});
+(0, node_test_1.describe)('validateDecisionGate — combined failures', () => {
+    (0, node_test_1.it)('missing heading AND insufficient count both reported', () => {
+        // Remove Frozen Decisions heading AND reduce risks
+        const content = VALID_DECISIONS
+            .replace('## Frozen Decisions', '## Decisions Made')
+            .replace('- Risk: Spec format drift — Mitigation: Required heading enforcement\n', '')
+            .replace('- Risk: Users skip stages — Mitigation: Hard gates between stages\n', '');
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.strictEqual(result.passed, false);
+        assert.ok(result.missing_sections.length > 0, 'Should have missing sections');
+        assert.ok(result.insufficient_counts.length > 0, 'Should have insufficient counts');
+    });
+    (0, node_test_1.it)('summary includes count of total issues', () => {
+        const content = '# Some Document\n\nNo required headings at all.';
+        const result = (0, imagine_gate_js_1.validateDecisionGate)(content);
+        assert.ok(result.summary.includes('FAIL'));
+        assert.ok(result.summary.includes('issue'), 'Summary should mention issues');
+    });
+});

package/dist/tests/imagine-input.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for GSWD Imagine Input Module
+ *
+ * Covers: parseIdeaFile, buildFromIntake, validateBrief, convergence
+ */
+export {};