gswd 1.0.0 → 1.1.0

package/dist/lib/imagine.js

@@ -0,0 +1,413 @@
+"use strict";
+/**
+ * GSWD Imagine Workflow Orchestrator
+ *
+ * Full pipeline: input -> agents -> synthesis -> gate -> artifacts -> state
+ * Implements GSWD_SPEC Section 8.2 end-to-end.
+ *
+ * Both interactive and auto modes are supported:
+ * - Interactive: presents direction checkpoint, awaits selection
+ * - Auto: scores directions via pain x WTP x reachability, selects highest
+ *
+ * Schema: GSWD_SPEC.md Section 8.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.runImagine = runImagine;
+const path = __importStar(require("node:path"));
+const state_js_1 = require("./state.js");
+const config_js_1 = require("./config.js");
+const imagine_input_js_1 = require("./imagine-input.js");
+const imagine_agents_js_1 = require("./imagine-agents.js");
+const imagine_synthesis_js_1 = require("./imagine-synthesis.js");
+const imagine_gate_js_1 = require("./imagine-gate.js");
+// ─── Artifact Building ──────────────────────────────────────────────────────
+/**
+ * Build IMAGINE.md content from selected direction and synthesis data.
+ */
+function buildImagineContent(brief, selected, synthesis, visionStatement, autoDecisions) {
+    const alternatives = synthesis.alternatives
+        .map((alt, i) => `### Alternative ${i + 1}: ${alt.label}\n- **ICP:** ${alt.icp_summary}\n- **Problem:** ${alt.problem_framing}\n- **Wedge:** ${alt.wedge}\n- **Differentiator:** ${alt.differentiator}`)
+        .join('\n\n');
+    const metrics = autoDecisions
+        ? autoDecisions.filter(d => d.type === 'metric').map(d => `- ${d.chosen}`).join('\n')
+        : '- To be defined during decision gate';
+    return `# Imagine
+
+## Vision
+${visionStatement}
+
+## Target User
+${brief.target_user}
+
+## Problem Statement
+${selected.problem_framing}
+
+## Product Direction
+### ${selected.label}
+- **ICP:** ${selected.icp_summary}
+- **Problem:** ${selected.problem_framing}
+- **Wedge:** ${selected.wedge}
+- **Differentiator:** ${selected.differentiator}
+- **Risks:** ${selected.risks.join('; ')}
+
+## Alternatives
+${alternatives}
+
+## Wedge / MVP Boundary
+${selected.wedge}
+
+## Success Metrics
+${metrics}
+`;
+}
+/**
+ * Sanitize a value for use in a single-line markdown bullet.
+ * Collapses newlines, strips heading markers, and trims to prevent
+ * multi-line content from breaking section boundaries in DECISIONS.md.
+ */
+function sanitizeBulletValue(value) {
+    return value
+        .replace(/\n+/g, ' ') // collapse newlines to spaces
+        .replace(/#+\s*/g, '') // strip markdown heading markers
+        .replace(/\s{2,}/g, ' ') // collapse multiple spaces
+        .trim();
+}
+/**
+ * Build DECISIONS.md content from selected direction, auto decisions, and risks.
+ */
+function buildDecisionsContent(selected, synthesis, brief, visionStatement, autoDecisions) {
+    // Build frozen decisions (need >= 8)
+    // Sanitize all interpolated values to prevent multi-line content from breaking section structure
+    const decisionPrefix = autoDecisions ? 'Auto-chosen: ' : '';
+    const frozenDecisions = [
+        `- ${decisionPrefix}**ICP:** ${sanitizeBulletValue(selected.icp_summary)}`,
+        `- ${decisionPrefix}**Problem Statement:** ${sanitizeBulletValue(selected.problem_framing)}`,
+        `- ${decisionPrefix}**Product Direction:** ${sanitizeBulletValue(selected.label)}`,
+        `- ${decisionPrefix}**Wedge / Entry Point:** ${sanitizeBulletValue(selected.wedge)}`,
+        `- ${decisionPrefix}**Differentiator:** ${sanitizeBulletValue(selected.differentiator)}`,
+        `- ${decisionPrefix}**Target User:** ${sanitizeBulletValue(brief.target_user)}`,
+        `- ${decisionPrefix}**Timing Rationale:** ${sanitizeBulletValue(brief.why_now)}`,
+        `- ${decisionPrefix}**MVP Boundary:** ${sanitizeBulletValue(selected.wedge)} (full product expansion deferred to post-validation)`,
+    ];
+    // Success metrics
+    const metricDecision = autoDecisions?.find(d => d.type === 'metric');
+    const metricsItems = metricDecision
+        ? metricDecision.chosen.split(',').map(m => `- ${m.trim()}`)
+        : ['- Activation rate', '- Week-1 retention'];
+    // Out of scope
+    const outOfScope = [
+        '- Features beyond MVP wedge scope',
+        '- Paid integrations (unless pre-approved)',
+        '- Multi-user / team collaboration (v1 is single-user)',
+    ];
+    // Risks from devils-advocate agent and direction risks
+    const risksContent = synthesis.raw_agent_outputs['devils-advocate'] || '';
+    const riskLines = extractRiskItems(risksContent, selected.risks);
+    // Open questions
+    const openQuestions = synthesis.agent_warnings.length > 0
+        ? synthesis.agent_warnings.map(w => `- ${w}`)
+        : ['- None at this time'];
+    return `# Decisions
+
+## Vision
+${visionStatement}
+
+## Frozen Decisions
+${frozenDecisions.join('\n')}
+
+## Success Metrics
+${metricsItems.join('\n')}
+
+## Out of Scope
+${outOfScope.join('\n')}
+
+## Risks & Mitigations
+${riskLines.join('\n')}
+
+## Open Questions
+${openQuestions.join('\n')}
+`;
+}
+/**
+ * Extract risk items from devils-advocate output, ensuring >= 5 items.
+ */
+function extractRiskItems(risksContent, directionRisks) {
+    const items = [];
+    if (risksContent) {
+        // Extract from ## Risks section
+        const risksMatch = risksContent.match(/##\s*Risks\s*\n([\s\S]*?)(?=\n##|$)/);
+        if (risksMatch) {
+            const lines = risksMatch[1].split('\n')
+                .filter(l => l.trim().startsWith('-'))
+                .map(l => l.trim())
+                .slice(0, 8);
+            items.push(...lines);
+        }
+        // Extract from ## Mitigations section
+        const mitigationsMatch = risksContent.match(/##\s*Mitigations\s*\n([\s\S]*?)(?=\n##|$)/);
+        if (mitigationsMatch && items.length < 5) {
+            const lines = mitigationsMatch[1].split('\n')
+                .filter(l => l.trim().startsWith('-'))
+                .map(l => l.trim())
+                .slice(0, 5 - items.length);
+            items.push(...lines);
+        }
+    }
+    // Add direction risks if we need more
+    for (const risk of directionRisks) {
+        if (items.length >= 5)
+            break;
+        items.push(`- **Direction risk:** ${risk}`);
+    }
+    // Ensure minimum 5
+    while (items.length < 5) {
+        items.push(`- Risk ${items.length + 1}: To be identified during Specify stage`);
+    }
+    return items;
+}
+/**
+ * Build artifact content from agent raw output, falling back to a message.
+ */
+function buildAgentArtifact(agentName, rawOutputs, fallback) {
+    const content = rawOutputs[agentName];
+    return content || fallback;
+}
+// ─── Vision Synthesis ───────────────────────────────────────────────────────
+/**
+ * Synthesize an aspirational vision statement from brief and selected direction.
+ * Vision = future state the product enables, NOT product description.
+ * Example: "A world where solo founders never build the wrong thing because
+ * their specification process is as rigorous as their code."
+ *
+ * This is a template-based synthesis; in manual mode, the LLM in start.md
+ * will generate a richer vision and pass it via options.visionStatement.
+ */
+function synthesizeVisionStatement(brief, selected) {
+    const userContext = brief.target_user || 'users';
+    const problemContext = selected.problem_framing || brief.vision;
+    return `A world where ${userContext} achieve ${problemContext} effortlessly — because the right tools make clarity the default, not the exception.`;
+}
+// ─── Main Workflow ──────────────────────────────────────────────────────────
+/**
+ * Run the Imagine workflow end-to-end.
+ *
+ * Implements GSWD_SPEC Section 8.2 Steps 1-6:
+ * 1. Load state and config
+ * 2. Collect founder input (file or intake)
+ * 3. Spawn parallel agents
+ * 4. Synthesize into proposed direction + 2 alternatives
+ * 5. Decision gate (must freeze)
+ * 6. Write docs and update state
+ */
+async function runImagine(options) {
+    const planningDir = options.planningDir || path.join(process.cwd(), '.planning');
+    const gswdDir = path.join(planningDir, 'gswd');
+    const statePath = path.join(gswdDir, 'STATE.json');
+    const configPath = options.configPath || path.join(planningDir, 'config.json');
+    try {
+        // ── Step 1: Load state and config ──────────────────────────────────
+        const state = (0, state_js_1.readState)(statePath);
+        if (!state) {
+            return { status: 'error', artifacts_written: [], error: 'No STATE.json found. Run init first.' };
+        }
+        const config = (0, config_js_1.getGswdConfig)(configPath);
+        // Mark imagine as in_progress
+        state.stage = 'imagine';
+        state.stage_status.imagine = 'in_progress';
+        (0, state_js_1.writeState)(statePath, state);
+        // ── Step 2: Collect input ──────────────────────────────────────────
+        let brief;
+        if (options.ideaFilePath) {
+            brief = (0, imagine_input_js_1.parseIdeaFile)(options.ideaFilePath);
+        }
+        else if (options.intakeAnswers) {
+            brief = (0, imagine_input_js_1.buildFromIntake)(options.intakeAnswers);
+        }
+        else {
+            return {
+                status: 'error',
+                artifacts_written: [],
+                error: 'No input: provide ideaFilePath or intakeAnswers',
+            };
+        }
+        const validation = (0, imagine_input_js_1.validateBrief)(brief);
+        if (!validation.valid) {
+            return {
+                status: 'error',
+                artifacts_written: [],
+                error: `Invalid brief: missing fields [${validation.missing.join(', ')}]`,
+            };
+        }
+        // ── Step 3: Spawn agents ──────────────────────────────────────────
+        let agentResults;
+        const agentHeadlines = [];
+        if (options.skipResearch) {
+            // Create minimal results from brief content
+            agentResults = imagine_agents_js_1.IMAGINE_AGENTS.map(agent => ({
+                agent: agent.name,
+                content: `## ${agent.requiredHeadings[0]?.replace('## ', '') || 'Output'}\nGenerated from starter brief.\n\n${brief.vision}\n${brief.target_user}\n${brief.why_now}`,
+                status: 'complete',
+                duration_ms: 0,
+            }));
+        }
+        else {
+            const spawnFn = options.spawnFn;
+            if (!spawnFn) {
+                return {
+                    status: 'error',
+                    artifacts_written: [],
+                    error: 'No spawnFn provided for agent orchestration',
+                };
+            }
+            // Allocate ID ranges for imagine agents before spawning (FNDN-05)
+            try {
+                (0, state_js_1.allocateIdRange)(statePath, 'J', 'journey-mapper', 50);
+                (0, state_js_1.allocateIdRange)(statePath, 'FR', 'market-researcher', 50);
+            }
+            catch {
+                // Non-fatal — ID allocation failure should not block imagine
+            }
+            agentResults = await (0, imagine_agents_js_1.orchestrateAgents)(imagine_agents_js_1.IMAGINE_AGENTS, config.max_parallel_agents, brief, spawnFn, options.previousAgentOutputs, options.userFeedback, (result) => { agentHeadlines.push(result); });
+        }
+        // Build research summary (IMAGINE-01)
+        const researchSummary = (0, imagine_synthesis_js_1.buildResearchSummary)(agentResults, brief);
+        // Mid-stage checkpoint: agents complete (RESM-02)
+        (0, state_js_1.writeCheckpoint)(statePath, 'gswd/imagine', 'agents-complete');
+        // ── Step 4: Synthesize directions ─────────────────────────────────
+        const synthesis = (0, imagine_synthesis_js_1.synthesizeDirections)(agentResults);
+        // ── Step 5: Direction selection ───────────────────────────────────
+        let selected;
+        let autoDecisions;
+        if (options.autoMode) {
+            const autoResult = (0, imagine_synthesis_js_1.autoSelectDirection)(synthesis);
+            selected = autoResult.selected;
+            autoDecisions = autoResult.decisions;
+        }
+        else if (options.selectedDirectionIndex !== undefined) {
+            const allDirections = [synthesis.proposed, ...synthesis.alternatives];
+            const idx = Math.max(0, Math.min(options.selectedDirectionIndex, allDirections.length - 1));
+            selected = allDirections[idx];
+        }
+        else {
+            // Default to proposed direction
+            selected = synthesis.proposed;
+        }
+        // Mid-stage checkpoint: direction selected (RESM-02)
+        (0, state_js_1.writeCheckpoint)(statePath, 'gswd/imagine', 'direction-selected');
+        // ── Step 5.5: Synthesize vision statement (IMAGINE-05) ───────────
+        let visionStatement;
+        if (options.visionStatement) {
+            // User already approved/edited a vision statement (manual mode)
+            visionStatement = options.visionStatement;
+        }
+        else {
+            // Auto-generate from brief + selected direction
+            visionStatement = synthesizeVisionStatement(brief, selected);
+        }
+        // ── Step 6: Build artifacts ──────────────────────────────────────
+        const imagineContent = buildImagineContent(brief, selected, synthesis, visionStatement, autoDecisions);
+        const decisionsContent = buildDecisionsContent(selected, synthesis, brief, visionStatement, autoDecisions);
+        const icpContent = buildAgentArtifact('icp-persona', synthesis.raw_agent_outputs, `# Ideal Customer Profile\n\n## ICP Profile\n${selected.icp_summary}\n\n## Pain Points\nDerived from direction analysis.\n`);
+        const gtmContent = buildAgentArtifact('positioning', synthesis.raw_agent_outputs, `# Go-to-Market\n\n## Value Proposition\n${selected.differentiator}\n\n## Go-to-Market Angle\nTo be defined in Specify stage.\n`);
+        const competitionContent = buildAgentArtifact('market-researcher', synthesis.raw_agent_outputs, `# Competition\n\n## Market Overview\nMarket research data unavailable.\n\n## Competitors\nTo be researched.\n`);
+        // ── Step 7: Validate decision gate ───────────────────────────────
+        const gateResult = (0, imagine_gate_js_1.validateDecisionGate)(decisionsContent);
+        if (!gateResult.passed) {
+            // Do NOT update state to done
+            return {
+                status: 'gate_failed',
+                artifacts_written: [],
+                gate_result: gateResult,
+                selected_direction: selected,
+                error: `Decision gate failed: ${gateResult.summary}`,
+            };
+        }
+        // ── Step 8: Write artifacts ──────────────────────────────────────
+        const directionsContent = synthesis.raw_agent_outputs['brainstorm-alternatives'] || '';
+        const risksRawContent = synthesis.raw_agent_outputs['devils-advocate'] || '';
+        const artifacts = [
+            { name: 'IMAGINE.md', content: imagineContent },
+            { name: 'ICP.md', content: icpContent },
+            { name: 'GTM.md', content: gtmContent },
+            { name: 'COMPETITION.md', content: competitionContent },
+            { name: 'DECISIONS.md', content: decisionsContent },
+        ];
+        if (directionsContent)
+            artifacts.push({ name: 'DIRECTIONS.md', content: directionsContent });
+        if (risksRawContent)
+            artifacts.push({ name: 'RISKS.md', content: risksRawContent });
+        const artifactsWritten = [];
+        for (const artifact of artifacts) {
+            const artifactPath = path.join(planningDir, artifact.name);
+            (0, state_js_1.safeWriteFile)(artifactPath, artifact.content);
+            artifactsWritten.push(artifactPath);
+        }
+        // ── Step 9: Update state ─────────────────────────────────────────
+        const finalState = (0, state_js_1.readState)(statePath);
+        if (finalState) {
+            finalState.stage_status.imagine = 'done';
+            finalState.last_checkpoint = {
+                workflow: 'gswd/imagine',
+                checkpoint_id: 'complete',
+                timestamp: new Date().toISOString(),
+            };
+            // Record auto decisions in state
+            if (autoDecisions) {
+                finalState.auto.decisions = autoDecisions;
+            }
+            (0, state_js_1.writeState)(statePath, finalState);
+        }
+        // ── Step 10: Return result ───────────────────────────────────────
+        return {
+            status: 'complete',
+            artifacts_written: artifactsWritten,
+            gate_result: gateResult,
+            auto_decisions: autoDecisions,
+            selected_direction: selected,
+            research_summary: researchSummary,
+            vision_statement: visionStatement,
+            agent_headlines: agentHeadlines.length > 0 ? agentHeadlines : undefined,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status: 'error',
+            artifacts_written: [],
+            error: message,
+        };
+    }
+}

package/dist/lib/intake.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GSWD Intake Module — INTAKE.json persistence for idempotent resume
+ *
+ * Writes/reads the user's confirmed product description to .planning/gswd/INTAKE.json.
+ * Uses atomic write pattern from state.ts (safeWriteJson).
+ *
+ * INTAKE.json is separate from intake.md:
+ * - intake.md: text file passed to bootstrap CLI (imagine agents)
+ * - INTAKE.json: machine-readable state for resume
+ */
+export interface IntakeData {
+    version: 1;
+    recorded_at: string;
+    product_description: string;
+    source: 'interactive' | 'file';
+    idea_file?: string;
+}
+/**
+ * Write INTAKE.json atomically to the given GSWD directory.
+ * Persistence timing: called once after user confirms their product description
+ * (the "Did I get that right?" moment in start.md).
+ */
+export declare function writeIntake(gswdDir: string, data: Omit<IntakeData, 'version' | 'recorded_at'>): IntakeData;
+/**
+ * Read INTAKE.json. Returns null if missing or corrupt.
+ */
+export declare function readIntake(gswdDir: string): IntakeData | null;

package/dist/lib/intake.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * GSWD Intake Module — INTAKE.json persistence for idempotent resume
+ *
+ * Writes/reads the user's confirmed product description to .planning/gswd/INTAKE.json.
+ * Uses atomic write pattern from state.ts (safeWriteJson).
+ *
+ * INTAKE.json is separate from intake.md:
+ * - intake.md: text file passed to bootstrap CLI (imagine agents)
+ * - INTAKE.json: machine-readable state for resume
+ */
+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.writeIntake = writeIntake;
+exports.readIntake = readIntake;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const state_js_1 = require("./state.js");
+// ─── CRUD ────────────────────────────────────────────────────────────────────
+/**
+ * Write INTAKE.json atomically to the given GSWD directory.
+ * Persistence timing: called once after user confirms their product description
+ * (the "Did I get that right?" moment in start.md).
+ */
+function writeIntake(gswdDir, data) {
+    const intake = {
+        version: 1,
+        recorded_at: new Date().toISOString(),
+        ...data,
+    };
+    const intakePath = path.join(gswdDir, 'INTAKE.json');
+    (0, state_js_1.safeWriteJson)(intakePath, intake);
+    return intake;
+}
+/**
+ * Read INTAKE.json. Returns null if missing or corrupt.
+ */
+function readIntake(gswdDir) {
+    const intakePath = path.join(gswdDir, 'INTAKE.json');
+    try {
+        const content = fs.readFileSync(intakePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed.product_description !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/parse.d.ts

@@ -0,0 +1,59 @@
+/**
+ * GSWD Parse Module — ID extraction, heading validation, normalization
+ *
+ * Parses GSWD artifact files for IDs (J-NNN, FR-NNN, NFR-NNN, I-NNN, C-NNN),
+ * validates required heading structure, and normalizes malformed IDs.
+ *
+ * Schema: GSWD_SPEC.md Section 6.1-6.3
+ */
+/**
+ * Required headings per artifact file type, from GSWD_SPEC Section 6.3.
+ * These are the stable anchors used by audit/compile parsers.
+ */
+export declare const REQUIRED_HEADINGS: Record<string, string[]>;
+/**
+ * Normalize an ID to canonical format: PREFIX-NNN (3-digit minimum, zero-padded).
+ *
+ * - FR-1    -> FR-001
+ * - FR-01   -> FR-001
+ * - FR-001  -> FR-001 (no change)
+ * - FR-1000 -> FR-1000 (4+ digits kept as-is)
+ * - INVALID -> INVALID (unrecognized format returned as-is)
+ */
+export declare function normalizeId(rawId: string): string;
+export interface ExtractedId {
+    id: string;
+    raw: string;
+    normalized: boolean;
+}
+/**
+ * Extract IDs from content using regex.
+ *
+ * Regex: /\b(J|FR|NFR|I|C)-(\d{1,4})\b/g
+ * - Word boundary prevents partial matches (e.g., INFRASTRUCTURE-001)
+ * - Returns deduplicated array sorted by normalized ID ascending
+ * - Optional filter by idType (e.g., 'FR')
+ */
+export declare function extractIds(content: string, idType?: string): ExtractedId[];
+export interface HeadingValidation {
+    valid: boolean;
+    missing: string[];
+    present: string[];
+}
+/**
+ * Validate that a file contains all required headings for its type.
+ *
+ * - Looks up required headings from REQUIRED_HEADINGS[fileType]
+ * - Case-insensitive search as safety layer
+ * - Returns which headings are present and which are missing
+ * - Unknown file types are always valid (no required headings)
+ */
+export declare function validateHeadings(content: string, fileType: string): HeadingValidation;
+/**
+ * Extract content between a heading and the next heading of same or higher level.
+ *
+ * @param content - Full file content
+ * @param heading - The heading to extract content from (e.g., "## Section A")
+ * @returns Content string (trimmed) or null if heading not found
+ */
+export declare function extractHeadingContent(content: string, heading: string): string | null;