@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/intelligence/deliverable-extractor.js

@@ -1,909 +0,0 @@
-/**
- * Atomic deliverable extraction from parsed planning documents.
- * Transforms parsed sections into stream-ready deliverables.
- *
- * Phase 8B-C: Semantic splitting based on file content classification.
- * YAML-sourced deliverables are never auto-split (author knows best).
- */
-import { getSectionsAtLevel, flattenSections, extractYamlStreamDefinitions } from './plan-parser.js';
-import { categorizeStream } from './learning-engine.js';
-/**
- * Priority order for file classification (highest priority first).
- * When a file matches multiple patterns (e.g., types.test.ts), higher priority wins.
- */
-const CONCERN_PRIORITY = ['tests', 'migrations', 'docs', 'types', 'styles', 'core'];
-/**
- * Dependency order for split streams.
- * Defines execution sequence: types must exist before core, core before tests, etc.
- */
-const CONCERN_ORDER = ['types', 'migrations', 'styles', 'core', 'tests', 'docs'];
-/**
- * Classify a file path into a concern bucket based on filename and path.
- * Uses CONCERN_PRIORITY to resolve ambiguous matches.
- */
-export function classifyFile(filePath) {
-    const lower = filePath.toLowerCase();
-    const basename = lower.split('/').pop() ?? lower;
-    // Check in priority order - first match wins
-    for (const concern of CONCERN_PRIORITY) {
-        switch (concern) {
-            case 'tests':
-                if (lower.includes('/test') ||
-                    lower.includes('/__tests__/') ||
-                    basename.includes('.test.') ||
-                    basename.includes('.spec.') ||
-                    basename.startsWith('test_') ||
-                    basename.endsWith('_test.ts') ||
-                    basename.endsWith('_test.js')) {
-                    return 'tests';
-                }
-                break;
-            case 'migrations':
-                if (lower.includes('/migration') ||
-                    basename.includes('migration') ||
-                    basename.endsWith('.sql')) {
-                    return 'migrations';
-                }
-                break;
-            case 'docs':
-                if (lower.endsWith('.md') ||
-                    lower.includes('/docs/') ||
-                    lower.includes('/documentation/')) {
-                    return 'docs';
-                }
-                break;
-            case 'types':
-                if (basename.includes('types') ||
-                    basename.includes('schema') ||
-                    basename.includes('interface') ||
-                    basename === 'index.d.ts') {
-                    return 'types';
-                }
-                break;
-            case 'styles':
-                if (lower.endsWith('.css') ||
-                    lower.endsWith('.scss') ||
-                    lower.endsWith('.less') ||
-                    lower.endsWith('.sass') ||
-                    lower.includes('/styles/')) {
-                    return 'styles';
-                }
-                break;
-        }
-    }
-    // Default: everything else is core implementation
-    return 'core';
-}
-/**
- * Keywords associated with each concern for plan extraction.
- */
-const CONCERN_KEYWORDS = {
-    types: ['type', 'interface', 'schema', 'define', 'definition', 'typescript', 'zod'],
-    migrations: ['migrate', 'migration', 'schema', 'table', 'column', 'database', 'sql', 'alter'],
-    core: ['implement', 'create', 'add', 'configure', 'setup', 'install', 'build'],
-    tests: ['test', 'verify', 'check', 'assert', 'coverage', 'spec', 'expect'],
-    docs: ['document', 'readme', 'guide', 'example', 'usage', 'api reference'],
-    styles: ['style', 'css', 'scss', 'theme', 'design', 'token', 'color', 'layout'],
-};
-/**
- * Extract relevant plan lines for a specific concern.
- * Matches lines containing concern keywords or file names.
- * Never returns generic template text - always preserves original content.
- */
-export function extractPlanForConcern(originalPlan, concern, files) {
-    const lines = originalPlan.split('\n');
-    const keywords = CONCERN_KEYWORDS[concern];
-    // Extract file basenames for matching
-    const fileBasenames = files.map(f => {
-        const basename = f.split('/').pop() ?? f;
-        return basename.toLowerCase().replace(/\.[^.]+$/, ''); // Remove extension
-    });
-    // Find lines mentioning this concern's keywords or files
-    const relevantLines = lines.filter(line => {
-        const lower = line.toLowerCase();
-        // Check if line mentions any keyword
-        if (keywords.some(kw => lower.includes(kw))) {
-            return true;
-        }
-        // Check if line mentions any of the files (by basename)
-        if (fileBasenames.some(basename => lower.includes(basename))) {
-            return true;
-        }
-        return false;
-    });
-    // If we found relevant lines, use them
-    if (relevantLines.length > 0) {
-        return relevantLines.join('\n');
-    }
-    // Fallback: return original plan with file context (never generic template)
-    return `${originalPlan}\n\nFiles: ${files.join(', ')}`;
-}
-/**
- * Generate a stream ID from a section title.
- */
-export function generateStreamId(title, prefix) {
-    const base = title
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 40);
-    return prefix ? `${prefix}-${base}` : base;
-}
-/**
- * Extract files from "**Files:**" structured lists in markdown.
- * Matches patterns like:
- *   - Create: `src/foo.ts`
- *   - Modify: `src/bar.ts:42-50`
- *   - Test: `tests/foo.test.ts`
- *
- * "Create" and "Modify" → owned files
- * "Test" → owned files (the test file itself)
- * Line number suffixes (`:42-50`) are stripped.
- */
-function extractStructuredFiles(content) {
-    const owned = [];
-    const reads = [];
-    // Match Create:/Modify:/Test: with optional bullet prefix, anchored to start of line
-    const createModifyPattern = /^\s*[-*]?\s*(?:Create|Modify|Test):\s*`([^`]+)`/gim;
-    let match;
-    while ((match = createModifyPattern.exec(content)) !== null) {
-        // Strip line number suffixes like :42-50 or :123
-        const filePath = match[1].replace(/:\d+(-\d+)?$/, '').trim();
-        if (filePath && filePath.includes('.')) {
-            owned.push(filePath);
-        }
-    }
-    // Match "**File:** `path`" or "**New file:** `path`" → owned
-    // Common pattern in design docs: bold "File:" followed by backtick-quoted path
-    const filePattern = /\*\*(?:New\s+)?[Ff]ile:\*\*\s*`([^`]+)`/gi;
-    while ((match = filePattern.exec(content)) !== null) {
-        const filePath = match[1].replace(/:\d+(-\d+)?$/, '').trim();
-        if (filePath && filePath.includes('.')) {
-            owned.push(filePath);
-        }
-    }
-    // Match Read:/Reads:/Import:/Imports: with optional bullet prefix, anchored to start of line
-    const readPattern = /^\s*[-*]?\s*(?:Reads?|Imports?):\s*`([^`]+)`/gim;
-    while ((match = readPattern.exec(content)) !== null) {
-        const filePath = match[1].replace(/:\d+(-\d+)?$/, '').trim();
-        if (filePath && filePath.includes('.')) {
-            reads.push(filePath);
-        }
-    }
-    return { owned, reads };
-}
-/**
- * Extract imported file paths from code blocks.
- * Parses ES module imports and CommonJS require() calls.
- *
- * Path resolution:
- * - Relative imports ('./path'): resolved against code block filename directory.
- *   Skipped if no filename context available.
- * - Absolute-style imports ('src/path'): used as-is.
- * - Bare specifiers ('express', 'pg'): skipped (node_modules).
- * - .js extensions normalized to .ts (TypeScript ESM convention).
- */
-function extractImportsFromCodeBlocks(codeBlocks, excludeFiles) {
-    const imports = new Set();
-    const excludeSet = new Set(excludeFiles);
-    // Match: import ... from '...' or import '...'
-    const esImportRe = /(?:import\s+(?:[\s\S]*?\s+from\s+)?|import\s*\()['"]([^'"]+)['"]/g;
-    // Match: require('...')
-    const requireRe = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    for (const block of codeBlocks) {
-        const specifiers = [];
-        // Extract all import specifiers from this code block
-        let match;
-        esImportRe.lastIndex = 0;
-        while ((match = esImportRe.exec(block.code)) !== null) {
-            specifiers.push(match[1]);
-        }
-        requireRe.lastIndex = 0;
-        while ((match = requireRe.exec(block.code)) !== null) {
-            specifiers.push(match[1]);
-        }
-        for (const specifier of specifiers) {
-            const resolved = resolveImportSpecifier(specifier, block.filename);
-            if (!resolved)
-                continue;
-            if (excludeSet.has(resolved))
-                continue;
-            // Suffix match: resolved may be a shorter path (e.g. "routes/landing.ts")
-            // while excludeFiles has the full path (e.g. "src/v2/routes/landing.ts")
-            if (excludeFiles.some(f => f.endsWith('/' + resolved)))
-                continue;
-            imports.add(resolved);
-        }
-    }
-    return [...imports];
-}
-/**
- * Resolve an import specifier to a project file path.
- * Returns null for unresolvable or external imports.
- */
-function resolveImportSpecifier(specifier, contextFile) {
-    // Skip bare specifiers (node_modules): no '.' or '/' prefix, not starting with 'src/' etc.
-    if (!specifier.startsWith('.') && !specifier.startsWith('src/') && !specifier.startsWith('tests/') && !specifier.startsWith('lib/')) {
-        return null;
-    }
-    // Skip node: protocol
-    if (specifier.startsWith('node:')) {
-        return null;
-    }
-    let resolved;
-    if (specifier.startsWith('.')) {
-        // Relative import — needs filename context
-        if (!contextFile)
-            return null;
-        // Get directory of the context file
-        const parts = contextFile.split('/');
-        parts.pop(); // remove filename
-        const dir = parts.join('/');
-        // Resolve relative path
-        const segments = [...(dir ? dir.split('/') : [])];
-        for (const segment of specifier.split('/')) {
-            if (segment === '.')
-                continue;
-            if (segment === '..') {
-                segments.pop();
-            }
-            else {
-                segments.push(segment);
-            }
-        }
-        resolved = segments.join('/');
-    }
-    else {
-        // Absolute-style import (src/..., tests/...)
-        resolved = specifier;
-    }
-    // Normalize .js -> .ts (TypeScript ESM convention)
-    if (resolved.endsWith('.js')) {
-        resolved = resolved.replace(/\.js$/, '.ts');
-    }
-    // Add .ts if no extension
-    if (!resolved.includes('.')) {
-        resolved = resolved + '.ts';
-    }
-    return resolved;
-}
-/**
- * Infer owned files from section content and its children.
- * Priority order:
- * 1. "Create:/Modify:/Test:" in **Files:** sections (from section + children)
- * 2. Code block filename comments (// filename on first line)
- * 3. Explicit `owns: [files]` pattern in content
- * 4. NO blind fallback to fileReferences — that causes false ownership
- *
- * Files in explicit `reads:` declarations are excluded from ownership.
- */
-export function inferOwnedFiles(section, codeBlocks) {
-    const owned = new Set();
-    // First, extract files explicitly marked as reads-only
-    const readsFiles = new Set();
-    const readsMatch = section.content.match(/reads:\s*\[([^\]]+)\]/i);
-    if (readsMatch) {
-        const files = readsMatch[1].split(',').map(f => f.trim().replace(/[`"']/g, ''));
-        for (const f of files) {
-            if (f && f.includes('.')) {
-                readsFiles.add(f);
-            }
-        }
-    }
-    // Check structured file lists ("- Create: `path`", "- Modify: `path`")
-    // Search both section content and children content
-    const allContent = collectAllContent(section);
-    const proseContent = stripFencedCodeBlocks(allContent);
-    const structured = extractStructuredFiles(proseContent);
-    for (const f of structured.owned) {
-        if (!readsFiles.has(f)) {
-            owned.add(f);
-        }
-    }
-    // Add files from code block filename comments (indicates file is being created/modified)
-    // Also check children's code blocks
-    const allCodeBlocks = collectAllCodeBlocks(section, codeBlocks);
-    for (const block of allCodeBlocks) {
-        // Validate that filename looks like an actual file path (must have a file extension).
-        // This filters out code comments like "// free:" or "// Before:" that the parser
-        // mistakes for filenames via the `// <word>` heuristic.
-        if (block.filename && block.filename.includes('.') && !readsFiles.has(block.filename)) {
-            owned.add(block.filename);
-        }
-    }
-    // Check for "owns: [files]" pattern in content (explicit ownership)
-    // Search both section and children — strip code blocks to avoid matching examples
-    const ownsPattern = /owns:\s*\[([^\]]+)\]/gi;
-    let ownsMatch;
-    while ((ownsMatch = ownsPattern.exec(proseContent)) !== null) {
-        const files = ownsMatch[1].split(',').map(f => f.trim().replace(/[`"']/g, ''));
-        for (const f of files) {
-            if (f && f.includes('.') && !readsFiles.has(f)) {
-                owned.add(f);
-            }
-        }
-    }
-    // NO blind fallback to fileReferences — that causes false ownership.
-    // If no ownership signals were found, the section genuinely doesn't own files.
-    return [...owned];
-}
-/**
- * Remove fenced code block content from markdown text.
- * Preserves text outside fences. Handles unclosed fences (strips to end).
- */
-function stripFencedCodeBlocks(content) {
-    return content.replace(/^```[^\n]*\n[\s\S]*?^```\s*$/gm, '');
-}
-/**
- * Collect content from a section and all its children recursively.
- * Includes children titles for richer context (plan descriptions, categorization).
- */
-function collectAllContent(section) {
-    let content = section.content;
-    for (const child of section.children) {
-        // Include child title for context (e.g., "### 1.2 Provider Validation on Save")
-        content += '\n' + child.title + '\n' + collectAllContent(child);
-    }
-    return content;
-}
-/**
- * Collect code blocks from a section and all its children recursively.
- */
-function collectAllCodeBlocks(section, topLevelBlocks) {
-    const blocks = [...topLevelBlocks];
-    for (const child of section.children) {
-        blocks.push(...child.codeBlocks);
-        for (const grandchild of child.children) {
-            blocks.push(...collectAllCodeBlocks(grandchild, []));
-        }
-    }
-    return blocks;
-}
-/**
- * Extract the first meaningful line of prose from section content.
- * Skips empty lines, markdown formatting (---, **bold-only**), and short labels.
- * Returns empty string if no meaningful line found.
- */
-function extractFirstMeaningfulLine(content) {
-    const lines = content.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Skip empty lines
-        if (!trimmed)
-            continue;
-        // Skip horizontal rules
-        if (/^-{3,}$/.test(trimmed))
-            continue;
-        // Skip lines that are only markdown formatting (bold label, etc.)
-        if (/^\*\*[^*]+\*\*$/.test(trimmed) && trimmed.split(/\s+/).length <= 3)
-            continue;
-        // Must have more than 3 words to be "meaningful"
-        const wordCount = trimmed.split(/\s+/).filter(w => w.length > 0).length;
-        if (wordCount > 3) {
-            // Truncate to ~150 chars to keep items compact
-            if (trimmed.length > 150) {
-                return trimmed.slice(0, 147) + '...';
-            }
-            return trimmed;
-        }
-    }
-    return '';
-}
-/**
- * Build a description from a section, using structured extraction for large sections.
- *
- * When content exceeds budget AND the section has >= 3 children, switches from
- * raw prose dump to a numbered task list of H3 titles + first meaningful line.
- * This prevents silent data loss from .slice(0, budget) on large sections.
- */
-function buildStructuredDescription(section, ownedFiles, budget = 3000) {
-    const fullContent = collectAllContent(section);
-    // Simple sections: existing behavior
-    if (fullContent.length <= budget || section.children.length < 3) {
-        return fullContent.slice(0, budget);
-    }
-    // Complex sections: structured extraction
-    const parts = [];
-    // 1. Include intro (section's direct content before children, first 300 chars)
-    const intro = section.content.trim();
-    if (intro) {
-        parts.push(intro.slice(0, 300));
-    }
-    // 2. Build numbered task list from H3 children
-    for (let i = 0; i < section.children.length; i++) {
-        const child = section.children[i];
-        const title = child.title;
-        const detail = extractFirstMeaningfulLine(child.content);
-        // Find owned file paths mentioned in this child's content/references
-        const childFileRefs = child.fileReferences || [];
-        const relevantFiles = childFileRefs.filter(f => ownedFiles.includes(f));
-        let line = `${i + 1}. ${title}`;
-        if (relevantFiles.length > 0) {
-            line += ` (${relevantFiles.join(', ')})`;
-        }
-        if (detail) {
-            line += ` \u2014 ${detail}`;
-        }
-        parts.push(line);
-    }
-    let totalLen = 0;
-    const completeParts = [];
-    for (const part of parts) {
-        // Always include at least one part (the intro)
-        if (totalLen + part.length + 1 > budget && completeParts.length > 0)
-            break;
-        completeParts.push(part);
-        totalLen += part.length + 1; // +1 for newline join
-    }
-    return completeParts.join('\n');
-}
-/**
- * Infer read files from section content (files referenced but not owned).
- */
-export function inferReadFiles(section, ownedFiles) {
-    const reads = new Set();
-    // Check all content (section + children) for read markers — strip code blocks
-    // to avoid matching YAML patterns inside fenced examples
-    const allContent = collectAllContent(section);
-    const proseContent = stripFencedCodeBlocks(allContent);
-    // Check for "reads: [files]" YAML-like pattern
-    const readsMatch = proseContent.match(/reads:\s*\[([^\]]+)\]/i);
-    if (readsMatch) {
-        const files = readsMatch[1].split(',').map(f => f.trim().replace(/[`"']/g, ''));
-        for (const f of files) {
-            if (f && f.includes('.') && !ownedFiles.includes(f)) {
-                reads.add(f);
-            }
-        }
-    }
-    // Check for structured "- Read: `path`" markers (from Files: sections)
-    const structured = extractStructuredFiles(proseContent);
-    for (const f of structured.reads) {
-        if (!ownedFiles.includes(f)) {
-            reads.add(f);
-        }
-    }
-    // Extract imports from code blocks (section + children)
-    const allCodeBlocks = collectAllCodeBlocks(section, section.codeBlocks);
-    const importedFiles = extractImportsFromCodeBlocks(allCodeBlocks, ownedFiles);
-    for (const f of importedFiles) {
-        if (!ownedFiles.includes(f)) {
-            reads.add(f);
-        }
-    }
-    return [...reads];
-}
-/**
- * Check if files in a deliverable belong to multiple concerns.
- * Returns the concern groups for potential splitting.
- */
-function getConcernGroups(files) {
-    const groups = new Map();
-    for (const file of files) {
-        const concern = classifyFile(file);
-        if (!groups.has(concern)) {
-            groups.set(concern, []);
-        }
-        groups.get(concern).push(file);
-    }
-    return groups;
-}
-/**
- * Check if a deliverable should be split.
- * YAML-sourced deliverables are never split (author knows best).
- * Uses semantic concern-based analysis instead of templates.
- */
-export function shouldSplit(deliverable) {
-    // YAML-sourced deliverables are sacred - never auto-split
-    const meta = deliverable;
-    if (meta._fromYaml) {
-        return { split: false, reasons: [] };
-    }
-    const reasons = [];
-    // Too many owned files
-    if (deliverable.ownedFiles.length > 4) {
-        reasons.push(`Owns ${deliverable.ownedFiles.length} files (max recommended: 4)`);
-    }
-    // Check for compound description (multiple "and" conjunctions)
-    const andCount = (deliverable.description.match(/\band\b/gi) ?? []).length;
-    if (andCount > 2) {
-        reasons.push(`Description has ${andCount} "and" conjunctions (suggests multiple tasks)`);
-    }
-    // Check if files belong to multiple concerns (semantic splitting)
-    if (deliverable.ownedFiles.length > 1) {
-        const concernGroups = getConcernGroups(deliverable.ownedFiles);
-        if (concernGroups.size > 1) {
-            const concerns = [...concernGroups.keys()].join(', ');
-            reasons.push(`Files belong to ${concernGroups.size} different concerns (${concerns})`);
-        }
-    }
-    return { split: reasons.length > 0, reasons };
-}
-/**
- * Convert a YAML stream definition to a Deliverable.
- * Marks with _fromYaml: true so it's never auto-split.
- */
-function yamlToDeliverable(def) {
-    const category = categorizeStream(def.name, def.plan || '');
-    return {
-        id: def.id,
-        name: def.name,
-        description: def.plan || '',
-        category,
-        ownedFiles: def.owns || [],
-        readFiles: def.reads || [],
-        explicitDeps: def.deps || [],
-        codeExamples: [],
-        isAtomic: true,
-        // Mark as YAML-sourced - never auto-split
-        _fromYaml: true,
-        // Preserve verify and setup from YAML
-        _verify: def.verify,
-        _setup: def.setup,
-    };
-}
-/**
- * Extract deliverables from YAML stream definitions in all sections.
- * Scans entire document for yaml code blocks with stream definitions.
- */
-export function extractFromYamlBlocks(plan, prefix, diagnostics) {
-    const deliverables = [];
-    const allSections = flattenSections(plan.sections);
-    for (const section of allSections) {
-        const yamlDefs = extractYamlStreamDefinitions(section);
-        // Track YAML blocks for diagnostics
-        if (diagnostics) {
-            const yamlBlocks = section.codeBlocks.filter(b => b.language === 'yaml' || b.language === 'yml');
-            diagnostics.yamlBlocksFound += yamlBlocks.length;
-            diagnostics.yamlBlocksParsed += yamlDefs.length;
-        }
-        for (const def of yamlDefs) {
-            // Apply prefix to ID if provided
-            if (prefix && !def.id.startsWith(prefix)) {
-                def.id = `${prefix}-${def.id}`;
-            }
-            const deliverable = yamlToDeliverable(def);
-            // Check if should split
-            const splitCheck = shouldSplit(deliverable);
-            if (splitCheck.split) {
-                deliverable.isAtomic = false;
-                deliverable.suggestedSplit = splitCheck.reasons;
-            }
-            deliverables.push(deliverable);
-        }
-    }
-    return deliverables;
-}
-/**
- * Check if a plan contains YAML stream definitions.
- */
-export function hasYamlStreamDefinitions(plan) {
-    const allSections = flattenSections(plan.sections);
-    for (const section of allSections) {
-        const defs = extractYamlStreamDefinitions(section);
-        if (defs.length > 0) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Detect meta/non-deliverable sections by title pattern.
- * These are organizational sections that don't represent implementation work:
- * inventories, checklists, test plans, implementation order, etc.
- */
-function isMetaSection(titleLower) {
-    // Exact multi-word meta patterns
-    const metaPhrases = [
-        'test plan',
-        'implementation order',
-        'security checklist',
-        'gap inventory',
-        'task order',
-        'dependency order',
-        'execution order',
-        'deployment order',
-        'wave order',
-    ];
-    if (metaPhrases.some(phrase => titleLower.includes(phrase))) {
-        return true;
-    }
-    // Titles that ARE the meta topic (not just containing the word)
-    // e.g., "Checklist" or "Inventory" as standalone section titles
-    const metaWords = ['checklist', 'inventory', 'roadmap', 'timeline', 'schedule'];
-    const words = titleLower.split(/[\s:]+/).filter(w => w.length > 0);
-    const lastWord = words[words.length - 1] ?? '';
-    if (metaWords.includes(lastWord)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Extract deliverables from a parsed plan.
- * Automatically detects YAML stream definitions and uses them if found.
- * Falls back to header-based extraction if no YAML streams are present.
- */
-export function extractDeliverables(plan, options = {}) {
-    const { deliverableLevel = 2, prefix, preferYaml = true, diagnostics } = options;
-    // Check for YAML stream definitions first
-    if (preferYaml && hasYamlStreamDefinitions(plan)) {
-        if (diagnostics)
-            diagnostics.extractionPath = 'yaml';
-        const result = extractFromYamlBlocks(plan, prefix, diagnostics);
-        if (diagnostics)
-            diagnostics.deliverableCount = result.length;
-        return result;
-    }
-    // YAML check failed — count blocks for diagnostics (F2 auto-detection)
-    if (diagnostics) {
-        const allSections = flattenSections(plan.sections);
-        for (const section of allSections) {
-            diagnostics.yamlBlocksFound += section.codeBlocks.filter(b => b.language === 'yaml' || b.language === 'yml').length;
-        }
-        diagnostics.extractionPath = 'markdown';
-    }
-    // Fall back to header-based extraction
-    const deliverables = [];
-    const sections = getSectionsAtLevel(plan.sections, deliverableLevel);
-    if (diagnostics) {
-        for (const level of [2, 3, 4]) {
-            diagnostics.sectionsFound[level] = getSectionsAtLevel(plan.sections, level).length;
-        }
-    }
-    for (const section of sections) {
-        // Skip meta sections — match only when the title IS the meta topic,
-        // not when it merely contains the word (e.g., "Context Chunking" is NOT meta)
-        const titleLower = section.title.toLowerCase();
-        const titleWords = titleLower.split(/[\s:]+/).filter(w => w.length > 0);
-        const firstWord = titleWords[0] ?? '';
-        if ((titleLower.includes('overview') && sections.indexOf(section) === 0) ||
-            firstWord === 'summary' || titleLower === 'summary: task order' ||
-            firstWord === 'conclusion' ||
-            firstWord === 'introduction' ||
-            firstWord === 'context' ||
-            firstWord === 'background' ||
-            firstWord === 'appendix' ||
-            firstWord === 'references' ||
-            firstWord === 'changelog' ||
-            firstWord === 'prerequisites' ||
-            isMetaSection(titleLower)) {
-            if (diagnostics)
-                diagnostics.sectionsFilteredAsMeta.push(section.title);
-            continue;
-        }
-        const id = generateStreamId(section.title, prefix);
-        const ownedFiles = inferOwnedFiles(section, section.codeBlocks);
-        const readFiles = inferReadFiles(section, ownedFiles);
-        // Collect code blocks from children too (not just direct section)
-        const allCodeBlocks = collectAllCodeBlocks(section, section.codeBlocks);
-        // Collect read files from children too
-        // Conservative: when code blocks exist with imports, only add prose refs
-        // that match import targets. When no code blocks, keep all prose refs.
-        const importSignals = new Set(extractImportsFromCodeBlocks(allCodeBlocks, ownedFiles));
-        const hasImportSignals = importSignals.size > 0;
-        function collectChildReads(s) {
-            for (const ref of s.fileReferences) {
-                if (ownedFiles.includes(ref) || readFiles.includes(ref))
-                    continue;
-                // When code blocks provide import signals, only add prose refs that
-                // match an import (confirmed dependency). Otherwise keep all prose refs.
-                if (hasImportSignals && !importSignals.has(ref))
-                    continue;
-                readFiles.push(ref);
-            }
-            for (const child of s.children) {
-                collectChildReads(child);
-            }
-        }
-        for (const child of section.children) {
-            collectChildReads(child);
-        }
-        // Collect full content including children for richer descriptions and categorization
-        const fullContent = collectAllContent(section);
-        // Categorize the stream based on name and full content
-        const category = categorizeStream(section.title, fullContent);
-        const deliverable = {
-            id,
-            name: section.title,
-            description: buildStructuredDescription(section, ownedFiles),
-            category,
-            ownedFiles,
-            readFiles,
-            explicitDeps: section.explicitDeps,
-            codeExamples: allCodeBlocks,
-            isAtomic: true,
-            childCount: section.children.length,
-        };
-        // Check if should split
-        const splitCheck = shouldSplit(deliverable);
-        if (splitCheck.split) {
-            deliverable.isAtomic = false;
-            deliverable.suggestedSplit = splitCheck.reasons;
-        }
-        deliverables.push(deliverable);
-    }
-    if (diagnostics)
-        diagnostics.deliverableCount = deliverables.length;
-    return deliverables;
-}
-/**
- * Match a code block to a file concern based on language and content.
- * Used when code blocks lack explicit filename annotations.
- */
-function matchesCodeBlockToConcern(cb, concern) {
-    const lang = (cb.language || '').toLowerCase();
-    const code = cb.code.toLowerCase();
-    switch (concern) {
-        case 'migrations':
-            return lang === 'sql' || code.includes('create table') || code.includes('alter table');
-        case 'types':
-            return ((lang === 'typescript' || lang === 'ts') &&
-                (code.includes('export type ') || code.includes('export interface ') || code.includes('z.object')));
-        case 'tests':
-            return code.includes('describe(') || code.includes('it(') || code.includes('expect(');
-        case 'docs':
-            return lang === 'markdown' || lang === 'md';
-        case 'styles':
-            return lang === 'css' || lang === 'scss' || lang === 'less' || lang === 'sass';
-        case 'core':
-            // Core gets TypeScript/JavaScript blocks that aren't types or tests
-            return ((lang === 'typescript' || lang === 'ts' || lang === 'javascript' || lang === 'js') &&
-                !code.includes('export type ') &&
-                !code.includes('export interface ') &&
-                !code.includes('describe(') &&
-                !code.includes('it('));
-        default:
-            return false;
-    }
-}
-/**
- * Split a non-atomic deliverable using semantic file classification.
- *
- * Phase 8B-C: Files are grouped by concern (types, migrations, core, tests, docs).
- * Each group becomes a separate deliverable with:
- * - Relevant plan content extracted from original (not generic templates)
- * - Proper dependency chaining (types → migrations → core → tests → docs)
- * - Parent's explicit dependencies inherited by first split
- */
-export function splitDeliverable(deliverable) {
-    // YAML-sourced deliverables are never split
-    const meta = deliverable;
-    if (meta._fromYaml) {
-        return [{ ...deliverable, isAtomic: true }];
-    }
-    // Group files by concern
-    const concernGroups = getConcernGroups(deliverable.ownedFiles);
-    // If all files are same concern, don't split
-    if (concernGroups.size <= 1) {
-        return [{ ...deliverable, isAtomic: true }];
-    }
-    const result = [];
-    let prevId = null;
-    let idx = 0;
-    // Create splits in CONCERN_ORDER for proper dependency sequence
-    for (const concern of CONCERN_ORDER) {
-        const files = concernGroups.get(concern);
-        if (!files || files.length === 0)
-            continue;
-        idx++;
-        const splitId = `${deliverable.id}-${concern}`;
-        const splitName = `${deliverable.name} (${concern})`;
-        // Extract relevant plan content for this concern
-        const plan = extractPlanForConcern(deliverable.description, concern, files);
-        // Build dependencies
-        const deps = [];
-        // First split inherits parent's explicit dependencies
-        if (idx === 1 && deliverable.explicitDeps.length > 0) {
-            deps.push(...deliverable.explicitDeps);
-        }
-        // Subsequent splits depend on previous split
-        if (prevId) {
-            deps.push(prevId);
-        }
-        // Assign read files based on concern
-        let readFiles = [];
-        switch (concern) {
-            case 'types':
-                // Types don't need to read anything
-                break;
-            case 'core':
-            case 'migrations':
-                // Core/migrations inherit parent's read files
-                readFiles = [...deliverable.readFiles];
-                break;
-            case 'tests':
-                // Tests read the core files they're testing
-                const coreFiles = concernGroups.get('core') || [];
-                readFiles = [...coreFiles];
-                break;
-            case 'docs':
-                // Docs read the files they're documenting
-                const implFiles = concernGroups.get('core') || concernGroups.get('types') || [];
-                readFiles = [...implFiles];
-                break;
-        }
-        // Distribute code examples to splits
-        // Priority: filename match > concern-based matching (language + content keywords)
-        const codeExamples = deliverable.codeExamples.filter(cb => {
-            // Priority 1: filename match against owned files
-            if (cb.filename && files.some(f => cb.filename === f)) {
-                return true;
-            }
-            // Priority 2: concern-based matching (no filename)
-            if (!cb.filename) {
-                return matchesCodeBlockToConcern(cb, concern);
-            }
-            return false;
-        });
-        result.push({
-            id: splitId,
-            name: splitName,
-            description: plan,
-            category: deliverable.category,
-            ownedFiles: files,
-            readFiles,
-            explicitDeps: deps,
-            codeExamples,
-            isAtomic: true,
-        });
-        prevId = splitId;
-    }
-    return result;
-}
-/**
- * Process all deliverables, splitting non-atomic ones.
- */
-export function processDeliverables(deliverables) {
-    const result = [];
-    for (const d of deliverables) {
-        if (d.isAtomic) {
-            result.push(d);
-        }
-        else {
-            result.push(...splitDeliverable(d));
-        }
-    }
-    return result;
-}
-/**
- * Format deliverable as human-readable summary.
- */
-export function formatDeliverable(deliverable) {
-    const lines = [];
-    lines.push(`${deliverable.id}:`);
-    lines.push(`  Name: ${deliverable.name}`);
-    lines.push(`  Category: ${deliverable.category}`);
-    lines.push(`  Owns: ${deliverable.ownedFiles.join(', ') || '(none)'}`);
-    if (deliverable.readFiles.length > 0) {
-        lines.push(`  Reads: ${deliverable.readFiles.join(', ')}`);
-    }
-    if (deliverable.explicitDeps.length > 0) {
-        lines.push(`  Deps: ${deliverable.explicitDeps.join(', ')}`);
-    }
-    if (!deliverable.isAtomic) {
-        lines.push(`  ⚠️ Should split: ${deliverable.suggestedSplit?.join('; ')}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Format all deliverables as a report.
- */
-export function formatDeliverablesReport(deliverables) {
-    const atomic = deliverables.filter(d => d.isAtomic);
-    const nonAtomic = deliverables.filter(d => !d.isAtomic);
-    let report = `=== Deliverables Report ===\n\n`;
-    report += `Total: ${deliverables.length} deliverables\n`;
-    report += `  ${atomic.length} atomic (ready for streams)\n`;
-    report += `  ${nonAtomic.length} need splitting\n\n`;
-    if (nonAtomic.length > 0) {
-        report += `--- Needs Splitting ---\n\n`;
-        for (const d of nonAtomic) {
-            report += formatDeliverable(d) + '\n\n';
-        }
-    }
-    report += `--- Atomic Deliverables ---\n\n`;
-    for (const d of atomic) {
-        report += formatDeliverable(d) + '\n\n';
-    }
-    return report;
-}