@openlife/cli 1.7.3

package/dist/memory/ConversationMemory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationMemory = void 0;
+const OmniMemory_1 = require("./OmniMemory");
+const SessionManager_1 = require("./SessionManager");
+class ConversationMemory {
+    memory;
+    sessions;
+    constructor(memory = new OmniMemory_1.OmniMemory(), sessions = new SessionManager_1.SessionManager()) {
+        this.memory = memory;
+        this.sessions = sessions;
+    }
+    async recoverContext(userId, query) {
+        const session = this.sessions.getSession(userId);
+        const recentHistory = session.history
+            .slice(-8)
+            .map((h) => `${h.role}: ${h.content}`)
+            .join('\n');
+        let memorySnippet = '';
+        try {
+            memorySnippet = await this.memory.search(query);
+        }
+        catch {
+            memorySnippet = 'Busca de memória indisponível no momento.';
+        }
+        return {
+            recentHistory,
+            memorySnippet,
+            autoRecovered: Boolean(recentHistory.trim() || memorySnippet.trim())
+        };
+    }
+}
+exports.ConversationMemory = ConversationMemory;

package/dist/memory/LocalMemoryProvider.js

@@ -0,0 +1,86 @@
+"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.LocalMemoryProvider = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class LocalMemoryProvider {
+    filePath;
+    constructor(root = process.cwd()) {
+        this.filePath = path.join(root, '.artifacts', 'memory-records.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    name() {
+        return 'local';
+    }
+    async search(input) {
+        const records = this.getAll();
+        const terms = input.query.toLowerCase().split(/\s+/).filter(Boolean);
+        const filtered = records
+            .map(record => {
+            const hay = `${record.content} ${record.summary || ''} ${(record.tags || []).join(' ')}`.toLowerCase();
+            const namespaceOk = !input.namespace || this.matchNamespace(record.namespace, input.namespace);
+            const typeOk = !input.types?.length || input.types.includes(record.type);
+            const score = terms.reduce((acc, term) => acc + (hay.includes(term) ? 1 : 0), 0);
+            return { record, namespaceOk, typeOk, score };
+        })
+            .filter(item => item.namespaceOk && item.typeOk && item.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .map(item => item.record);
+        return filtered.slice(0, input.topK || 5);
+    }
+    async save(record) {
+        const all = this.getAll();
+        const deduped = record.dedupeKey
+            ? all.filter(item => item.dedupeKey !== record.dedupeKey)
+            : all;
+        deduped.push(record);
+        fs.writeFileSync(this.filePath, JSON.stringify(deduped, null, 2), 'utf-8');
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    matchNamespace(a, b) {
+        return Object.entries(b).every(([k, v]) => !v || a?.[k] === v);
+    }
+}
+exports.LocalMemoryProvider = LocalMemoryProvider;

package/dist/memory/Mem0Provider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mem0Provider = void 0;
+class Mem0Provider {
+    name() {
+        return 'mem0';
+    }
+    async search(input) {
+        void input;
+        return [];
+    }
+    async save(record) {
+        void record;
+    }
+}
+exports.Mem0Provider = Mem0Provider;

package/dist/memory/MemoryNamespacePolicy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryNamespacePolicy = void 0;
+class MemoryNamespacePolicy {
+    decide(input) {
+        const namespace = {
+            project: input.project || 'default',
+            user: input.user,
+            agent: input.agent,
+            squad: input.squad,
+            domain: input.domain || 'general'
+        };
+        const types = input.missionType === 'runtime'
+            ? ['working', 'episodic', 'semantic']
+            : input.missionType === 'engineering'
+                ? ['episodic', 'semantic']
+                : input.missionType === 'research'
+                    ? ['semantic', 'temporal']
+                    : ['working', 'episodic', 'semantic', 'profile'];
+        return {
+            namespace,
+            types,
+            rationale: `Namespace resolvido para project=${namespace.project}, user=${namespace.user || 'n/a'}, domain=${namespace.domain}, missionType=${input.missionType || 'general'}`
+        };
+    }
+}
+exports.MemoryNamespacePolicy = MemoryNamespacePolicy;

package/dist/memory/MemoryOrchestrator.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryOrchestrator = void 0;
+const MemoryProviderRegistry_1 = require("./MemoryProviderRegistry");
+const MemoryRetentionPolicy_1 = require("./MemoryRetentionPolicy");
+class MemoryOrchestrator {
+    registry;
+    retention;
+    constructor() {
+        this.registry = new MemoryProviderRegistry_1.MemoryProviderRegistry();
+        this.retention = new MemoryRetentionPolicy_1.MemoryRetentionPolicy();
+    }
+    async search(input, providers) {
+        const selected = this.resolveProviders(providers);
+        const all = [];
+        for (const provider of selected) {
+            const results = await provider.search(input);
+            for (const record of results) {
+                all.push({ provider: provider.name(), record });
+            }
+        }
+        return this.dedupeAndRank(all, input.query, input.topK || 5);
+    }
+    async save(input) {
+        const record = {
+            id: `${input.sourceMissionId || 'mem'}-${Date.now()}`,
+            type: input.type,
+            namespace: input.namespace || {},
+            content: input.content,
+            summary: input.summary,
+            tags: input.tags || [],
+            confidence: input.confidence ?? 0.8,
+            sourceMissionId: input.sourceMissionId,
+            dedupeKey: input.dedupeKey,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        const selected = this.resolveProviders(input.providers);
+        for (const provider of selected) {
+            await provider.save({ ...record });
+        }
+        return record;
+    }
+    resolveProviders(names) {
+        const providerNames = names?.length ? names : this.registry.list();
+        return providerNames
+            .map((name) => this.registry.get(name))
+            .filter((provider) => !!provider);
+    }
+    dedupeAndRank(results, query, topK) {
+        const seen = new Set();
+        const unique = results.filter((item) => {
+            const key = item.record.dedupeKey || `${item.record.summary || item.record.content}`.slice(0, 200);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        return unique
+            .filter((item) => this.retention.decide(item.record).keep)
+            .sort((a, b) => this.retention.score(b.record, query) - this.retention.score(a.record, query))
+            .slice(0, topK);
+    }
+}
+exports.MemoryOrchestrator = MemoryOrchestrator;

package/dist/memory/MemoryPromotionFlow.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryPromotionFlow = void 0;
+const MemoryOrchestrator_1 = require("./MemoryOrchestrator");
+class MemoryPromotionFlow {
+    orchestrator;
+    constructor() {
+        this.orchestrator = new MemoryOrchestrator_1.MemoryOrchestrator();
+    }
+    async promote(candidate, namespace, type = 'semantic') {
+        await this.orchestrator.save({
+            type,
+            namespace,
+            content: candidate.summary,
+            summary: candidate.summary.slice(0, 180),
+            tags: ['promotion', candidate.type],
+            confidence: 0.78,
+            sourceMissionId: candidate.sourceMissionId,
+            dedupeKey: `promotion:${candidate.id}`,
+            providers: ['local']
+        });
+    }
+    async retrieve(query, namespace, types) {
+        return this.orchestrator.search({
+            query,
+            namespace,
+            types,
+            topK: 8
+        }, ['local', 'mempalace']);
+    }
+}
+exports.MemoryPromotionFlow = MemoryPromotionFlow;

package/dist/memory/MemoryProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/memory/MemoryProviderRegistry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryProviderRegistry = void 0;
+const LocalMemoryProvider_1 = require("./LocalMemoryProvider");
+const MempalaceProvider_1 = require("./MempalaceProvider");
+const Mem0Provider_1 = require("./Mem0Provider");
+const ZepGraphitiProvider_1 = require("./ZepGraphitiProvider");
+const RedisAgentMemoryProvider_1 = require("./RedisAgentMemoryProvider");
+class MemoryProviderRegistry {
+    providers;
+    constructor() {
+        this.providers = {
+            local: new LocalMemoryProvider_1.LocalMemoryProvider(),
+            mempalace: new MempalaceProvider_1.MempalaceProvider(),
+            mem0: new Mem0Provider_1.Mem0Provider(),
+            'zep-graphiti': new ZepGraphitiProvider_1.ZepGraphitiProvider(),
+            'redis-ams': new RedisAgentMemoryProvider_1.RedisAgentMemoryProvider()
+        };
+    }
+    get(name) {
+        return this.providers[name] || null;
+    }
+    list() {
+        return Object.keys(this.providers);
+    }
+}
+exports.MemoryProviderRegistry = MemoryProviderRegistry;

package/dist/memory/MemoryRetentionPolicy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRetentionPolicy = void 0;
+class MemoryRetentionPolicy {
+    decide(record) {
+        const createdAt = new Date(record.createdAt).getTime();
+        const now = Date.now();
+        const ageDays = (now - createdAt) / (1000 * 60 * 60 * 24);
+        if (record.type === 'working') {
+            return {
+                keep: ageDays <= 7,
+                expiresAt: new Date(createdAt + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                rationale: 'Working memory expira rápido para evitar entulho operacional.'
+            };
+        }
+        if (record.type === 'temporal') {
+            return {
+                keep: ageDays <= 30,
+                expiresAt: new Date(createdAt + 30 * 24 * 60 * 60 * 1000).toISOString(),
+                rationale: 'Temporal memory retida por janela curta de contexto.'
+            };
+        }
+        if (record.type === 'profile') {
+            return {
+                keep: true,
+                rationale: 'Profile memory é persistente por padrão e exige remoção explícita.'
+            };
+        }
+        return {
+            keep: true,
+            rationale: 'Episodic/semantic memory pode permanecer até futura curadoria.'
+        };
+    }
+    score(record, query) {
+        const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const hay = `${record.content} ${record.summary || ''} ${(record.tags || []).join(' ')}`.toLowerCase();
+        const lexical = terms.reduce((acc, term) => acc + (hay.includes(term) ? 1 : 0), 0);
+        const confidence = record.confidence || 0.5;
+        const recencyBoost = this.recencyBoost(record.type, record.createdAt);
+        const typeBoost = this.typeBoost(record.type);
+        return lexical * 3 + confidence * 2 + recencyBoost + typeBoost;
+    }
+    recencyBoost(type, createdAt) {
+        const ageHours = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60);
+        if (type === 'working')
+            return ageHours < 24 ? 3 : ageHours < 72 ? 2 : 0;
+        if (type === 'temporal')
+            return ageHours < 168 ? 2 : 0;
+        return ageHours < 168 ? 1 : 0;
+    }
+    typeBoost(type) {
+        switch (type) {
+            case 'profile': return 3;
+            case 'semantic': return 2;
+            case 'episodic': return 1;
+            default: return 0;
+        }
+    }
+}
+exports.MemoryRetentionPolicy = MemoryRetentionPolicy;

package/dist/memory/MempalaceProvider.js

@@ -0,0 +1,72 @@
+"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.MempalaceProvider = void 0;
+const child_process = __importStar(require("child_process"));
+const util_1 = require("util");
+const exec = (0, util_1.promisify)(child_process.exec);
+class MempalaceProvider {
+    mempalacePath;
+    constructor(mempalacePath = process.env.MEMPALACE_BIN_PATH || '~/.venvs/mempalace/bin/mempalace') {
+        this.mempalacePath = mempalacePath;
+    }
+    name() {
+        return 'mempalace';
+    }
+    async search(input) {
+        const safeQuery = input.query.replace(/"/g, '\\"');
+        const command = `bash -c "${this.mempalacePath} search \\\"${safeQuery}\\\""`;
+        try {
+            const { stdout } = await exec(command);
+            if (!stdout.trim())
+                return [];
+            return [{
+                    id: `mempalace-${Date.now()}`,
+                    type: 'episodic',
+                    namespace: input.namespace || {},
+                    content: stdout,
+                    summary: stdout.slice(0, 200),
+                    createdAt: new Date().toISOString()
+                }];
+        }
+        catch {
+            return [];
+        }
+    }
+    async save(record) {
+        void record;
+    }
+}
+exports.MempalaceProvider = MempalaceProvider;

package/dist/memory/OmniMemory.js

@@ -0,0 +1,106 @@
+"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.OmniMemory = void 0;
+const child_process = __importStar(require("child_process"));
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LocalMemoryProvider_1 = require("./LocalMemoryProvider");
+const MemoryOrchestrator_1 = require("./MemoryOrchestrator");
+const ToolsetGuard_1 = require("../orchestrator/toolset/ToolsetGuard");
+const exec = (0, util_1.promisify)(child_process.exec);
+class OmniMemory {
+    mempalacePath;
+    localProvider;
+    orchestrator;
+    constructor() {
+        this.mempalacePath = process.env.MEMPALACE_BIN_PATH || '~/.venvs/mempalace/bin/mempalace';
+        this.localProvider = new LocalMemoryProvider_1.LocalMemoryProvider();
+        this.orchestrator = new MemoryOrchestrator_1.MemoryOrchestrator();
+    }
+    async search(query, namespace) {
+        const queryObj = { query, topK: 5, namespace };
+        const hits = await this.orchestrator.search(queryObj, ['local', 'mempalace']);
+        if (hits.length) {
+            return hits.map(hit => `- [${hit.provider}] ${hit.record.summary || hit.record.content}`).join('\n');
+        }
+        console.log(`[OMNI-MEMORY] Buscando no MemPalace: "${query}"...`);
+        try {
+            const safeQuery = query.replace(/"/g, '\\"');
+            const command = `bash -c "${this.mempalacePath} search \\\"${safeQuery}\\\""`;
+            const { stdout } = await exec(command);
+            if (!stdout.trim() || stdout.includes("No results found")) {
+                return "Nenhuma memória encontrada no Palácio para este termo.";
+            }
+            const citation = `\n\n[RAG de Evidências: Buscado em ${new Date().toISOString()}]`;
+            return stdout + citation;
+        }
+        catch (error) {
+            console.warn(`[OMNI-MEMORY] Aviso ao buscar no MemPalace (pode ser ausência de resultados):`, error);
+            return "Busca na Omni-Memory concluída com alertas ou sem resultados diretos.";
+        }
+    }
+    async saveFact(fact, metadata, namespace) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('memory', 'OmniMemory.saveFact');
+        const content = `\n\n### Fato Salvo\n**Timestamp:** ${new Date(metadata.timestamp).toISOString()}\n**Fonte:** [${metadata.source_uri}](${metadata.source_uri})\n\n${fact}\n`;
+        const evidenceFile = path.join(process.cwd(), 'evidence_log.md');
+        fs.appendFileSync(evidenceFile, content);
+        await this.orchestrator.save({
+            type: 'semantic',
+            namespace,
+            content: fact,
+            summary: fact.slice(0, 180),
+            tags: ['fact', 'evidence'],
+            confidence: 0.85,
+            dedupeKey: `${metadata.source_uri}:${fact.slice(0, 80)}`,
+            providers: ['local']
+        });
+        console.log(`[OMNI-MEMORY] Fato salvo com evidências em ${evidenceFile}`);
+    }
+    async wakeup() {
+        console.log(`[OMNI-MEMORY] Executando protocolo de Wake-up (L0 + L1)...`);
+        try {
+            const command = `bash -c "${this.mempalacePath} wake-up"`;
+            const { stdout } = await exec(command);
+            return stdout;
+        }
+        catch (error) {
+            console.error(`[OMNI-MEMORY] Erro no Wake-up:`, error);
+            return "Falha ao acordar o MemPalace.";
+        }
+    }
+}
+exports.OmniMemory = OmniMemory;

package/dist/memory/RedisAgentMemoryProvider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisAgentMemoryProvider = void 0;
+class RedisAgentMemoryProvider {
+    name() {
+        return 'redis-ams';
+    }
+    async search(input) {
+        void input;
+        return [];
+    }
+    async save(record) {
+        void record;
+    }
+}
+exports.RedisAgentMemoryProvider = RedisAgentMemoryProvider;

package/dist/memory/SessionManager.js

@@ -0,0 +1,86 @@
+"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.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class SessionManager {
+    sessionsDir;
+    constructor() {
+        // As sessões de longa duração ficam salvas localmente para resiliência
+        this.sessionsDir = path.join(process.cwd(), '.sessions');
+        if (!fs.existsSync(this.sessionsDir)) {
+            fs.mkdirSync(this.sessionsDir, { recursive: true });
+        }
+    }
+    getSession(userId) {
+        const sessionFile = path.join(this.sessionsDir, `session_${userId}.json`);
+        if (fs.existsSync(sessionFile)) {
+            try {
+                const data = fs.readFileSync(sessionFile, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (e) {
+                console.error(`[SESSION MANAGER] Erro ao ler sessão de ${userId}. Criando nova.`);
+            }
+        }
+        // Retorna sessão em branco (Nova)
+        return {
+            id: userId,
+            lastActive: new Date().toISOString(),
+            history: [],
+            activeContext: { budgetSpent: 0 }
+        };
+    }
+    saveSession(session) {
+        session.lastActive = new Date().toISOString();
+        const sessionFile = path.join(this.sessionsDir, `session_${session.id}.json`);
+        fs.writeFileSync(sessionFile, JSON.stringify(session, null, 2));
+    }
+    addMessage(userId, role, content) {
+        const session = this.getSession(userId);
+        session.history.push({
+            role,
+            content,
+            timestamp: new Date().toISOString()
+        });
+        // Mantém apenas as últimas 50 interações para não estourar o contexto (Compressão Base)
+        if (session.history.length > 50) {
+            session.history = session.history.slice(session.history.length - 50);
+        }
+        this.saveSession(session);
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/memory/ZepGraphitiProvider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZepGraphitiProvider = void 0;
+class ZepGraphitiProvider {
+    name() {
+        return 'zep-graphiti';
+    }
+    async search(input) {
+        void input;
+        return [];
+    }
+    async save(record) {
+        void record;
+    }
+}
+exports.ZepGraphitiProvider = ZepGraphitiProvider;