magi-ai 0.1.0

package/dist/src/engine/hallucination-detector.js

@@ -0,0 +1,215 @@
+/**
+ * HallucinationDetector — Detects fabricated content in MAGI opinions
+ *
+ * Stateless detector that identifies 4 types of hallucinations:
+ * 1. Fabricated file paths (generic placeholder paths)
+ * 2. Abnormal line numbers (impossibly large or zero)
+ * 3. Vote-reasoning mismatch (contradictory vote + reasoning)
+ * 4. Fabricated references (non-existent RFC/CVE numbers)
+ *
+ * Part of B-02 LCL (shared consciousness pool).
+ */
+// ── Constants ────────────────────────────────────────────────────
+/** Paths that are commonly valid and should not be flagged */
+const VALID_PATH_PREFIXES = [
+    '/dev/', '/tmp/', '/usr/', '/etc/', '/var/', '/bin/', '/sbin/',
+    '/opt/', '/lib/', '/proc/', '/sys/', '/home/', '/root/',
+];
+/** Generic placeholder path patterns that indicate fabrication */
+const FABRICATED_PATH_PATTERNS = [
+    /\/path\/to\//i,
+    /\/foo\/bar\//i,
+    /\/example\//i,
+    /\/some\//i,
+    /\/my\//i,
+    /\/test\/fake\//i,
+];
+/** Threshold above which line numbers are suspicious */
+const LINE_NUMBER_THRESHOLD = 50000;
+/** Negative sentiment keywords for vote-reasoning mismatch */
+const NEGATIVE_KEYWORDS = [
+    'terrible', 'awful', 'dangerous', 'critical', 'vulnerability',
+    'broken', 'fatal', 'catastrophic', 'unacceptable', 'severe',
+    'disastrous', 'horrible', 'unsafe', 'exploit', 'malicious',
+];
+/** Positive sentiment keywords for vote-reasoning mismatch */
+const POSITIVE_KEYWORDS = [
+    'excellent', 'great', 'clean', 'solid', 'well-structured',
+    'impressive', 'robust', 'elegant', 'optimal', 'perfect',
+    'outstanding', 'brilliant', 'exemplary', 'superb', 'flawless',
+];
+/** Minimum confidence threshold for purification */
+const PURIFY_CONFIDENCE_THRESHOLD = 0.7;
+// ── HallucinationDetector ────────────────────────────────────────
+export class HallucinationDetector {
+    /**
+     * Run all hallucination checks on an opinion.
+     * Returns an array of reports (empty if no hallucinations detected).
+     */
+    detect(opinion) {
+        const text = `${opinion.reasoning} ${opinion.keyPoints.join(' ')} ${opinion.suggestions?.join(' ') ?? ''}`;
+        const reports = [];
+        reports.push(...this.checkFilePaths(text));
+        reports.push(...this.checkLineNumbers(text));
+        reports.push(...this.checkVoteReasoningMismatch(opinion));
+        reports.push(...this.checkFabricatedReferences(text));
+        return reports;
+    }
+    /**
+     * Create a purified copy of the opinion with hallucinations annotated.
+     * Only purifies reports with confidence >= PURIFY_CONFIDENCE_THRESHOLD.
+     */
+    purify(opinion, reports) {
+        const actionableReports = reports.filter(r => r.confidence >= PURIFY_CONFIDENCE_THRESHOLD);
+        if (actionableReports.length === 0) {
+            return opinion;
+        }
+        let reasoning = opinion.reasoning;
+        const keyPoints = [...opinion.keyPoints];
+        const suggestions = opinion.suggestions ? [...opinion.suggestions] : undefined;
+        for (const report of actionableReports) {
+            if (report.location) {
+                const loc = report.location;
+                const replacement = `[PURIFIED: ${report.type}]`;
+                reasoning = reasoning.replaceAll(loc, replacement);
+                for (let i = 0; i < keyPoints.length; i++) {
+                    const kp = keyPoints[i];
+                    if (kp !== undefined) {
+                        keyPoints[i] = kp.replaceAll(loc, replacement);
+                    }
+                }
+                if (suggestions) {
+                    for (let i = 0; i < suggestions.length; i++) {
+                        const sg = suggestions[i];
+                        if (sg !== undefined) {
+                            suggestions[i] = sg.replaceAll(loc, replacement);
+                        }
+                    }
+                }
+            }
+        }
+        // Reduce confidence proportionally to hallucination severity
+        const avgConfidence = actionableReports.reduce((sum, r) => sum + r.confidence, 0) / actionableReports.length;
+        const penalty = avgConfidence * 0.2 * actionableReports.length;
+        const adjustedConfidence = Math.max(0.1, opinion.confidence - penalty);
+        return {
+            ...opinion,
+            reasoning,
+            keyPoints,
+            suggestions,
+            confidence: Math.round(adjustedConfidence * 100) / 100,
+        };
+    }
+    // ── Private check methods ──────────────────────────────────────
+    /** Detect fabricated file paths like /path/to/xxx, /foo/bar/baz.ts */
+    checkFilePaths(text) {
+        const reports = [];
+        // Match Unix-style absolute paths
+        const pathRegex = /(?:^|\s)(\/[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+){2,})/g;
+        let match;
+        while ((match = pathRegex.exec(text)) !== null) {
+            const filePath = match[1] ?? '';
+            if (!filePath)
+                continue;
+            // Skip known valid paths
+            if (VALID_PATH_PREFIXES.some(prefix => filePath.startsWith(prefix))) {
+                continue;
+            }
+            // Check against fabricated patterns
+            if (FABRICATED_PATH_PATTERNS.some(pattern => pattern.test(filePath))) {
+                reports.push({
+                    type: 'fabricated-path',
+                    description: `Suspected fabricated file path: ${filePath}`,
+                    confidence: filePath.includes('/path/to/') ? 0.9 : 0.7,
+                    location: filePath,
+                });
+            }
+        }
+        return reports;
+    }
+    /** Detect abnormal line numbers (line 0, line > 50000) */
+    checkLineNumbers(text) {
+        const reports = [];
+        const lineRegex = /\bline\s+(\d+)\b/gi;
+        let match;
+        while ((match = lineRegex.exec(text)) !== null) {
+            const lineNum = parseInt(match[1] ?? '', 10);
+            if (Number.isNaN(lineNum))
+                continue;
+            if (lineNum === 0 || lineNum > LINE_NUMBER_THRESHOLD) {
+                reports.push({
+                    type: 'abnormal-line-number',
+                    description: `Abnormal line number: ${lineNum}${lineNum === 0 ? ' (line 0 does not exist)' : ` (exceeds ${LINE_NUMBER_THRESHOLD})`}`,
+                    confidence: 0.8,
+                    location: match[0],
+                });
+            }
+        }
+        return reports;
+    }
+    /** Detect mismatch between vote and reasoning sentiment */
+    checkVoteReasoningMismatch(opinion) {
+        const reports = [];
+        const lowerReasoning = opinion.reasoning.toLowerCase();
+        const negativeCount = NEGATIVE_KEYWORDS.filter(kw => lowerReasoning.includes(kw)).length;
+        const positiveCount = POSITIVE_KEYWORDS.filter(kw => lowerReasoning.includes(kw)).length;
+        if (opinion.vote === 'APPROVE' && negativeCount >= 2 && negativeCount > positiveCount) {
+            const confidence = Math.min(0.8, 0.6 + negativeCount * 0.05);
+            reports.push({
+                type: 'vote-reasoning-mismatch',
+                description: `APPROVE vote contradicts negative reasoning (${negativeCount} negative keywords found)`,
+                confidence: Math.round(confidence * 100) / 100,
+            });
+        }
+        if (opinion.vote === 'REJECT' && positiveCount >= 2 && positiveCount > negativeCount) {
+            const confidence = Math.min(0.8, 0.6 + positiveCount * 0.05);
+            reports.push({
+                type: 'vote-reasoning-mismatch',
+                description: `REJECT vote contradicts positive reasoning (${positiveCount} positive keywords found)`,
+                confidence: Math.round(confidence * 100) / 100,
+            });
+        }
+        return reports;
+    }
+    /** Detect fabricated RFC/CVE references */
+    checkFabricatedReferences(text) {
+        const reports = [];
+        // RFC numbers: valid RFCs are currently in the range 1-9999 (roughly)
+        const rfcRegex = /\bRFC\s+(\d+)\b/gi;
+        let match;
+        while ((match = rfcRegex.exec(text)) !== null) {
+            const rfcNumStr = match[1] ?? '';
+            const rfcNum = parseInt(rfcNumStr, 10);
+            if (Number.isNaN(rfcNum))
+                continue;
+            if (rfcNum > 99000) {
+                reports.push({
+                    type: 'fabricated-reference',
+                    description: `Suspected fabricated RFC number: RFC ${rfcNum}`,
+                    confidence: 0.85,
+                    location: match[0],
+                });
+            }
+        }
+        // CVE numbers: format is CVE-YYYY-NNNN+
+        const cveRegex = /\bCVE-(\d{4})-(\d+)\b/gi;
+        while ((match = cveRegex.exec(text)) !== null) {
+            const yearStr = match[1] ?? '';
+            const seqStr = match[2] ?? '';
+            const year = parseInt(yearStr, 10);
+            const seqNum = parseInt(seqStr, 10);
+            if (Number.isNaN(year) || Number.isNaN(seqNum))
+                continue;
+            // Future years or absurdly high sequence numbers
+            if (year > 2026 || seqNum > 90000) {
+                reports.push({
+                    type: 'fabricated-reference',
+                    description: `Suspected fabricated CVE: CVE-${yearStr}-${seqStr}`,
+                    confidence: 0.85,
+                    location: match[0],
+                });
+            }
+        }
+        return reports;
+    }
+}

package/dist/src/engine/human-resolver.d.ts

@@ -0,0 +1,19 @@
+import type { MagiOpinion } from '../types/core.js';
+import type { ConsensusResult, VoteSummary } from '../types/consensus.js';
+/**
+ * Human-in-the-loop resolver for deadlock situations.
+ *
+ * When the MAGI units cannot reach consensus, presents the deadlocked
+ * opinions to the user and asks them to make the final call.
+ *
+ * Only activates in TTY mode. Non-TTY environments fall back to
+ * the standard DEADLOCK result.
+ */
+export declare class HumanResolver {
+    isAvailable(): boolean;
+    resolve(opinions: MagiOpinion[], votes: VoteSummary): Promise<ConsensusResult>;
+    private printDeadlockBanner;
+    private printOpinionsSummary;
+    private promptUserDecision;
+    private buildResult;
+}

package/dist/src/engine/human-resolver.js

@@ -0,0 +1,89 @@
+import { createInterface } from 'node:readline/promises';
+import chalk from 'chalk';
+/**
+ * Human-in-the-loop resolver for deadlock situations.
+ *
+ * When the MAGI units cannot reach consensus, presents the deadlocked
+ * opinions to the user and asks them to make the final call.
+ *
+ * Only activates in TTY mode. Non-TTY environments fall back to
+ * the standard DEADLOCK result.
+ */
+export class HumanResolver {
+    isAvailable() {
+        return process.stdin.isTTY === true && process.stdout.isTTY === true;
+    }
+    async resolve(opinions, votes) {
+        this.printDeadlockBanner();
+        this.printOpinionsSummary(opinions);
+        const choice = await this.promptUserDecision(opinions);
+        return this.buildResult(choice, opinions, votes);
+    }
+    printDeadlockBanner() {
+        console.error('');
+        console.error(chalk.yellow.bold('  ══════════════════════════════════════'));
+        console.error(chalk.yellow.bold('   DEADLOCK — Human decision required'));
+        console.error(chalk.yellow.bold('  ══════════════════════════════════════'));
+        console.error('');
+    }
+    printOpinionsSummary(opinions) {
+        for (let i = 0; i < opinions.length; i++) {
+            const o = opinions[i];
+            const voteColor = o.vote === 'APPROVE' ? chalk.green : o.vote === 'REJECT' ? chalk.red : chalk.yellow;
+            console.error(`  [${i + 1}] ${chalk.bold(o.unit)}: ${voteColor(o.vote)} (${(o.confidence * 100).toFixed(0)}%)`);
+            console.error(chalk.gray(`      ${o.reasoning.slice(0, 120)}`));
+            if (o.keyPoints.length > 0) {
+                console.error(chalk.gray(`      Key: ${o.keyPoints.slice(0, 2).join(', ')}`));
+            }
+            console.error('');
+        }
+    }
+    async promptUserDecision(opinions) {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            const options = opinions.map((o, i) => `${i + 1}=${o.unit}`).join(', ');
+            const answer = await rl.question(chalk.cyan(`  Choose a unit's position (${options}) or A=approve / R=reject: `));
+            const trimmed = answer.trim().toUpperCase();
+            // Direct vote
+            if (trimmed === 'A' || trimmed === 'APPROVE') {
+                const reason = await rl.question(chalk.gray('  Reason (Enter to skip): '));
+                return { vote: 'APPROVE', reasoning: reason.trim() || 'Human override: approved' };
+            }
+            if (trimmed === 'R' || trimmed === 'REJECT') {
+                const reason = await rl.question(chalk.gray('  Reason (Enter to skip): '));
+                return { vote: 'REJECT', reasoning: reason.trim() || 'Human override: rejected' };
+            }
+            // Unit selection by number
+            const idx = parseInt(trimmed, 10) - 1;
+            if (idx >= 0 && idx < opinions.length) {
+                const selected = opinions[idx];
+                return { vote: selected.vote, reasoning: `Human selected ${selected.unit}'s position` };
+            }
+            // Invalid input → default to first unit
+            console.error(chalk.yellow('  Invalid input, defaulting to first unit\'s position.'));
+            const first = opinions[0];
+            return { vote: first.vote, reasoning: `Human defaulted to ${first.unit}'s position` };
+        }
+        finally {
+            rl.close();
+        }
+    }
+    buildResult(choice, opinions, votes) {
+        const decision = choice.vote === 'APPROVE' ? 'MAJORITY_APPROVE' : 'MAJORITY_REJECT';
+        const confidences = opinions.map((o) => o.confidence);
+        const avgConfidence = confidences.length > 0
+            ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length
+            : 0;
+        const dissent = opinions
+            .filter((o) => o.vote !== choice.vote && o.vote !== 'ABSTAIN')
+            .map((o) => ({ unit: o.unit, vote: o.vote, reasoning: o.reasoning }));
+        return {
+            decision,
+            method: 'human',
+            votes,
+            confidence: avgConfidence,
+            summary: `MAGI DECISION: ${decision.replace(/_/g, ' ')} (via HUMAN)\n${choice.reasoning}`,
+            dissent: dissent.length > 0 ? dissent : undefined,
+        };
+    }
+}

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

@@ -0,0 +1,64 @@
+/**
+ * A-05 補完計画 (Instrumentality) — Deadlock Fusion Engine
+ *
+ * When deliberation reaches a deadlock after 3+ rounds, this engine
+ * fuses all unit opinions into a single synthesized assessment.
+ *
+ * The fusion process:
+ * 1. Detect deadlock conditions (shouldTrigger)
+ * 2. Build a weighted fusion prompt from all opinions
+ * 3. Execute via the primary adapter (MELCHIOR)
+ * 4. Parse and validate the fused opinion
+ * 5. Apply confidence discount (0.85x) since the opinion is derived
+ *
+ * Emits: 'instrumentality:triggered', 'fusion:complete'
+ */
+import type { MagiTask, MagiOpinion, DeliberationRound } from '../types/core.js';
+import type { FusionWeights, InstrumentalityResult } from '../types/phase-i.js';
+import type { MagiEventBus } from './events.js';
+import type { AdapterRegistry } from '../adapters/registry.js';
+export declare class InstrumentalityEngine {
+    private readonly adapters;
+    private readonly eventBus;
+    constructor(adapters: AdapterRegistry, eventBus?: MagiEventBus);
+    /**
+     * Determine whether Instrumentality should trigger.
+     *
+     * Conditions:
+     * - consensusDecision is 'DEADLOCK'
+     * - At least MIN_ROUNDS_FOR_TRIGGER rounds have been completed
+     */
+    shouldTrigger(rounds: DeliberationRound[], consensusDecision: string): boolean;
+    /**
+     * Fuse multiple unit opinions into a single synthesized opinion.
+     *
+     * Steps:
+     * 1. Build effective weights (defaults + custom overrides)
+     * 2. Construct the fusion prompt
+     * 3. Execute via MELCHIOR (first registered adapter)
+     * 4. Parse and validate the response
+     * 5. Apply confidence discount and return FusedOpinion
+     */
+    fuse(opinions: MagiOpinion[], task: MagiTask, weights?: FusionWeights): Promise<InstrumentalityResult>;
+    /**
+     * Build a structured fusion prompt from all opinions.
+     * Each opinion is presented as a section with its assigned weight.
+     */
+    buildFusionPrompt(opinions: MagiOpinion[], task: MagiTask, weights: FusionWeights): string;
+    /**
+     * Estimate the token cost of a fusion operation.
+     * Includes the prompt construction + expected output.
+     */
+    estimateTokenCost(opinions: MagiOpinion[], task: MagiTask): number;
+    /**
+     * Build effective fusion weights.
+     * Uses defaults for known units (MELCHIOR, BALTHASAR, CASPER).
+     * Unknown units receive equal weight distributed from remaining allocation.
+     */
+    private buildEffectiveWeights;
+    /**
+     * Parse the adapter response into a validated opinion payload.
+     * Tries structured output first, then JSON extraction from raw text.
+     */
+    private parseResponse;
+}