magi-ai 0.1.0

package/dist/src/engine/berserk-orchestrator.js

@@ -0,0 +1,378 @@
+/**
+ * A-03 暴走モード (BERSERK) — BerserkOrchestrator
+ *
+ * Evolutionary deliberation engine that generates 5 strategy variants
+ * per unit, scores candidates by fitness, and iterates until UNANIMOUS
+ * consensus is reached or maxRounds safety valve triggers.
+ *
+ * Flow:
+ * 1. Generate 5 BerserkStrategy prompts (alpha~epsilon)
+ * 2. Execute adapters x strategies in parallel (up to concurrencyLimit)
+ * 3. Score candidates by fitness (confidence, reasoning quality, key points)
+ * 4. Select top-N survivors
+ * 5. Present survivors to ConsensusEngine
+ * 6. If UNANIMOUS → done. Else → re-vote with next round.
+ *
+ * Cache is intentionally disabled — BERSERK demands fresh computation.
+ * Timeout overrides are not applied — each adapter uses its own defaults.
+ */
+import { isUnanimous as isUnanimousDecision } from '../types/consensus.js';
+import { ConsensusEngine } from './consensus.js';
+import { UnitExecutor } from './kernel/unit-executor.js';
+import { LatencyTracker } from '../utils/latency-tracker.js';
+import { Semaphore } from '../utils/semaphore.js';
+import { logger } from '../utils/logger.js';
+import { fireAndForget } from '../utils/fire-and-forget.js';
+import { createAbstainOpinion } from '../utils/abstain-factory.js';
+import { randomUUID } from 'node:crypto';
+// ── Default configuration ──────────────────────────────────────
+const DEFAULT_BERSERK_CONFIG = {
+    maxRounds: 10,
+    concurrencyLimit: 5,
+    survivorCount: 5,
+};
+const DEFAULT_CONSENSUS_CONFIG = {
+    quorum: 2,
+    deadlockStrategy: 'melchior-tiebreak',
+    minConfidenceThreshold: 0,
+    useWeightedVoting: false,
+};
+// ── Strategy definitions ───────────────────────────────────────
+/**
+ * Generate 5 distinct BerserkStrategy definitions.
+ * Each provides a unique analytical perspective to maximize opinion diversity.
+ */
+export function generateStrategyPrompts() {
+    return [
+        {
+            label: 'alpha',
+            name: '楽観 (Optimistic)',
+            promptPrefix: [
+                'You are in OPTIMISTIC mode. Focus on the best-case outcomes.',
+                'Identify opportunities, strengths, and potential benefits.',
+                'Assume favorable conditions and highlight positive aspects.',
+                'Look for creative solutions and innovative approaches.',
+                'Your perspective emphasizes what could go RIGHT.',
+            ].join('\n'),
+        },
+        {
+            label: 'beta',
+            name: '悲観 (Pessimistic)',
+            promptPrefix: [
+                'You are in PESSIMISTIC mode. Focus on worst-case scenarios.',
+                'Identify risks, weaknesses, and potential failures.',
+                'Assume unfavorable conditions and highlight vulnerabilities.',
+                'Consider edge cases, resource constraints, and failure modes.',
+                'Your perspective emphasizes what could go WRONG.',
+            ].join('\n'),
+        },
+        {
+            label: 'gamma',
+            name: '破壊的創造 (Destructive Creation)',
+            promptPrefix: [
+                'You are in DESTRUCTIVE CREATION mode. Challenge every assumption.',
+                'Tear down the existing approach and rebuild from first principles.',
+                'Question fundamental premises. Propose radical alternatives.',
+                'Think orthogonally — what if the problem itself is wrong?',
+                'Your perspective demolishes conventions to find breakthrough solutions.',
+            ].join('\n'),
+        },
+        {
+            label: 'delta',
+            name: '対抗的 (Adversarial)',
+            promptPrefix: [
+                'You are in ADVERSARIAL mode. Argue against the majority position.',
+                'Find flaws in popular reasoning. Play devil\'s advocate.',
+                'Stress-test every argument. Probe for logical fallacies.',
+                'Consider how an attacker, saboteur, or malicious actor would exploit this.',
+                'Your perspective is deliberately contrarian to strengthen analysis.',
+            ].join('\n'),
+        },
+        {
+            label: 'epsilon',
+            name: '保守的 (Conservative)',
+            promptPrefix: [
+                'You are in CONSERVATIVE mode. Prioritize stability and safety.',
+                'Favor proven approaches over novel ones.',
+                'Minimize risk, preserve backward compatibility, and avoid breaking changes.',
+                'Consider long-term maintenance burden and operational complexity.',
+                'Your perspective values reliability and predictability above all.',
+            ].join('\n'),
+        },
+    ];
+}
+// ── Fitness scoring ────────────────────────────────────────────
+/** Score a candidate opinion for evolutionary fitness. */
+function computeFitness(opinion) {
+    const confidenceScore = opinion.confidence * 0.5;
+    const reasoningQuality = computeReasoningQuality(opinion.reasoning) * 0.3;
+    const keyPointScore = computeKeyPointScore(opinion.keyPoints) * 0.2;
+    return confidenceScore + reasoningQuality + keyPointScore;
+}
+/**
+ * Estimate reasoning quality from text length and structure.
+ * Normalized to 0.0 - 1.0.
+ */
+function computeReasoningQuality(reasoning) {
+    if (!reasoning)
+        return 0;
+    const length = reasoning.length;
+    // Diminishing returns beyond 2000 chars
+    const lengthScore = Math.min(length / 2000, 1.0);
+    // Bonus for structured reasoning (sentences, paragraphs)
+    const sentenceCount = (reasoning.match(/[.!?。！？]\s/g) ?? []).length + 1;
+    const structureBonus = Math.min(sentenceCount / 10, 0.3);
+    return Math.min(lengthScore + structureBonus, 1.0);
+}
+/**
+ * Score key points by count and average length.
+ * Normalized to 0.0 - 1.0.
+ */
+function computeKeyPointScore(keyPoints) {
+    if (!keyPoints || keyPoints.length === 0)
+        return 0;
+    const countScore = Math.min(keyPoints.length / 5, 1.0);
+    const avgLength = keyPoints.reduce((sum, kp) => sum + kp.length, 0) / keyPoints.length;
+    const qualityScore = Math.min(avgLength / 100, 1.0);
+    return (countScore + qualityScore) / 2;
+}
+// ── BerserkOrchestrator ────────────────────────────────────────
+export class BerserkOrchestrator {
+    adapters;
+    pipelines;
+    contextManager;
+    eventBus;
+    config;
+    semaphore;
+    consensusEngine;
+    strategies;
+    type666Firewall;
+    unitExecutor;
+    fileAccessEnabled;
+    constructor(adapters, pipelines, contextManager, eventBus, config, type666Firewall, fileAccessEnabled) {
+        this.adapters = adapters;
+        this.pipelines = pipelines;
+        this.contextManager = contextManager;
+        this.eventBus = eventBus;
+        this.config = { ...DEFAULT_BERSERK_CONFIG, ...config };
+        this.semaphore = new Semaphore(this.config.concurrencyLimit);
+        this.consensusEngine = new ConsensusEngine(DEFAULT_CONSENSUS_CONFIG);
+        this.strategies = generateStrategyPrompts();
+        this.type666Firewall = type666Firewall;
+        this.fileAccessEnabled = fileAccessEnabled;
+        this.unitExecutor = new UnitExecutor({
+            adapters,
+            pipelines,
+            contextManager,
+            latencyTracker: new LatencyTracker(),
+            eventBus,
+            modules: {},
+        });
+    }
+    // ── Public API ─────────────────────────────────────────────
+    /**
+     * Execute BERSERK deliberation.
+     *
+     * Generates strategy-varied opinions in parallel, selects by fitness,
+     * and iterates until UNANIMOUS or maxRounds.
+     */
+    async deliberate(task, signal) {
+        const id = task.id ?? randomUUID();
+        const startedAt = new Date();
+        const rounds = [];
+        const berserkRounds = [];
+        const pipeline = this.pipelines.get(task.type);
+        // Phase K: Firewall scan before BERSERK execution
+        if (this.type666Firewall) {
+            const scanResult = this.type666Firewall.scan(task.description);
+            if (!scanResult.passed) {
+                logger.warn('Type-666 Firewall blocked BERSERK input', {
+                    threats: scanResult.threats.length, totalScore: scanResult.totalScore,
+                });
+                logger.audit('firewall.blocked_berserk', id, {
+                    threats: scanResult.threats.length, totalScore: scanResult.totalScore,
+                });
+                throw new Error(`Type-666 Firewall blocked BERSERK: ${scanResult.threats.length} threats detected (score: ${scanResult.totalScore.toFixed(2)})`);
+            }
+            logger.audit('firewall.scan_berserk', id, { passed: true, totalScore: scanResult.totalScore });
+        }
+        await this.contextManager.initWorkspace(id, task);
+        logger.info('BERSERK MODE ACTIVATED', { id, maxRounds: this.config.maxRounds });
+        logger.audit('berserk.activated', id, {
+            strategies: this.strategies.map(s => s.label),
+            maxRounds: this.config.maxRounds,
+        });
+        this.eventBus?.emit('berserk:activated', {
+            deliberationId: id,
+            round: 0,
+            candidateCount: this.adapters.size * this.strategies.length,
+            strategies: this.strategies.map(s => s.label),
+            emittedAt: new Date(),
+        });
+        for (let round = 1; round <= this.config.maxRounds; round++) {
+            if (signal?.aborted) {
+                throw new Error('BERSERK deliberation cancelled');
+            }
+            logger.info(`BERSERK round ${round}/${this.config.maxRounds}`, { id });
+            // 1. Execute all adapter x strategy combinations in parallel
+            const candidates = await this.executeParallel(task, this.strategies, pipeline, id);
+            // 2. Score and select survivors
+            const survivors = this.fitnessSelection(candidates);
+            // 3. Build a DeliberationRound from survivors
+            const roundStart = new Date();
+            const survivorOpinions = survivors.map(s => s.opinion);
+            const deliberationRound = {
+                roundNumber: round,
+                phase: 'initial-opinion',
+                opinions: survivorOpinions,
+                startedAt: roundStart,
+                completedAt: new Date(),
+            };
+            rounds.push(deliberationRound);
+            // Save round (fire-and-forget)
+            fireAndForget(this.contextManager.saveRound(id, deliberationRound), 'berserk.saveRound');
+            // 4. Check consensus via ConsensusEngine
+            const consensus = this.consensusEngine.calculate(survivorOpinions);
+            const isUnanimous = isUnanimousDecision(consensus.decision);
+            const berserkRound = {
+                roundNumber: round,
+                candidates,
+                survivors,
+                consensusReached: isUnanimous,
+                decision: consensus.decision,
+            };
+            berserkRounds.push(berserkRound);
+            logger.info(`BERSERK round ${round} result: ${consensus.decision}`, {
+                id,
+                candidateCount: candidates.length,
+                survivorCount: survivors.length,
+                unanimous: isUnanimous,
+            });
+            if (isUnanimous) {
+                logger.info('BERSERK UNANIMOUS reached — deactivating', { id, round });
+                break;
+            }
+            // If we've hit maxRounds without unanimity, use the last consensus
+            if (round === this.config.maxRounds) {
+                logger.warn('BERSERK maxRounds reached — forcing deactivation', {
+                    id, maxRounds: this.config.maxRounds, decision: consensus.decision,
+                });
+            }
+        }
+        // Final consensus from the last round's survivors
+        const lastRound = rounds[rounds.length - 1];
+        const finalOpinions = lastRound?.opinions ?? [];
+        const finalConsensus = this.consensusEngine.calculate(finalOpinions);
+        const completedAt = new Date();
+        const totalDurationMs = completedAt.getTime() - startedAt.getTime();
+        logger.info('BERSERK MODE DEACTIVATED', {
+            id,
+            rounds: rounds.length,
+            decision: finalConsensus.decision,
+            totalDurationMs,
+        });
+        logger.audit('berserk.deactivated', id, {
+            totalRounds: rounds.length,
+            decision: finalConsensus.decision,
+            totalDurationMs,
+        });
+        this.eventBus?.emit('berserk:deactivated', {
+            deliberationId: id,
+            totalRounds: rounds.length,
+            decision: finalConsensus.decision,
+            emittedAt: new Date(),
+        });
+        const deliberation = {
+            id,
+            task,
+            rounds,
+            consensus: finalConsensus,
+            totalDurationMs,
+            startedAt,
+            completedAt,
+        };
+        await this.contextManager.saveDeliberation(deliberation).catch((err) => {
+            logger.warn('Failed to save BERSERK deliberation', { error: String(err) });
+        });
+        return deliberation;
+    }
+    // ── Parallel execution ────────────────────────────────────
+    /**
+     * Execute all adapter x strategy combinations in parallel,
+     * bounded by the Semaphore concurrency limit.
+     */
+    async executeParallel(task, strategies, pipeline, deliberationId) {
+        const allAdapters = this.adapters.getAll();
+        // Build execution list: adapter x strategy
+        const execPairs = [];
+        for (const adapter of allAdapters) {
+            for (const strategy of strategies) {
+                execPairs.push({ adapter, strategy });
+            }
+        }
+        // Execute with semaphore-bounded concurrency via shared UnitExecutor
+        const results = await Promise.allSettled(execPairs.map(({ adapter, strategy }) => this.semaphore.run(() => this.unitExecutor.execute({
+            deliberationId,
+            adapter,
+            task,
+            pipeline,
+            phase: 'initial-opinion',
+            previousRounds: [],
+            config: pipeline.defaultConfig,
+            berserkStrategy: { name: strategy.name, promptPrefix: strategy.promptPrefix },
+            fileAccessEnabled: this.fileAccessEnabled,
+        }))));
+        const candidates = [];
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const { adapter, strategy } = execPairs[i];
+            if (result.status === 'fulfilled') {
+                const opinion = result.value;
+                const fitnessScore = computeFitness(opinion);
+                candidates.push({
+                    unit: adapter.unit,
+                    strategy: strategy.label,
+                    opinion,
+                    fitnessScore,
+                });
+            }
+            else {
+                // Adapter failure -> ABSTAIN fallback candidate
+                logger.warn(`BERSERK adapter failure: ${adapter.unit}/${strategy.label}`, {
+                    error: String(result.reason),
+                });
+                logger.audit('berserk.adapter_failure', deliberationId, {
+                    unit: adapter.unit,
+                    strategy: strategy.label,
+                    error: String(result.reason),
+                });
+                const fallbackOpinion = createAbstainOpinion(adapter.unit, `${adapter.displayName} failed in BERSERK strategy ${strategy.label}: ${result.reason?.message ?? 'unknown error'}`, ['Adapter execution failed in BERSERK mode']);
+                candidates.push({
+                    unit: adapter.unit,
+                    strategy: strategy.label,
+                    opinion: fallbackOpinion,
+                    fitnessScore: 0,
+                });
+            }
+        }
+        return candidates;
+    }
+    // ── Fitness selection ─────────────────────────────────────
+    /**
+     * Select top-N candidates by fitness score.
+     * Returns candidates sorted by fitness descending, capped at survivorCount.
+     */
+    fitnessSelection(candidates) {
+        const sorted = [...candidates].sort((a, b) => b.fitnessScore - a.fitnessScore);
+        return sorted.slice(0, this.config.survivorCount);
+    }
+    // ── Accessors (for testing) ───────────────────────────────
+    /** Get the strategies used by this orchestrator. */
+    getStrategies() {
+        return [...this.strategies];
+    }
+    /** Get the current config. */
+    getConfig() {
+        return { ...this.config };
+    }
+}

package/dist/src/engine/change-metrics.d.ts

@@ -0,0 +1,56 @@
+/**
+ * ChangeMetrics — Kamei metrics computation module (Phase K Step 0)
+ *
+ * Shared by AngelDetector (A-04) and DeadSeaScrolls (A-08).
+ * Computes commit-level metrics: NS/ND/NF/entropy/LA/LD/NDEV/AGE
+ * plus file-level helpers and co-change graph construction.
+ *
+ * All git commands use execFile with array arguments (no shell injection)
+ * and a 10-second timeout.
+ */
+import type { KameiMetrics, CommitFileChange, CochangeEdge } from '../types/phase-k.js';
+/**
+ * Execute a git command with array arguments and 10s timeout.
+ * Returns trimmed stdout.
+ */
+export declare function execGit(args: string[], cwd?: string): Promise<string>;
+/**
+ * Parse `git diff-tree --no-commit-id -r --numstat` output
+ * to extract file changes for a single commit.
+ */
+export declare function getCommitFiles(commitHash: string, cwd?: string): Promise<CommitFileChange[]>;
+/**
+ * Get the age of a file in days since its last modification.
+ * Uses `git log -1 --format=%ct` to get the last commit timestamp.
+ */
+export declare function getFileAge(filePath: string, cwd?: string): Promise<number>;
+/**
+ * Count unique developers (by email) who have touched a file.
+ * Uses `git log --format=%ae`.
+ */
+export declare function getFileDevCount(filePath: string, cwd?: string): Promise<number>;
+/**
+ * Compute Shannon entropy of changes across files.
+ * Uses proportion of (linesAdded + linesDeleted) per file relative to total.
+ * Pure function, no I/O.
+ */
+export declare function computeEntropy(changes: CommitFileChange[]): number;
+/**
+ * Build a co-change graph from a list of commits.
+ * For each commit, every pair of files changed together gets an edge
+ * with weight incremented by 1.
+ */
+export declare function getCochangeGraph(commitHashes: string[], cwd?: string): Promise<CochangeEdge[]>;
+/**
+ * Compute full Kamei metrics for a single commit.
+ *
+ * - NS = number of unique top-level directories (subsystems)
+ * - ND = number of unique directory paths
+ * - NF = number of changed files
+ * - entropy = Shannon entropy of line changes
+ * - LA = total lines added
+ * - LD = total lines deleted
+ * - NDEV = max unique developer count across changed files
+ * - AGE = average file age in days across changed files
+ */
+export declare function computeKameiMetrics(commitHash: string, cwd?: string): Promise<KameiMetrics>;

package/dist/src/engine/change-metrics.js

@@ -0,0 +1,214 @@
+/**
+ * ChangeMetrics — Kamei metrics computation module (Phase K Step 0)
+ *
+ * Shared by AngelDetector (A-04) and DeadSeaScrolls (A-08).
+ * Computes commit-level metrics: NS/ND/NF/entropy/LA/LD/NDEV/AGE
+ * plus file-level helpers and co-change graph construction.
+ *
+ * All git commands use execFile with array arguments (no shell injection)
+ * and a 10-second timeout.
+ */
+import { execFile } from 'node:child_process';
+const GIT_TIMEOUT_MS = 10_000;
+// ── Git helper ──────────────────────────────────────────────
+/**
+ * Execute a git command with array arguments and 10s timeout.
+ * Returns trimmed stdout.
+ */
+export async function execGit(args, cwd) {
+    const options = {
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: 10 * 1024 * 1024, // 10 MB
+    };
+    if (cwd) {
+        options.cwd = cwd;
+    }
+    return new Promise((resolve, reject) => {
+        execFile('git', args, options, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+// ── getCommitFiles ──────────────────────────────────────────
+/**
+ * Parse `git diff-tree --no-commit-id -r --numstat` output
+ * to extract file changes for a single commit.
+ */
+export async function getCommitFiles(commitHash, cwd) {
+    const output = await execGit(['diff-tree', '--no-commit-id', '-r', '--numstat', commitHash], cwd);
+    if (!output)
+        return [];
+    const lines = output.split('\n');
+    const changes = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // numstat format: "added\tdeleted\tfilepath"
+        // Binary files show: "-\t-\tfilepath"
+        const parts = trimmed.split('\t');
+        if (parts.length < 3)
+            continue;
+        const addedStr = parts[0];
+        const deletedStr = parts[1];
+        const filePath = parts.slice(2).join('\t'); // handle paths with tabs (unlikely but safe)
+        const isBinary = addedStr === '-' && deletedStr === '-';
+        const linesAdded = isBinary ? 0 : parseInt(addedStr, 10);
+        const linesDeleted = isBinary ? 0 : parseInt(deletedStr, 10);
+        changes.push({
+            status: 'M', // numstat does not provide status; default to M
+            filePath,
+            linesAdded: Number.isNaN(linesAdded) ? 0 : linesAdded,
+            linesDeleted: Number.isNaN(linesDeleted) ? 0 : linesDeleted,
+        });
+    }
+    return changes;
+}
+// ── getFileAge ──────────────────────────────────────────────
+/**
+ * Get the age of a file in days since its last modification.
+ * Uses `git log -1 --format=%ct` to get the last commit timestamp.
+ */
+export async function getFileAge(filePath, cwd) {
+    const output = await execGit(['log', '-1', '--format=%ct', '--', filePath], cwd);
+    if (!output)
+        return 0;
+    const timestamp = parseInt(output, 10);
+    if (Number.isNaN(timestamp))
+        return 0;
+    const now = Date.now() / 1000; // current time in seconds
+    const diffSeconds = now - timestamp;
+    return Math.max(0, Math.floor(diffSeconds / 86400)); // convert to days
+}
+// ── getFileDevCount ─────────────────────────────────────────
+/**
+ * Count unique developers (by email) who have touched a file.
+ * Uses `git log --format=%ae`.
+ */
+export async function getFileDevCount(filePath, cwd) {
+    const output = await execGit(['log', '--format=%ae', '--', filePath], cwd);
+    if (!output)
+        return 0;
+    const emails = output.split('\n').filter(Boolean);
+    const unique = new Set(emails);
+    return unique.size;
+}
+// ── computeEntropy ──────────────────────────────────────────
+/**
+ * Compute Shannon entropy of changes across files.
+ * Uses proportion of (linesAdded + linesDeleted) per file relative to total.
+ * Pure function, no I/O.
+ */
+export function computeEntropy(changes) {
+    if (changes.length === 0)
+        return 0;
+    const total = changes.reduce((sum, c) => sum + c.linesAdded + c.linesDeleted, 0);
+    if (total === 0)
+        return 0;
+    let entropy = 0;
+    for (const change of changes) {
+        const fileChanges = change.linesAdded + change.linesDeleted;
+        if (fileChanges === 0)
+            continue;
+        const p = fileChanges / total;
+        entropy -= p * Math.log2(p);
+    }
+    return entropy;
+}
+// ── getCochangeGraph ────────────────────────────────────────
+/**
+ * Build a co-change graph from a list of commits.
+ * For each commit, every pair of files changed together gets an edge
+ * with weight incremented by 1.
+ */
+export async function getCochangeGraph(commitHashes, cwd) {
+    const edgeMap = new Map();
+    for (const hash of commitHashes) {
+        const files = await getCommitFiles(hash, cwd);
+        const filePaths = files.map(f => f.filePath);
+        // Generate all pairs (i < j) to avoid duplicates
+        for (let i = 0; i < filePaths.length; i++) {
+            for (let j = i + 1; j < filePaths.length; j++) {
+                const a = filePaths[i];
+                const b = filePaths[j];
+                // Canonical key: sorted alphabetically
+                const key = a < b ? `${a}\0${b}` : `${b}\0${a}`;
+                edgeMap.set(key, (edgeMap.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    const edges = [];
+    for (const [key, weight] of edgeMap) {
+        const [fileA, fileB] = key.split('\0');
+        edges.push({ fileA, fileB, weight });
+    }
+    return edges;
+}
+// ── computeKameiMetrics ─────────────────────────────────────
+/**
+ * Compute full Kamei metrics for a single commit.
+ *
+ * - NS = number of unique top-level directories (subsystems)
+ * - ND = number of unique directory paths
+ * - NF = number of changed files
+ * - entropy = Shannon entropy of line changes
+ * - LA = total lines added
+ * - LD = total lines deleted
+ * - NDEV = max unique developer count across changed files
+ * - AGE = average file age in days across changed files
+ */
+export async function computeKameiMetrics(commitHash, cwd) {
+    const files = await getCommitFiles(commitHash, cwd);
+    const NF = files.length;
+    const LA = files.reduce((sum, f) => sum + f.linesAdded, 0);
+    const LD = files.reduce((sum, f) => sum + f.linesDeleted, 0);
+    const entropy = computeEntropy(files);
+    // Directories and subsystems
+    const directories = new Set();
+    const subsystems = new Set();
+    for (const file of files) {
+        const parts = file.filePath.split('/');
+        if (parts.length > 1) {
+            // Top-level directory = subsystem
+            subsystems.add(parts[0]);
+            // Full directory path (everything except the filename)
+            directories.add(parts.slice(0, -1).join('/'));
+        }
+        else {
+            // Root-level file: subsystem is '.' (root)
+            subsystems.add('.');
+            directories.add('.');
+        }
+    }
+    const NS = subsystems.size;
+    const ND = directories.size;
+    // NDEV and AGE require per-file git queries
+    let maxDevCount = 0;
+    let totalAge = 0;
+    if (files.length > 0) {
+        const devCounts = await Promise.all(files.map(f => getFileDevCount(f.filePath, cwd)));
+        const ages = await Promise.all(files.map(f => getFileAge(f.filePath, cwd)));
+        for (const count of devCounts) {
+            if (count > maxDevCount)
+                maxDevCount = count;
+        }
+        totalAge = ages.reduce((sum, age) => sum + age, 0);
+    }
+    const NDEV = maxDevCount;
+    const AGE = files.length > 0 ? totalAge / files.length : 0;
+    return {
+        commitHash,
+        NS,
+        ND,
+        NF,
+        entropy,
+        LA,
+        LD,
+        NDEV,
+        AGE,
+    };
+}

package/dist/src/engine/consensus.d.ts

@@ -0,0 +1,20 @@
+import type { ConsensusResult, ConsensusConfig } from '../types/consensus.js';
+import type { MagiOpinion } from '../types/core.js';
+/**
+ * MAGI Consensus Engine
+ *
+ * Calculates consensus from N MAGI units' opinions (2-7) using:
+ * - Unanimous: all agree
+ * - Majority: more than half of non-abstain voters
+ * - Deadlock resolution: configurable strategy
+ */
+export declare class ConsensusEngine {
+    private config;
+    constructor(config: ConsensusConfig);
+    calculate(opinions: MagiOpinion[]): ConsensusResult;
+    private tallyVotes;
+    private resolveDeadlock;
+    private getUnitWeight;
+    private buildResult;
+    private buildSummary;
+}