gswd 1.0.1 → 1.1.0

package/dist/lib/config.d.ts

@@ -0,0 +1,49 @@
+/**
+ * GSWD Config Module — config.json merge under gswd key
+ *
+ * Config is stored in .planning/config.json under the `gswd` key.
+ * Merge operations NEVER touch keys outside `gswd`.
+ *
+ * Schema: GSWD_SPEC.md Section 5.2
+ */
+export interface GswdAutoConfig {
+    policy: 'strict' | 'balanced' | 'aggressive';
+    allow_paid_integrations_under_budget: boolean;
+    default_auth_model: string;
+    default_data_store: string;
+    default_stack: string;
+    preapproved_integrations: string[];
+}
+export interface GswdConfig {
+    mode: string;
+    strict_gates: boolean;
+    max_parallel_agents: number;
+    external_research: boolean;
+    integration_budget_usd_month: number;
+    doc_verbosity: string;
+    phase_style: string;
+    auto: GswdAutoConfig;
+    [key: string]: unknown;
+}
+/**
+ * Default GSWD config matching GSWD_SPEC Section 5.2.
+ */
+export declare const GSWD_CONFIG_DEFAULTS: GswdConfig;
+/**
+ * Read config.json. Returns empty object if missing or invalid.
+ */
+export declare function readConfig(configPath: string): Record<string, unknown>;
+/**
+ * Merge GSWD config into config.json under the `gswd` key.
+ * - Reads existing config (preserves ALL non-gswd keys)
+ * - Deep merges: existing gswd values take precedence over defaults
+ * - Fills in missing defaults
+ * - Writes back atomically
+ *
+ * CRITICAL: Never touches any key outside `gswd`.
+ */
+export declare function mergeGswdConfig(configPath: string, gswdOverrides?: Partial<GswdConfig>): void;
+/**
+ * Get GSWD config with all defaults filled in for missing fields.
+ */
+export declare function getGswdConfig(configPath: string): GswdConfig;

package/dist/lib/config.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * GSWD Config Module — config.json merge under gswd key
+ *
+ * Config is stored in .planning/config.json under the `gswd` key.
+ * Merge operations NEVER touch keys outside `gswd`.
+ *
+ * Schema: GSWD_SPEC.md Section 5.2
+ */
+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 });
+exports.GSWD_CONFIG_DEFAULTS = void 0;
+exports.readConfig = readConfig;
+exports.mergeGswdConfig = mergeGswdConfig;
+exports.getGswdConfig = getGswdConfig;
+const fs = __importStar(require("node:fs"));
+const state_js_1 = require("./state.js");
+// ─── Defaults ────────────────────────────────────────────────────────────────
+/**
+ * Default GSWD config matching GSWD_SPEC Section 5.2.
+ */
+exports.GSWD_CONFIG_DEFAULTS = {
+    mode: 'balanced',
+    strict_gates: true,
+    max_parallel_agents: 4,
+    external_research: true,
+    integration_budget_usd_month: 100,
+    doc_verbosity: 'normal',
+    phase_style: 'thin',
+    auto: {
+        policy: 'balanced',
+        allow_paid_integrations_under_budget: false,
+        default_auth_model: 'passwordless_email',
+        default_data_store: 'sqlite',
+        default_stack: 'node_typescript',
+        preapproved_integrations: [],
+    },
+};
+// ─── Config CRUD ─────────────────────────────────────────────────────────────
+/**
+ * Read config.json. Returns empty object if missing or invalid.
+ */
+function readConfig(configPath) {
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Deep merge helper: merge source into target, source values take precedence.
+ * Only merges plain objects recursively; arrays and primitives are replaced.
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sourceVal = source[key];
+        const targetVal = result[key];
+        if (typeof sourceVal === 'object' &&
+            sourceVal !== null &&
+            !Array.isArray(sourceVal) &&
+            typeof targetVal === 'object' &&
+            targetVal !== null &&
+            !Array.isArray(targetVal)) {
+            result[key] = deepMerge(targetVal, sourceVal);
+        }
+        else {
+            result[key] = sourceVal;
+        }
+    }
+    return result;
+}
+/**
+ * Merge GSWD config into config.json under the `gswd` key.
+ * - Reads existing config (preserves ALL non-gswd keys)
+ * - Deep merges: existing gswd values take precedence over defaults
+ * - Fills in missing defaults
+ * - Writes back atomically
+ *
+ * CRITICAL: Never touches any key outside `gswd`.
+ */
+function mergeGswdConfig(configPath, gswdOverrides) {
+    // Read existing config (preserves GSD keys, etc.)
+    const existing = readConfig(configPath);
+    // Start with defaults
+    let mergedGswd = { ...exports.GSWD_CONFIG_DEFAULTS };
+    // Apply overrides on top of defaults
+    if (gswdOverrides) {
+        mergedGswd = deepMerge(mergedGswd, gswdOverrides);
+    }
+    // Apply existing user values on top (user values take precedence)
+    const existingGswd = existing.gswd;
+    if (typeof existingGswd === 'object' && existingGswd !== null && !Array.isArray(existingGswd)) {
+        mergedGswd = deepMerge(mergedGswd, existingGswd);
+    }
+    // Write back: existing config with updated gswd key
+    existing.gswd = mergedGswd;
+    (0, state_js_1.safeWriteJson)(configPath, existing);
+}
+/**
+ * Get GSWD config with all defaults filled in for missing fields.
+ */
+function getGswdConfig(configPath) {
+    const config = readConfig(configPath);
+    const gswdRaw = config.gswd;
+    if (typeof gswdRaw !== 'object' || gswdRaw === null || Array.isArray(gswdRaw)) {
+        return { ...exports.GSWD_CONFIG_DEFAULTS };
+    }
+    // Merge defaults under existing values
+    const merged = deepMerge({ ...exports.GSWD_CONFIG_DEFAULTS }, gswdRaw);
+    return merged;
+}

package/dist/lib/imagine-agents.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GSWD Imagine Agents Module — Agent definitions, orchestration, and result collection
+ *
+ * Provides batched parallel agent spawning that respects max_parallel_agents config.
+ * Agent definitions describe the 5 research agents from GSWD_SPEC Section 11.1.
+ * Actual Task() integration happens in the workflow orchestrator (imagine.ts).
+ *
+ * Schema: GSWD_SPEC.md Section 8.2 Steps 3-4, Section 11.1
+ */
+import type { StarterBrief } from './imagine-input.js';
+export interface AgentDefinition {
+    name: string;
+    definitionPath: string;
+    outputArtifact: string;
+    requiredHeadings: string[];
+}
+export interface AgentResult {
+    agent: string;
+    content: string;
+    status: 'complete' | 'failed';
+    error?: string;
+    duration_ms?: number;
+}
+export type SpawnFn = (prompt: string) => Promise<string>;
+export type OnAgentComplete = (result: {
+    agent: string;
+    headline: string;
+    status: 'complete' | 'failed';
+}) => void;
+/**
+ * The 5 research agents for the Imagine stage.
+ * Names match GSWD_SPEC Section 11.1 file names.
+ */
+export declare const IMAGINE_AGENTS: AgentDefinition[];
+/**
+ * Build the prompt that will be passed to Task() for an agent.
+ *
+ * Reads agent definition file and injects StarterBrief as context.
+ */
+export declare function buildAgentPrompt(agent: AgentDefinition, brief: StarterBrief, previousOutput?: string, userFeedback?: string): string;
+/**
+ * Orchestrate agents in batches respecting maxParallel concurrency limit.
+ *
+ * Splits agents into batches of maxParallel size, executes each batch
+ * concurrently, collects results. Failed agents are marked with status: 'failed'
+ * but do not crash the orchestration.
+ *
+ * @param agents - Array of agent definitions to spawn
+ * @param maxParallel - Maximum concurrent agents (from config.max_parallel_agents)
+ * @param brief - StarterBrief input for all agents
+ * @param spawnFn - Function that spawns an agent (Task() wrapper)
+ * @returns All agent results including failures
+ */
+export declare function orchestrateAgents(agents: AgentDefinition[], maxParallel: number, brief: StarterBrief, spawnFn: SpawnFn, previousOutputs?: Record<string, string>, userFeedback?: string, onComplete?: OnAgentComplete): Promise<AgentResult[]>;

package/dist/lib/imagine-agents.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * GSWD Imagine Agents Module — Agent definitions, orchestration, and result collection
+ *
+ * Provides batched parallel agent spawning that respects max_parallel_agents config.
+ * Agent definitions describe the 5 research agents from GSWD_SPEC Section 11.1.
+ * Actual Task() integration happens in the workflow orchestrator (imagine.ts).
+ *
+ * Schema: GSWD_SPEC.md Section 8.2 Steps 3-4, Section 11.1
+ */
+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 });
+exports.IMAGINE_AGENTS = void 0;
+exports.buildAgentPrompt = buildAgentPrompt;
+exports.orchestrateAgents = orchestrateAgents;
+const fs = __importStar(require("node:fs"));
+const render_js_1 = require("./render.js");
+// ─── Agent Definitions ───────────────────────────────────────────────────────
+/**
+ * The 5 research agents for the Imagine stage.
+ * Names match GSWD_SPEC Section 11.1 file names.
+ */
+exports.IMAGINE_AGENTS = [
+    {
+        name: 'market-researcher',
+        definitionPath: 'agents/gswd/market-researcher.md',
+        outputArtifact: 'COMPETITION.md',
+        requiredHeadings: ['## Market Overview', '## Competitors'],
+    },
+    {
+        name: 'icp-persona',
+        definitionPath: 'agents/gswd/icp-persona.md',
+        outputArtifact: 'ICP.md',
+        requiredHeadings: ['## ICP Profile', '## Pain Points'],
+    },
+    {
+        name: 'positioning',
+        definitionPath: 'agents/gswd/positioning.md',
+        outputArtifact: 'GTM.md',
+        requiredHeadings: ['## Value Proposition'],
+    },
+    {
+        name: 'brainstorm-alternatives',
+        definitionPath: 'agents/gswd/brainstorm-alternatives.md',
+        outputArtifact: 'DIRECTIONS',
+        requiredHeadings: ['## Direction 1', '## Direction 2', '## Direction 3'],
+    },
+    {
+        name: 'devils-advocate',
+        definitionPath: 'agents/gswd/devils-advocate.md',
+        outputArtifact: 'RISKS',
+        requiredHeadings: ['## Risks'],
+    },
+];
+// ─── Prompt Building ─────────────────────────────────────────────────────────
+/**
+ * Build the prompt that will be passed to Task() for an agent.
+ *
+ * Reads agent definition file and injects StarterBrief as context.
+ */
+function buildAgentPrompt(agent, brief, previousOutput, userFeedback) {
+    let definition;
+    try {
+        definition = fs.readFileSync(agent.definitionPath, 'utf-8');
+    }
+    catch {
+        definition = `Agent: ${agent.name}\nRole: Research agent for ${agent.outputArtifact}`;
+    }
+    const briefJson = JSON.stringify(brief, null, 2);
+    let prompt = `${definition}
+
+<starter_brief>
+${briefJson}
+</starter_brief>`;
+    // Re-run augmentation (IMAGINE-03): include previous output + user feedback
+    if (previousOutput || userFeedback) {
+        prompt += '\n\n<rerun_context>';
+        if (previousOutput) {
+            prompt += `\n\n## Previous Output\nYour previous research produced the following findings. Build on these — do not start from scratch unless the user feedback explicitly asks for a different direction.\n\n${previousOutput}`;
+        }
+        if (userFeedback) {
+            prompt += `\n\n## User Feedback\nThe user was not satisfied with the previous directions and provided this feedback. Use it to refine your research:\n\n${userFeedback}`;
+        }
+        prompt += '\n</rerun_context>';
+    }
+    prompt += `\n\nProduce your output now. Include all required headings: ${agent.requiredHeadings.join(', ')}.`;
+    return prompt;
+}
+// ─── Orchestration ───────────────────────────────────────────────────────────
+/**
+ * Orchestrate agents in batches respecting maxParallel concurrency limit.
+ *
+ * Splits agents into batches of maxParallel size, executes each batch
+ * concurrently, collects results. Failed agents are marked with status: 'failed'
+ * but do not crash the orchestration.
+ *
+ * @param agents - Array of agent definitions to spawn
+ * @param maxParallel - Maximum concurrent agents (from config.max_parallel_agents)
+ * @param brief - StarterBrief input for all agents
+ * @param spawnFn - Function that spawns an agent (Task() wrapper)
+ * @returns All agent results including failures
+ */
+async function orchestrateAgents(agents, maxParallel, brief, spawnFn, previousOutputs, userFeedback, onComplete) {
+    const results = [];
+    // Split into batches
+    for (let i = 0; i < agents.length; i += maxParallel) {
+        const batch = agents.slice(i, i + maxParallel);
+        // Execute batch in parallel
+        const batchPromises = batch.map(async (agent) => {
+            const start = Date.now();
+            try {
+                const previousOutput = previousOutputs?.[agent.name];
+                const prompt = buildAgentPrompt(agent, brief, previousOutput, userFeedback);
+                const content = await spawnFn(prompt);
+                const result = {
+                    agent: agent.name,
+                    content,
+                    status: 'complete',
+                    duration_ms: Date.now() - start,
+                };
+                if (onComplete) {
+                    onComplete({
+                        agent: agent.name,
+                        headline: (0, render_js_1.extractHeadline)(result.content, agent.name),
+                        status: result.status,
+                    });
+                }
+                return result;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const result = {
+                    agent: agent.name,
+                    content: '',
+                    status: 'failed',
+                    error: message,
+                    duration_ms: Date.now() - start,
+                };
+                if (onComplete) {
+                    onComplete({
+                        agent: agent.name,
+                        headline: message || 'Agent failed',
+                        status: 'failed',
+                    });
+                }
+                return result;
+            }
+        });
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+    }
+    return results;
+}

package/dist/lib/imagine-gate.d.ts

@@ -0,0 +1,47 @@
+/**
+ * GSWD Imagine Gate Module — Decision gate validation for DECISIONS.md
+ *
+ * Pure function: validates DECISIONS.md against hard gate requirements.
+ * No side effects, no file writes, no state mutations.
+ *
+ * Gate requirements (GSWD_SPEC Section 3.3, Appendix A1):
+ * - ## Frozen Decisions: >= 8 items
+ * - ## Success Metrics: 1-3 items
+ * - ## Out of Scope: >= 1 item
+ * - ## Risks & Mitigations: >= 5 items
+ * - ## Open Questions: >= 0 items (section must exist)
+ */
+export interface InsufficientCount {
+    section: string;
+    required: number;
+    actual: number;
+    constraint?: string;
+}
+export interface GateResult {
+    passed: boolean;
+    missing_sections: string[];
+    insufficient_counts: InsufficientCount[];
+    summary: string;
+}
+/**
+ * Count list items in a section.
+ *
+ * Counts lines starting with:
+ * - `- ` (bullet)
+ * - `* ` (bullet)
+ * - `N. ` or `N) ` (numbered)
+ * - `### ` (sub-headings as items)
+ *
+ * Returns 0 for empty/null/undefined content.
+ */
+export declare function countListItems(content: string | null | undefined): number;
+/**
+ * Validate DECISIONS.md against the hard gate requirements.
+ *
+ * Step 1: Required headings (via parse.ts validateHeadings)
+ * Step 2: Item counts per section (via parse.ts extractHeadingContent + countListItems)
+ * Step 3: Build structured result
+ *
+ * Returns: GateResult with passed/failed status, missing sections, and count issues.
+ */
+export declare function validateDecisionGate(decisionsContent: string): GateResult;

package/dist/lib/imagine-gate.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * GSWD Imagine Gate Module — Decision gate validation for DECISIONS.md
+ *
+ * Pure function: validates DECISIONS.md against hard gate requirements.
+ * No side effects, no file writes, no state mutations.
+ *
+ * Gate requirements (GSWD_SPEC Section 3.3, Appendix A1):
+ * - ## Frozen Decisions: >= 8 items
+ * - ## Success Metrics: 1-3 items
+ * - ## Out of Scope: >= 1 item
+ * - ## Risks & Mitigations: >= 5 items
+ * - ## Open Questions: >= 0 items (section must exist)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countListItems = countListItems;
+exports.validateDecisionGate = validateDecisionGate;
+const parse_js_1 = require("./parse.js");
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Count list items in a section.
+ *
+ * Counts lines starting with:
+ * - `- ` (bullet)
+ * - `* ` (bullet)
+ * - `N. ` or `N) ` (numbered)
+ * - `### ` (sub-headings as items)
+ *
+ * Returns 0 for empty/null/undefined content.
+ */
+function countListItems(content) {
+    if (!content)
+        return 0;
+    const lines = content.split('\n');
+    let count = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^[-*]\s+/.test(trimmed)) {
+            count++;
+        }
+        else if (/^\d+[.)]\s+/.test(trimmed)) {
+            count++;
+        }
+        else if (/^###\s+/.test(trimmed)) {
+            count++;
+        }
+    }
+    return count;
+}
+// ─── Gate Validation ─────────────────────────────────────────────────────────
+/**
+ * Validate DECISIONS.md against the hard gate requirements.
+ *
+ * Step 1: Required headings (via parse.ts validateHeadings)
+ * Step 2: Item counts per section (via parse.ts extractHeadingContent + countListItems)
+ * Step 3: Build structured result
+ *
+ * Returns: GateResult with passed/failed status, missing sections, and count issues.
+ */
+function validateDecisionGate(decisionsContent) {
+    // Step 1: Required headings
+    const headingResult = (0, parse_js_1.validateHeadings)(decisionsContent, 'DECISIONS.md');
+    // Step 2: Count items per section
+    const insufficient = [];
+    // Frozen Decisions: >= 8
+    const frozenSection = (0, parse_js_1.extractHeadingContent)(decisionsContent, '## Frozen Decisions');
+    const frozenCount = countListItems(frozenSection);
+    if (frozenCount < 8) {
+        insufficient.push({
+            section: 'Frozen Decisions',
+            required: 8,
+            actual: frozenCount,
+        });
+    }
+    // Success Metrics: 1-3
+    const metricsSection = (0, parse_js_1.extractHeadingContent)(decisionsContent, '## Success Metrics');
+    const metricsCount = countListItems(metricsSection);
+    if (metricsCount < 1 || metricsCount > 3) {
+        insufficient.push({
+            section: 'Success Metrics',
+            required: metricsCount < 1 ? 1 : 3,
+            actual: metricsCount,
+            constraint: '1-3',
+        });
+    }
+    // Out of Scope: >= 1
+    const outOfScopeSection = (0, parse_js_1.extractHeadingContent)(decisionsContent, '## Out of Scope');
+    const outOfScopeCount = countListItems(outOfScopeSection);
+    if (outOfScopeCount < 1) {
+        insufficient.push({
+            section: 'Out of Scope',
+            required: 1,
+            actual: outOfScopeCount,
+        });
+    }
+    // Risks & Mitigations: >= 5
+    const risksSection = (0, parse_js_1.extractHeadingContent)(decisionsContent, '## Risks & Mitigations');
+    const risksCount = countListItems(risksSection);
+    if (risksCount < 5) {
+        insufficient.push({
+            section: 'Risks & Mitigations',
+            required: 5,
+            actual: risksCount,
+        });
+    }
+    // Open Questions: >= 0 (section must exist, but can be empty)
+    // No count check needed — heading presence is sufficient
+    // Step 3: Build result
+    const passed = headingResult.valid && insufficient.length === 0;
+    const totalIssues = headingResult.missing.length + insufficient.length;
+    let summary;
+    if (passed) {
+        summary = 'PASS: All 5 sections present, counts valid';
+    }
+    else {
+        const issues = [];
+        if (headingResult.missing.length > 0) {
+            issues.push(`${headingResult.missing.length} missing heading(s)`);
+        }
+        if (insufficient.length > 0) {
+            issues.push(`${insufficient.length} insufficient count(s)`);
+        }
+        summary = `FAIL: ${totalIssues} issue(s) — ${issues.join(', ')}`;
+    }
+    return {
+        passed,
+        missing_sections: headingResult.missing,
+        insufficient_counts: insufficient,
+        summary,
+    };
+}

package/dist/lib/imagine-input.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GSWD Imagine Input Module — Input collection with file parsing and intake building
+ *
+ * Two input paths converge to a single StarterBrief interface:
+ * 1. parseIdeaFile: Parse @idea.md into a starter brief
+ * 2. buildFromIntake: Build from 3-question intake answers
+ *
+ * Schema: GSWD_SPEC.md Section 8.2, Steps 1-2
+ */
+export interface StarterBrief {
+    vision: string;
+    target_user: string;
+    why_now: string;
+    raw_themes: string[];
+    source: 'file' | 'intake';
+}
+export interface IntakeAnswers {
+    vision: string;
+    user: string;
+    whyNow: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    missing: string[];
+}
+/**
+ * Parse an @idea.md file into a StarterBrief.
+ *
+ * Extracts vision, target user, timing, and themes from freeform markdown.
+ * Falls back to first 200 chars if specific fields can't be extracted.
+ * Throws on empty or non-existent files.
+ */
+export declare function parseIdeaFile(filePath: string): StarterBrief;
+/**
+ * Build a StarterBrief from 3-question intake answers.
+ *
+ * Maps: vision -> vision, user -> target_user, whyNow -> why_now.
+ * Extracts themes by splitting answers on delimiters.
+ */
+export declare function buildFromIntake(answers: IntakeAnswers): StarterBrief;
+/**
+ * Validate that a StarterBrief has sufficient signal for research agents.
+ *
+ * Checks: vision > 10 chars, target_user > 5 chars, why_now > 5 chars, raw_themes >= 1.
+ */
+export declare function validateBrief(brief: StarterBrief): ValidationResult;