@wundam/orchex 1.0.0-rc.1

package/dist/intelligence/dependency-inferrer.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Dependency inference from deliverables.
+ * Builds a dependency graph and detects cycles.
+ */
+import type { Deliverable } from './deliverable-extractor.js';
+import type { LearnDiagnostics } from './diagnostics.js';
+/**
+ * Edge in the dependency graph.
+ */
+export interface DependencyEdge {
+    /** Source deliverable ID (the one that depends on target) */
+    from: string;
+    /** Target deliverable ID (the one being depended upon) */
+    to: string;
+    /** How this dependency was inferred */
+    reason: 'explicit' | 'file-ownership' | 'content-pattern';
+    /** Human-readable explanation */
+    explanation: string;
+}
+/**
+ * Result of dependency analysis.
+ */
+export interface DependencyGraph {
+    /** Map of deliverable ID → IDs it depends on */
+    dependencies: Map<string, string[]>;
+    /** All edges with explanations */
+    edges: DependencyEdge[];
+    /** Detected cycles (if any) */
+    cycles: string[][];
+    /** Whether the graph is acyclic (valid) */
+    isAcyclic: boolean;
+}
+/**
+ * Match a deliverable ID or name to find the target in the deliverables list.
+ * Handles fuzzy matching for explicit deps that may use different casing.
+ *
+ * When a match resolves to a split sub-stream, automatically resolves to the
+ * `-core` sibling to ensure correct dependency targeting.
+ */
+export declare function findDeliverableMatch(query: string, deliverables: Deliverable[]): Deliverable | undefined;
+/**
+ * Detect if a deliverable is a cleanup/removal stream.
+ * Cleanup streams DELETE files rather than CREATE them.
+ */
+export declare function isCleanupStream(d: Deliverable): boolean;
+/**
+ * Infer dependencies from file ownership overlaps.
+ * If deliverable B reads files owned by deliverable A, B depends on A.
+ *
+ * NOTE: Cleanup streams are excluded from ownership registration because
+ * they DELETE files rather than CREATE them. This prevents incorrect
+ * dependencies where readers would wait for cleanup (backwards order).
+ */
+export declare function inferFileOwnershipDeps(deliverables: Deliverable[]): DependencyEdge[];
+/**
+ * Infer dependencies from content type patterns.
+ * - Tests depend on their corresponding implementation
+ * - Docs may depend on the feature they document
+ */
+export declare function inferContentPatternDeps(deliverables: Deliverable[]): DependencyEdge[];
+/**
+ * Convert explicit dependency mentions to edges.
+ */
+export declare function inferExplicitDeps(deliverables: Deliverable[], options?: {
+    diagnostics?: LearnDiagnostics;
+}): DependencyEdge[];
+/**
+ * Detect cycles in the dependency graph using DFS.
+ * Returns all cycles found.
+ */
+export declare function detectCycles(dependencies: Map<string, string[]>): string[][];
+/**
+ * Build a complete dependency graph from deliverables.
+ * Combines explicit, file-ownership, and content-pattern dependencies.
+ */
+export declare function buildDependencyGraph(deliverables: Deliverable[], options?: {
+    diagnostics?: LearnDiagnostics;
+}): DependencyGraph;
+/**
+ * Apply inferred dependencies back to deliverables.
+ * Returns a new array with updated explicitDeps.
+ */
+export declare function applyInferredDeps(deliverables: Deliverable[], graph: DependencyGraph): Deliverable[];
+/**
+ * Format dependency graph as human-readable report.
+ */
+export declare function formatDependencyReport(graph: DependencyGraph): string;

package/dist/intelligence/dependency-inferrer.js

@@ -0,0 +1,403 @@
+/**
+ * Dependency inference from deliverables.
+ * Builds a dependency graph and detects cycles.
+ */
+/**
+ * Concern suffixes used by the semantic splitter.
+ * When a deliverable is split, its ID becomes `{parentId}-{concern}`.
+ */
+const SPLIT_CONCERN_SUFFIXES = ['-types', '-migrations', '-core', '-tests', '-docs'];
+/**
+ * When a fuzzy match resolves to a split sub-stream (e.g., `feature-migrations`),
+ * resolve to the `-core` sibling instead — the actual implementation.
+ *
+ * Rationale: external deps like "Depends on Feature X" target the implementation,
+ * not migrations or types. The `-core` split owns the source code that downstream
+ * streams import from. If no `-core` exists, falls back to the latest implementation
+ * concern (migrations > types) before test/docs concerns.
+ */
+function resolveToCoreSibling(matched, deliverables) {
+    const suffix = SPLIT_CONCERN_SUFFIXES.find(s => matched.id.endsWith(s));
+    if (!suffix)
+        return matched; // not a split sub-stream
+    const parentPrefix = matched.id.slice(0, -suffix.length);
+    // Find all siblings from the same split parent
+    const siblings = deliverables.filter(d => SPLIT_CONCERN_SUFFIXES.some(s => d.id === `${parentPrefix}${s}`));
+    if (siblings.length <= 1)
+        return matched; // no siblings — not actually a split
+    // Prefer -core (the implementation)
+    const coreSibling = siblings.find(d => d.id === `${parentPrefix}-core`);
+    if (coreSibling)
+        return coreSibling;
+    // No core sibling — pick last implementation concern (skip tests/docs)
+    const implOrder = ['-migrations', '-types'];
+    for (const implSuffix of implOrder) {
+        const sibling = siblings.find(d => d.id === `${parentPrefix}${implSuffix}`);
+        if (sibling)
+            return sibling;
+    }
+    return matched;
+}
+/**
+ * Match a deliverable ID or name to find the target in the deliverables list.
+ * Handles fuzzy matching for explicit deps that may use different casing.
+ *
+ * When a match resolves to a split sub-stream, automatically resolves to the
+ * `-core` sibling to ensure correct dependency targeting.
+ */
+export function findDeliverableMatch(query, deliverables) {
+    const queryLower = query.toLowerCase().trim();
+    // Exact ID match (no sibling resolution — explicit IDs are intentional)
+    const exactId = deliverables.find(d => d.id === query);
+    if (exactId)
+        return exactId;
+    // Exact name match (case insensitive)
+    const exactName = deliverables.find(d => d.name.toLowerCase() === queryLower);
+    if (exactName)
+        return resolveToCoreSibling(exactName, deliverables);
+    // ID contains query or query contains ID
+    const partialId = deliverables.find(d => d.id.includes(queryLower) || queryLower.includes(d.id));
+    if (partialId)
+        return resolveToCoreSibling(partialId, deliverables);
+    // Name similarity (words overlap)
+    const queryWords = queryLower.split(/[\s-_]+/).filter(w => w.length > 2);
+    const byNameOverlap = deliverables.find(d => {
+        const nameWords = d.name.toLowerCase().split(/[\s-_]+/);
+        const overlap = queryWords.filter(qw => nameWords.some(nw => nw.includes(qw) || qw.includes(nw)));
+        return overlap.length >= queryWords.length * 0.5;
+    });
+    if (byNameOverlap)
+        return resolveToCoreSibling(byNameOverlap, deliverables);
+    return undefined;
+}
+/**
+ * Detect if a deliverable is a cleanup/removal stream.
+ * Cleanup streams DELETE files rather than CREATE them.
+ */
+export function isCleanupStream(d) {
+    const text = `${d.name} ${d.description}`.toLowerCase();
+    return /\b(cleanup|clean\s*up|remove|delete|drop)\b/.test(text);
+}
+/**
+ * Infer dependencies from file ownership overlaps.
+ * If deliverable B reads files owned by deliverable A, B depends on A.
+ *
+ * NOTE: Cleanup streams are excluded from ownership registration because
+ * they DELETE files rather than CREATE them. This prevents incorrect
+ * dependencies where readers would wait for cleanup (backwards order).
+ */
+export function inferFileOwnershipDeps(deliverables) {
+    const edges = [];
+    // Build ownership map: file → owning deliverable
+    // Skip cleanup streams - they delete files, don't create them for others
+    const ownershipMap = new Map();
+    for (const d of deliverables) {
+        if (isCleanupStream(d))
+            continue;
+        for (const file of d.ownedFiles) {
+            ownershipMap.set(file, d);
+        }
+    }
+    // Check each deliverable's read files against ownership
+    for (const d of deliverables) {
+        for (const readFile of d.readFiles) {
+            const owner = ownershipMap.get(readFile);
+            if (owner && owner.id !== d.id) {
+                edges.push({
+                    from: d.id,
+                    to: owner.id,
+                    reason: 'file-ownership',
+                    explanation: `${d.id} reads ${readFile} which is owned by ${owner.id}`,
+                });
+            }
+        }
+    }
+    // Drop mutual file-ownership pairs: if A→B and B→A both exist,
+    // these are context reads (both streams reading each other's files
+    // for understanding), not sequencing dependencies.
+    const edgeKeys = new Set(edges.map(e => `${e.from}→${e.to}`));
+    const mutualKeys = new Set();
+    for (const edge of edges) {
+        const reverse = `${edge.to}→${edge.from}`;
+        if (edgeKeys.has(reverse)) {
+            mutualKeys.add(`${edge.from}→${edge.to}`);
+            mutualKeys.add(reverse);
+        }
+    }
+    return edges.filter(e => !mutualKeys.has(`${e.from}→${e.to}`));
+}
+/**
+ * Infer dependencies from content type patterns.
+ * - Tests depend on their corresponding implementation
+ * - Docs may depend on the feature they document
+ */
+export function inferContentPatternDeps(deliverables) {
+    const edges = [];
+    for (const d of deliverables) {
+        // Test deliverables depend on implementation
+        if (d.category === 'test') {
+            // Look for matching implementation deliverable
+            const baseName = d.id.replace(/-tests?$/, '').replace(/^tests?-/, '');
+            const implDeliverable = deliverables.find(other => other.id !== d.id &&
+                other.category === 'code' &&
+                (other.id === baseName ||
+                    other.id === `${baseName}-core` ||
+                    other.id === `${baseName}-service` ||
+                    other.id === `${baseName}-implementation`));
+            if (implDeliverable) {
+                edges.push({
+                    from: d.id,
+                    to: implDeliverable.id,
+                    reason: 'content-pattern',
+                    explanation: `${d.id} (test) depends on ${implDeliverable.id} (implementation)`,
+                });
+            }
+        }
+        // Tutorial/docs may depend on the feature they document
+        if (d.category === 'docs' || d.category === 'tutorial') {
+            // Remove common prefixes and suffixes to find the base feature name
+            const baseName = d.id
+                .replace(/^docs?-/, '')
+                .replace(/-docs?$/, '')
+                .replace(/^tutorials?-/, '')
+                .replace(/-tutorials?$/, '');
+            // Priority-based matching: prefer service/core over types
+            const codeDeliverables = deliverables.filter(other => other.id !== d.id && other.category === 'code');
+            const featureDeliverable = 
+            // Priority 1: exact match
+            codeDeliverables.find(other => other.id === baseName) ||
+                // Priority 2: service/core variants
+                codeDeliverables.find(other => other.id === `${baseName}-service` ||
+                    other.id === `${baseName}-core` ||
+                    other.id === `${baseName}-implementation`) ||
+                // Priority 3: any match starting with base (but not types)
+                codeDeliverables.find(other => other.id.startsWith(`${baseName}-`) && !other.id.includes('types'));
+            if (featureDeliverable) {
+                edges.push({
+                    from: d.id,
+                    to: featureDeliverable.id,
+                    reason: 'content-pattern',
+                    explanation: `${d.id} (${d.category}) documents ${featureDeliverable.id}`,
+                });
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Convert explicit dependency mentions to edges.
+ */
+export function inferExplicitDeps(deliverables, options) {
+    const edges = [];
+    for (const d of deliverables) {
+        for (const depMention of d.explicitDeps) {
+            const target = findDeliverableMatch(depMention, deliverables);
+            if (target && target.id !== d.id) {
+                edges.push({
+                    from: d.id,
+                    to: target.id,
+                    reason: 'explicit',
+                    explanation: `${d.id} explicitly depends on "${depMention}" (matched ${target.id})`,
+                });
+            }
+            else if (!target) {
+                const msg = `Stream '${d.id}': unmatched explicit dep '${depMention}'`;
+                options?.diagnostics?.unmatchedDeps.push(msg);
+                options?.diagnostics?.warnings.push(msg);
+            }
+        }
+    }
+    return edges;
+}
+/**
+ * Detect cycles in the dependency graph using DFS.
+ * Returns all cycles found.
+ */
+export function detectCycles(dependencies) {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    function dfs(node) {
+        visited.add(node);
+        recursionStack.add(node);
+        path.push(node);
+        const deps = dependencies.get(node) || [];
+        for (const dep of deps) {
+            if (!visited.has(dep)) {
+                dfs(dep);
+            }
+            else if (recursionStack.has(dep)) {
+                // Found a cycle - extract it from the path
+                const cycleStart = path.indexOf(dep);
+                if (cycleStart !== -1) {
+                    const cycle = [...path.slice(cycleStart), dep];
+                    cycles.push(cycle);
+                }
+            }
+        }
+        path.pop();
+        recursionStack.delete(node);
+    }
+    // Run DFS from all nodes
+    for (const node of dependencies.keys()) {
+        if (!visited.has(node)) {
+            dfs(node);
+        }
+    }
+    return cycles;
+}
+/**
+ * Break cycles that consist entirely of file-ownership edges.
+ * For each such cycle, remove the edge from the stream with the fewest
+ * total dependencies (least connected). Ties broken alphabetically for
+ * determinism.
+ *
+ * Mixed-reason cycles (containing explicit or content-pattern edges)
+ * are left intact — those are genuine user errors.
+ */
+function breakFileOwnershipCycles(cycles, edges, dependencies) {
+    let broken = 0;
+    const removedKeys = new Set();
+    for (const cycle of cycles) {
+        // Get edges that form this cycle
+        const cycleEdgePairs = [];
+        for (let i = 0; i < cycle.length - 1; i++) {
+            cycleEdgePairs.push({ from: cycle[i], to: cycle[i + 1] });
+        }
+        // Find matching edges and check if all are file-ownership
+        const matchedEdges = [];
+        for (const pair of cycleEdgePairs) {
+            const edge = edges.find(e => e.from === pair.from && e.to === pair.to && !removedKeys.has(`${e.from}→${e.to}`));
+            if (edge)
+                matchedEdges.push(edge);
+        }
+        if (matchedEdges.length === 0)
+            continue;
+        const allFileOwnership = matchedEdges.every(e => e.reason === 'file-ownership');
+        if (!allFileOwnership)
+            continue;
+        // Pick the weakest edge: from the stream with fewest total deps,
+        // then alphabetically for determinism
+        const edgeToRemove = matchedEdges.reduce((weakest, current) => {
+            const weakestDeps = dependencies.get(weakest.from)?.length ?? 0;
+            const currentDeps = dependencies.get(current.from)?.length ?? 0;
+            if (currentDeps < weakestDeps)
+                return current;
+            if (currentDeps === weakestDeps && current.from < weakest.from)
+                return current;
+            return weakest;
+        });
+        // Remove from edges array
+        const idx = edges.indexOf(edgeToRemove);
+        if (idx !== -1)
+            edges.splice(idx, 1);
+        // Remove from dependency map
+        const fromDeps = dependencies.get(edgeToRemove.from);
+        if (fromDeps) {
+            const depIdx = fromDeps.indexOf(edgeToRemove.to);
+            if (depIdx !== -1)
+                fromDeps.splice(depIdx, 1);
+        }
+        removedKeys.add(`${edgeToRemove.from}→${edgeToRemove.to}`);
+        broken++;
+    }
+    return { broken };
+}
+/**
+ * Build a complete dependency graph from deliverables.
+ * Combines explicit, file-ownership, and content-pattern dependencies.
+ */
+export function buildDependencyGraph(deliverables, options) {
+    // Collect all edges
+    const allEdges = [
+        ...inferExplicitDeps(deliverables, options),
+        ...inferFileOwnershipDeps(deliverables),
+        ...inferContentPatternDeps(deliverables),
+    ];
+    // Deduplicate edges (same from→to pair)
+    const seenEdges = new Set();
+    const uniqueEdges = [];
+    for (const edge of allEdges) {
+        const key = `${edge.from}→${edge.to}`;
+        if (!seenEdges.has(key)) {
+            seenEdges.add(key);
+            uniqueEdges.push(edge);
+        }
+    }
+    // Build dependency map
+    const dependencies = new Map();
+    // Initialize all deliverables
+    for (const d of deliverables) {
+        dependencies.set(d.id, []);
+    }
+    // Add edges
+    for (const edge of uniqueEdges) {
+        const deps = dependencies.get(edge.from) || [];
+        if (!deps.includes(edge.to)) {
+            deps.push(edge.to);
+        }
+        dependencies.set(edge.from, deps);
+    }
+    // Detect and resolve cycles
+    let cycles = detectCycles(dependencies);
+    // Auto-resolve cycles that consist entirely of file-ownership edges
+    if (cycles.length > 0) {
+        const { broken } = breakFileOwnershipCycles(cycles, uniqueEdges, dependencies);
+        if (broken > 0) {
+            // Re-detect after edge removal
+            cycles = detectCycles(dependencies);
+        }
+    }
+    return {
+        dependencies,
+        edges: uniqueEdges,
+        cycles,
+        isAcyclic: cycles.length === 0,
+    };
+}
+/**
+ * Apply inferred dependencies back to deliverables.
+ * Returns a new array with updated explicitDeps.
+ */
+export function applyInferredDeps(deliverables, graph) {
+    return deliverables.map(d => {
+        const inferredDeps = graph.dependencies.get(d.id) || [];
+        // Merge with existing explicit deps, deduplicate
+        const allDeps = [...new Set([...d.explicitDeps, ...inferredDeps])];
+        return {
+            ...d,
+            explicitDeps: allDeps,
+        };
+    });
+}
+/**
+ * Format dependency graph as human-readable report.
+ */
+export function formatDependencyReport(graph) {
+    const lines = ['=== Dependency Analysis ===', ''];
+    // Summary
+    lines.push(`Total edges: ${graph.edges.length}`);
+    lines.push(`Acyclic: ${graph.isAcyclic ? 'Yes ✓' : 'No ⚠️'}`);
+    if (graph.cycles.length > 0) {
+        lines.push('');
+        lines.push('--- Cycles Detected ---');
+        for (const cycle of graph.cycles) {
+            lines.push(`  ${cycle.join(' → ')}`);
+        }
+    }
+    lines.push('');
+    lines.push('--- Dependencies by Deliverable ---');
+    for (const [id, deps] of graph.dependencies) {
+        if (deps.length > 0) {
+            lines.push(`${id}: ${deps.join(', ')}`);
+        }
+    }
+    lines.push('');
+    lines.push('--- Edge Details ---');
+    for (const edge of graph.edges) {
+        lines.push(`${edge.from} → ${edge.to} (${edge.reason})`);
+        lines.push(`    ${edge.explanation}`);
+    }
+    return lines.join('\n');
+}

package/dist/intelligence/diagnostics.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Diagnostics collected during the learn pipeline.
+ * Threaded as an optional parameter; returned in tool responses.
+ */
+export interface LearnDiagnostics {
+    yamlBlocksFound: number;
+    yamlBlocksParsed: number;
+    yamlParseErrors: string[];
+    extractionPath: 'yaml' | 'markdown' | null;
+    sectionsFound: Record<number, number>;
+    sectionsFilteredAsMeta: string[];
+    deliverableCount: number;
+    splitCount: number;
+    unmatchedDeps: string[];
+    ownershipConflicts: string[];
+    warnings: string[];
+}
+export declare function createDiagnostics(): LearnDiagnostics;
+/**
+ * Detect files claimed by multiple streams.
+ * Returns human-readable conflict descriptions.
+ */
+export declare function detectOwnershipConflicts(streams: Record<string, {
+    owns?: string[];
+}>): string[];

package/dist/intelligence/diagnostics.js

@@ -0,0 +1,36 @@
+export function createDiagnostics() {
+    return {
+        yamlBlocksFound: 0,
+        yamlBlocksParsed: 0,
+        yamlParseErrors: [],
+        extractionPath: null,
+        sectionsFound: {},
+        sectionsFilteredAsMeta: [],
+        deliverableCount: 0,
+        splitCount: 0,
+        unmatchedDeps: [],
+        ownershipConflicts: [],
+        warnings: [],
+    };
+}
+/**
+ * Detect files claimed by multiple streams.
+ * Returns human-readable conflict descriptions.
+ */
+export function detectOwnershipConflicts(streams) {
+    const fileOwners = new Map();
+    for (const [id, stream] of Object.entries(streams)) {
+        for (const file of stream.owns || []) {
+            const owners = fileOwners.get(file) || [];
+            owners.push(id);
+            fileOwners.set(file, owners);
+        }
+    }
+    const conflicts = [];
+    for (const [file, owners] of fileOwners) {
+        if (owners.length > 1) {
+            conflicts.push(`${file} owned by: ${owners.join(', ')}`);
+        }
+    }
+    return conflicts;
+}

package/dist/intelligence/error-analyzer.d.ts

@@ -0,0 +1,7 @@
+export interface ErrorAnalysis {
+    category: ErrorCategory;
+    retryable: boolean;
+    suggestion: string;
+}
+export type ErrorCategory = 'timeout' | 'network' | 'rate_limit' | 'edit_mismatch' | 'invalid_artifact' | 'environment' | 'ownership_violation' | 'test_failure' | 'lint_error' | 'runtime_error' | 'unknown';
+export declare function analyzeError(errorString: string): ErrorAnalysis;

package/dist/intelligence/error-analyzer.js

@@ -0,0 +1,76 @@
+const PATTERNS = [
+    // Infrastructure errors — not fixable by regenerating prompts
+    {
+        pattern: /timed?\s*out|ETIMEDOUT|deadline|timeout/i,
+        category: 'timeout',
+        retryable: false,
+        suggestion: 'Timeout is an infrastructure issue. Consider increasing stream timeout or reducing scope.',
+    },
+    {
+        pattern: /network error|ECONNREFUSED|ECONNRESET|EHOSTUNREACH|socket hang up/i,
+        category: 'network',
+        retryable: false,
+        suggestion: 'Network connectivity issue. Check API endpoint availability and network configuration.',
+    },
+    {
+        pattern: /rate limit|too many requests|429|quota exceeded/i,
+        category: 'rate_limit',
+        retryable: false,
+        suggestion: 'Rate limited by API. Wait before retrying or reduce parallel stream count.',
+    },
+    // Fixable errors — can be resolved by retry with better context
+    {
+        pattern: /old_?content.*not found|edit.*mismatch|does not match|oldContent/i,
+        category: 'edit_mismatch',
+        retryable: true,
+        suggestion: 'The file content changed since context was built. Re-read the file and retry with updated content.',
+    },
+    {
+        pattern: /invalid.*artifact|parse.*error|orchex-artifact.*not found|JSON\.parse/i,
+        category: 'invalid_artifact',
+        retryable: true,
+        suggestion: 'The agent produced malformed output. Retry with clearer instructions about the artifact format.',
+    },
+    {
+        pattern: /ENOENT|EACCES|EPERM|ENOSPC|no such file|permission denied/i,
+        category: 'environment',
+        retryable: false,
+        suggestion: 'File system error. Check file paths and permissions.',
+    },
+    {
+        pattern: /ownership violation|outside owned files|SECURITY.*path traversal|SECURITY.*absolute path/i,
+        category: 'ownership_violation',
+        retryable: true,
+        suggestion: 'File operation attempted outside owned files. The fix stream should only modify files in the owns list, or the owns list should be updated to include the new file.',
+    },
+    {
+        pattern: /test.*fail|expect.*received|assertion.*error|FAIL\s+tests\//i,
+        category: 'test_failure',
+        retryable: true,
+        suggestion: 'Tests are failing. Include the test error output in the retry prompt so the agent can fix the issue.',
+    },
+    {
+        pattern: /lint|eslint|prettier|formatting/i,
+        category: 'lint_error',
+        retryable: true,
+        suggestion: 'Lint or formatting error. Include the lint output in the retry prompt.',
+    },
+    {
+        pattern: /TypeError|ReferenceError|SyntaxError|Cannot find module|cannot find name|TS\d{4}/i,
+        category: 'runtime_error',
+        retryable: true,
+        suggestion: 'Code has type or runtime errors. Include the error output and relevant type definitions in the retry prompt.',
+    },
+];
+export function analyzeError(errorString) {
+    for (const { pattern, category, retryable, suggestion } of PATTERNS) {
+        if (pattern.test(errorString)) {
+            return { category, retryable, suggestion };
+        }
+    }
+    return {
+        category: 'unknown',
+        retryable: true,
+        suggestion: 'Unknown error. Retry with the full error message included in the prompt.',
+    };
+}

package/dist/intelligence/file-chunker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chunks a file's content, selecting only the most relevant sections if it's large.
+ * For files over minLines, returns sections around lines matching any of the keywords (case-insensitive).
+ *
+ * - Keeps several lines of surrounding context (`contextRadius`).
+ * - If no matches, falls back to the first and last section slices.
+ *
+ * @param content The full file content
+ * @param keywords List of relevant keywords (from the stream plan)
+ * @param minLines Minimum lines above which chunking is triggered (default: 300)
+ * @param contextRadius How many lines before/after a match to include (default: 10)
+ * @param maxTotalLines Max total lines to include from this file (default: 120)
+ * @returns string (either chunks joined by \n, or full content if not large enough)
+ */
+export declare function extractRelevantChunks(content: string, keywords: string[], minLines?: number, contextRadius?: number, maxTotalLines?: number, withLineNumbers?: boolean): string;