dino-spec 7.5.0 → 8.0.0

package/README.md

@@ -10,15 +10,16 @@
 <__|-|__|
 ```
 
-**dino-spec** brings structured, context-aware development to [Claude Code](https://claude.ai/code). It automatically maintains session state, provides 23 MCP tools, and enables intelligent context retrieval.
+**dino-spec** brings structured, context-aware development to [Claude Code](https://claude.ai/code). It automatically maintains session state, provides 33 MCP tools, and enables intelligent context retrieval.
 
 ## Features
 
-- **MCP Integration** - 23 tools + 19 resources auto-configured during init
+- **MCP Integration** - 33 tools + 19 resources auto-configured during init
 - **Session State** - Automatic tracking of focus, test/build/lint status, blockers
 - **Persistent Memory** - Decisions, patterns, learnings survive across sessions
 - **Workflow Skills** - Phases from discovery to completion (`/dino.*`)
 - **Task Delegation** - Specialized agents with context handoffs
+- **Recursive Agents** - Self-spawning agents with complexity-based depth control (v8.0.0)
 - **Recursive Retrieval** - RLM-style query decomposition with quality feedback
 - **Dynamic Partitioning** - Intelligent codebase segmentation (directory, feature, dependency, time)
 - **Context REPL** - Declarative DSL for model-driven exploration
@@ -99,6 +100,9 @@ Key tools available via Claude Code:
 | `dino_context_repl` | Declarative context queries |
 | `dino_recursive_query` | RLM-style retrieval |
 | `dino_partition` | Intelligent codebase partitioning |
+| `dino_agent_analyze` | Analyze task complexity for spawn decisions |
+| `dino_agent_spawn_decision` | Get recursive agent spawn recommendation |
+| `dino_agent_tree` | Display agent execution tree |
 | `dino_task_create` | Create task in registry |
 | `dino_plan_create` | Create implementation plan |
 

package/dist/core/agents/index.d.ts

@@ -1,14 +1,16 @@
 /**
- * Agent Coordination Module - v7.2.0
+ * Agent Coordination Module - v8.0.0
  *
  * Multi-agent coordination features:
  * - Action space masking (tool availability by phase/role)
  * - Parallel agent orchestration (task coordination)
  * - Agent context budgets (token management)
+ * - Recursive agents (v8.0.0): self-spawning agents with depth control
  */
 export type { ToolCategory, ToolDefinition, MaskingSessionState, MaskingTaskState, AgentMaskingContext, ToolAvailability, ActionMask, ConflictStrategy, ParallelExecutionRequest, AgentSpawnContext, AgentExecutionResult, ConflictType, Conflict, ConflictDetection, ParallelExecutionResult, ExecutionWave, ParallelExecutionPlan, AgentBudgetStatus, TaskComplexity, AgentBudget, BudgetAllocationRequest, BudgetWarning, BudgetHandoff, BudgetRecovery, BudgetStats, } from './types.js';
 export { TOOL_DEFINITIONS, PHASE_RESTRICTIONS, ROLE_PERMISSIONS, checkToolAvailability, generateActionMask, getRecommendedTools, createDefaultContext, formatActionMask, } from './action-mask.js';
 export { ROLE_BASE_BUDGETS, COMPLEXITY_MULTIPLIERS, HANDOFF_RESERVE_PERCENT, MIN_USEFUL_BUDGET, AgentBudgetManager, budgetManager, calculateRecommendedBudget, formatBudget, hasSufficientBudget, } from './budgets.js';
 export { getChildTasks, identifyParallelizableTasks, createParallelPlan, createSpawnContext, formatSpawnContext, detectConflicts, resolveConflicts, synthesizeResults, prepareParallelExecution, completeParallelExecution, formatParallelPlan, } from './orchestrator.js';
 export { runBootstrap, type InitContext } from './initializer.js';
+export * from './recursive/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/agents/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EAEV,YAAY,EACZ,cAAc,EAEd,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EAEV,gBAAgB,EAChB,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,iBAAiB,EACjB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EAErB,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,uBAAuB,EACvB,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,GACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,aAAa,EACb,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,YAAY,EAEV,YAAY,EACZ,cAAc,EAEd,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EAEV,gBAAgB,EAChB,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,iBAAiB,EACjB,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EAErB,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,uBAAuB,EACvB,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,GACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,aAAa,EACb,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGlE,cAAc,sBAAsB,CAAC"}

package/dist/core/agents/index.js

@@ -1,10 +1,11 @@
 /**
- * Agent Coordination Module - v7.2.0
+ * Agent Coordination Module - v8.0.0
  *
  * Multi-agent coordination features:
  * - Action space masking (tool availability by phase/role)
  * - Parallel agent orchestration (task coordination)
  * - Agent context budgets (token management)
+ * - Recursive agents (v8.0.0): self-spawning agents with depth control
  */
 // Action masking
 export { TOOL_DEFINITIONS, PHASE_RESTRICTIONS, ROLE_PERMISSIONS, checkToolAvailability, generateActionMask, getRecommendedTools, createDefaultContext, formatActionMask, } from './action-mask.js';
@@ -14,4 +15,6 @@ export { ROLE_BASE_BUDGETS, COMPLEXITY_MULTIPLIERS, HANDOFF_RESERVE_PERCENT, MIN
 export { getChildTasks, identifyParallelizableTasks, createParallelPlan, createSpawnContext, formatSpawnContext, detectConflicts, resolveConflicts, synthesizeResults, prepareParallelExecution, completeParallelExecution, formatParallelPlan, } from './orchestrator.js';
 // Re-export initializer for completeness
 export { runBootstrap } from './initializer.js';
+// v8.0.0: Recursive agents
+export * from './recursive/index.js';
 //# sourceMappingURL=index.js.map

package/dist/core/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmCH,iBAAiB;AACjB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,UAAU;AACV,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,gBAAgB;AAChB,OAAO,EACL,aAAa,EACb,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAE3B,yCAAyC;AACzC,OAAO,EAAE,YAAY,EAAoB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/agents/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmCH,iBAAiB;AACjB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,UAAU;AACV,OAAO,EACL,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,gBAAgB;AAChB,OAAO,EACL,aAAa,EACb,2BAA2B,EAC3B,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAE3B,yCAAyC;AACzC,OAAO,EAAE,YAAY,EAAoB,MAAM,kBAAkB,CAAC;AAElE,2BAA2B;AAC3B,cAAc,sBAAsB,CAAC"}

package/dist/core/agents/recursive/aggregator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Quality-Weighted Aggregator - v8.0.0
+ *
+ * Aggregates results from child agents:
+ * - Quality-weighted merging of findings
+ * - Deduplication and similarity-based merging
+ * - Multi-level aggregation (leaf → branch → root)
+ * - Configurable aggregation strategies
+ */
+import type { RecursiveCheckpoint, AggregationConfig, AggregationResult } from './types.js';
+/**
+ * Aggregate results from multiple child checkpoints
+ */
+export declare function aggregateCheckpoints(checkpoints: RecursiveCheckpoint[], config?: AggregationConfig): AggregationResult;
+/**
+ * Aggregate results from a single level of the tree
+ */
+export declare function aggregateLevel(childResults: AggregationResult[], config?: AggregationConfig): AggregationResult;
+//# sourceMappingURL=aggregator.d.ts.map

package/dist/core/agents/recursive/aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/recursive/aggregator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EAIlB,MAAM,YAAY,CAAC;AAyCpB;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,mBAAmB,EAAE,EAClC,MAAM,GAAE,iBAA8C,GACrD,iBAAiB,CA+EnB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,iBAAiB,EAAE,EACjC,MAAM,GAAE,iBAA8C,GACrD,iBAAiB,CA+DnB"}

package/dist/core/agents/recursive/aggregator.js

@@ -0,0 +1,556 @@
+/**
+ * Quality-Weighted Aggregator - v8.0.0
+ *
+ * Aggregates results from child agents:
+ * - Quality-weighted merging of findings
+ * - Deduplication and similarity-based merging
+ * - Multi-level aggregation (leaf → branch → root)
+ * - Configurable aggregation strategies
+ */
+import { DEFAULT_AGGREGATION_CONFIG } from './types.js';
+// =============================================================================
+// Constants
+// =============================================================================
+/**
+ * Quality weight for aggregation scoring
+ */
+const QUALITY_WEIGHT = 0.6;
+/**
+ * Priority weight for aggregation scoring
+ */
+const PRIORITY_WEIGHT = 0.4;
+/**
+ * Finding type importance for deduplication
+ */
+const FINDING_TYPE_WEIGHTS = {
+    issue: 1.0, // Issues are most important
+    pattern: 0.9, // Patterns are very important
+    dependency: 0.8, // Dependencies are important
+    opportunity: 0.7, // Opportunities are nice to have
+    note: 0.5, // Notes are lowest priority
+};
+/**
+ * Confidence multipliers
+ */
+const CONFIDENCE_MULTIPLIERS = {
+    high: 1.0,
+    medium: 0.7,
+    low: 0.4,
+};
+// =============================================================================
+// Core Functions
+// =============================================================================
+/**
+ * Aggregate results from multiple child checkpoints
+ */
+export function aggregateCheckpoints(checkpoints, config = DEFAULT_AGGREGATION_CONFIG) {
+    if (checkpoints.length === 0) {
+        return createEmptyResult('No checkpoints to aggregate');
+    }
+    try {
+        // Extract and weight all findings
+        const weightedFindings = extractWeightedFindings(checkpoints);
+        // Apply aggregation strategy
+        let aggregatedFindings;
+        switch (config.strategy) {
+            case 'quality-weighted':
+                aggregatedFindings = aggregateQualityWeighted(weightedFindings, config);
+                break;
+            case 'union-all':
+                aggregatedFindings = aggregateUnionAll(weightedFindings, config);
+                break;
+            case 'priority-based':
+                aggregatedFindings = aggregatePriorityBased(weightedFindings, config);
+                break;
+            case 'consensus':
+                aggregatedFindings = aggregateConsensus(weightedFindings, config);
+                break;
+            default:
+                aggregatedFindings = aggregateQualityWeighted(weightedFindings, config);
+        }
+        // Apply deduplication if enabled
+        const { findings: dedupedFindings, duplicatesRemoved } = config.deduplicate
+            ? deduplicateFindings(aggregatedFindings)
+            : { findings: aggregatedFindings, duplicatesRemoved: 0 };
+        // Apply similarity merging if enabled
+        const { findings: mergedFindings, mergeCount } = config.mergeSimilar
+            ? mergeSimilarFindings(dedupedFindings, config.similarityThreshold)
+            : { findings: dedupedFindings, mergeCount: 0 };
+        // Filter by minimum quality
+        const qualityFiltered = filterByQuality(mergedFindings, config.minQuality, checkpoints);
+        // Limit to max findings
+        const finalFindings = qualityFiltered.slice(0, config.maxFindings);
+        // Aggregate files
+        const aggregatedFiles = aggregateFiles(checkpoints, config);
+        // Combine suggestions
+        const suggestions = aggregateSuggestions(checkpoints);
+        // Calculate combined quality
+        const quality = calculateAggregatedQuality(checkpoints, finalFindings);
+        // Generate summary
+        const summary = generateAggregatedSummary(checkpoints, finalFindings);
+        // Calculate statistics
+        const stats = {
+            sourceCount: checkpoints.length,
+            totalFindingsInput: weightedFindings.length,
+            findingsOutput: finalFindings.length,
+            duplicatesRemoved,
+            findingsMerged: mergeCount,
+            lowQualityFiltered: mergedFindings.length - qualityFiltered.length,
+            qualityImprovement: calculateQualityImprovement(checkpoints, quality),
+        };
+        return {
+            success: true,
+            findings: finalFindings,
+            files: aggregatedFiles,
+            suggestions,
+            quality,
+            stats,
+            summary,
+        };
+    }
+    catch (error) {
+        return createEmptyResult(`Aggregation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Aggregate results from a single level of the tree
+ */
+export function aggregateLevel(childResults, config = DEFAULT_AGGREGATION_CONFIG) {
+    if (childResults.length === 0) {
+        return createEmptyResult('No child results to aggregate');
+    }
+    // Combine findings from all child results
+    const allFindings = [];
+    for (const result of childResults) {
+        for (const finding of result.findings) {
+            allFindings.push({
+                finding,
+                sourceAgentId: 'child-result',
+                qualityWeight: result.quality.score,
+                priorityWeight: 0.5,
+                combinedWeight: result.quality.score * 0.7 + 0.3,
+            });
+        }
+    }
+    // Apply quality-weighted aggregation
+    const aggregatedFindings = aggregateQualityWeighted(allFindings, config);
+    // Combine files
+    const allFiles = [];
+    for (const result of childResults) {
+        allFiles.push(...result.files);
+    }
+    const dedupedFiles = deduplicateFiles(allFiles).slice(0, config.maxFiles);
+    // Combine suggestions
+    const allSuggestions = [];
+    for (const result of childResults) {
+        allSuggestions.push(...result.suggestions);
+    }
+    const uniqueSuggestions = deduplicateSuggestions(allSuggestions);
+    // Calculate combined quality
+    const avgQuality = childResults.reduce((sum, r) => sum + r.quality.score, 0) / childResults.length;
+    const quality = createQualityScore(avgQuality);
+    // Generate summary
+    const summary = `Aggregated from ${childResults.length} child results: ${aggregatedFindings.length} findings`;
+    // Calculate stats
+    const stats = {
+        sourceCount: childResults.length,
+        totalFindingsInput: allFindings.length,
+        findingsOutput: aggregatedFindings.length,
+        duplicatesRemoved: allFindings.length - aggregatedFindings.length,
+        findingsMerged: 0,
+        lowQualityFiltered: 0,
+        qualityImprovement: 0,
+    };
+    return {
+        success: true,
+        findings: aggregatedFindings,
+        files: dedupedFiles,
+        suggestions: uniqueSuggestions,
+        quality,
+        stats,
+        summary,
+    };
+}
+// =============================================================================
+// Aggregation Strategies
+// =============================================================================
+/**
+ * Quality-weighted aggregation (default)
+ */
+function aggregateQualityWeighted(findings, config) {
+    // Sort by combined weight
+    const sorted = [...findings].sort((a, b) => b.combinedWeight - a.combinedWeight);
+    // Take top findings
+    return sorted.slice(0, config.maxFindings).map(wf => wf.finding);
+}
+/**
+ * Union all findings (with deduplication)
+ */
+function aggregateUnionAll(findings, config) {
+    return findings.slice(0, config.maxFindings * 2).map(wf => wf.finding);
+}
+/**
+ * Priority-based aggregation
+ */
+function aggregatePriorityBased(findings, config) {
+    // Sort by priority weight then quality weight
+    const sorted = [...findings].sort((a, b) => {
+        if (b.priorityWeight !== a.priorityWeight) {
+            return b.priorityWeight - a.priorityWeight;
+        }
+        return b.qualityWeight - a.qualityWeight;
+    });
+    return sorted.slice(0, config.maxFindings).map(wf => wf.finding);
+}
+/**
+ * Consensus aggregation (only findings from multiple sources)
+ */
+function aggregateConsensus(findings, config) {
+    // Group similar findings
+    const groups = groupSimilarFindings(findings, config.similarityThreshold);
+    // Only keep findings with multiple sources
+    const consensusGroups = groups.filter(g => g.length >= 2);
+    // Take best from each group
+    const results = [];
+    for (const group of consensusGroups) {
+        // Sort by combined weight
+        group.sort((a, b) => b.combinedWeight - a.combinedWeight);
+        results.push(group[0].finding);
+    }
+    return results.slice(0, config.maxFindings);
+}
+// =============================================================================
+// Finding Processing
+// =============================================================================
+/**
+ * Extract weighted findings from checkpoints
+ */
+function extractWeightedFindings(checkpoints) {
+    const weighted = [];
+    for (const cp of checkpoints) {
+        const qualityWeight = cp.quality.score;
+        for (const finding of cp.checkpoint.findings) {
+            // Calculate finding-specific weight
+            const typeWeight = FINDING_TYPE_WEIGHTS[finding.type];
+            const confWeight = CONFIDENCE_MULTIPLIERS[finding.confidence];
+            const findingWeight = typeWeight * confWeight;
+            // Calculate priority based on agent context
+            const priorityWeight = findingWeight;
+            // Combined weight
+            const combinedWeight = qualityWeight * QUALITY_WEIGHT +
+                priorityWeight * PRIORITY_WEIGHT;
+            weighted.push({
+                finding,
+                sourceAgentId: cp.agentId,
+                qualityWeight,
+                priorityWeight,
+                combinedWeight,
+            });
+        }
+    }
+    return weighted;
+}
+/**
+ * Deduplicate findings based on description similarity
+ */
+function deduplicateFindings(findings) {
+    const seen = new Set();
+    const deduplicated = [];
+    for (const finding of findings) {
+        // Normalize for comparison
+        const normalized = normalizeFindingForComparison(finding);
+        if (!seen.has(normalized)) {
+            seen.add(normalized);
+            deduplicated.push(finding);
+        }
+    }
+    return {
+        findings: deduplicated,
+        duplicatesRemoved: findings.length - deduplicated.length,
+    };
+}
+/**
+ * Merge similar findings
+ */
+function mergeSimilarFindings(findings, threshold) {
+    if (findings.length <= 1) {
+        return { findings, mergeCount: 0 };
+    }
+    const merged = [];
+    const used = new Set();
+    let mergeCount = 0;
+    for (let i = 0; i < findings.length; i++) {
+        if (used.has(i))
+            continue;
+        const current = findings[i];
+        const similar = [current];
+        used.add(i);
+        // Find similar findings
+        for (let j = i + 1; j < findings.length; j++) {
+            if (used.has(j))
+                continue;
+            const similarity = calculateFindingSimilarity(current, findings[j]);
+            if (similarity >= threshold) {
+                similar.push(findings[j]);
+                used.add(j);
+                mergeCount++;
+            }
+        }
+        // Merge similar findings
+        if (similar.length > 1) {
+            merged.push(mergeFindingGroup(similar));
+        }
+        else {
+            merged.push(current);
+        }
+    }
+    return { findings: merged, mergeCount };
+}
+/**
+ * Filter findings by quality threshold
+ */
+function filterByQuality(findings, minQuality, checkpoints) {
+    // Build a map of finding to source checkpoint quality
+    const findingQualities = new Map();
+    for (const cp of checkpoints) {
+        for (const finding of cp.checkpoint.findings) {
+            findingQualities.set(finding, cp.quality.score);
+        }
+    }
+    return findings.filter(f => {
+        const quality = findingQualities.get(f);
+        return quality === undefined || quality >= minQuality;
+    });
+}
+// =============================================================================
+// File Processing
+// =============================================================================
+/**
+ * Aggregate files from checkpoints
+ */
+function aggregateFiles(checkpoints, config) {
+    const allFiles = [];
+    for (const cp of checkpoints) {
+        allFiles.push(...cp.checkpoint.nextContext.relevantFiles);
+    }
+    // Deduplicate and take top files
+    return deduplicateFiles(allFiles).slice(0, config.maxFiles);
+}
+/**
+ * Deduplicate files by path
+ */
+function deduplicateFiles(files) {
+    const byPath = new Map();
+    for (const file of files) {
+        if (!byPath.has(file.path)) {
+            byPath.set(file.path, file);
+        }
+        else {
+            // Keep the one with longer summary (more info)
+            const existing = byPath.get(file.path);
+            if (file.summary.length > existing.summary.length) {
+                byPath.set(file.path, file);
+            }
+        }
+    }
+    return Array.from(byPath.values());
+}
+// =============================================================================
+// Suggestion Processing
+// =============================================================================
+/**
+ * Aggregate suggestions from checkpoints
+ */
+function aggregateSuggestions(checkpoints) {
+    const allSuggestions = [];
+    for (const cp of checkpoints) {
+        allSuggestions.push(...cp.checkpoint.nextContext.suggestions);
+    }
+    return deduplicateSuggestions(allSuggestions);
+}
+/**
+ * Deduplicate suggestions
+ */
+function deduplicateSuggestions(suggestions) {
+    const seen = new Set();
+    const unique = [];
+    for (const suggestion of suggestions) {
+        const normalized = suggestion.toLowerCase().trim();
+        if (!seen.has(normalized)) {
+            seen.add(normalized);
+            unique.push(suggestion);
+        }
+    }
+    return unique.slice(0, 5);
+}
+// =============================================================================
+// Quality Calculation
+// =============================================================================
+/**
+ * Calculate aggregated quality score
+ */
+function calculateAggregatedQuality(checkpoints, finalFindings) {
+    if (checkpoints.length === 0) {
+        return createQualityScore(0);
+    }
+    // Average quality from sources
+    const avgSourceQuality = checkpoints.reduce((sum, cp) => sum + cp.quality.score, 0) / checkpoints.length;
+    // Bonus for finding coverage
+    const totalSourceFindings = checkpoints.reduce((sum, cp) => sum + cp.checkpoint.findings.length, 0);
+    const coverageRatio = totalSourceFindings > 0
+        ? finalFindings.length / totalSourceFindings
+        : 0;
+    const coverageBonus = Math.min(0.1, coverageRatio * 0.2);
+    // Combined score
+    const finalScore = Math.min(1, avgSourceQuality + coverageBonus);
+    return createQualityScore(finalScore);
+}
+/**
+ * Calculate quality improvement from aggregation
+ */
+function calculateQualityImprovement(checkpoints, aggregatedQuality) {
+    if (checkpoints.length === 0)
+        return 0;
+    const avgSourceQuality = checkpoints.reduce((sum, cp) => sum + cp.quality.score, 0) / checkpoints.length;
+    return aggregatedQuality.score - avgSourceQuality;
+}
+/**
+ * Create a quality score object
+ */
+function createQualityScore(score) {
+    return {
+        score: Math.max(0, Math.min(1, score)),
+        dimensions: {
+            relevance: score,
+            completeness: score * 0.9,
+            consistency: score * 0.95,
+            novelty: score * 0.5,
+        },
+        trend: 'stable',
+        confidence: Math.min(1, score + 0.2),
+        action: score >= 0.6 ? 'continue' : score >= 0.3 ? 'refine' : 'stop',
+    };
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Normalize finding for comparison
+ */
+function normalizeFindingForComparison(finding) {
+    return `${finding.type}:${finding.description.toLowerCase().trim()}:${finding.location || ''}`;
+}
+/**
+ * Calculate similarity between two findings (0-1)
+ */
+function calculateFindingSimilarity(a, b) {
+    // Same type is required for similarity
+    if (a.type !== b.type)
+        return 0;
+    // Same location is a strong signal
+    if (a.location && b.location && a.location === b.location) {
+        return 0.8;
+    }
+    // Compare descriptions using token overlap
+    const tokensA = new Set(a.description.toLowerCase().split(/\s+/));
+    const tokensB = new Set(b.description.toLowerCase().split(/\s+/));
+    const intersection = new Set([...tokensA].filter(t => tokensB.has(t)));
+    const union = new Set([...tokensA, ...tokensB]);
+    const jaccardSimilarity = intersection.size / union.size;
+    return jaccardSimilarity;
+}
+/**
+ * Group similar findings together
+ */
+function groupSimilarFindings(findings, threshold) {
+    const groups = [];
+    const used = new Set();
+    for (let i = 0; i < findings.length; i++) {
+        if (used.has(i))
+            continue;
+        const group = [findings[i]];
+        used.add(i);
+        for (let j = i + 1; j < findings.length; j++) {
+            if (used.has(j))
+                continue;
+            const similarity = calculateFindingSimilarity(findings[i].finding, findings[j].finding);
+            if (similarity >= threshold) {
+                group.push(findings[j]);
+                used.add(j);
+            }
+        }
+        groups.push(group);
+    }
+    return groups;
+}
+/**
+ * Merge a group of similar findings into one
+ */
+function mergeFindingGroup(findings) {
+    if (findings.length === 0) {
+        throw new Error('Cannot merge empty group');
+    }
+    if (findings.length === 1) {
+        return findings[0];
+    }
+    // Use the highest confidence finding as base
+    const sorted = [...findings].sort((a, b) => {
+        const confA = CONFIDENCE_MULTIPLIERS[a.confidence];
+        const confB = CONFIDENCE_MULTIPLIERS[b.confidence];
+        return confB - confA;
+    });
+    const base = sorted[0];
+    // Merge locations if different
+    const locations = new Set(findings.map(f => f.location).filter(Boolean));
+    const mergedLocation = locations.size > 1
+        ? Array.from(locations).join(', ')
+        : base.location;
+    return {
+        type: base.type,
+        description: base.description,
+        location: mergedLocation,
+        confidence: base.confidence,
+    };
+}
+/**
+ * Generate summary for aggregated results
+ */
+function generateAggregatedSummary(checkpoints, findings) {
+    const sourceCount = checkpoints.length;
+    const findingCount = findings.length;
+    const avgQuality = checkpoints.reduce((sum, cp) => sum + cp.quality.score, 0) / Math.max(1, checkpoints.length);
+    const issueCount = findings.filter(f => f.type === 'issue').length;
+    const patternCount = findings.filter(f => f.type === 'pattern').length;
+    let summary = `Aggregated ${findingCount} findings from ${sourceCount} agents (${(avgQuality * 100).toFixed(0)}% avg quality)`;
+    if (issueCount > 0) {
+        summary += `. Found ${issueCount} issue${issueCount > 1 ? 's' : ''}`;
+    }
+    if (patternCount > 0) {
+        summary += `. Identified ${patternCount} pattern${patternCount > 1 ? 's' : ''}`;
+    }
+    return summary;
+}
+/**
+ * Create empty result with error message
+ */
+function createEmptyResult(error) {
+    return {
+        success: false,
+        findings: [],
+        files: [],
+        suggestions: [],
+        quality: createQualityScore(0),
+        stats: {
+            sourceCount: 0,
+            totalFindingsInput: 0,
+            findingsOutput: 0,
+            duplicatesRemoved: 0,
+            findingsMerged: 0,
+            lowQualityFiltered: 0,
+            qualityImprovement: 0,
+        },
+        summary: '',
+        error,
+    };
+}
+//# sourceMappingURL=aggregator.js.map