@openlife/cli 1.7.3

package/dist/orchestrator/Gateway.js

@@ -0,0 +1,508 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gateway = void 0;
+const telegraf_1 = require("telegraf");
+const filters_1 = require("telegraf/filters");
+const IntentClassifier_1 = require("./IntentClassifier");
+const Gatekeeper_1 = require("./Gatekeeper");
+const VoiceManager_1 = require("./VoiceManager");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const express_1 = __importDefault(require("express"));
+const GovernanceLayer_1 = require("./GovernanceLayer");
+const WatchdogHeartbeat_1 = require("./util/WatchdogHeartbeat");
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+class Gateway {
+    bot = null;
+    reasoningMode = (() => {
+        const raw = String(process.env.OPENLIFE_REASONING_MODE || 'errors').toLowerCase();
+        return raw === 'off' || raw === 'always' ? raw : 'errors';
+    })();
+    classifier;
+    gatekeeper;
+    voiceManager;
+    app;
+    server = null;
+    ttsEnabled;
+    governance;
+    allowedTelegramUserId;
+    isShuttingDown = false;
+    watchdog = null;
+    bootTs = Date.now();
+    constructor() {
+        this.classifier = new IntentClassifier_1.IntentClassifier();
+        this.gatekeeper = new Gatekeeper_1.Gatekeeper();
+        this.voiceManager = new VoiceManager_1.VoiceManager();
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.ttsEnabled = (process.env.OPENLIFE_ENABLE_TTS || '').toLowerCase() === 'true';
+        this.governance = new GovernanceLayer_1.GovernanceLayer();
+        this.allowedTelegramUserId = (process.env.OPENLIFE_TELEGRAM_ALLOWED_USER_ID || '1344110010').trim() || null;
+        const token = process.env.TELEGRAM_BOT_TOKEN;
+        if (token && token.trim() !== '') {
+            this.bot = new telegraf_1.Telegraf(token);
+        }
+    }
+    /**
+     * Redact a Telegram bot token in any log line. Public so callers can
+     * use the same helper to scrub their own logs. Token shape is
+     * `<numeric_id>:<35-char_secret>`; we keep the numeric prefix and
+     * mask the rest.
+     *
+     * Story 4.3 — OpenLife v1.3 Agent OS Integration.
+     */
+    static redactBotToken(text) {
+        return String(text).replace(/(\d{6,12}):[A-Za-z0-9_-]{20,}/g, '$1:[REDACTED]');
+    }
+    /**
+     * Validate the configured TELEGRAM_BOT_TOKEN by calling getMe.
+     * Returns `{ ok: true, botId, botUsername }` on success;
+     * `{ ok: false, error, status? }` on failure. Never throws.
+     * Never logs the token itself.
+     *
+     * Story 4.3 — OpenLife v1.3 Agent OS Integration.
+     */
+    async validateBotToken(opts = {}) {
+        const token = process.env.TELEGRAM_BOT_TOKEN;
+        if (!token || token.trim() === '') {
+            return { ok: false, error: 'token_missing' };
+        }
+        const timeoutMs = opts.timeoutMs ?? 8000;
+        const url = `https://api.telegram.org/bot${token}/getMe`;
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            const res = await fetch(url, { signal: controller.signal });
+            clearTimeout(timer);
+            if (!res.ok) {
+                return { ok: false, error: 'getme_failed', status: res.status };
+            }
+            const body = await res.json();
+            if (!body?.ok || !body.result?.id || !body.result.username) {
+                return { ok: false, error: 'invalid_getme_response' };
+            }
+            return { ok: true, botId: body.result.id, botUsername: body.result.username };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: 'getme_exception', status: msg.includes('aborted') ? 408 : undefined };
+        }
+    }
+    start() {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('gateway', 'Gateway.start');
+        const adminUser = process.env.OPENLIFE_ADMIN_USER || 'admin';
+        const adminPass = process.env.OPENLIFE_ADMIN_PASS || '';
+        const adminAuth = (req, res, next) => {
+            if (!adminPass)
+                return next();
+            const header = String(req.headers.authorization || '');
+            if (!header.startsWith('Basic ')) {
+                res.setHeader('WWW-Authenticate', 'Basic realm="OpenLife Admin"');
+                return res.status(401).json({ ok: false, error: 'auth_required' });
+            }
+            const decoded = Buffer.from(header.slice(6), 'base64').toString('utf-8');
+            const [user, pass] = decoded.split(':');
+            if (user !== adminUser || pass !== adminPass) {
+                return res.status(403).json({ ok: false, error: 'forbidden' });
+            }
+            next();
+        };
+        const triggerUser = (process.env.OPENLIFE_TRIGGER_USER || '').trim();
+        const triggerPass = (process.env.OPENLIFE_TRIGGER_PASS || '').trim();
+        const triggerAuthEnabled = !!(triggerUser && triggerPass);
+        if (!triggerAuthEnabled) {
+            console.warn('[GATEWAY] WARNING: /api/v1/trigger sem autenticação. Defina OPENLIFE_TRIGGER_USER e OPENLIFE_TRIGGER_PASS para internet-exposed deploys.');
+        }
+        const triggerAuth = (req, res, next) => {
+            if (!triggerAuthEnabled)
+                return next();
+            const header = String(req.headers.authorization || '');
+            if (!header.startsWith('Basic ')) {
+                res.setHeader('WWW-Authenticate', 'Basic realm="OpenLife Trigger"');
+                return res.status(401).json({ ok: false, error: 'auth_required' });
+            }
+            const decoded = Buffer.from(header.slice(6), 'base64').toString('utf-8');
+            const sepIdx = decoded.indexOf(':');
+            const user = sepIdx >= 0 ? decoded.slice(0, sepIdx) : decoded;
+            const pass = sepIdx >= 0 ? decoded.slice(sepIdx + 1) : '';
+            if (user !== triggerUser || pass !== triggerPass) {
+                return res.status(403).json({ ok: false, error: 'forbidden' });
+            }
+            next();
+        };
+        // Configuração do Webhook (Fase 4)
+        this.app.post('/api/v1/trigger', triggerAuth, async (req, res) => {
+            const payload = req.body;
+            console.log('[WEBHOOK] Nova task recebida:', payload);
+            // Simula o contexto do Telegram para o pipeline interno do Brain
+            const mockCtx = {
+                reply: async (text) => console.log('[WEBHOOK-REPLY]', text),
+                sendChatAction: async (action) => { },
+                message: { from: { id: payload.user_id || 'webhook' }, text: payload.text }
+            };
+            try {
+                await this.processInput(mockCtx, mockCtx.message.from.id.toString(), payload.text);
+                res.status(200).json({ status: 'success', message: 'Task enviada ao Córtex' });
+            }
+            catch (err) {
+                res.status(500).json({ status: 'error', error: String(err) });
+            }
+        });
+        this.app.get('/api/v1/admin/teams', adminAuth, (_req, res) => {
+            const file = path.join(process.cwd(), '.catalog', 'teams.json');
+            const teams = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+            res.status(200).json({ ok: true, teams });
+        });
+        this.app.get('/api/v1/admin/networks', adminAuth, (_req, res) => {
+            const file = path.join(process.cwd(), '.catalog', 'skill-networks.json');
+            const networks = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+            res.status(200).json({ ok: true, networks });
+        });
+        this.app.post('/api/v1/admin/teams/upsert', adminAuth, (req, res) => {
+            const body = req.body || {};
+            if (!body.id)
+                return res.status(400).json({ ok: false, error: 'id obrigatório' });
+            const dir = path.join(process.cwd(), '.catalog');
+            const file = path.join(dir, 'teams.json');
+            fs.mkdirSync(dir, { recursive: true });
+            const arr = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+            const next = { id: String(body.id), domain: String(body.domain || 'general'), description: String(body.description || ''), slaProfile: String(body.slaProfile || 'balanced'), members: Array.isArray(body.members) ? body.members : [] };
+            const idx = arr.findIndex((x) => x.id === next.id);
+            if (idx >= 0)
+                arr[idx] = { ...arr[idx], ...next };
+            else
+                arr.push(next);
+            fs.writeFileSync(file, JSON.stringify(arr, null, 2), 'utf-8');
+            res.status(200).json({ ok: true, team: next });
+        });
+        this.app.post('/api/v1/admin/networks/upsert', adminAuth, (req, res) => {
+            const body = req.body || {};
+            if (!body.id)
+                return res.status(400).json({ ok: false, error: 'id obrigatório' });
+            const dir = path.join(process.cwd(), '.catalog');
+            const file = path.join(dir, 'skill-networks.json');
+            fs.mkdirSync(dir, { recursive: true });
+            const arr = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+            const next = { id: String(body.id), domain: String(body.domain || 'general'), nodes: Array.isArray(body.nodes) ? body.nodes : [] };
+            const idx = arr.findIndex((x) => x.id === next.id);
+            if (idx >= 0)
+                arr[idx] = { ...arr[idx], ...next };
+            else
+                arr.push(next);
+            fs.writeFileSync(file, JSON.stringify(arr, null, 2), 'utf-8');
+            res.status(200).json({ ok: true, network: next });
+        });
+        this.app.get('/api/v1/admin/status', adminAuth, (_req, res) => {
+            res.status(200).json({ ok: true, service: 'openlife-gateway', mode: this.reasoningMode, telegram: !!this.bot, now: new Date().toISOString() });
+        });
+        this.app.get('/admin', adminAuth, (_req, res) => {
+            res.sendFile(path.join(process.cwd(), 'src', 'admin_panel.html'));
+        });
+        this.app.get('/', (_req, res) => {
+            res.status(200).json({ ok: true, service: 'openlife-gateway' });
+        });
+        // Story 6.6 — watchdog/health endpoint for external supervisors
+        this.app.get('/health', (_req, res) => {
+            const uptime_s = Math.floor((Date.now() - this.bootTs) / 1000);
+            res.status(200).json({
+                ok: true,
+                service: 'openlife-gateway',
+                uptime_s,
+                pid: process.pid,
+                telegram: !!this.bot,
+                shutting_down: this.isShuttingDown,
+                ts: new Date().toISOString(),
+            });
+        });
+        // Heartbeat file emission (best-effort; opt-out via OPENLIFE_HEARTBEAT_DISABLE)
+        if ((process.env.OPENLIFE_HEARTBEAT_DISABLE || '').toLowerCase() !== 'true') {
+            try {
+                const intervalMs = Number(process.env.OPENLIFE_HEARTBEAT_INTERVAL_MS || 30_000);
+                this.watchdog = new WatchdogHeartbeat_1.WatchdogHeartbeat({ intervalMs });
+                this.watchdog.start();
+            }
+            catch (err) {
+                console.error('[GATEWAY] Failed to start watchdog heartbeat:', err);
+            }
+        }
+        const port = Number(process.env.PORT || 3000);
+        this.server = this.app.listen(port, () => {
+            console.log(`[GATEWAY] Servidor Express de Webhooks rodando na porta ${port}`);
+        });
+        if (!this.bot) {
+            console.log("[GATEWAY] Telegram Token não fornecido. Rodando apenas em modo CLI local.");
+            return;
+        }
+        console.log("[GATEWAY] Inicializando receptor Multimodal do Telegram...");
+        this.bot.catch((err, ctx) => {
+            console.error('[GATEWAY] Erro global no Telegram update handler:', err);
+            void this.safeReply(ctx, 'Desculpe — houve timeout no processamento. Tente novamente em instantes.');
+        });
+        // 1. Processamento de TEXTO
+        this.bot.on((0, filters_1.message)('text'), async (ctx) => {
+            if (ctx.message.from.is_bot)
+                return;
+            const userId = ctx.message.from.id.toString();
+            const text = ctx.message.text;
+            console.log(`\n[TELEGRAM] Nova mensagem de texto de ${userId}: "${text}"`);
+            try {
+                await this.processInput(ctx, userId, text);
+            }
+            catch (err) {
+                console.error('[GATEWAY] Erro no handler de texto:', err);
+            }
+        });
+        // 2. Processamento de ÁUDIO (Ouvidos)
+        this.bot.on((0, filters_1.message)('voice'), async (ctx) => {
+            if (ctx.message.from.is_bot)
+                return;
+            const userId = ctx.message.from.id.toString();
+            console.log(`\n[TELEGRAM] Novo Áudio recebido de ${userId}`);
+            await ctx.sendChatAction('record_voice');
+            try {
+                // Aqui o Telegram nos dá o Link do arquivo OGG.
+                // O VoiceManager vai processar (via Whisper ou preparar para Gemini 2.5)
+                const voiceFileId = ctx.message.voice.file_id;
+                const fileLink = await ctx.telegram.getFileLink(voiceFileId);
+                const transcribedText = await this.voiceManager.processAudioInput(fileLink.toString());
+                await ctx.reply(`🎙️ (Ouvido): "${transcribedText}"`);
+                await this.processInput(ctx, userId, transcribedText);
+            }
+            catch (err) {
+                console.error("[GATEWAY] Erro ao processar áudio:", err);
+                await ctx.reply("Desculpe, não consegui entender o áudio no momento.");
+            }
+        });
+        // 3. Processamento de IMAGEM (Olhos)
+        this.bot.on((0, filters_1.message)('photo'), async (ctx) => {
+            if (ctx.message.from.is_bot)
+                return;
+            const userId = ctx.message.from.id.toString();
+            console.log(`\n[TELEGRAM] Nova Imagem (Visão) recebida de ${userId}`);
+            await ctx.sendChatAction('typing');
+            try {
+                const photo = ctx.message.photo.pop(); // Pega a maior resolução
+                if (!photo)
+                    throw new Error("Foto inválida.");
+                const fileLink = await ctx.telegram.getFileLink(photo.file_id);
+                // Download the image locally
+                const tempDir = path.join(process.cwd(), '.temp_images');
+                if (!fs.existsSync(tempDir))
+                    fs.mkdirSync(tempDir, { recursive: true });
+                const localPath = path.join(tempDir, `${photo.file_id}.jpg`);
+                const response = await (0, axios_1.default)({ url: fileLink.toString(), responseType: 'stream' });
+                await new Promise((resolve, reject) => {
+                    response.data.pipe(fs.createWriteStream(localPath))
+                        .on('finish', resolve)
+                        .on('error', reject);
+                });
+                const caption = ctx.message.caption || "Descreva e analise esta imagem enviada pelo usuário.";
+                // O texto enviado com a imagem + a tag do arquivo local vai pro Córtex (Brain.ts resolverá)
+                this.voiceManager.logMediaRoute('vision', 'gemini', 'success', 'prefer_gemini_for_media=true');
+                const multimodalInput = `${caption}\n[LOCAL_ATTACHMENT: ${localPath}]`;
+                await this.processInput(ctx, userId, multimodalInput);
+            }
+            catch (err) {
+                console.error("[GATEWAY] Erro ao processar imagem:", err);
+                await ctx.reply("Erro no módulo de visão ao baixar a imagem.");
+            }
+        });
+        this.bot.launch().catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('409') || msg.includes('terminated by other getUpdates request')) {
+                console.error('[GATEWAY] Telegram 409 Conflict: outra instância está conectada com este bot. Mantendo processo vivo para healthcheck; Telegram polling fica desativado nesta instância.');
+                return;
+            }
+            console.error('[GATEWAY] Falha ao iniciar Telegram bot:', err);
+            process.exit(1);
+        });
+        console.log("[GATEWAY] Telegram Bot escutando com suporte Multimodal (Voz/Visão).");
+    }
+    async shutdown(reason = 'manual') {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        console.log(`[GATEWAY] Iniciando shutdown gracioso (motivo: ${reason})...`);
+        if (this.watchdog) {
+            try {
+                this.watchdog.emit(); // final beat so supervisors see fresh ts before we go
+                this.watchdog.stop();
+            }
+            catch (err) {
+                console.error('[GATEWAY] Falha ao parar watchdog heartbeat:', err);
+            }
+        }
+        try {
+            this.flushAgentQueue();
+        }
+        catch (err) {
+            console.error('[GATEWAY] Falha ao flushar fila durante shutdown:', err);
+        }
+        if (this.bot) {
+            try {
+                this.bot.stop(reason);
+            }
+            catch (err) {
+                console.error('[GATEWAY] Falha ao parar Telegraf bot:', err);
+            }
+        }
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close((err) => {
+                    if (err)
+                        console.error('[GATEWAY] Falha ao fechar servidor Express:', err);
+                    resolve();
+                });
+            });
+            this.server = null;
+        }
+        console.log('[GATEWAY] Graceful shutdown complete');
+    }
+    flushAgentQueue() {
+        const stateDir = process.env.OPENLIFE_STATE_DIR || path.join(process.cwd(), '.openlife');
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+        const queueFile = path.join(stateDir, 'agent-queue.json');
+        if (!fs.existsSync(queueFile)) {
+            fs.writeFileSync(queueFile, JSON.stringify({ items: [], lastFlushedAt: new Date().toISOString() }, null, 2), 'utf-8');
+            return;
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(queueFile, 'utf-8'));
+            raw.lastFlushedAt = new Date().toISOString();
+            fs.writeFileSync(queueFile, JSON.stringify(raw, null, 2), 'utf-8');
+        }
+        catch {
+            fs.writeFileSync(queueFile, JSON.stringify({ items: [], lastFlushedAt: new Date().toISOString(), note: 'recreated_after_parse_error' }, null, 2), 'utf-8');
+        }
+    }
+    async processTextForTest(userId, text) {
+        let finalReply = '';
+        const testCtx = {
+            sendChatAction: async (_action) => { },
+            reply: async (message) => { finalReply = message; },
+            sendVoice: async (_source, options) => {
+                finalReply = options?.caption || '[voice_sent]';
+            }
+        };
+        await this.processInput(testCtx, userId, text);
+        return finalReply;
+    }
+    async processImageForTest(userId, imagePath, caption = 'Descreva esta imagem.') {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('vision', 'Gateway.processImageForTest');
+        const multimodalInput = `${caption}\n[LOCAL_ATTACHMENT: ${imagePath}]`;
+        return this.processTextForTest(userId, multimodalInput);
+    }
+    isAuthorizedUser(userId) {
+        if (!this.allowedTelegramUserId)
+            return true;
+        return userId === this.allowedTelegramUserId;
+    }
+    async processInput(ctx, userId, text) {
+        if (!this.isAuthorizedUser(userId)) {
+            console.warn(`[GATEWAY] Acesso negado para userId=${userId}`);
+            await this.safeReply(ctx, 'Acesso negado por policy de segurança deste bot.');
+            return;
+        }
+        const stopTyping = this.startTypingIndicator(ctx);
+        const trace = [];
+        try {
+            trace.push(`🔎 classify_intent: "${text.slice(0, 80).replace(/\n/g, ' ')}${text.length > 80 ? '...' : ''}"`);
+            const task = await this.classifier.classify(text);
+            trace.push(`🧭 route_task: "${String(task.intent)}"`);
+            const response = await this.gatekeeper.routeTask(task, text, userId);
+            trace.push(`✅ finalize_reply: "${String(task.intent)}"`);
+            const safeResponse = this.governance.redact(response);
+            const finalResponse = this.reasoningMode === 'always' ? `${trace.join('\n')}\n\n${safeResponse}` : safeResponse;
+            if (this.ttsEnabled && typeof ctx.sendVoice === 'function') {
+                try {
+                    const audioPath = await this.voiceManager.generateSpeech(finalResponse);
+                    await ctx.sendVoice({ source: audioPath }, { caption: finalResponse });
+                }
+                catch (ttsError) {
+                    console.log("[GATEWAY] Fallback para texto (Erro no TTS).", ttsError);
+                    await this.safeReply(ctx, finalResponse);
+                }
+            }
+            else {
+                await this.safeReply(ctx, finalResponse);
+            }
+        }
+        catch (err) {
+            console.error("[GATEWAY] Erro ao orquestrar a tarefa:", err);
+            const errMsg = this.reasoningMode !== 'off'
+                ? `${trace.join('\n')}\n\n❌ error: "${err instanceof Error ? err.message : String(err)}"\n\nErro no córtex ao processar a solicitação.`
+                : "Erro no córtex ao processar a solicitação.";
+            await this.safeReply(ctx, errMsg);
+        }
+        finally {
+            stopTyping();
+        }
+    }
+    startTypingIndicator(ctx) {
+        let stopped = false;
+        const sendTyping = async () => {
+            if (stopped)
+                return;
+            try {
+                await ctx.sendChatAction('typing');
+            }
+            catch (err) {
+                console.error('[GATEWAY] Falha ao enviar indicador de digitação:', err);
+            }
+        };
+        void sendTyping();
+        const timer = setInterval(() => { void sendTyping(); }, 4000);
+        return () => {
+            stopped = true;
+            clearInterval(timer);
+        };
+    }
+    async safeReply(ctx, text) {
+        try {
+            await ctx.reply(text);
+        }
+        catch (replyErr) {
+            console.error('[GATEWAY] Falha ao responder no Telegram:', replyErr);
+        }
+    }
+}
+exports.Gateway = Gateway;

package/dist/orchestrator/GovernanceConsentStore.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GovernanceConsentStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class GovernanceConsentStore {
+    root;
+    filePath;
+    constructor(root = process.cwd()) {
+        this.root = root;
+        this.filePath = path.join(this.root, '.openlife', 'governance-consents.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    read() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+    }
+    write(records) {
+        (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, records);
+    }
+    approve(userId, scope = 'destructive-action') {
+        const records = this.read().filter((record) => record.userId !== userId || record.scope !== scope);
+        records.push({ userId, scope, approvedAt: new Date().toISOString() });
+        this.write(records);
+    }
+    hasRecentApproval(userId, scope = 'destructive-action', windowMinutes = 15) {
+        const threshold = Date.now() - windowMinutes * 60 * 1000;
+        return this.read().some((record) => record.userId === userId && record.scope === scope && new Date(record.approvedAt).getTime() >= threshold);
+    }
+}
+exports.GovernanceConsentStore = GovernanceConsentStore;