thevoidforge 21.0.0

package/dist/wizard/lib/anomaly-detection.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Anomaly Detection — Spend spikes, traffic drops, conversion changes (§9.17).
+ *
+ * Runs hourly as a heartbeat daemon scheduled job.
+ * Compares current metrics against rolling averages.
+ * Alerts when deviations exceed thresholds.
+ *
+ * PRD Reference: §9.7 (hourly anomaly detection), §9.17 (thresholds)
+ */
+type Cents = number & {
+    readonly __brand: 'Cents';
+};
+type AnomalyType = 'spend_spike' | 'traffic_drop' | 'conversion_change' | 'roas_drop';
+type AnomalySeverity = 'warning' | 'alert' | 'critical';
+interface Anomaly {
+    type: AnomalyType;
+    severity: AnomalySeverity;
+    platform?: string;
+    metric: string;
+    currentValue: number;
+    expectedValue: number;
+    deviationPercent: number;
+    message: string;
+    timestamp: string;
+}
+declare const THRESHOLDS: {
+    spendSpikeWarning: number;
+    spendSpikeAlert: number;
+    spendSpikeCritical: number;
+    trafficDropWarning: number;
+    trafficDropAlert: number;
+    trafficDropCritical: number;
+    conversionChangeThreshold: number;
+    roasDropWarning: number;
+    roasDropAlert: number;
+};
+/** Run all anomaly checks for the current period */
+export declare function runAnomalyDetection(metrics: {
+    spendByPlatform: Array<{
+        platform: string;
+        currentHour: Cents;
+        avgHourly: Cents;
+    }>;
+    traffic: {
+        currentDay: number;
+        avgDaily: number;
+    };
+    conversion: {
+        currentRate: number;
+        avgRate: number;
+    };
+    roasByPlatform: Array<{
+        platform: string;
+        current: number;
+        avg: number;
+    }>;
+}): Anomaly[];
+export type { Anomaly, AnomalyType, AnomalySeverity };
+export { THRESHOLDS };

package/dist/wizard/lib/anomaly-detection.js

@@ -0,0 +1,122 @@
+/**
+ * Anomaly Detection — Spend spikes, traffic drops, conversion changes (§9.17).
+ *
+ * Runs hourly as a heartbeat daemon scheduled job.
+ * Compares current metrics against rolling averages.
+ * Alerts when deviations exceed thresholds.
+ *
+ * PRD Reference: §9.7 (hourly anomaly detection), §9.17 (thresholds)
+ */
+// ── Thresholds ────────────────────────────────────────
+const THRESHOLDS = {
+    // Spend spike: current hour spend > X% of daily average hourly spend
+    spendSpikeWarning: 50, // 50% above average
+    spendSpikeAlert: 100, // 100% above average (double)
+    spendSpikeCritical: 200, // 200% above average (triple)
+    // Traffic drop: current day traffic > X% below 7-day average
+    trafficDropWarning: 20, // 20% below average
+    trafficDropAlert: 40, // 40% below average
+    trafficDropCritical: 60, // 60% below average
+    // Conversion rate change: > X% from 7-day average
+    conversionChangeThreshold: 20, // 20% change in either direction
+    // ROAS drop: current < X% of 7-day average
+    roasDropWarning: 20, // 20% below average
+    roasDropAlert: 40, // 40% below average
+};
+// ── Detection Functions ───────────────────────────────
+function detectSpendSpike(currentHourSpend, avgHourlySpend, platform) {
+    if (avgHourlySpend === 0)
+        return null;
+    const deviation = ((currentHourSpend - avgHourlySpend) / avgHourlySpend) * 100;
+    if (deviation < THRESHOLDS.spendSpikeWarning)
+        return null;
+    const severity = deviation >= THRESHOLDS.spendSpikeCritical ? 'critical' :
+        deviation >= THRESHOLDS.spendSpikeAlert ? 'alert' : 'warning';
+    return {
+        type: 'spend_spike',
+        severity,
+        platform,
+        metric: 'hourly_spend',
+        currentValue: currentHourSpend,
+        expectedValue: avgHourlySpend,
+        deviationPercent: Math.round(deviation),
+        message: `Spend spike on ${platform}: $${(currentHourSpend / 100).toFixed(2)}/hr vs $${(avgHourlySpend / 100).toFixed(2)}/hr average (+${Math.round(deviation)}%)`,
+        timestamp: new Date().toISOString(),
+    };
+}
+function detectTrafficDrop(currentDayTraffic, avgDailyTraffic) {
+    if (avgDailyTraffic === 0)
+        return null;
+    const deviation = ((avgDailyTraffic - currentDayTraffic) / avgDailyTraffic) * 100;
+    if (deviation < THRESHOLDS.trafficDropWarning)
+        return null;
+    const severity = deviation >= THRESHOLDS.trafficDropCritical ? 'critical' :
+        deviation >= THRESHOLDS.trafficDropAlert ? 'alert' : 'warning';
+    return {
+        type: 'traffic_drop',
+        severity,
+        metric: 'daily_traffic',
+        currentValue: currentDayTraffic,
+        expectedValue: avgDailyTraffic,
+        deviationPercent: -Math.round(deviation),
+        message: `Traffic drop: ${currentDayTraffic} visitors today vs ${avgDailyTraffic} average (-${Math.round(deviation)}%)`,
+        timestamp: new Date().toISOString(),
+    };
+}
+function detectConversionChange(currentRate, avgRate) {
+    if (avgRate === 0)
+        return null;
+    const deviation = ((currentRate - avgRate) / avgRate) * 100;
+    if (Math.abs(deviation) < THRESHOLDS.conversionChangeThreshold)
+        return null;
+    return {
+        type: 'conversion_change',
+        severity: Math.abs(deviation) >= 40 ? 'alert' : 'warning',
+        metric: 'conversion_rate',
+        currentValue: currentRate,
+        expectedValue: avgRate,
+        deviationPercent: Math.round(deviation),
+        message: `Conversion rate ${deviation > 0 ? 'increase' : 'decrease'}: ${currentRate.toFixed(1)}% vs ${avgRate.toFixed(1)}% average (${deviation > 0 ? '+' : ''}${Math.round(deviation)}%)`,
+        timestamp: new Date().toISOString(),
+    };
+}
+function detectRoasDrop(currentRoas, avgRoas, platform) {
+    if (avgRoas === 0)
+        return null;
+    const deviation = ((avgRoas - currentRoas) / avgRoas) * 100;
+    if (deviation < THRESHOLDS.roasDropWarning)
+        return null;
+    return {
+        type: 'roas_drop',
+        severity: deviation >= THRESHOLDS.roasDropAlert ? 'alert' : 'warning',
+        platform,
+        metric: 'roas',
+        currentValue: currentRoas,
+        expectedValue: avgRoas,
+        deviationPercent: -Math.round(deviation),
+        message: `ROAS drop on ${platform}: ${currentRoas.toFixed(1)}x vs ${avgRoas.toFixed(1)}x average (-${Math.round(deviation)}%)`,
+        timestamp: new Date().toISOString(),
+    };
+}
+/** Run all anomaly checks for the current period */
+export function runAnomalyDetection(metrics) {
+    const anomalies = [];
+    for (const s of metrics.spendByPlatform) {
+        const a = detectSpendSpike(s.currentHour, s.avgHourly, s.platform);
+        if (a)
+            anomalies.push(a);
+    }
+    const td = detectTrafficDrop(metrics.traffic.currentDay, metrics.traffic.avgDaily);
+    if (td)
+        anomalies.push(td);
+    const cc = detectConversionChange(metrics.conversion.currentRate, metrics.conversion.avgRate);
+    if (cc)
+        anomalies.push(cc);
+    for (const r of metrics.roasByPlatform) {
+        const a = detectRoasDrop(r.current, r.avg, r.platform);
+        if (a)
+            anomalies.push(a);
+    }
+    return anomalies;
+}
+export { THRESHOLDS };

package/dist/wizard/lib/anthropic.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Anthropic API utilities — model resolution and helpers.
+ *
+ * Fetches available models from the API and picks the best one
+ * for PRD generation. No hardcoded model IDs.
+ */
+export interface ResolvedModel {
+    id: string;
+    maxTokens: number;
+}
+/**
+ * Resolve the best available model for PRD generation.
+ *
+ * Strategy: pick the newest Opus (most capable — PRD generation is a one-time
+ * operation where quality matters most). Falls back to Sonnet, then Haiku.
+ */
+export declare function resolveBestModel(apiKey: string): Promise<string>;
+/** Resolve model ID + max output tokens for the selected model */
+export declare function resolveModelWithLimits(apiKey: string): Promise<ResolvedModel>;
+/** Clear the cached model (e.g., if the API key changes) */
+export declare function clearModelCache(): void;

package/dist/wizard/lib/anthropic.js

@@ -0,0 +1,105 @@
+/**
+ * Anthropic API utilities — model resolution and helpers.
+ *
+ * Fetches available models from the API and picks the best one
+ * for PRD generation. No hardcoded model IDs.
+ */
+import { request as httpsRequest } from 'node:https';
+/** Preference order: most capable first, then newest within family */
+const MODEL_PREFERENCE = [
+    'claude-opus',
+    'claude-sonnet',
+    'claude-haiku',
+];
+/** Max output tokens by model family — use each model's full capacity */
+const MAX_OUTPUT_TOKENS = {
+    'claude-opus': 32768,
+    'claude-sonnet': 16384,
+    'claude-haiku': 8192,
+};
+const DEFAULT_MAX_TOKENS = 16384;
+let cachedModel = null;
+/** Fetch available models from the Anthropic API */
+function fetchModels(apiKey) {
+    return new Promise((resolve, reject) => {
+        const req = httpsRequest({
+            hostname: 'api.anthropic.com',
+            path: '/v1/models',
+            method: 'GET',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            timeout: 10000,
+        }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk.toString(); });
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error(`Models API returned ${res.statusCode}: ${body}`));
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(body);
+                    resolve(parsed.data ?? []);
+                }
+                catch {
+                    reject(new Error('Failed to parse models response'));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Models request timed out'));
+        });
+        req.end();
+    });
+}
+/**
+ * Resolve the best available model for PRD generation.
+ *
+ * Strategy: pick the newest Opus (most capable — PRD generation is a one-time
+ * operation where quality matters most). Falls back to Sonnet, then Haiku.
+ */
+export async function resolveBestModel(apiKey) {
+    if (cachedModel)
+        return cachedModel;
+    let models;
+    try {
+        models = await fetchModels(apiKey);
+    }
+    catch {
+        // If we can't reach the models endpoint, fall back to a known-good model.
+        // This is the one hardcoded fallback — everything else is dynamic.
+        return 'claude-sonnet-4-6';
+    }
+    if (models.length === 0) {
+        return 'claude-sonnet-4-6';
+    }
+    // Sort each model into preference buckets, newest first within each bucket
+    for (const prefix of MODEL_PREFERENCE) {
+        const matches = models
+            .filter((m) => m.id.startsWith(prefix))
+            .sort((a, b) => b.created_at.localeCompare(a.created_at));
+        if (matches.length > 0) {
+            cachedModel = matches[0].id;
+            return cachedModel;
+        }
+    }
+    // Nothing matched our preferences — pick the newest model overall
+    const sorted = [...models].sort((a, b) => b.created_at.localeCompare(a.created_at));
+    cachedModel = sorted[0].id;
+    return cachedModel;
+}
+/** Resolve model ID + max output tokens for the selected model */
+export async function resolveModelWithLimits(apiKey) {
+    const id = await resolveBestModel(apiKey);
+    const family = MODEL_PREFERENCE.find((prefix) => id.startsWith(prefix));
+    const maxTokens = family ? (MAX_OUTPUT_TOKENS[family] ?? DEFAULT_MAX_TOKENS) : DEFAULT_MAX_TOKENS;
+    return { id, maxTokens };
+}
+/** Clear the cached model (e.g., if the API key changes) */
+export function clearModelCache() {
+    cachedModel = null;
+}

package/dist/wizard/lib/asset-scanner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * PRD asset scanner — identifies image/visual requirements from PRD prose.
+ * Used by Celebrimbor's /imagine command to find what needs generating.
+ * Pure text analysis — no API calls, no side effects.
+ */
+export interface AssetRequirement {
+    description: string;
+    category: string;
+    context: string;
+    width: number;
+    height: number;
+    section: string;
+}
+/**
+ * Scan a PRD document for visual asset requirements.
+ * Returns a list of assets that need generating.
+ */
+export declare function scanPrdForAssets(prdContent: string): AssetRequirement[];
+/**
+ * Extract brand/style keywords from the PRD for style prefix generation.
+ * Looks for Section 14 (Brand) or any section mentioning "brand", "style", "aesthetic".
+ */
+export declare function extractBrandStyle(prdContent: string): string[];

package/dist/wizard/lib/asset-scanner.js

@@ -0,0 +1,107 @@
+/**
+ * PRD asset scanner — identifies image/visual requirements from PRD prose.
+ * Used by Celebrimbor's /imagine command to find what needs generating.
+ * Pure text analysis — no API calls, no side effects.
+ */
+/** Patterns that indicate a visual asset requirement in PRD prose. */
+const ASSET_PATTERNS = [
+    { pattern: /illustrat(?:ion|ed|e)/i, category: 'illustration' },
+    { pattern: /portrait/i, category: 'portrait' },
+    { pattern: /silhouette/i, category: 'portrait' },
+    { pattern: /avatar/i, category: 'portrait' },
+    { pattern: /(?:custom\s+)?\bicon\b/i, category: 'icon' },
+    { pattern: /og[:\s-]image/i, category: 'og-image' },
+    { pattern: /social\s+(?:sharing\s+)?image/i, category: 'og-image' },
+    { pattern: /hero\s+(?:image|banner|art)/i, category: 'hero' },
+    { pattern: /splash\s+(?:page|screen)/i, category: 'hero' },
+    { pattern: /background\s+image/i, category: 'background' },
+    { pattern: /cover\s+image/i, category: 'background' },
+    { pattern: /\blogo\b/i, category: 'logo' },
+    { pattern: /\bfavicon\b/i, category: 'icon' },
+    { pattern: /comic\s+strip/i, category: 'illustration' },
+    { pattern: /comic\s+panel/i, category: 'illustration' },
+    { pattern: /screenshot/i, category: 'screenshot' },
+    { pattern: /mockup/i, category: 'screenshot' },
+];
+/** Default dimensions per asset category. */
+const CATEGORY_DIMENSIONS = {
+    'portrait': { width: 1024, height: 1024 },
+    'illustration': { width: 1024, height: 1024 },
+    'og-image': { width: 1200, height: 630 },
+    'hero': { width: 1792, height: 1024 },
+    'background': { width: 1792, height: 1024 },
+    'logo': { width: 512, height: 512 },
+    'icon': { width: 512, height: 512 },
+    'screenshot': { width: 1280, height: 720 },
+};
+/**
+ * Scan a PRD document for visual asset requirements.
+ * Returns a list of assets that need generating.
+ */
+export function scanPrdForAssets(prdContent) {
+    const assets = [];
+    const lines = prdContent.split('\n');
+    let currentSection = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track section headers
+        const headerMatch = line.match(/^#{1,4}\s+(.+)/);
+        if (headerMatch) {
+            currentSection = headerMatch[1].trim();
+            continue;
+        }
+        // Check each line against asset patterns
+        for (const { pattern, category } of ASSET_PATTERNS) {
+            if (pattern.test(line)) {
+                // Extract surrounding context (current line + next line for description)
+                const contextLines = lines.slice(Math.max(0, i - 1), Math.min(lines.length, i + 3));
+                const context = contextLines.join(' ').trim();
+                const dims = CATEGORY_DIMENSIONS[category] || { width: 1024, height: 1024 };
+                assets.push({
+                    description: line.trim(),
+                    category,
+                    context,
+                    width: dims.width,
+                    height: dims.height,
+                    section: currentSection,
+                });
+                break; // One match per line is enough
+            }
+        }
+    }
+    // Deduplicate by description similarity
+    const seen = new Set();
+    return assets.filter(a => {
+        const key = a.description.toLowerCase().slice(0, 60);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * Extract brand/style keywords from the PRD for style prefix generation.
+ * Looks for Section 14 (Brand) or any section mentioning "brand", "style", "aesthetic".
+ */
+export function extractBrandStyle(prdContent) {
+    const keywords = [];
+    const lines = prdContent.split('\n');
+    let inBrandSection = false;
+    for (const line of lines) {
+        const headerMatch = line.match(/^#{1,4}\s+(.+)/);
+        if (headerMatch) {
+            const title = headerMatch[1].toLowerCase();
+            inBrandSection = title.includes('brand') || title.includes('style') || title.includes('aesthetic') || title.includes('design') || title.includes('personality');
+            continue;
+        }
+        if (inBrandSection && line.trim()) {
+            // Extract adjectives and style keywords
+            const styleWords = line.match(/\b(minimal|bold|playful|professional|elegant|modern|retro|vintage|comic|pulp|neon|dark|light|cinematic|warm|cool|vibrant|muted|halftone|watercolor|photorealistic|illustration|flat|gradient|geometric|organic)\b/gi);
+            if (styleWords) {
+                keywords.push(...styleWords.map(w => w.toLowerCase()));
+            }
+        }
+    }
+    // Deduplicate
+    return [...new Set(keywords)];
+}

package/dist/wizard/lib/audit-log.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Audit Log — Append-only JSON lines logger for Avengers Tower Remote.
+ *
+ * Layer 5 of the 5-layer security architecture.
+ * Every security-relevant action is recorded.
+ * File permissions: 0600 (owner read/write only).
+ * Rotation: at 10MB, rename to .1 and start fresh.
+ */
+export type AuditEventType = 'login_attempt' | 'login_success' | 'login_failure' | 'logout' | 'session_create' | 'session_expire' | 'vault_unlock' | 'vault_lock' | 'terminal_start' | 'terminal_end' | 'ssh_connect' | 'deploy' | 'credential_access' | 'project_create' | 'project_delete' | 'health_failure' | 'user_create' | 'user_remove' | 'role_change' | 'invite_create' | 'invite_complete' | 'access_denied' | 'access_grant' | 'access_revoke';
+export interface AuditEntry {
+    timestamp: string;
+    event: AuditEventType;
+    ip: string;
+    user: string;
+    details: Record<string, string | number | boolean>;
+}
+/** Ensure the log directory exists. Called once on startup. */
+export declare function initAuditLog(): Promise<void>;
+/**
+ * Append an audit entry. Never throws — logging must not crash the server.
+ * If the write fails, the entry is lost (acceptable tradeoff vs. crashing).
+ */
+export declare function audit(event: AuditEventType, ip: string, user: string, details?: Record<string, string | number | boolean>): Promise<void>;

package/dist/wizard/lib/audit-log.js

@@ -0,0 +1,70 @@
+/**
+ * Audit Log — Append-only JSON lines logger for Avengers Tower Remote.
+ *
+ * Layer 5 of the 5-layer security architecture.
+ * Every security-relevant action is recorded.
+ * File permissions: 0600 (owner read/write only).
+ * Rotation: at 10MB, rename to .1 and start fresh.
+ */
+import { appendFile, stat, rename, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const VOIDFORGE_DIR = join(homedir(), '.voidforge');
+const LOG_PATH = join(VOIDFORGE_DIR, 'audit.log');
+const MAX_SIZE_BYTES = 10 * 1024 * 1024; // 10MB rotation threshold
+let initialized = false;
+/** Ensure the log directory exists. Called once on startup. */
+export async function initAuditLog() {
+    if (initialized)
+        return;
+    await mkdir(VOIDFORGE_DIR, { recursive: true });
+    initialized = true;
+}
+const MAX_ROTATIONS = 7; // Keep 7 rotated files (.1 through .7) for financial audit trail
+/** Check if log needs rotation and rotate if so. */
+async function rotateIfNeeded() {
+    try {
+        const stats = await stat(LOG_PATH);
+        if (stats.size >= MAX_SIZE_BYTES) {
+            // v17.0: 7-rotation scheme instead of single .1 (preserves financial audit trail).
+            // Shift .6 → .7, .5 → .6, ... .1 → .2, then current → .1
+            for (let i = MAX_ROTATIONS - 1; i >= 1; i--) {
+                try {
+                    await rename(LOG_PATH + '.' + i, LOG_PATH + '.' + (i + 1));
+                }
+                catch { /* file doesn't exist at this slot — skip */ }
+            }
+            await rename(LOG_PATH, LOG_PATH + '.1');
+        }
+    }
+    catch {
+        // File doesn't exist yet — that's fine
+    }
+}
+/**
+ * Append an audit entry. Never throws — logging must not crash the server.
+ * If the write fails, the entry is lost (acceptable tradeoff vs. crashing).
+ */
+export async function audit(event, ip, user, details = {}) {
+    try {
+        if (!initialized)
+            await initAuditLog();
+        await rotateIfNeeded();
+        const entry = {
+            timestamp: new Date().toISOString(),
+            event,
+            ip,
+            user,
+            details,
+        };
+        // JSON lines format: one JSON object per line, newline-terminated
+        const line = JSON.stringify(entry) + '\n';
+        // Append with 0600 permissions (creates file if needed)
+        await appendFile(LOG_PATH, line, { mode: 0o600 });
+    }
+    catch {
+        // Audit logging must never crash the server.
+        // If we can't write, the entry is lost — but the server stays up.
+        console.error('Audit log write failed');
+    }
+}

package/dist/wizard/lib/autonomy-controller.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Autonomy Controller — Tier 2 supervised + Tier 3 full autonomy (v12.3-v12.4).
+ *
+ * Manages the autonomous execution loop: proposal → delay → execute/veto.
+ * Implements circuit breakers, kill switch, deploy freeze, strategic sync.
+ *
+ * PRD Reference: ROADMAP v12.3-v12.4, DEEP_CURRENT.md Autonomy Tiers + Security
+ */
+import type { CampaignProposal } from './campaign-proposer.js';
+interface AutonomyState {
+    tier: 1 | 2 | 3;
+    active: boolean;
+    stopped: boolean;
+    pendingProposal?: {
+        proposal: CampaignProposal;
+        proposedAt: string;
+        executeAt: string;
+        vetoed: boolean;
+    };
+    campaignsRun: number;
+    consecutiveCampaigns: number;
+    lastHumanReview: string;
+    lastStrategicSync: string;
+    circuitBreakers: {
+        driftScore: number;
+        consecutiveCriticals: number;
+        spendIncreaseStreak: number;
+        roasBelow1: number;
+    };
+    deployFreezeWindows: Array<{
+        dayOfWeek: number;
+        startHour: number;
+        endHour: number;
+    }>;
+}
+declare const AUTONOMY_STATE_PATH: string;
+declare const DEFAULT_STATE: AutonomyState;
+export declare function loadAutonomyState(): Promise<AutonomyState>;
+export declare function saveAutonomyState(state: AutonomyState): Promise<void>;
+interface CircuitBreakerResult {
+    safe: boolean;
+    reason?: string;
+    action?: 'pause' | 'downgrade_to_tier1' | 'stop';
+}
+/**
+ * Check all circuit breakers. Returns whether autonomous operation should continue.
+ */
+export declare function checkCircuitBreakers(state: AutonomyState): CircuitBreakerResult;
+/**
+ * Queue a proposal for Tier 2 execution (24h delay).
+ */
+export declare function queueProposal(state: AutonomyState, proposal: CampaignProposal): AutonomyState;
+/**
+ * Check if a pending Tier 2 proposal is ready to execute.
+ */
+export declare function isProposalReady(state: AutonomyState): boolean;
+/**
+ * Veto a pending Tier 2 proposal.
+ */
+export declare function vetoProposal(state: AutonomyState): AutonomyState;
+export declare function engageKillSwitch(state: AutonomyState): AutonomyState;
+export declare function disengageKillSwitch(state: AutonomyState): AutonomyState;
+export declare function recordStrategicSync(state: AutonomyState): AutonomyState;
+export declare function recordCampaignComplete(state: AutonomyState): AutonomyState;
+interface SoftLimits {
+    maxConsecutiveMissions: number;
+    maxDeploysPerDay: number;
+    aggregateDailySpendCeiling: number;
+    strategicDriftThreshold: number;
+    explorationBudgetPercent: number;
+    lessonDecayHalfLifeDays: number;
+    minRoasBeforeFreeze: number;
+}
+declare const DEFAULT_SOFT_LIMITS: SoftLimits;
+export type { AutonomyState, CircuitBreakerResult, SoftLimits };
+export { DEFAULT_STATE, DEFAULT_SOFT_LIMITS, AUTONOMY_STATE_PATH };