gswd 1.0.1 → 1.1.0

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

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Tests for GSWD Imagine Input Module
+ *
+ * Covers: parseIdeaFile, buildFromIntake, validateBrief, convergence
+ */
+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 imagine_input_js_1 = require("../lib/imagine-input.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+const STRUCTURED_IDEA = `# Task Management App
+
+A modern task management tool for busy professionals.
+
+## Target Audience
+Built for remote teams and freelancers who struggle with existing tools.
+
+## The Problem
+Current task management tools are too complex. There's a growing frustration with bloated software that takes longer to configure than to use.
+
+## Key Features
+- Simple drag-and-drop interface
+- Real-time collaboration
+- Calendar integration
+- AI-powered task prioritization
+
+## Technical Approach
+- **React** frontend with **TypeScript**
+- **Node.js** backend
+- **PostgreSQL** database
+`;
+const FREEFORM_IDEA = `I want to build a meal planning app that helps busy parents plan weekly meals. The problem is that parents waste hours every week deciding what to cook and creating grocery lists. There's an opportunity in the growing health-conscious market. The app should suggest recipes based on dietary preferences and automatically generate shopping lists. It should be simple enough for anyone to use.`;
+const MINIMAL_IDEA = `A tool for developers to track code quality metrics over time.`;
+const EMPTY_IDEA = `short`;
+// ─── Test Helpers ────────────────────────────────────────────────────────────
+let tmpDir;
+function setup() {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-input-test-'));
+}
+function cleanup() {
+    if (tmpDir && fs.existsSync(tmpDir)) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+function writeTestFile(name, content) {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return filePath;
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('parseIdeaFile', () => {
+    (0, node_test_1.beforeEach)(() => setup());
+    (0, node_test_1.afterEach)(() => cleanup());
+    (0, node_test_1.it)('parses a well-structured idea file with headings', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        assert.ok(brief.vision.length > 0, 'vision should be non-empty');
+        assert.ok(brief.target_user.length > 0, 'target_user should be non-empty');
+        assert.ok(brief.why_now.length > 0, 'why_now should be non-empty');
+        assert.strictEqual(brief.source, 'file');
+    });
+    (0, node_test_1.it)('extracts raw_themes from headings and bullet points', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        assert.ok(brief.raw_themes.length >= 3, `Should have at least 3 themes, got ${brief.raw_themes.length}`);
+        // Should include headings and bullets
+        const allThemes = brief.raw_themes.join(' ').toLowerCase();
+        assert.ok(allThemes.includes('drag') || allThemes.includes('collaboration') || allThemes.includes('calendar') || allThemes.includes('features'), 'Should extract themes from bullet points or headings');
+    });
+    (0, node_test_1.it)('handles freeform text without headings', () => {
+        const filePath = writeTestFile('idea.md', FREEFORM_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        assert.ok(brief.vision.length > 0, 'vision should be non-empty');
+        assert.ok(brief.target_user.length > 0, 'target_user should be non-empty');
+        assert.ok(brief.why_now.length > 0, 'why_now should be non-empty');
+        assert.strictEqual(brief.source, 'file');
+    });
+    (0, node_test_1.it)('throws on empty file (< 10 chars)', () => {
+        const filePath = writeTestFile('empty.md', EMPTY_IDEA);
+        assert.throws(() => (0, imagine_input_js_1.parseIdeaFile)(filePath), /too short/i, 'Should throw on short file');
+    });
+    (0, node_test_1.it)('throws on non-existent file', () => {
+        assert.throws(() => (0, imagine_input_js_1.parseIdeaFile)('/tmp/nonexistent-idea-file-12345.md'), /cannot read/i, 'Should throw on missing file');
+    });
+    (0, node_test_1.it)('uses fallback when specific fields cannot be extracted', () => {
+        const filePath = writeTestFile('minimal.md', MINIMAL_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        // All fields should have content (fallback to first 200 chars)
+        assert.ok(brief.vision.length > 0, 'vision should have fallback content');
+        assert.ok(brief.target_user.length > 0, 'target_user should have fallback content');
+        assert.ok(brief.why_now.length > 0, 'why_now should have fallback content');
+    });
+    (0, node_test_1.it)('returns source: file', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        assert.strictEqual(brief.source, 'file');
+    });
+    (0, node_test_1.it)('extracts target user from "for" and "built for" patterns', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const brief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        // The structured idea mentions "for remote teams and freelancers"
+        const lower = brief.target_user.toLowerCase();
+        assert.ok(lower.includes('remote') || lower.includes('freelancer') || lower.includes('professional') || lower.includes('for'), `target_user should mention the target audience, got: "${brief.target_user}"`);
+    });
+});
+(0, node_test_1.describe)('buildFromIntake', () => {
+    (0, node_test_1.it)('maps answers correctly to StarterBrief fields', () => {
+        const brief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'An AI-powered code review tool',
+            user: 'Software development teams',
+            whyNow: 'LLMs are now good enough to understand code context',
+        });
+        assert.strictEqual(brief.vision, 'An AI-powered code review tool');
+        assert.strictEqual(brief.target_user, 'Software development teams');
+        assert.strictEqual(brief.why_now, 'LLMs are now good enough to understand code context');
+    });
+    (0, node_test_1.it)('extracts themes from comma-separated content in answers', () => {
+        const brief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'A marketplace for handmade goods, vintage items, and craft supplies',
+            user: 'Artisans, crafters, and vintage collectors',
+            whyNow: 'Etsy fees are rising, and sellers want alternatives',
+        });
+        assert.ok(brief.raw_themes.length >= 3, `Should extract themes, got ${brief.raw_themes.length}`);
+    });
+    (0, node_test_1.it)('returns source: intake', () => {
+        const brief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'A simple note-taking app',
+            user: 'Students and researchers',
+            whyNow: 'Existing tools are too complex',
+        });
+        assert.strictEqual(brief.source, 'intake');
+    });
+    (0, node_test_1.it)('handles minimal single-sentence answers', () => {
+        const brief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'A fitness tracker',
+            user: 'Gym-goers',
+            whyNow: 'Health awareness',
+        });
+        assert.ok(brief.vision.length > 0);
+        assert.ok(brief.target_user.length > 0);
+        assert.ok(brief.why_now.length > 0);
+        assert.ok(brief.raw_themes.length >= 1, 'Should extract at least 1 theme');
+    });
+});
+(0, node_test_1.describe)('validateBrief', () => {
+    (0, node_test_1.it)('returns valid: true for a complete brief', () => {
+        const brief = {
+            vision: 'An AI-powered code review tool for development teams',
+            target_user: 'Software development teams',
+            why_now: 'LLMs are now capable of understanding code',
+            raw_themes: ['AI', 'code review', 'development'],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, true);
+        assert.deepStrictEqual(result.missing, []);
+    });
+    (0, node_test_1.it)('returns valid: false with missing fields for empty vision', () => {
+        const brief = {
+            vision: '',
+            target_user: 'Developers',
+            why_now: 'Growing market',
+            raw_themes: ['dev'],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.missing.includes('vision'));
+    });
+    (0, node_test_1.it)('returns valid: false with missing fields for empty target_user', () => {
+        const brief = {
+            vision: 'A great product idea here',
+            target_user: '',
+            why_now: 'Growing market',
+            raw_themes: ['dev'],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.missing.includes('target_user'));
+    });
+    (0, node_test_1.it)('returns valid: false for brief with no raw_themes', () => {
+        const brief = {
+            vision: 'A great product idea here',
+            target_user: 'Developers',
+            why_now: 'Growing market',
+            raw_themes: [],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.missing.includes('raw_themes'));
+    });
+    (0, node_test_1.it)('returns valid: true even with minimal content meeting thresholds', () => {
+        const brief = {
+            vision: 'A basic tool', // 12 chars > 10
+            target_user: 'People', // 6 chars > 5
+            why_now: 'Needed', // 6 chars > 5
+            raw_themes: ['one'],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, true);
+    });
+    (0, node_test_1.it)('returns valid: false for vision too short (<= 10 chars)', () => {
+        const brief = {
+            vision: 'Short',
+            target_user: 'Developers',
+            why_now: 'Growing market',
+            raw_themes: ['dev'],
+            source: 'intake',
+        };
+        const result = (0, imagine_input_js_1.validateBrief)(brief);
+        assert.strictEqual(result.valid, false);
+        assert.ok(result.missing.includes('vision'));
+    });
+});
+(0, node_test_1.describe)('Convergence', () => {
+    (0, node_test_1.beforeEach)(() => setup());
+    (0, node_test_1.afterEach)(() => cleanup());
+    (0, node_test_1.it)('StarterBrief from file and intake have same shape (same keys)', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const fileBrief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        const intakeBrief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'A task management app',
+            user: 'Remote teams',
+            whyNow: 'Tools are too complex',
+        });
+        const fileKeys = Object.keys(fileBrief).sort();
+        const intakeKeys = Object.keys(intakeBrief).sort();
+        assert.deepStrictEqual(fileKeys, intakeKeys, 'Both paths should produce same keys');
+    });
+    (0, node_test_1.it)('both pass validateBrief when well-formed', () => {
+        const filePath = writeTestFile('idea.md', STRUCTURED_IDEA);
+        const fileBrief = (0, imagine_input_js_1.parseIdeaFile)(filePath);
+        const intakeBrief = (0, imagine_input_js_1.buildFromIntake)({
+            vision: 'A comprehensive task management app for teams',
+            user: 'Remote workers and freelancers',
+            whyNow: 'Existing tools are bloated and overpriced',
+        });
+        const fileResult = (0, imagine_input_js_1.validateBrief)(fileBrief);
+        const intakeResult = (0, imagine_input_js_1.validateBrief)(intakeBrief);
+        assert.strictEqual(fileResult.valid, true, `File brief should be valid, missing: ${fileResult.missing}`);
+        assert.strictEqual(intakeResult.valid, true, `Intake brief should be valid, missing: ${intakeResult.missing}`);
+    });
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Tests for GSWD Imagine Synthesis Module
+ *
+ * Covers: synthesizeDirections, scoreIcpOptions, autoSelectDirection
+ * Minimum 14 test cases per Plan 02-04.
+ */
+export {};

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

@@ -0,0 +1,380 @@
+"use strict";
+/**
+ * Tests for GSWD Imagine Synthesis Module
+ *
+ * Covers: synthesizeDirections, scoreIcpOptions, autoSelectDirection
+ * Minimum 14 test cases per Plan 02-04.
+ */
+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_synthesis_js_1 = require("../lib/imagine-synthesis.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+function makeCompleteResult(agent, content) {
+    return { agent, content, status: 'complete', duration_ms: 100 };
+}
+function makeFailedResult(agent, error) {
+    return { agent, content: '', status: 'failed', error, duration_ms: 50 };
+}
+const MARKET_CONTENT = `## Market Overview
+The developer tools market is growing rapidly. Manual specification writing is slow and expensive.
+
+## Competitors
+- Notion AI: general-purpose, not spec-focused
+- Linear: project management, no spec generation
+
+## Market Gaps
+No tool converts founder ideas into execution-grade specs automatically.
+
+## Opportunities
+Community-driven adoption through open source channels on GitHub and Discord.`;
+const ICP_CONTENT = `## ICP Profile
+Solo founders building SaaS products; technical enough to use CLI tools but struggle with product thinking.
+
+## Pain Points
+- Pain of writing specs manually is high — tedious, time-consuming, frustrating
+- Struggle to think through edge cases before building
+- Waste time building wrong features
+
+## Willingness to Pay
+Early-stage founders have limited budget but will pay for tools that save time. Price point around $29-49/mo for premium subscription.
+
+## Reachability
+Active in Indie Hackers community, Twitter, Product Hunt, Hacker News. Many attend virtual meetups and subscribe to newsletters.`;
+const POSITIONING_CONTENT = `## Value Proposition
+For solo founders who struggle with product specs, GSWD is a CLI tool that turns fuzzy ideas into execution-grade specifications.
+
+## Positioning Statement
+Category: Developer productivity tools
+Differentiation: AI-powered spec generation vs manual templates
+Proof points: Deterministic output, traceable requirements
+
+## Key Differentiators
+- Automated research agents vs manual brainstorming
+- Deterministic compilation to project plans
+- Built for terminal-native developers
+
+## Go-to-Market Angle
+Channel: Indie Hackers, Hacker News, open source GitHub community
+Message: "Stop guessing, start building with clarity"
+Wedge: Free CLI that generates DECISIONS.md from a 3-question intake`;
+const BRAINSTORM_CONTENT = `## Direction 1: CLI Spec Generator — Most Natural
+**ICP:** Solo SaaS founders who code but don't spec
+**Problem:** Founders skip specification, leading to wasted build cycles and painful rework
+**Wedge:** 3-question CLI intake that produces DECISIONS.md in 5 minutes
+**Differentiator:** AI agents do the research a PM would do, but in 2 minutes
+**MVP scope:** Imagine stage only (intake → agents → decisions)
+**Risk:** Founders may not trust AI-generated specs
+
+## Direction 2: Team Alignment Tool — Different Angle
+**ICP:** Small engineering teams (2-5 people) at early-stage startups who pay for premium tools
+**Problem:** Misalignment between founder vision and developer execution is expensive and frustrating
+**Wedge:** Shared spec document generated from async founder + dev inputs
+**Differentiator:** Bridges the gap between business thinking and technical execution
+**MVP scope:** Collaborative spec editing with conflict detection
+**Risk:** Requires multi-user features early, which is slow and complex
+
+## Direction 3: Idea Validator — Contrarian
+**ICP:** Pre-revenue founders exploring ideas via community forums and Reddit
+**Problem:** Founders invest months building products nobody wants — a manual, tedious waste
+**Wedge:** Instant market viability score from a one-paragraph idea description
+**Differentiator:** Scoring algorithm with transparent rationale, not a black box
+**MVP scope:** Input → market score → top 3 risks → go/no-go recommendation
+**Risk:** Scoring without real data may feel unreliable`;
+const RISKS_CONTENT = `## Assumptions Challenged
+- Assumption: Founders want CLI tools → Plausible but niche
+- Assumption: AI can replace PM thinking → Questionable for complex products
+
+## Risks
+- **Risk:** AI-generated specs may be too generic to be useful
+  - **Likelihood:** Medium
+  - **Impact:** High
+  - **Category:** Technical
+- **Risk:** Solo founders may not pay for spec tools — expensive tooling competes with free alternatives
+  - **Likelihood:** High
+  - **Impact:** High
+  - **Category:** Business
+- **Risk:** LLM quality degrades over time or costs increase
+  - **Likelihood:** Low
+  - **Impact:** Medium
+  - **Category:** Technical
+- **Risk:** Manual specification habit is hard to break — struggle to change behavior
+  - **Likelihood:** Medium
+  - **Impact:** Medium
+  - **Category:** Market
+- **Risk:** Competitors add spec features to existing tools
+  - **Likelihood:** Medium
+  - **Impact:** High
+  - **Category:** Market
+
+## Mitigations
+- Validate with 10 user interviews before building premium features
+- Open source core to reduce adoption friction via community channels
+
+## Red Flags
+- If no one completes the 3-question intake in beta, rethink UX`;
+function allAgentsComplete() {
+    return [
+        makeCompleteResult('market-researcher', MARKET_CONTENT),
+        makeCompleteResult('icp-persona', ICP_CONTENT),
+        makeCompleteResult('positioning', POSITIONING_CONTENT),
+        makeCompleteResult('brainstorm-alternatives', BRAINSTORM_CONTENT),
+        makeCompleteResult('devils-advocate', RISKS_CONTENT),
+    ];
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('synthesizeDirections', () => {
+    (0, node_test_1.it)('with all 5 agents complete: produces proposed + 2 alternatives with non-empty fields', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.ok(synthesis.proposed, 'Should have proposed direction');
+        assert.strictEqual(synthesis.alternatives.length, 2, 'Should have 2 alternatives');
+        // Check proposed has all fields non-empty
+        assert.ok(synthesis.proposed.label.length > 0, 'Proposed label should be non-empty');
+        assert.ok(synthesis.proposed.icp_summary.length > 0, 'Proposed ICP should be non-empty');
+        assert.ok(synthesis.proposed.problem_framing.length > 0, 'Proposed problem should be non-empty');
+        assert.ok(synthesis.proposed.wedge.length > 0, 'Proposed wedge should be non-empty');
+        assert.ok(synthesis.proposed.differentiator.length > 0, 'Proposed differentiator should be non-empty');
+        assert.ok(synthesis.proposed.risks.length > 0, 'Proposed risks should be non-empty');
+        // Check alternatives have all fields non-empty
+        for (const alt of synthesis.alternatives) {
+            assert.ok(alt.label.length > 0, 'Alternative label should be non-empty');
+            assert.ok(alt.icp_summary.length > 0, 'Alternative ICP should be non-empty');
+            assert.ok(alt.problem_framing.length > 0, 'Alternative problem should be non-empty');
+        }
+    });
+    (0, node_test_1.it)('with brainstorm-alternatives failed: produces degraded directions with warning', () => {
+        const results = [
+            makeCompleteResult('market-researcher', MARKET_CONTENT),
+            makeCompleteResult('icp-persona', ICP_CONTENT),
+            makeCompleteResult('positioning', POSITIONING_CONTENT),
+            makeFailedResult('brainstorm-alternatives', 'Agent timeout'),
+            makeCompleteResult('devils-advocate', RISKS_CONTENT),
+        ];
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.strictEqual(synthesis.alternatives.length, 2, 'Should still have 2 alternatives');
+        assert.ok(synthesis.agent_warnings.some(w => w.includes('brainstorm-alternatives')), 'Should warn about brainstorm-alternatives failure');
+        // Directions should be degraded but present
+        assert.ok(synthesis.proposed.label.includes('Direction'), 'Should have direction label');
+    });
+    (0, node_test_1.it)('with icp-persona failed: proposed direction has generic ICP with warning', () => {
+        const results = [
+            makeCompleteResult('market-researcher', MARKET_CONTENT),
+            makeFailedResult('icp-persona', 'Agent crashed'),
+            makeCompleteResult('positioning', POSITIONING_CONTENT),
+            makeCompleteResult('brainstorm-alternatives', BRAINSTORM_CONTENT),
+            makeCompleteResult('devils-advocate', RISKS_CONTENT),
+        ];
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.ok(synthesis.agent_warnings.some(w => w.includes('icp-persona')), 'Should warn about icp-persona failure');
+        // Proposed should still exist with ICP from brainstorm content
+        assert.ok(synthesis.proposed.icp_summary.length > 0, 'Should have ICP data from brainstorm');
+    });
+    (0, node_test_1.it)('with all agents failed: returns structure with all warnings, minimal content', () => {
+        const results = [
+            makeFailedResult('market-researcher', 'fail'),
+            makeFailedResult('icp-persona', 'fail'),
+            makeFailedResult('positioning', 'fail'),
+            makeFailedResult('brainstorm-alternatives', 'fail'),
+            makeFailedResult('devils-advocate', 'fail'),
+        ];
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.strictEqual(synthesis.agent_warnings.length, 5, 'Should have 5 warnings');
+        assert.ok(synthesis.proposed, 'Should still have proposed direction');
+        assert.strictEqual(synthesis.alternatives.length, 2, 'Should still have 2 alternatives');
+        assert.deepStrictEqual(synthesis.raw_agent_outputs, {}, 'No raw outputs when all failed');
+    });
+    (0, node_test_1.it)('agent_warnings array lists failed agent names', () => {
+        const results = [
+            makeCompleteResult('market-researcher', MARKET_CONTENT),
+            makeFailedResult('icp-persona', 'timeout'),
+            makeCompleteResult('positioning', POSITIONING_CONTENT),
+            makeCompleteResult('brainstorm-alternatives', BRAINSTORM_CONTENT),
+            makeFailedResult('devils-advocate', 'crash'),
+        ];
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.strictEqual(synthesis.agent_warnings.length, 2, 'Should have 2 warnings');
+        assert.ok(synthesis.agent_warnings.some(w => w.includes('icp-persona')));
+        assert.ok(synthesis.agent_warnings.some(w => w.includes('devils-advocate')));
+    });
+    (0, node_test_1.it)('raw_agent_outputs contains entries for each complete agent', () => {
+        const results = [
+            makeCompleteResult('market-researcher', MARKET_CONTENT),
+            makeCompleteResult('icp-persona', ICP_CONTENT),
+            makeFailedResult('positioning', 'fail'),
+            makeCompleteResult('brainstorm-alternatives', BRAINSTORM_CONTENT),
+            makeCompleteResult('devils-advocate', RISKS_CONTENT),
+        ];
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        assert.strictEqual(Object.keys(synthesis.raw_agent_outputs).length, 4);
+        assert.ok('market-researcher' in synthesis.raw_agent_outputs);
+        assert.ok('icp-persona' in synthesis.raw_agent_outputs);
+        assert.ok('brainstorm-alternatives' in synthesis.raw_agent_outputs);
+        assert.ok('devils-advocate' in synthesis.raw_agent_outputs);
+        assert.ok(!('positioning' in synthesis.raw_agent_outputs), 'Failed agent should not be in raw outputs');
+    });
+});
+(0, node_test_1.describe)('scoreIcpOptions', () => {
+    (0, node_test_1.it)('direction with more pain keywords scores higher on pain factor', () => {
+        const highPain = {
+            label: 'High Pain',
+            icp_summary: 'Users in pain, struggling with frustration and tedious manual processes that waste time',
+            problem_framing: 'Painful, slow, expensive process that is broken and inefficient',
+            wedge: 'Fix the pain',
+            differentiator: 'Eliminates struggle',
+            risks: ['Manual process risk'],
+        };
+        const lowPain = {
+            label: 'Low Pain',
+            icp_summary: 'Users who want a nice tool',
+            problem_framing: 'Could be better',
+            wedge: 'Simple improvement',
+            differentiator: 'Slightly better UX',
+            risks: ['Adoption risk'],
+        };
+        const result = (0, imagine_synthesis_js_1.scoreIcpOptions)([highPain, lowPain]);
+        const highScore = result.scores.find(s => s.label === 'High Pain');
+        const lowScore = result.scores.find(s => s.label === 'Low Pain');
+        assert.ok(highScore.score > lowScore.score, 'High pain should score higher');
+    });
+    (0, node_test_1.it)('direction with payment keywords scores higher on WTP factor', () => {
+        const highWtp = {
+            label: 'High WTP',
+            icp_summary: 'Users willing to pay premium pricing for subscription tools, budget available to invest',
+            problem_framing: 'Worth the cost to purchase a solution',
+            wedge: 'Premium subscription',
+            differentiator: 'Revenue-generating pricing model',
+            risks: ['Spend too much'],
+        };
+        const lowWtp = {
+            label: 'Low WTP',
+            icp_summary: 'Free tool users',
+            problem_framing: 'Open source solution',
+            wedge: 'Free tier',
+            differentiator: 'No cost',
+            risks: ['No revenue'],
+        };
+        const result = (0, imagine_synthesis_js_1.scoreIcpOptions)([highWtp, lowWtp]);
+        const high = result.scores.find(s => s.label === 'High WTP');
+        const low = result.scores.find(s => s.label === 'Low WTP');
+        assert.ok(high.score > low.score, 'High WTP should score higher');
+    });
+    (0, node_test_1.it)('score is in range [0, 10]', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const allDirs = [synthesis.proposed, ...synthesis.alternatives];
+        const scoreResult = (0, imagine_synthesis_js_1.scoreIcpOptions)(allDirs);
+        for (const entry of scoreResult.scores) {
+            assert.ok(entry.score >= 0, `Score ${entry.score} should be >= 0`);
+            assert.ok(entry.score <= 10, `Score ${entry.score} should be <= 10`);
+        }
+    });
+    (0, node_test_1.it)('returns scores sorted descending', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const allDirs = [synthesis.proposed, ...synthesis.alternatives];
+        const scoreResult = (0, imagine_synthesis_js_1.scoreIcpOptions)(allDirs);
+        for (let i = 1; i < scoreResult.scores.length; i++) {
+            assert.ok(scoreResult.scores[i - 1].score >= scoreResult.scores[i].score, 'Scores should be sorted descending');
+        }
+    });
+    (0, node_test_1.it)('returns index of highest-scoring direction in original array', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const allDirs = [synthesis.proposed, ...synthesis.alternatives];
+        const scoreResult = (0, imagine_synthesis_js_1.scoreIcpOptions)(allDirs);
+        const topLabel = scoreResult.scores[0].label;
+        const expectedIndex = allDirs.findIndex(d => d.label === topLabel);
+        assert.strictEqual(scoreResult.index, expectedIndex, 'Index should match highest-scoring direction');
+    });
+});
+(0, node_test_1.describe)('autoSelectDirection', () => {
+    (0, node_test_1.it)('selects the highest-scoring direction', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { selected } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        // Verify the selected direction exists
+        const allDirs = [synthesis.proposed, ...synthesis.alternatives];
+        const match = allDirs.find(d => d.label === selected.label);
+        assert.ok(match, 'Selected direction should be one of the 3 directions');
+    });
+    (0, node_test_1.it)('produces AutoDecision records for direction, ICP, wedge, metric', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { decisions } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        const types = decisions.map(d => d.type);
+        assert.ok(types.includes('direction'), 'Should have direction decision');
+        assert.ok(types.includes('icp'), 'Should have ICP decision');
+        assert.ok(types.includes('wedge'), 'Should have wedge decision');
+        assert.ok(types.includes('metric'), 'Should have metric decision');
+    });
+    (0, node_test_1.it)('each decision has non-empty rationale', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { decisions } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        for (const decision of decisions) {
+            assert.ok(decision.rationale.length > 0, `Decision '${decision.type}' should have rationale`);
+        }
+    });
+    (0, node_test_1.it)('each decision has recorded_at timestamp', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { decisions } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        for (const decision of decisions) {
+            assert.ok(decision.recorded_at, `Decision '${decision.type}' should have recorded_at`);
+            // Validate ISO format
+            const date = new Date(decision.recorded_at);
+            assert.ok(!isNaN(date.getTime()), `recorded_at should be valid ISO date`);
+        }
+    });
+    (0, node_test_1.it)('each decision has type field', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { decisions } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        for (const decision of decisions) {
+            assert.ok(decision.type.length > 0, 'Decision should have type');
+            assert.ok(['direction', 'icp', 'wedge', 'metric'].includes(decision.type), `Type '${decision.type}' should be one of the expected types`);
+        }
+    });
+    (0, node_test_1.it)('direction decision includes score', () => {
+        const results = allAgentsComplete();
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(results);
+        const { decisions } = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+        const dirDecision = decisions.find(d => d.type === 'direction');
+        assert.ok(dirDecision.score !== undefined, 'Direction decision should have score');
+        assert.ok(typeof dirDecision.score === 'number', 'Score should be a number');
+    });
+});