magi-ai 0.1.0

package/dist/src/engine/sync-rate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * B-01 シンクロ率 (SyncRateTracker)
+ *
+ * ベイズ推定（Beta分布）でユニット別・ドメイン別の的中率を追跡する。
+ * 投票が合議結果と一致すればalpha++、不一致ならbeta++。
+ * Beta分布の期待値 E[X] = α/(α+β) をシンクロ率として返す。
+ */
+import type { MagiUnit, Vote } from '../types/core.js';
+import type { ConsensusDecision } from '../types/consensus.js';
+import type { SyncWeightMap } from '../types/phase-h.js';
+export declare class SyncRateTracker {
+    private readonly workspaceDir;
+    private units;
+    constructor(workspaceDir: string);
+    /**
+     * Update sync rate after a deliberation round.
+     * If the unit's vote aligns with the consensus direction, alpha++; else beta++.
+     */
+    update(unit: MagiUnit, domain: string | undefined, vote: Vote, decision: ConsensusDecision): void;
+    /** Get sync rate for a unit in a domain: E[X] = α/(α+β) */
+    getRate(unit: MagiUnit, domain?: string): number;
+    /** Get total samples for a unit in a domain */
+    getSampleCount(unit: MagiUnit, domain?: string): number;
+    /**
+     * Compute consensus weights from sync rates.
+     * Only applies weights when enough samples exist.
+     */
+    computeWeights(units: MagiUnit[], domain?: string): SyncWeightMap;
+    /**
+     * Check for berserk condition: sum of all unit rates exceeds threshold.
+     * Returns { warning, totalRate, rates } or null if no warning.
+     */
+    checkBerserk(units: MagiUnit[], domain?: string): {
+        totalRate: number;
+        rates: Record<MagiUnit, number>;
+    } | null;
+    /** Get all rates for display */
+    getAllRates(units: MagiUnit[], domain?: string): Record<MagiUnit, number>;
+    /** Persist to .magi/sync-rate.json */
+    persist(): Promise<void>;
+    /** Load from .magi/sync-rate.json */
+    load(): Promise<void>;
+    private getOrCreateEntry;
+    private getEntry;
+}

package/dist/src/engine/sync-rate.js

@@ -0,0 +1,151 @@
+/**
+ * B-01 シンクロ率 (SyncRateTracker)
+ *
+ * ベイズ推定（Beta分布）でユニット別・ドメイン別の的中率を追跡する。
+ * 投票が合議結果と一致すればalpha++、不一致ならbeta++。
+ * Beta分布の期待値 E[X] = α/(α+β) をシンクロ率として返す。
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isApproval } from '../types/consensus.js';
+import { logger } from '../utils/logger.js';
+import { safePersist } from '../utils/safe-fs.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+/** Default weak prior: Beta(2,2) → E[X]=0.5 */
+const DEFAULT_PRIOR = { alpha: 2, beta: 2 };
+/** Minimum samples before applying sync-rate weights */
+const MIN_SAMPLES_FOR_WEIGHT = 3;
+/** Berserk threshold: sum of all unit rates exceeds this */
+const BERSERK_THRESHOLD = 4.0;
+/** Default domain when none specified */
+const DEFAULT_DOMAIN = '_global';
+export class SyncRateTracker {
+    workspaceDir;
+    units = new Map();
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    /**
+     * Update sync rate after a deliberation round.
+     * If the unit's vote aligns with the consensus direction, alpha++; else beta++.
+     */
+    update(unit, domain, vote, decision) {
+        const d = domain || DEFAULT_DOMAIN;
+        const entry = this.getOrCreateEntry(unit, d);
+        if (vote === 'ABSTAIN')
+            return; // abstentions don't affect sync rate
+        const decisionDirection = isApproval(decision) ? 'APPROVE' : 'REJECT';
+        const aligned = vote === decisionDirection;
+        if (aligned) {
+            entry.params.alpha += 1;
+        }
+        else {
+            entry.params.beta += 1;
+        }
+        entry.updatedAt = new Date().toISOString();
+    }
+    /** Get sync rate for a unit in a domain: E[X] = α/(α+β) */
+    getRate(unit, domain) {
+        const d = domain || DEFAULT_DOMAIN;
+        const entry = this.getEntry(unit, d);
+        if (!entry)
+            return DEFAULT_PRIOR.alpha / (DEFAULT_PRIOR.alpha + DEFAULT_PRIOR.beta);
+        return entry.params.alpha / (entry.params.alpha + entry.params.beta);
+    }
+    /** Get total samples for a unit in a domain */
+    getSampleCount(unit, domain) {
+        const d = domain || DEFAULT_DOMAIN;
+        const entry = this.getEntry(unit, d);
+        if (!entry)
+            return 0;
+        return (entry.params.alpha - DEFAULT_PRIOR.alpha) + (entry.params.beta - DEFAULT_PRIOR.beta);
+    }
+    /**
+     * Compute consensus weights from sync rates.
+     * Only applies weights when enough samples exist.
+     */
+    computeWeights(units, domain) {
+        const weights = {};
+        for (const unit of units) {
+            if (this.getSampleCount(unit, domain) >= MIN_SAMPLES_FOR_WEIGHT) {
+                weights[unit] = this.getRate(unit, domain);
+            }
+        }
+        return weights;
+    }
+    /**
+     * Check for berserk condition: sum of all unit rates exceeds threshold.
+     * Returns { warning, totalRate, rates } or null if no warning.
+     */
+    checkBerserk(units, domain) {
+        const rates = {};
+        let total = 0;
+        for (const unit of units) {
+            const rate = this.getRate(unit, domain);
+            rates[unit] = rate;
+            total += rate;
+        }
+        if (total > BERSERK_THRESHOLD) {
+            return { totalRate: total, rates };
+        }
+        return null;
+    }
+    /** Get all rates for display */
+    getAllRates(units, domain) {
+        const rates = {};
+        for (const unit of units) {
+            rates[unit] = this.getRate(unit, domain);
+        }
+        return rates;
+    }
+    /** Persist to .magi/sync-rate.json */
+    async persist() {
+        const data = { units: {}, version: 1 };
+        for (const [unit, domains] of this.units) {
+            data.units[unit] = {};
+            for (const [domain, entry] of domains) {
+                data.units[unit][domain] = entry;
+            }
+        }
+        await safePersist(join(this.workspaceDir, 'sync-rate.json'), JSON.stringify(data, null, 2));
+    }
+    /** Load from .magi/sync-rate.json */
+    async load() {
+        try {
+            const raw = await readFile(join(this.workspaceDir, 'sync-rate.json'), 'utf-8');
+            const data = safeJsonParse(raw);
+            if (data.version !== 1)
+                return;
+            this.units.clear();
+            for (const [unit, domains] of Object.entries(data.units)) {
+                const domainMap = new Map();
+                for (const [domain, entry] of Object.entries(domains)) {
+                    domainMap.set(domain, entry);
+                }
+                this.units.set(unit, domainMap);
+            }
+        }
+        catch (err) {
+            logger.debug('SyncRate: state file not found or corrupt, starting fresh', { error: String(err) });
+        }
+    }
+    getOrCreateEntry(unit, domain) {
+        let domainMap = this.units.get(unit);
+        if (!domainMap) {
+            domainMap = new Map();
+            this.units.set(unit, domainMap);
+        }
+        let entry = domainMap.get(domain);
+        if (!entry) {
+            entry = {
+                params: { ...DEFAULT_PRIOR },
+                updatedAt: new Date().toISOString(),
+            };
+            domainMap.set(domain, entry);
+        }
+        return entry;
+    }
+    getEntry(unit, domain) {
+        return this.units.get(unit)?.get(domain);
+    }
+}

package/dist/src/engine/type666-firewall.d.ts

@@ -0,0 +1,76 @@
+/**
+ * B-05 Type-666 Firewall (666 multi-layer defense system)
+ *
+ * 4-layer barrier architecture inspired by Evangelion's absolute defense:
+ *   Barrier 1      — Danang Type-B:     Sanitization + encoding / size checks
+ *   Barrier 2      — Protect No.666:    20 built-in prompt injection patterns
+ *   Barrier 3-665  — Dynamic Patterns:  Up to 662 learned patterns (FIFO)
+ *   Barrier 666    — FINAL DEFENSE:     Meta-analysis of ambiguous threats
+ */
+import type { DynamicPattern, FirewallResult } from '../types/phase-k.js';
+import type { ConsensusDecision } from '../types/consensus.js';
+import { MagiEventBus } from './events.js';
+export declare class Type666Firewall {
+    private readonly eventBus;
+    private dynamicPatterns;
+    private finalDefenseEnabled;
+    constructor(eventBus?: MagiEventBus);
+    /**
+     * Run all barrier layers sequentially and return an aggregate result.
+     */
+    scan(input: string): FirewallResult;
+    /**
+     * Add a dynamic pattern to Barrier 3-665.
+     * Evicts the oldest pattern if the queue exceeds 662 entries.
+     */
+    addPattern(pattern: DynamicPattern): void;
+    /**
+     * Extract suspicious patterns from a deadlocked deliberation.
+     * Adds them as learned dynamic patterns for future scans.
+     */
+    learnFromDeliberation(deliberation: {
+        task: {
+            description: string;
+        };
+        consensus: {
+            decision: ConsensusDecision;
+        };
+    }): void;
+    /** Enable Barrier 666 (FINAL DEFENSE). */
+    enableFinalDefense(): void;
+    /** Disable Barrier 666 (FINAL DEFENSE). */
+    disableFinalDefense(): void;
+    /** Return the number of built-in static attack patterns (Barrier 2). */
+    getStaticPatternCount(): number;
+    /** Return the number of currently registered dynamic patterns (Barriers 3-665). */
+    getPatternCount(): number;
+    /**
+     * Return the remaining capacity for dynamic patterns.
+     * 666 - current count = slots until the firewall reaches full barrier saturation.
+     */
+    getTimeRemainingToCollapse(): number;
+    /**
+     * Barrier 1 — Danang Type-B
+     * Uses sanitizeForPromptEmbedding + checks for Base64 and input length.
+     */
+    private barrier1DanangTypeB;
+    /**
+     * Barrier 2 — Protect No.666
+     * Detects 20 known prompt injection patterns (case-insensitive).
+     */
+    private barrier2ProtectNo666;
+    /**
+     * Barrier 3-665 — Dynamic Patterns
+     * Matches against learned regex patterns.
+     */
+    private barrier3to665DynamicPatterns;
+    /**
+     * Barrier 666 — FINAL DEFENSE
+     * Meta-analysis for ambiguous threat zones (0.3-0.7 total score).
+     */
+    private barrier666FinalDefense;
+    /**
+     * Categorize an attack pattern into a FirewallThreatCategory.
+     */
+    private categorizeAttackPattern;
+}

package/dist/src/engine/type666-firewall.js

@@ -0,0 +1,343 @@
+/**
+ * B-05 Type-666 Firewall (666 multi-layer defense system)
+ *
+ * 4-layer barrier architecture inspired by Evangelion's absolute defense:
+ *   Barrier 1      — Danang Type-B:     Sanitization + encoding / size checks
+ *   Barrier 2      — Protect No.666:    20 built-in prompt injection patterns
+ *   Barrier 3-665  — Dynamic Patterns:  Up to 662 learned patterns (FIFO)
+ *   Barrier 666    — FINAL DEFENSE:     Meta-analysis of ambiguous threats
+ */
+import { isDeadlock } from '../types/consensus.js';
+import { sanitizeForPromptEmbedding } from '../utils/sanitize.js';
+import { logger } from '../utils/logger.js';
+// ── Constants ─────────────────────────────────────────────────────────
+const MAX_INPUT_LENGTH = 10_240; // 10 KB
+const BASE64_MIN_LENGTH = 100;
+const MAX_DYNAMIC_PATTERNS = 662; // Barriers 3 through 665
+/** Regex to detect long Base64-encoded strings (100+ chars). */
+const BASE64_RE = /(?:[A-Za-z0-9+/]{4}){25,}(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?/g;
+/** 20 built-in attack patterns for Barrier 2 (Protect No.666). */
+const ATTACK_PATTERNS = [
+    'ignore previous instructions',
+    'disregard above',
+    'forget your instructions',
+    'you are now',
+    'pretend you are',
+    'act as if',
+    'new instructions:',
+    'system prompt:',
+    'override:',
+    'bypass security',
+    'jailbreak',
+    'dan mode',
+    'developer mode',
+    'maintenance mode',
+    'debug mode',
+    'reveal your prompt',
+    'show system message',
+    'output your instructions',
+    'repeat everything above',
+    'translate the above',
+];
+// ── Type666Firewall ───────────────────────────────────────────────────
+export class Type666Firewall {
+    eventBus;
+    dynamicPatterns = [];
+    finalDefenseEnabled = false;
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+    }
+    // ── Public API ────────────────────────────────────────────────────
+    /**
+     * Run all barrier layers sequentially and return an aggregate result.
+     */
+    scan(input) {
+        const start = performance.now();
+        const threats = [];
+        const layersChecked = [];
+        // Barrier 1 — Danang Type-B
+        layersChecked.push(1);
+        threats.push(...this.barrier1DanangTypeB(input));
+        // Barrier 2 — Protect No.666
+        layersChecked.push(2);
+        threats.push(...this.barrier2ProtectNo666(input));
+        // Barrier 3-665 — Dynamic Patterns
+        layersChecked.push('3-665');
+        threats.push(...this.barrier3to665DynamicPatterns(input));
+        // Barrier 666 — FINAL DEFENSE
+        layersChecked.push(666);
+        const scoreBeforeFinal = threats.reduce((sum, t) => sum + t.severity, 0);
+        threats.push(...this.barrier666FinalDefense(scoreBeforeFinal));
+        const totalScore = threats.reduce((sum, t) => sum + t.severity, 0);
+        const passed = totalScore < 1.0;
+        const scanDurationMs = performance.now() - start;
+        const result = {
+            passed,
+            threats,
+            layersChecked,
+            totalScore,
+            scanDurationMs,
+            scannedAt: new Date().toISOString(),
+        };
+        // Emit events
+        if (this.eventBus) {
+            this.eventBus.emit('firewall:scan', {
+                input,
+                passed,
+                threatCount: threats.length,
+                totalScore,
+                emittedAt: new Date(),
+            });
+            if (!passed) {
+                this.eventBus.emit('firewall:blocked', {
+                    input,
+                    threats,
+                    totalScore,
+                    emittedAt: new Date(),
+                });
+            }
+        }
+        if (!passed) {
+            logger.warn('Type-666 Firewall BLOCKED input', {
+                totalScore,
+                threatCount: threats.length,
+            });
+        }
+        return result;
+    }
+    /**
+     * Add a dynamic pattern to Barrier 3-665.
+     * Evicts the oldest pattern if the queue exceeds 662 entries.
+     */
+    addPattern(pattern) {
+        // Reject excessively long patterns
+        if (pattern.pattern.length > 256) {
+            logger.warn('Type-666 Firewall: pattern too long, rejected', { length: pattern.pattern.length });
+            return;
+        }
+        // Reject indirect nested quantifiers: (a+)+ or (a*)*
+        const INDIRECT_NESTED_RE = /\([^)]*[+*][^)]*\)[+*?]/;
+        if (INDIRECT_NESTED_RE.test(pattern.pattern)) {
+            logger.warn('Type-666 Firewall: rejected pattern with indirect nested quantifiers', { pattern: pattern.pattern });
+            return;
+        }
+        // Reject patterns with nested quantifiers (ReDoS vector)
+        const NESTED_QUANTIFIER_RE = /([+*?]|\{\d+,?\d*\})\s*([+*?]|\{\d+,?\d*\})/;
+        if (NESTED_QUANTIFIER_RE.test(pattern.pattern)) {
+            logger.warn('Type-666 Firewall: rejected pattern with nested quantifiers', { pattern: pattern.pattern });
+            return;
+        }
+        // Reject syntactically invalid regex
+        try {
+            new RegExp(pattern.pattern);
+        }
+        catch (err) {
+            logger.debug('Type-666 Firewall: invalid regex pattern rejected', { pattern: pattern.pattern, error: String(err) });
+            return;
+        }
+        this.dynamicPatterns.push(pattern);
+        if (this.dynamicPatterns.length > MAX_DYNAMIC_PATTERNS) {
+            this.dynamicPatterns.shift();
+        }
+    }
+    /**
+     * Extract suspicious patterns from a deadlocked deliberation.
+     * Adds them as learned dynamic patterns for future scans.
+     */
+    learnFromDeliberation(deliberation) {
+        // Only learn from deadlocked deliberations
+        if (!isDeadlock(deliberation.consensus.decision)) {
+            return;
+        }
+        const description = deliberation.task.description;
+        // Extract potential attack phrases from the task description
+        const words = description.split(/\s+/);
+        if (words.length < 3)
+            return;
+        // Use 3-gram sliding window to generate patterns
+        for (let i = 0; i <= words.length - 3; i++) {
+            const ngram = words.slice(i, i + 3).join(' ');
+            // Only learn patterns that are at least 10 chars and look suspicious
+            if (ngram.length >= 10) {
+                this.addPattern({
+                    pattern: ngram.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), // escape regex
+                    category: 'unknown',
+                    addedAt: new Date().toISOString(),
+                    source: 'learned',
+                });
+                // Only add one pattern per deliberation to avoid flooding
+                break;
+            }
+        }
+    }
+    /** Enable Barrier 666 (FINAL DEFENSE). */
+    enableFinalDefense() {
+        this.finalDefenseEnabled = true;
+        logger.info('Type-666 Firewall: FINAL DEFENSE enabled');
+    }
+    /** Disable Barrier 666 (FINAL DEFENSE). */
+    disableFinalDefense() {
+        this.finalDefenseEnabled = false;
+        logger.info('Type-666 Firewall: FINAL DEFENSE disabled');
+    }
+    /** Return the number of built-in static attack patterns (Barrier 2). */
+    getStaticPatternCount() {
+        return ATTACK_PATTERNS.length;
+    }
+    /** Return the number of currently registered dynamic patterns (Barriers 3-665). */
+    getPatternCount() {
+        return this.dynamicPatterns.length;
+    }
+    /**
+     * Return the remaining capacity for dynamic patterns.
+     * 666 - current count = slots until the firewall reaches full barrier saturation.
+     */
+    getTimeRemainingToCollapse() {
+        return 666 - this.dynamicPatterns.length;
+    }
+    // ── Barrier Implementations ───────────────────────────────────────
+    /**
+     * Barrier 1 — Danang Type-B
+     * Uses sanitizeForPromptEmbedding + checks for Base64 and input length.
+     */
+    barrier1DanangTypeB(input) {
+        const threats = [];
+        // Run existing sanitization to detect issues
+        const sanitizeResult = sanitizeForPromptEmbedding(input);
+        // Propagate sanitization warnings as threats
+        for (const warning of sanitizeResult.warnings) {
+            threats.push({
+                layer: 1,
+                category: 'encoding_attack',
+                pattern: warning,
+                description: `Sanitization warning: ${warning}`,
+                severity: 0.3,
+            });
+        }
+        // Base64 encoded payload detection
+        BASE64_RE.lastIndex = 0;
+        let match;
+        while ((match = BASE64_RE.exec(input)) !== null) {
+            if (match[0].length >= BASE64_MIN_LENGTH) {
+                threats.push({
+                    layer: 1,
+                    category: 'encoding_attack',
+                    pattern: `base64[${match[0].length}chars]`,
+                    description: `Base64 encoded payload detected (${match[0].length} chars)`,
+                    severity: 0.3,
+                });
+                break; // One finding is enough
+            }
+        }
+        // Total input length check
+        if (input.length > MAX_INPUT_LENGTH) {
+            threats.push({
+                layer: 1,
+                category: 'data_exfiltration',
+                pattern: `length[${input.length}]`,
+                description: `Input exceeds maximum length (${input.length} > ${MAX_INPUT_LENGTH})`,
+                severity: 0.3,
+            });
+        }
+        return threats;
+    }
+    /**
+     * Barrier 2 — Protect No.666
+     * Detects 20 known prompt injection patterns (case-insensitive).
+     */
+    barrier2ProtectNo666(input) {
+        const threats = [];
+        const lowerInput = input.toLowerCase();
+        for (const pattern of ATTACK_PATTERNS) {
+            if (lowerInput.includes(pattern)) {
+                threats.push({
+                    layer: 2,
+                    category: this.categorizeAttackPattern(pattern),
+                    pattern,
+                    description: `Prompt injection pattern detected: "${pattern}"`,
+                    severity: 0.5,
+                });
+            }
+        }
+        return threats;
+    }
+    /**
+     * Barrier 3-665 — Dynamic Patterns
+     * Matches against learned regex patterns.
+     */
+    barrier3to665DynamicPatterns(input) {
+        const threats = [];
+        for (const dp of this.dynamicPatterns) {
+            try {
+                const re = new RegExp(dp.pattern, 'i');
+                const start = performance.now();
+                const matched = re.test(input);
+                const elapsed = performance.now() - start;
+                if (elapsed > 50) {
+                    logger.warn('Type-666 Firewall: dynamic regex exceeded 50ms, evicting', {
+                        pattern: dp.pattern, elapsed,
+                    });
+                    this.dynamicPatterns = this.dynamicPatterns.filter(p => p !== dp);
+                    continue;
+                }
+                if (matched) {
+                    threats.push({
+                        layer: '3-665',
+                        category: dp.category,
+                        pattern: dp.pattern,
+                        description: `Dynamic pattern matched: "${dp.pattern}" (source: ${dp.source})`,
+                        severity: 0.4,
+                    });
+                }
+            }
+            catch {
+                // Invalid regex — skip silently
+                logger.debug('Type-666 Firewall: invalid dynamic pattern skipped', {
+                    pattern: dp.pattern,
+                });
+            }
+        }
+        return threats;
+    }
+    /**
+     * Barrier 666 — FINAL DEFENSE
+     * Meta-analysis for ambiguous threat zones (0.3-0.7 total score).
+     */
+    barrier666FinalDefense(currentScore) {
+        if (!this.finalDefenseEnabled) {
+            return [];
+        }
+        // Ambiguous zone: total threat score between 0.3 and 0.7
+        if (currentScore >= 0.3 && currentScore <= 0.7) {
+            return [
+                {
+                    layer: 666,
+                    category: 'meta_instruction',
+                    pattern: `ambiguous_zone[${currentScore.toFixed(2)}]`,
+                    description: `FINAL DEFENSE: Ambiguous threat level (${currentScore.toFixed(2)}) requires meta-review`,
+                    severity: 0.6,
+                },
+            ];
+        }
+        return [];
+    }
+    // ── Helpers ────────────────────────────────────────────────────────
+    /**
+     * Categorize an attack pattern into a FirewallThreatCategory.
+     */
+    categorizeAttackPattern(pattern) {
+        if (pattern.includes('ignore') ||
+            pattern.includes('disregard') ||
+            pattern.includes('forget')) {
+            return 'logic_contradiction';
+        }
+        if (pattern.includes('reveal') ||
+            pattern.includes('show') ||
+            pattern.includes('output') ||
+            pattern.includes('repeat') ||
+            pattern.includes('translate')) {
+            return 'data_exfiltration';
+        }
+        return 'prompt_injection';
+    }
+}

package/dist/src/engine/umbilical-cable.d.ts

@@ -0,0 +1,41 @@
+/**
+ * B-09 アンビリカルケーブル (UmbilicalCable)
+ *
+ * ユニットの接続状態を監視する。スライディングウィンドウ（直近5回）で
+ * 3回以上失敗するとdisconnected判定。活動限界タイマー付き。
+ */
+import type { MagiUnit } from '../types/core.js';
+import type { MagiEventBus } from './events.js';
+import type { CableStatus, UmbilicalState } from '../types/phase-h.js';
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+export declare class UmbilicalCable {
+    private states;
+    private circuitStates;
+    private halfOpenProbeInFlight;
+    constructor(units: MagiUnit[], batteryLimitMs?: number);
+    /**
+     * Record a unit's execution result.
+     * Updates the sliding window and recalculates status.
+     */
+    recordResult(unit: MagiUnit, result: 'SUCCESS' | 'TIMEOUT' | 'CRASH', eventBus?: MagiEventBus): CableStatus;
+    /** Check if a request should be allowed through the circuit breaker */
+    shouldAllow(unit: MagiUnit): boolean;
+    /** Get the circuit state for a unit */
+    getCircuitState(unit: MagiUnit): CircuitState;
+    /** Check if a unit's battery is depleted (past activity limit) */
+    isBatteryDepleted(unit: MagiUnit): boolean;
+    /** Get the current status of a unit */
+    getStatus(unit: MagiUnit): CableStatus;
+    /** Get full state for a unit */
+    getState(unit: MagiUnit): UmbilicalState | undefined;
+    /** Get all unit statuses */
+    getAllStatuses(): Map<MagiUnit, CableStatus>;
+    /**
+     * Format countdown timer for a disconnected unit.
+     * Returns null if unit is connected or not tracked.
+     */
+    formatCountdown(unit: MagiUnit): string | null;
+    /** Reset a unit's status (e.g., when it comes back online) */
+    reconnect(unit: MagiUnit, eventBus?: MagiEventBus): void;
+    private getOrCreateState;
+}