aiden-runtime 3.16.0

package/dist/core/mcpClient.js

@@ -0,0 +1,442 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpClient = exports.MCPClient = void 0;
+exports.connectMcpServer = connectMcpServer;
+exports.disconnectMcpServer = disconnectMcpServer;
+exports.listMcpServers = listMcpServers;
+exports.listMcpTools = listMcpTools;
+exports.callMcpTool = callMcpTool;
+// core/mcpClient.ts — MCP (Model Context Protocol) client.
+// Supports both stdio and HTTP MCP servers using JSON-RPC 2.0.
+// Protocol version: 2024-11-05 (MCP spec 1.x)
+//
+// JSON-RPC methods used:
+//   "initialize"  — capability handshake on connect
+//   "tools/list"  — discover available tools
+//   "tools/call"  — invoke a tool with arguments
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const version_1 = require("./version");
+// ── Paths ──────────────────────────────────────────────────────
+const LEGACY_CONFIG_PATH = path_1.default.join(process.cwd(), 'config', 'mcp-servers.json');
+const MCP_CONFIG_PATH = path_1.default.join(process.cwd(), 'workspace', 'config', 'mcp.json');
+// ── McpManager — new native client (Phase 1) ──────────────────
+class McpManager {
+    constructor() {
+        this.configs = new Map();
+        this.stdioConns = new Map();
+        this.toolCache = new Map();
+    }
+    // ── Connect ──────────────────────────────────────────────
+    async connect(config) {
+        this.configs.set(config.name, config);
+        if (config.transport === 'stdio') {
+            await this._connectStdio(config);
+        }
+        else {
+            await this._connectHttp(config);
+        }
+    }
+    // ── Disconnect ───────────────────────────────────────────
+    async disconnect(serverName) {
+        const conn = this.stdioConns.get(serverName);
+        if (conn) {
+            if (conn.retryTimer)
+                clearTimeout(conn.retryTimer);
+            conn.proc.kill();
+            this.stdioConns.delete(serverName);
+        }
+        this.toolCache.delete(serverName);
+        console.log(`[McpManager] Disconnected: ${serverName}`);
+    }
+    // ── List ─────────────────────────────────────────────────
+    servers() {
+        return Array.from(this.configs.keys());
+    }
+    tools() {
+        return Array.from(this.toolCache.values()).flat();
+    }
+    // ── Call tool ────────────────────────────────────────────
+    async call(toolName, args) {
+        // toolName format: 'serverName:originalName'
+        const colonIdx = toolName.indexOf(':');
+        if (colonIdx === -1)
+            throw new Error(`Invalid MCP tool name: "${toolName}" (expected "server:tool")`);
+        const serverName = toolName.slice(0, colonIdx);
+        const origName = toolName.slice(colonIdx + 1);
+        const config = this.configs.get(serverName);
+        if (!config)
+            throw new Error(`MCP server not configured: "${serverName}"`);
+        if (config.transport === 'stdio') {
+            return this._callStdio(serverName, origName, args);
+        }
+        else {
+            return this._callHttp(config, origName, args);
+        }
+    }
+    // ── Load workspace/config/mcp.json ───────────────────────
+    async loadConfig() {
+        try {
+            if (!fs_1.default.existsSync(MCP_CONFIG_PATH))
+                return;
+            const raw = JSON.parse(fs_1.default.readFileSync(MCP_CONFIG_PATH, 'utf-8'));
+            const servers = raw.servers ?? [];
+            for (const srv of servers) {
+                try {
+                    // Expand $ENV_VAR references in env values
+                    const env = {};
+                    for (const [k, v] of Object.entries(srv.env ?? {})) {
+                        env[k] = v.startsWith('$')
+                            ? (process.env[v.slice(1)] ?? '')
+                            : v;
+                    }
+                    await this.connect({ ...srv, env });
+                    console.log(`[McpManager] Connected server from config: ${srv.name}`);
+                }
+                catch (e) {
+                    console.warn(`[McpManager] Failed to connect "${srv.name}": ${e.message}`);
+                }
+            }
+        }
+        catch (e) {
+            if (!String(e.message).includes('ENOENT')) {
+                console.warn(`[McpManager] Failed to load config: ${e.message}`);
+            }
+        }
+    }
+    // ── Stdio transport ──────────────────────────────────────
+    async _connectStdio(config) {
+        const [cmd, ...rest] = (config.command ?? 'npx').split(' ');
+        const args = [...rest, ...(config.args ?? [])];
+        const env = { ...process.env, ...(config.env ?? {}) };
+        const proc = (0, child_process_1.spawn)(cmd, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env,
+            shell: false,
+        });
+        const conn = {
+            proc,
+            buffer: '',
+            pending: new Map(),
+            nextId: 1,
+            config,
+            retryCount: 0,
+        };
+        this.stdioConns.set(config.name, conn);
+        proc.stdout.on('data', (chunk) => {
+            conn.buffer += chunk.toString();
+            // Process newline-delimited JSON messages
+            const lines = conn.buffer.split('\n');
+            conn.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const msg = JSON.parse(trimmed);
+                    if (msg.id != null && conn.pending.has(msg.id)) {
+                        const { resolve, reject } = conn.pending.get(msg.id);
+                        conn.pending.delete(msg.id);
+                        if (msg.error)
+                            reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+                        else
+                            resolve(msg.result);
+                    }
+                }
+                catch { }
+            }
+        });
+        proc.on('exit', () => {
+            this._scheduleReconnect(config, conn);
+        });
+        proc.stderr.on('data', (chunk) => {
+            // Suppress stderr noise — MCP servers write startup logs here
+        });
+        // Handshake: send "initialize"
+        try {
+            await this._rpcStdio(conn, 'initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'aiden', version: version_1.VERSION },
+            });
+            // Discover tools
+            const result = await this._rpcStdio(conn, 'tools/list', {});
+            const raw = result?.tools ?? [];
+            const tools = raw.map((t) => ({
+                name: `${config.name}:${t.name}`,
+                description: String(t.description || t.name),
+                inputSchema: t.inputSchema ?? {},
+                serverName: config.name,
+                originalName: t.name,
+            }));
+            this.toolCache.set(config.name, tools);
+            conn.retryCount = 0;
+            console.log(`[McpManager] stdio/${config.name}: ${tools.length} tool(s) discovered`);
+        }
+        catch (e) {
+            console.warn(`[McpManager] stdio/${config.name} handshake failed: ${e.message}`);
+        }
+    }
+    async _rpcStdio(conn, method, params) {
+        return new Promise((resolve, reject) => {
+            const id = conn.nextId++;
+            const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+            conn.pending.set(id, { resolve, reject });
+            const timer = setTimeout(() => {
+                conn.pending.delete(id);
+                reject(new Error(`RPC timeout: ${method}`));
+            }, 15000);
+            conn.proc.stdin.write(msg, () => clearTimeout(timer));
+        });
+    }
+    async _callStdio(serverName, toolName, args) {
+        const conn = this.stdioConns.get(serverName);
+        if (!conn)
+            throw new Error(`MCP server "${serverName}" not connected`);
+        const result = await this._rpcStdio(conn, 'tools/call', { name: toolName, arguments: args });
+        const content = result?.content ?? [];
+        return content.map((c) => (typeof c.text === 'string' ? c.text : JSON.stringify(c))).join('\n');
+    }
+    _scheduleReconnect(config, conn) {
+        if (conn.retryCount >= 5) {
+            console.warn(`[McpManager] stdio/${config.name}: giving up after 5 retries`);
+            return;
+        }
+        const delayMs = Math.min(1000 * Math.pow(2, conn.retryCount), 30000);
+        conn.retryCount++;
+        conn.retryTimer = setTimeout(() => {
+            console.log(`[McpManager] Reconnecting ${config.name} (attempt ${conn.retryCount})…`);
+            this.stdioConns.delete(config.name);
+            this._connectStdio(config).catch(() => { });
+        }, delayMs);
+    }
+    // ── HTTP transport ───────────────────────────────────────
+    async _connectHttp(config) {
+        if (!config.url)
+            throw new Error(`HTTP MCP server "${config.name}" has no url`);
+        try {
+            // send "initialize"
+            await this._rpcHttp(config.url, 'initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'aiden', version: version_1.VERSION },
+            });
+            // discover tools via "tools/list"
+            const result = await this._rpcHttp(config.url, 'tools/list', {});
+            const raw = result?.tools ?? [];
+            const tools = raw.map((t) => ({
+                name: `${config.name}:${t.name}`,
+                description: String(t.description || t.name),
+                inputSchema: t.inputSchema ?? {},
+                serverName: config.name,
+                originalName: t.name,
+            }));
+            this.toolCache.set(config.name, tools);
+            console.log(`[McpManager] http/${config.name}: ${tools.length} tool(s) discovered`);
+        }
+        catch (e) {
+            console.warn(`[McpManager] http/${config.name} handshake failed: ${e.message}`);
+        }
+    }
+    async _rpcHttp(url, method, params) {
+        let rpcUrl = url.replace(/\/$/, '');
+        // Some servers expect /rpc; others accept POST to root
+        const r = await fetch(rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!r.ok)
+            throw new Error(`HTTP ${r.status}`);
+        const data = await r.json();
+        if (data?.error)
+            throw new Error(`MCP error ${data.error.code}: ${data.error.message}`);
+        return data?.result;
+    }
+    async _callHttp(config, toolName, args) {
+        const result = await this._rpcHttp(config.url, 'tools/call', { name: toolName, arguments: args });
+        const content = result?.content ?? [];
+        return content.map((c) => (typeof c.text === 'string' ? c.text : JSON.stringify(c))).join('\n');
+    }
+}
+// ── Singleton McpManager ──────────────────────────────────────
+const mcpManager = new McpManager();
+// Load config in background on startup (no-throw)
+setImmediate(() => mcpManager.loadConfig().catch(() => { }));
+// ── Named function exports (Phase 1 API) ──────────────────────
+async function connectMcpServer(config) {
+    return mcpManager.connect(config);
+}
+async function disconnectMcpServer(serverName) {
+    return mcpManager.disconnect(serverName);
+}
+function listMcpServers() {
+    return mcpManager.servers();
+}
+function listMcpTools() {
+    return mcpManager.tools();
+}
+async function callMcpTool(toolName, args) {
+    return mcpManager.call(toolName, args);
+}
+// ══════════════════════════════════════════════════════════════
+// Legacy MCPClient class — kept intact for backward compat
+// Used by: agentLoop.ts, api/server.ts, toolRegistry.ts
+// ══════════════════════════════════════════════════════════════
+class MCPClient {
+    constructor() {
+        this.servers = [];
+        this.toolCache = new Map();
+        this.load();
+    }
+    // ── Server management ──────────────────────────────────────
+    addServer(name, url, description = '') {
+        this.servers = this.servers.filter(s => s.name !== name);
+        const server = {
+            name,
+            url: url.replace(/\/$/, ''),
+            enabled: true,
+            description,
+            addedAt: Date.now(),
+        };
+        this.servers.push(server);
+        this.save();
+        console.log(`[MCP] Server added: ${name} → ${server.url}`);
+        return server;
+    }
+    removeServer(name) {
+        this.servers = this.servers.filter(s => s.name !== name);
+        this.toolCache.delete(name);
+        this.save();
+        console.log(`[MCP] Server removed: ${name}`);
+    }
+    toggleServer(name, enabled) {
+        const s = this.servers.find(s => s.name === name);
+        if (!s)
+            return false;
+        s.enabled = enabled;
+        if (!enabled)
+            this.toolCache.delete(name);
+        this.save();
+        return true;
+    }
+    listServers() {
+        return this.servers;
+    }
+    // ── Tool discovery ─────────────────────────────────────────
+    async discoverTools(serverName) {
+        const server = this.servers.find(s => s.name === serverName);
+        if (!server || !server.enabled)
+            return [];
+        try {
+            const r = await fetch(`${server.url}/tools/list`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+                signal: AbortSignal.timeout(8000),
+            });
+            if (!r.ok) {
+                console.warn(`[MCP] discoverTools ${serverName}: HTTP ${r.status}`);
+                return [];
+            }
+            const data = await r.json();
+            const rawTools = data?.result?.tools ?? [];
+            const tools = rawTools.map((t) => ({
+                name: `mcp_${serverName}_${t.name}`,
+                description: String(t.description || t.name),
+                inputSchema: t.inputSchema ?? {},
+                serverName,
+            }));
+            this.toolCache.set(serverName, tools);
+            console.log(`[MCP] Discovered ${tools.length} tool(s) from ${serverName}`);
+            return tools;
+        }
+        catch (e) {
+            console.warn(`[MCP] discoverTools ${serverName}: ${e.message}`);
+            return [];
+        }
+    }
+    async discoverAllServers() {
+        const results = await Promise.allSettled(this.servers.filter(s => s.enabled).map(s => this.discoverTools(s.name)));
+        return results.flatMap(r => r.status === 'fulfilled' ? r.value : []);
+    }
+    // ── Tool execution ─────────────────────────────────────────
+    async callTool(serverName, toolName, input) {
+        const server = this.servers.find(s => s.name === serverName);
+        if (!server)
+            return { success: false, output: `MCP server "${serverName}" not found` };
+        if (!server.enabled)
+            return { success: false, output: `MCP server "${serverName}" is disabled` };
+        try {
+            const r = await fetch(`${server.url}/tools/call`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0', id: 1, method: 'tools/call',
+                    params: { name: toolName, arguments: input },
+                }),
+                signal: AbortSignal.timeout(30000),
+            });
+            if (!r.ok)
+                return { success: false, output: `MCP call failed: HTTP ${r.status}` };
+            const data = await r.json();
+            const content = data?.result?.content ?? [];
+            const output = content
+                .map((c) => (typeof c.text === 'string' ? c.text : JSON.stringify(c)))
+                .join('\n').trim();
+            if (data?.error) {
+                return { success: false, output: `MCP error ${data.error.code ?? ''}: ${data.error.message ?? JSON.stringify(data.error)}` };
+            }
+            return { success: true, output: output || '(empty response)' };
+        }
+        catch (e) {
+            return { success: false, output: `MCP error: ${e.message}` };
+        }
+    }
+    // ── Cache accessors ────────────────────────────────────────
+    getAllCachedTools() {
+        return Array.from(this.toolCache.values()).flat();
+    }
+    getCachedToolsForServer(serverName) {
+        return this.toolCache.get(serverName) ?? [];
+    }
+    // ── Persistence ────────────────────────────────────────────
+    load() {
+        try {
+            const p = fs_1.default.existsSync(MCP_CONFIG_PATH) ? MCP_CONFIG_PATH : LEGACY_CONFIG_PATH;
+            if (!fs_1.default.existsSync(p))
+                return;
+            const raw = fs_1.default.readFileSync(p, 'utf-8');
+            // Legacy format: plain array of MCPServer
+            // New format: { servers: [...] }
+            const parsed = JSON.parse(raw);
+            this.servers = Array.isArray(parsed) ? parsed : (parsed.servers ?? []);
+            setImmediate(() => this.discoverAllServers().catch(() => { }));
+        }
+        catch (e) {
+            console.warn(`[MCP] Failed to load config: ${e.message}`);
+            this.servers = [];
+        }
+    }
+    save() {
+        try {
+            fs_1.default.mkdirSync(path_1.default.dirname(LEGACY_CONFIG_PATH), { recursive: true });
+            fs_1.default.writeFileSync(LEGACY_CONFIG_PATH, JSON.stringify(this.servers, null, 2));
+        }
+        catch (e) {
+            console.warn(`[MCP] Failed to save config: ${e.message}`);
+        }
+    }
+}
+exports.MCPClient = MCPClient;
+// ── Legacy singleton (backward compat) ────────────────────────
+exports.mcpClient = new MCPClient();

package/dist/core/memoryDistiller.js

@@ -0,0 +1,165 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+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.distillSession = distillSession;
+exports.distillAllActiveSessions = distillAllActiveSessions;
+// core/memoryDistiller.ts — Session-end memory distillation (N+27).
+// After a session ends (exit, idle, or SSE close), distils the full
+// conversation into 5-15 compact facts via LLM and persists them
+// into semantic memory. Next session they surface via BM25 search
+// without re-loading any conversation history.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const conversationMemory_1 = require("./conversationMemory");
+const semanticMemory_1 = require("./semanticMemory");
+const agentLoop_1 = require("./agentLoop");
+const router_1 = require("../providers/router");
+// ── Constants ─────────────────────────────────────────────────
+const DISTILL_PROMPT = `You are a memory distillation system. You will be given a conversation transcript.
+Extract 5 to 15 concise, self-contained facts that would be useful to know in a future session.
+Focus on:
+- Files created, modified, or deleted (include full paths)
+- Decisions made and the reasons behind them
+- Problems solved and the approach that worked
+- User preferences observed (style, tools, workflows)
+- Important entities: repos, APIs, services, credentials locations
+- Tasks completed and their outcomes
+
+Output ONLY a plain list, one fact per line, each starting with "- ".
+No headings, no explanations, no blank lines between facts.
+Facts must be self-contained (understandable without the conversation).
+Maximum 15 facts. Minimum 5 facts if the conversation has meaningful content.`;
+const MAX_TRANSCRIPT_CHARS = 32000; // ~8k tokens
+const DISTILL_MARKER_PATH = path_1.default.join(process.cwd(), 'workspace', 'distilled_sessions.json');
+// ── distillSession ────────────────────────────────────────────
+// Main entry point. Reads exchanges for the given sessionId,
+// calls LLM to extract facts, persists to semantic memory.
+// Never throws — all errors are logged and swallowed.
+async function distillSession(sessionId, timeoutMs = 15000) {
+    try {
+        // Load the correct session
+        conversationMemory_1.conversationMemory.setSession(sessionId);
+        const exchanges = conversationMemory_1.conversationMemory.state?.exchanges;
+        if (!exchanges || exchanges.length < 3) {
+            return { factsExtracted: 0, facts: [], skipped: 'too few exchanges' };
+        }
+        // Check if already distilled
+        if (isAlreadyDistilled(sessionId)) {
+            return { factsExtracted: 0, facts: [], skipped: 'already distilled' };
+        }
+        // Build transcript
+        let transcript = '';
+        for (const ex of exchanges) {
+            const turn = `User: ${ex.userMessage}\nAssistant: ${ex.aiReply}\n\n`;
+            if (transcript.length + turn.length > MAX_TRANSCRIPT_CHARS)
+                break;
+            transcript += turn;
+        }
+        if (!transcript.trim()) {
+            return { factsExtracted: 0, facts: [], skipped: 'empty transcript' };
+        }
+        // Call LLM with timeout
+        const tier = (0, router_1.getModelForTask)('planner');
+        const prompt = `${DISTILL_PROMPT}\n\n---TRANSCRIPT---\n${transcript}`;
+        const raw = await Promise.race([
+            (0, agentLoop_1.callLLM)(prompt, tier.apiKey, tier.model, tier.providerName),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('distill timeout')), timeoutMs)),
+        ]);
+        // Parse bullet lines
+        const facts = (raw || '')
+            .split('\n')
+            .map(l => l.replace(/^[-*•]\s*/, '').trim())
+            .filter(l => l.length > 10)
+            .slice(0, 15);
+        if (facts.length === 0) {
+            return { factsExtracted: 0, facts: [], skipped: 'no facts parsed' };
+        }
+        // Persist each fact to semantic memory
+        for (const fact of facts) {
+            semanticMemory_1.semanticMemory.add(fact, 'fact', ['distilled', sessionId]);
+        }
+        // N+33: update structured Honcho user profile from distilled facts (non-blocking)
+        Promise.resolve().then(() => __importStar(require('./userProfile'))).then(({ updateProfile }) => updateProfile(facts)).catch(() => { });
+        // Mark session as distilled
+        markDistilled(sessionId);
+        console.log(`[MemoryDistiller] Distilled ${facts.length} facts from session ${sessionId}`);
+        return { factsExtracted: facts.length, facts };
+    }
+    catch (err) {
+        console.warn('[MemoryDistiller] distillSession failed (non-fatal):', err?.message);
+        return { factsExtracted: 0, facts: [], skipped: err?.message ?? 'unknown error' };
+    }
+}
+// ── distillAllActiveSessions ──────────────────────────────────
+// Distils every known session — used on SIGINT/SIGTERM so no
+// session is lost when the server shuts down.
+async function distillAllActiveSessions(timeoutMs = 8000) {
+    try {
+        const sessions = conversationMemory_1.conversationMemory.getSessions();
+        await Promise.allSettled(sessions.map(sid => distillSession(sid, timeoutMs)));
+    }
+    catch (err) {
+        console.warn('[MemoryDistiller] distillAllActiveSessions failed:', err?.message);
+    }
+}
+// ── Distilled-session tracking ────────────────────────────────
+function loadDistilledSet() {
+    try {
+        if (fs_1.default.existsSync(DISTILL_MARKER_PATH)) {
+            return new Set(JSON.parse(fs_1.default.readFileSync(DISTILL_MARKER_PATH, 'utf-8')));
+        }
+    }
+    catch { }
+    return new Set();
+}
+function isAlreadyDistilled(sessionId) {
+    return loadDistilledSet().has(sessionId);
+}
+function markDistilled(sessionId) {
+    try {
+        const set = loadDistilledSet();
+        set.add(sessionId);
+        fs_1.default.mkdirSync(path_1.default.dirname(DISTILL_MARKER_PATH), { recursive: true });
+        fs_1.default.writeFileSync(DISTILL_MARKER_PATH, JSON.stringify([...set], null, 2) + '\n', 'utf-8');
+    }
+    catch { }
+}