magi-ai 0.1.0

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

@@ -0,0 +1,225 @@
+/**
+ * DriftDetector — ASI (Absolute Synchronization Index) ドリフト検知 (A-01)
+ *
+ * 12次元BehaviorVectorを計算し、各MAGIユニットの行動パターンの
+ * 安定性を追跡する。直近ウィンドウ(50件)の平均ベクトルとの距離を
+ * ASI (0-1) として計算し、閾値以下が3連続でドリフト警告を発火する。
+ */
+import { tokenize } from './engram-manager.js';
+// ── Constants ────────────────────────────────────────────────
+const WINDOW_SIZE = 50;
+const DEFAULT_ASI_THRESHOLD = 0.75;
+const CONSECUTIVE_DRIFT_LIMIT = 3;
+const VECTOR_DIMENSIONS = 12;
+// ── Vector helpers ───────────────────────────────────────────
+function defaultVector() {
+    return {
+        approveRate: 0,
+        rejectRate: 0,
+        abstainRate: 0,
+        avgConfidence: 0,
+        avgKeyPointCount: 0,
+        avgReasoningLength: 0,
+        agreementRate: 0,
+        dissenterRate: 0,
+        responseTimeNorm: 0,
+        vocabularyDiversity: 0,
+        sentimentPolarity: 0,
+        detailLevel: 0,
+    };
+}
+function vectorToArray(v) {
+    return [
+        v.approveRate, v.rejectRate, v.abstainRate,
+        v.avgConfidence, v.avgKeyPointCount, v.avgReasoningLength,
+        v.agreementRate, v.dissenterRate, v.responseTimeNorm,
+        v.vocabularyDiversity, v.sentimentPolarity, v.detailLevel,
+    ];
+}
+function euclideanDistance(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = (a[i] ?? 0) - (b[i] ?? 0);
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}
+/** Normalize distance to 0-1 range using max possible distance in unit hypercube */
+function normalizeDistance(dist) {
+    // Max distance in 12-dimensional unit hypercube = sqrt(12) ≈ 3.46
+    const maxDist = Math.sqrt(VECTOR_DIMENSIONS);
+    return Math.max(0, Math.min(1, 1 - dist / maxDist));
+}
+// ── DriftDetector ────────────────────────────────────────────
+export class DriftDetector {
+    snapshots = new Map();
+    profiles = new Map();
+    consecutiveDrifts = new Map();
+    threshold;
+    constructor(threshold = DEFAULT_ASI_THRESHOLD) {
+        this.threshold = threshold;
+    }
+    /**
+     * Update behavior data for a unit after a deliberation.
+     * Call for each unit's opinion in the final round.
+     */
+    updateVector(unit, opinion, consensusDecision) {
+        const snapList = this.snapshots.get(unit) ?? [];
+        // Compute vocabulary diversity
+        const tokens = tokenize(opinion.reasoning);
+        const unique = new Set(tokens);
+        const vocabDiv = tokens.length > 0 ? unique.size / tokens.length : 0;
+        // Simple sentiment: count positive/negative signal words
+        const sentiment = this.estimateSentiment(opinion.reasoning);
+        // Detail level: keyPoints * reasoning length normalized
+        const detail = Math.min(1, (opinion.keyPoints.length * opinion.reasoning.length) / 5000);
+        const agreedWithConsensus = consensusDecision.includes(opinion.vote) ||
+            (opinion.vote === 'APPROVE' && consensusDecision.includes('APPROVE')) ||
+            (opinion.vote === 'REJECT' && consensusDecision.includes('REJECT'));
+        snapList.push({
+            vote: opinion.vote,
+            confidence: opinion.confidence,
+            keyPointCount: opinion.keyPoints.length,
+            reasoningLength: opinion.reasoning.length,
+            agreedWithConsensus,
+            responseTimeMs: opinion.meta.durationMs,
+            vocabularyDiversity: vocabDiv,
+            sentimentPolarity: sentiment,
+            detailLevel: detail,
+        });
+        // Trim to window size
+        if (snapList.length > WINDOW_SIZE) {
+            snapList.splice(0, snapList.length - WINDOW_SIZE);
+        }
+        this.snapshots.set(unit, snapList);
+        // Recompute profile
+        this.recomputeProfile(unit);
+    }
+    /**
+     * Compute ASI (Absolute Synchronization Index) for a unit.
+     * Returns 0-1 where 1 = perfectly stable, 0 = completely drifted.
+     */
+    computeASI(unit) {
+        const profile = this.profiles.get(unit);
+        if (!profile || profile.sampleCount < 5) {
+            return 1.0; // Insufficient data → assume stable
+        }
+        const snapList = this.snapshots.get(unit);
+        if (!snapList || snapList.length < 5) {
+            return 1.0;
+        }
+        // Compute current vector from most recent subset (last 10 or all if < 10)
+        const recentCount = Math.min(10, snapList.length);
+        const recent = snapList.slice(-recentCount);
+        const recentVector = this.computeVectorFromSnapshots(recent);
+        // Distance between overall profile and recent behavior
+        const profileArr = vectorToArray(profile.vector);
+        const recentArr = vectorToArray(recentVector);
+        const dist = euclideanDistance(profileArr, recentArr);
+        return normalizeDistance(dist);
+    }
+    /**
+     * Check for drift and emit warning if threshold breached.
+     * Returns true if drift warning was emitted.
+     */
+    checkDrift(unit, eventBus) {
+        const asi = this.computeASI(unit);
+        const driftCount = this.consecutiveDrifts.get(unit) ?? 0;
+        if (asi < this.threshold) {
+            const newCount = driftCount + 1;
+            this.consecutiveDrifts.set(unit, newCount);
+            if (newCount >= CONSECUTIVE_DRIFT_LIMIT) {
+                eventBus?.emit('memory:drift-warning', {
+                    unit,
+                    asiScore: asi,
+                    threshold: this.threshold,
+                    consecutiveCount: newCount,
+                    emittedAt: new Date(),
+                });
+                return true;
+            }
+        }
+        else {
+            // Reset consecutive counter on non-drift
+            this.consecutiveDrifts.set(unit, 0);
+        }
+        return false;
+    }
+    /** Get the current profile for a unit */
+    getProfile(unit) {
+        return this.profiles.get(unit);
+    }
+    /** Get consecutive drift count for a unit */
+    getConsecutiveDrifts(unit) {
+        return this.consecutiveDrifts.get(unit) ?? 0;
+    }
+    // ── Private ────────────────────────────────────────────────
+    recomputeProfile(unit) {
+        const snapList = this.snapshots.get(unit);
+        if (!snapList || snapList.length === 0)
+            return;
+        const vector = this.computeVectorFromSnapshots(snapList);
+        this.profiles.set(unit, {
+            unit,
+            vector,
+            sampleCount: snapList.length,
+            windowSize: WINDOW_SIZE,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    computeVectorFromSnapshots(snaps) {
+        const n = snaps.length;
+        if (n === 0)
+            return defaultVector();
+        let approve = 0, reject = 0, abstain = 0;
+        let totalConf = 0, totalKP = 0, totalRL = 0;
+        let totalAgreed = 0, totalDissent = 0;
+        let totalRT = 0, totalVD = 0, totalSP = 0, totalDL = 0;
+        let maxRT = 1;
+        for (const s of snaps) {
+            if (s.vote === 'APPROVE')
+                approve++;
+            else if (s.vote === 'REJECT')
+                reject++;
+            else
+                abstain++;
+            totalConf += s.confidence;
+            totalKP += s.keyPointCount;
+            totalRL += s.reasoningLength;
+            if (s.agreedWithConsensus)
+                totalAgreed++;
+            else
+                totalDissent++;
+            totalRT += s.responseTimeMs;
+            if (s.responseTimeMs > maxRT)
+                maxRT = s.responseTimeMs;
+            totalVD += s.vocabularyDiversity;
+            totalSP += s.sentimentPolarity;
+            totalDL += s.detailLevel;
+        }
+        return {
+            approveRate: approve / n,
+            rejectRate: reject / n,
+            abstainRate: abstain / n,
+            avgConfidence: totalConf / n,
+            avgKeyPointCount: Math.min(1, (totalKP / n) / 10), // normalize to 0-1
+            avgReasoningLength: Math.min(1, (totalRL / n) / 2000), // normalize to 0-1
+            agreementRate: totalAgreed / n,
+            dissenterRate: totalDissent / n,
+            responseTimeNorm: (totalRT / n) / maxRT, // relative to max
+            vocabularyDiversity: totalVD / n,
+            sentimentPolarity: totalSP / n,
+            detailLevel: totalDL / n,
+        };
+    }
+    estimateSentiment(text) {
+        const positive = /\b(good|great|excellent|correct|safe|secure|efficient|clean|clear|well|approve|benefit|advantage)\b/gi;
+        const negative = /\b(bad|poor|wrong|unsafe|insecure|slow|messy|unclear|reject|risk|danger|vulnerability|issue|problem)\b/gi;
+        const posCount = (text.match(positive) ?? []).length;
+        const negCount = (text.match(negative) ?? []).length;
+        const total = posCount + negCount;
+        if (total === 0)
+            return 0;
+        return (posCount - negCount) / total; // -1 to 1
+    }
+}

package/dist/src/engine/dummy-plug.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A-06 ダミープラグ (DummyPlugSystem)
+ *
+ * ダウンしたユニットの代替意見を行動プロファイルから生成する。
+ * 各ユニットの投票パターン、平均confidence、頻出keyPointsを追跡し、
+ * 統計的に尤もらしい代替意見を生成する。
+ *
+ * 安全装置:
+ * - confidence上限0.5
+ * - 3サンプル未満は生成拒否
+ * - UNANIMOUS判定から除外可能
+ * - [DUMMY PLUG]フラグ明示
+ */
+import type { MagiUnit, MagiOpinion } from '../types/core.js';
+import type { DummyPlugOpinion, UnitProfile, RecoveryProtocolResult } from '../types/phase-h.js';
+import type { SyncRateTracker } from './sync-rate.js';
+export declare class DummyPlugSystem {
+    private readonly syncRateTracker?;
+    private profiles;
+    constructor(syncRateTracker?: SyncRateTracker | undefined);
+    /**
+     * Record a real opinion to build behavior profile.
+     * Should NOT be called for dummy plug opinions.
+     */
+    recordOpinion(opinion: MagiOpinion, domain?: string): void;
+    /**
+     * Generate a proxy opinion for a down unit.
+     * Returns null if insufficient profile data (< 3 samples).
+     */
+    generateProxy(downUnit: MagiUnit, _activeUnits: MagiUnit[], currentOpinions: MagiOpinion[], domain?: string): DummyPlugOpinion | null;
+    /**
+     * Build a recovery brief for a unit that's come back online.
+     * Summarizes what happened during the rounds it missed.
+     */
+    buildRecoveryBrief(unit: MagiUnit, missedRounds: number): RecoveryProtocolResult;
+    /** Get profile for a unit */
+    getProfile(unit: MagiUnit): UnitProfile | undefined;
+    /** Get units that should be excluded from UNANIMOUS judgment */
+    getDummyUnits(opinions: MagiOpinion[]): MagiUnit[];
+    private pickMostLikelyVote;
+    private generateReasoning;
+    private pickKeyPoints;
+    private getOrCreateProfile;
+}

package/dist/src/engine/dummy-plug.js

@@ -0,0 +1,190 @@
+/**
+ * A-06 ダミープラグ (DummyPlugSystem)
+ *
+ * ダウンしたユニットの代替意見を行動プロファイルから生成する。
+ * 各ユニットの投票パターン、平均confidence、頻出keyPointsを追跡し、
+ * 統計的に尤もらしい代替意見を生成する。
+ *
+ * 安全装置:
+ * - confidence上限0.5
+ * - 3サンプル未満は生成拒否
+ * - UNANIMOUS判定から除外可能
+ * - [DUMMY PLUG]フラグ明示
+ */
+/** Minimum samples required to generate a proxy opinion */
+const MIN_PROFILE_SAMPLES = 3;
+/** Maximum confidence for dummy plug opinions */
+const MAX_DUMMY_CONFIDENCE = 0.5;
+export class DummyPlugSystem {
+    syncRateTracker;
+    profiles = new Map();
+    constructor(syncRateTracker) {
+        this.syncRateTracker = syncRateTracker;
+    }
+    /**
+     * Record a real opinion to build behavior profile.
+     * Should NOT be called for dummy plug opinions.
+     */
+    recordOpinion(opinion, domain) {
+        const profile = this.getOrCreateProfile(opinion.unit);
+        const d = domain ?? '_global';
+        // Update global vote distribution
+        profile.voteDistribution[opinion.vote] =
+            (profile.voteDistribution[opinion.vote] ?? 0) + 1;
+        // Update running average confidence
+        const prevTotal = profile.averageConfidence * profile.sampleCount;
+        profile.sampleCount++;
+        profile.averageConfidence = (prevTotal + opinion.confidence) / profile.sampleCount;
+        // Track frequent key points (keep top 20)
+        for (const kp of opinion.keyPoints) {
+            if (!profile.frequentKeyPoints.includes(kp)) {
+                profile.frequentKeyPoints.push(kp);
+            }
+        }
+        if (profile.frequentKeyPoints.length > 20) {
+            profile.frequentKeyPoints = profile.frequentKeyPoints.slice(-20);
+        }
+        // Update domain-specific profile
+        if (!profile.domainProfiles[d]) {
+            profile.domainProfiles[d] = {
+                voteDistribution: { APPROVE: 0, REJECT: 0, ABSTAIN: 0 },
+                averageConfidence: 0,
+            };
+        }
+        const dp = profile.domainProfiles[d];
+        dp.voteDistribution[opinion.vote] =
+            (dp.voteDistribution[opinion.vote] ?? 0) + 1;
+        // Domain-specific average confidence (simplified running avg)
+        const domainTotal = Object.values(dp.voteDistribution).reduce((a, b) => a + b, 0);
+        dp.averageConfidence =
+            ((dp.averageConfidence * (domainTotal - 1)) + opinion.confidence) / domainTotal;
+    }
+    /**
+     * Generate a proxy opinion for a down unit.
+     * Returns null if insufficient profile data (< 3 samples).
+     */
+    generateProxy(downUnit, _activeUnits, currentOpinions, domain) {
+        const profile = this.profiles.get(downUnit);
+        if (!profile || profile.sampleCount < MIN_PROFILE_SAMPLES) {
+            return null;
+        }
+        const d = domain ?? '_global';
+        const domainProfile = profile.domainProfiles[d];
+        const voteDist = domainProfile?.voteDistribution ?? profile.voteDistribution;
+        // Pick the most likely vote
+        const vote = this.pickMostLikelyVote(voteDist);
+        // Calculate confidence: capped at MAX_DUMMY_CONFIDENCE, further reduced by sync rate
+        let confidence = Math.min(domainProfile?.averageConfidence ?? profile.averageConfidence, MAX_DUMMY_CONFIDENCE);
+        // Apply sync rate decay if available
+        if (this.syncRateTracker) {
+            const syncRate = this.syncRateTracker.getRate(downUnit, domain);
+            confidence *= syncRate;
+        }
+        // Clamp confidence
+        confidence = Math.max(0.05, Math.min(confidence, MAX_DUMMY_CONFIDENCE));
+        // Generate reasoning from profile
+        const reasoning = this.generateReasoning(downUnit, vote, profile, currentOpinions);
+        // Pick representative key points from profile
+        const keyPoints = this.pickKeyPoints(profile, 3);
+        return {
+            unit: downUnit,
+            vote,
+            confidence,
+            reasoning,
+            keyPoints: ['[DUMMY PLUG] 代替意見', ...keyPoints],
+            rawOutput: '',
+            meta: {
+                durationMs: 0,
+                exitCode: 0,
+                retryCount: 0,
+                structuredOutput: false,
+            },
+            isDummyPlug: true,
+            sourceUnit: downUnit,
+            profileSamples: profile.sampleCount,
+        };
+    }
+    /**
+     * Build a recovery brief for a unit that's come back online.
+     * Summarizes what happened during the rounds it missed.
+     */
+    buildRecoveryBrief(unit, missedRounds) {
+        const profile = this.profiles.get(unit);
+        const lines = [
+            `[RECOVERY PROTOCOL] ${unit} 復帰ブリーフ`,
+            `欠席ラウンド数: ${missedRounds}`,
+            ``,
+        ];
+        if (profile && profile.sampleCount > 0) {
+            const dist = profile.voteDistribution;
+            const total = Object.values(dist).reduce((a, b) => a + b, 0);
+            lines.push(`行動プロファイル (${total}サンプル):`);
+            lines.push(`  APPROVE: ${((dist.APPROVE / total) * 100).toFixed(0)}%`);
+            lines.push(`  REJECT: ${((dist.REJECT / total) * 100).toFixed(0)}%`);
+            lines.push(`  ABSTAIN: ${((dist.ABSTAIN / total) * 100).toFixed(0)}%`);
+            lines.push(`  平均確信度: ${(profile.averageConfidence * 100).toFixed(1)}%`);
+        }
+        else {
+            lines.push('行動プロファイル: データ不足');
+        }
+        return {
+            unit,
+            missedRounds,
+            brief: lines.join('\n'),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /** Get profile for a unit */
+    getProfile(unit) {
+        return this.profiles.get(unit);
+    }
+    /** Get units that should be excluded from UNANIMOUS judgment */
+    getDummyUnits(opinions) {
+        return opinions
+            .filter(o => 'isDummyPlug' in o && o.isDummyPlug)
+            .map(o => o.unit);
+    }
+    pickMostLikelyVote(dist) {
+        let maxVote = 'ABSTAIN';
+        let maxCount = 0;
+        for (const [vote, count] of Object.entries(dist)) {
+            if (count > maxCount) {
+                maxVote = vote;
+                maxCount = count;
+            }
+        }
+        return maxVote;
+    }
+    generateReasoning(unit, vote, profile, currentOpinions) {
+        const lines = [
+            `[DUMMY PLUG] ${unit}の行動プロファイルに基づく代替意見`,
+            `投票: ${vote} (過去${profile.sampleCount}回の審議パターンから推定)`,
+        ];
+        if (currentOpinions.length > 0) {
+            const otherVotes = currentOpinions.map(o => `${o.unit}: ${o.vote}`).join(', ');
+            lines.push(`他ユニットの投票: ${otherVotes}`);
+        }
+        return lines.join('\n');
+    }
+    pickKeyPoints(profile, count) {
+        if (profile.frequentKeyPoints.length === 0) {
+            return ['プロファイルベースの推定意見'];
+        }
+        // Pick the most recent key points
+        return profile.frequentKeyPoints.slice(-count);
+    }
+    getOrCreateProfile(unit) {
+        let profile = this.profiles.get(unit);
+        if (!profile) {
+            profile = {
+                voteDistribution: { APPROVE: 0, REJECT: 0, ABSTAIN: 0 },
+                averageConfidence: 0,
+                frequentKeyPoints: [],
+                domainProfiles: {},
+                sampleCount: 0,
+            };
+            this.profiles.set(unit, profile);
+        }
+        return profile;
+    }
+}

package/dist/src/engine/engram-manager.d.ts

@@ -0,0 +1,55 @@
+/**
+ * EngramManager — 記憶・人格モジュール (A-01)
+ *
+ * MAGIシステムの長期記憶。過去の審議をエピソード記憶として保存し、
+ * TF-IDFベースの類似検索で関連する過去審議を検索する。
+ * 50件ごとに自動でセマンティック圧縮を行い、
+ * 手続き的戦略(どのタスクタイプでどの戦略が有効か)を蓄積する。
+ */
+import type { MagiDeliberation } from '../types/core.js';
+import type { EpisodicMemory, SemanticPattern, ProceduralStrategy, ISimilarityEngine } from '../types/phase-i.js';
+import type { MagiEventBus } from './events.js';
+/**
+ * Tokenize text for TF-IDF: English space-split + Japanese bi-gram.
+ * Simple but effective for mixed-language deliberation content.
+ */
+export declare function tokenize(text: string): string[];
+/** Cosine similarity between two TF-IDF vectors */
+export declare function cosineSimilarity(a: Map<string, number>, b: Map<string, number>): number;
+/** Built-in TF-IDF similarity engine */
+export declare class TfIdfEngine implements ISimilarityEngine {
+    computeSimilarity(query: string, documents: string[]): number[];
+}
+export declare class EngramManager {
+    private episodic;
+    private semantic;
+    private procedural;
+    private readonly baseDir;
+    private readonly engine;
+    private eventBus?;
+    private episodicSinceConsolidation;
+    constructor(workspaceDir: string, eventBus?: MagiEventBus, engine?: ISimilarityEngine);
+    /** Record a completed deliberation as episodic memory (fire-and-forget safe) */
+    recordDeliberation(delib: MagiDeliberation): Promise<void>;
+    /** Find similar past deliberations using TF-IDF cosine similarity */
+    findSimilar(taskDescription: string, limit?: number): EpisodicMemory[];
+    /**
+     * Consolidate episodic memories → semantic patterns + procedural strategies.
+     * Rule-based extraction (no AI call needed).
+     */
+    consolidate(): Promise<void>;
+    /** Load all memory from disk */
+    load(): Promise<void>;
+    /** Persist all memory to disk */
+    persist(): Promise<void>;
+    private persistEpisodic;
+    private loadEpisodic;
+    private persistSemantic;
+    private loadSemantic;
+    private persistProcedural;
+    private loadProcedural;
+    getEpisodicMemories(): readonly EpisodicMemory[];
+    getSemanticPatterns(): readonly SemanticPattern[];
+    getProceduralStrategies(): readonly ProceduralStrategy[];
+    getEpisodicSinceConsolidation(): number;
+}