labgate 0.5.10 → 0.5.11

package/dist/lib/ui.js

@@ -46,6 +46,7 @@ const container_js_1 = require("./container.js");
 const audit_js_1 = require("./audit.js");
 const slurm_db_js_1 = require("./slurm-db.js");
 const slurm_poller_js_1 = require("./slurm-poller.js");
+const results_store_js_1 = require("./results-store.js");
 const policy_js_1 = require("./policy.js");
 const license_js_1 = require("./license.js");
 const log = __importStar(require("./log.js"));
@@ -60,6 +61,13 @@ const LABGATE_INSTRUCTION_END = '<!-- LABGATE_SESSION_INSTRUCTION_END -->';
 // ── SLURM module state (initialised in startUI when slurm.enabled) ──
 let slurmDB = null;
 let slurmPoller = null;
+let resultsStore = null;
+function getResultsStore() {
+    if (!resultsStore) {
+        resultsStore = new results_store_js_1.ResultsStore((0, config_js_1.getResultsDbPath)());
+    }
+    return resultsStore;
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -1372,6 +1380,93 @@ async function handleStopSession(req, res) {
         json(res, { ok: false, error: err.message ?? String(err) }, 500);
     }
 }
+function resolveCliEntrypoint() {
+    const distCli = (0, path_1.resolve)(__dirname, '..', 'cli.js');
+    if ((0, fs_1.existsSync)(distCli))
+        return distCli;
+    const binCli = (0, path_1.resolve)(__dirname, '..', '..', 'bin', 'labgate.js');
+    if ((0, fs_1.existsSync)(binCli))
+        return binCli;
+    throw new Error('Could not find LabGate CLI entrypoint');
+}
+function relaunchSessionDetached(agent, workdir) {
+    const cliEntrypoint = resolveCliEntrypoint();
+    const child = (0, child_process_1.spawn)(process.execPath, [cliEntrypoint, agent, workdir, '--no-footer'], {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+    });
+    child.unref();
+}
+async function waitForSessionFileRemoval(sessionFile, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    while ((0, fs_1.existsSync)(sessionFile) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+}
+async function handleRestartSession(req, res) {
+    try {
+        const body = await readBody(req);
+        const parsed = JSON.parse(body || '{}');
+        const id = normalizeSessionId(parsed.id || '');
+        if (!id) {
+            json(res, { ok: false, error: 'Missing or invalid session id' }, 400);
+            return;
+        }
+        const dir = (0, config_js_1.getSessionsDir)();
+        const localHost = (0, os_1.hostname)();
+        const sessionFile = (0, path_1.join)(dir, id + '.json');
+        if (!(0, fs_1.existsSync)(sessionFile)) {
+            json(res, { ok: false, error: 'Session not found' }, 404);
+            return;
+        }
+        const data = JSON.parse((0, fs_1.readFileSync)(sessionFile, 'utf-8'));
+        if (data.node !== localHost) {
+            json(res, { ok: false, error: 'Session is on a different node (' + data.node + ')' }, 400);
+            return;
+        }
+        const agent = String(data.agent || '').toLowerCase();
+        const workdir = String(data.workdir || '');
+        if (!agent || !workdir) {
+            json(res, { ok: false, error: 'Session file is missing agent or workdir' }, 400);
+            return;
+        }
+        if (agent !== 'claude' && agent !== 'codex') {
+            json(res, { ok: false, error: `Unsupported agent: ${agent}` }, 400);
+            return;
+        }
+        try {
+            process.kill(data.pid, 'SIGTERM');
+        }
+        catch {
+            // Process is already gone. Continue with cleanup + relaunch.
+        }
+        await waitForSessionFileRemoval(sessionFile);
+        if ((0, fs_1.existsSync)(sessionFile)) {
+            let stillRunning = false;
+            try {
+                process.kill(data.pid, 0);
+                stillRunning = true;
+            }
+            catch {
+                // Process is gone.
+            }
+            if (stillRunning) {
+                json(res, { ok: false, error: 'Session did not stop in time. Please stop it first and retry.' }, 409);
+                return;
+            }
+            try {
+                (0, fs_1.unlinkSync)(sessionFile);
+            }
+            catch { /* best effort */ }
+        }
+        relaunchSessionDetached(agent, workdir);
+        json(res, { ok: true, restarted: { id, agent, workdir } });
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 500);
+    }
+}
 /**
  * Validate a host path: exists, is a directory, and is readable.
  * Returns { valid: true/false, error?, path? } — advisory only, does not block.
@@ -1467,6 +1562,581 @@ async function collectContainerStats(sessionIds) {
     containerStatsCache = new Map();
     return containerStatsCache;
 }
+function mapContainerPathToHost(path, sandboxHome) {
+    if (path.startsWith('/home/sandbox/')) {
+        return (0, path_1.join)(sandboxHome, path.slice('/home/sandbox/'.length));
+    }
+    if (path === '/labgate-config/config.json')
+        return (0, config_js_1.getConfigPath)();
+    if (path === '/labgate-config/slurm.db')
+        return (0, config_js_1.getSlurmDbPath)();
+    return path;
+}
+function readMcpConfigData() {
+    const sandboxHome = (0, config_js_1.getSandboxHome)();
+    const mcpConfigPath = (0, path_1.join)(sandboxHome, '.claude.json');
+    let mcpJson = {};
+    try {
+        if ((0, fs_1.existsSync)(mcpConfigPath)) {
+            mcpJson = JSON.parse((0, fs_1.readFileSync)(mcpConfigPath, 'utf-8'));
+        }
+    }
+    catch {
+        mcpJson = {};
+    }
+    return {
+        sandboxHome,
+        mcpConfigPath,
+        mcpConfigExists: (0, fs_1.existsSync)(mcpConfigPath),
+        mcpJson,
+        registeredServers: (mcpJson.mcpServers || {}),
+    };
+}
+function resolveServerPathFromEntry(entry, sandboxHome) {
+    if (!entry || !Array.isArray(entry.args) || typeof entry.args[0] !== 'string')
+        return null;
+    return mapContainerPathToHost(entry.args[0], sandboxHome);
+}
+function resolveDbPathFromEntry(entry, sandboxHome) {
+    if (!entry || !Array.isArray(entry.args))
+        return null;
+    const idx = entry.args.findIndex((arg) => arg === '--db');
+    if (idx < 0 || typeof entry.args[idx + 1] !== 'string')
+        return null;
+    return mapContainerPathToHost(entry.args[idx + 1], sandboxHome);
+}
+function inferServerState(id, configured, entry, sandboxHome) {
+    const registered = !!entry;
+    if (!configured)
+        return { configured, registered, ready: false, reason: 'disabled_in_config' };
+    if (!registered)
+        return { configured, registered, ready: false, reason: 'not_registered_yet' };
+    const command = entry?.command;
+    if (!command || typeof command !== 'string') {
+        return { configured, registered, ready: false, reason: 'missing_command' };
+    }
+    const serverPath = resolveServerPathFromEntry(entry, sandboxHome);
+    if (command === 'node' && (!serverPath || !(0, fs_1.existsSync)(serverPath))) {
+        return { configured, registered, ready: false, reason: 'missing_bundle_or_script' };
+    }
+    if (id === 'labgate-slurm') {
+        const usesSandboxModules = !!serverPath && serverPath.startsWith((0, path_1.join)(sandboxHome, '.mcp-servers'));
+        const sqlitePkg = usesSandboxModules
+            ? (0, path_1.join)(sandboxHome, '.mcp-servers', 'node_modules', 'better-sqlite3')
+            : (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', 'better-sqlite3');
+        if (!(0, fs_1.existsSync)(sqlitePkg)) {
+            return { configured, registered, ready: false, reason: 'missing_dependency_better_sqlite3' };
+        }
+    }
+    return { configured, registered, ready: true, reason: 'ready' };
+}
+function normalizeMcpEntryForHost(entry, sandboxHome) {
+    const command = mapContainerPathToHost(String(entry.command || ''), sandboxHome);
+    const args = Array.isArray(entry.args) ? entry.args.map((arg) => mapContainerPathToHost(String(arg), sandboxHome)) : [];
+    const env = typeof entry.env === 'object' && entry.env ? { ...entry.env } : {};
+    if (env.LABGATE_CONFIG_PATH)
+        env.LABGATE_CONFIG_PATH = mapContainerPathToHost(env.LABGATE_CONFIG_PATH, sandboxHome);
+    if (env.LABGATE_CONTAINER_MODE === '1')
+        delete env.LABGATE_CONTAINER_MODE;
+    return { command, args, env };
+}
+function collectMcpState() {
+    const config = (0, config_js_1.loadConfig)();
+    const { sandboxHome, mcpConfigPath, mcpConfigExists, registeredServers } = readMcpConfigData();
+    const slurmConfigured = config.slurm.enabled && config.slurm.mcp_server;
+    const clusterConfigured = config.slurm.enabled && config.slurm.mcp_server;
+    const datasetsConfigured = true;
+    const resultsConfigured = true;
+    const slurmEntry = registeredServers['labgate-slurm'];
+    const clusterEntry = registeredServers['labgate-cluster'];
+    const datasetsEntry = registeredServers['labgate-datasets'];
+    const resultsEntry = registeredServers['labgate-results'];
+    const slurmState = inferServerState('labgate-slurm', slurmConfigured, slurmEntry, sandboxHome);
+    const clusterState = inferServerState('labgate-cluster', clusterConfigured, clusterEntry, sandboxHome);
+    const datasetsState = inferServerState('labgate-datasets', datasetsConfigured, datasetsEntry, sandboxHome);
+    const resultsState = inferServerState('labgate-results', resultsConfigured, resultsEntry, sandboxHome);
+    const servers = [
+        {
+            id: 'labgate-slurm',
+            name: 'labgate-slurm',
+            description: 'SLURM job tracker. Query job status, read output, and manage SLURM jobs.',
+            active: slurmState.ready,
+            configured: slurmState.configured,
+            registered: slurmState.registered,
+            ready: slurmState.ready,
+            reason: slurmState.reason,
+            command: slurmEntry?.command || null,
+            args: Array.isArray(slurmEntry?.args) ? slurmEntry.args : null,
+            env: slurmEntry?.env || null,
+            mcpConfigPath,
+            serverPath: resolveServerPathFromEntry(slurmEntry, sandboxHome),
+            dbPath: resolveDbPathFromEntry(slurmEntry, sandboxHome),
+            tools: [
+                { name: 'list_slurm_jobs', title: 'List SLURM Jobs', description: 'List tracked SLURM jobs with filtering by state or search' },
+                { name: 'get_slurm_job', title: 'Get SLURM Job Details', description: 'Get detailed info about a specific SLURM job' },
+                { name: 'get_slurm_output', title: 'Read SLURM Job Output', description: 'Read stdout/stderr output of a SLURM job' },
+                { name: 'cancel_slurm_job', title: 'Cancel SLURM Job', description: 'Cancel a pending or running SLURM job' },
+                { name: 'set_slurm_job_notes', title: 'Set SLURM Job Notes', description: 'Add or update notes on a SLURM job' },
+            ],
+        },
+        {
+            id: 'labgate-cluster',
+            name: 'labgate-cluster',
+            description: 'Cluster helper. Inspect partitions, limits, queue pressure, and available environment modules.',
+            active: clusterState.ready,
+            configured: clusterState.configured,
+            registered: clusterState.registered,
+            ready: clusterState.ready,
+            reason: clusterState.reason,
+            command: clusterEntry?.command || null,
+            args: Array.isArray(clusterEntry?.args) ? clusterEntry.args : null,
+            env: clusterEntry?.env || null,
+            mcpConfigPath,
+            serverPath: resolveServerPathFromEntry(clusterEntry, sandboxHome),
+            dbPath: resolveDbPathFromEntry(clusterEntry, sandboxHome),
+            tools: [
+                { name: 'get_cluster_partitions', title: 'Get Cluster Partitions', description: 'List SLURM partitions with availability, node counts, and limits' },
+                { name: 'get_partition_limits', title: 'Get Partition Limits', description: 'Show partition policy limits from SLURM configuration' },
+                { name: 'get_queue_pressure', title: 'Get Queue Pressure', description: 'Summarize pending/running load by partition' },
+                { name: 'find_module', title: 'Find Environment Modules', description: 'Search available HPC environment modules before job submission' },
+            ],
+        },
+        {
+            id: 'labgate-datasets',
+            name: 'labgate-datasets',
+            description: 'Dataset manager. Register, browse, search, and inspect datasets mounted in the sandbox.',
+            active: datasetsState.ready,
+            configured: datasetsState.configured,
+            registered: datasetsState.registered,
+            ready: datasetsState.ready,
+            reason: datasetsState.reason,
+            command: datasetsEntry?.command || null,
+            args: Array.isArray(datasetsEntry?.args) ? datasetsEntry.args : null,
+            env: datasetsEntry?.env || null,
+            mcpConfigPath,
+            serverPath: resolveServerPathFromEntry(datasetsEntry, sandboxHome),
+            dbPath: resolveDbPathFromEntry(datasetsEntry, sandboxHome),
+            tools: [
+                { name: 'list_datasets', title: 'List Datasets', description: 'List all configured datasets with stats' },
+                { name: 'inspect_dataset', title: 'Inspect Dataset', description: 'Browse dataset directory contents' },
+                { name: 'search_dataset', title: 'Search Dataset Files', description: 'Search for files by pattern in a dataset' },
+                { name: 'get_dataset_summary', title: 'Dataset Summary', description: 'Get size, file count, and extension breakdown' },
+                { name: 'read_dataset_file', title: 'Read Dataset File', description: 'Read text file contents from a dataset' },
+                { name: 'validate_dataset', title: 'Validate Dataset', description: 'Validate dataset path/name/mode before registration' },
+                { name: 'register_dataset', title: 'Register Dataset', description: 'Add a host directory as a named dataset' },
+                { name: 'update_dataset', title: 'Update Dataset', description: 'Update an existing dataset registration' },
+                { name: 'unregister_dataset', title: 'Unregister Dataset', description: 'Remove a dataset from the config' },
+            ],
+        },
+        {
+            id: 'labgate-results',
+            name: 'labgate-results',
+            description: 'Results registry. Record and retrieve structured findings across sessions.',
+            active: resultsState.ready,
+            configured: resultsState.configured,
+            registered: resultsState.registered,
+            ready: resultsState.ready,
+            reason: resultsState.reason,
+            command: resultsEntry?.command || null,
+            args: Array.isArray(resultsEntry?.args) ? resultsEntry.args : null,
+            env: resultsEntry?.env || null,
+            mcpConfigPath,
+            serverPath: resolveServerPathFromEntry(resultsEntry, sandboxHome),
+            dbPath: null,
+            tools: [
+                { name: 'list_results', title: 'List Results', description: 'List recorded results with filtering and pagination' },
+                { name: 'register_result', title: 'Register Result', description: 'Create a new structured result entry' },
+                { name: 'get_result', title: 'Get Result', description: 'Retrieve one result by id' },
+                { name: 'update_result', title: 'Update Result', description: 'Update an existing result entry' },
+                { name: 'delete_result', title: 'Delete Result', description: 'Delete a result entry' },
+            ],
+        },
+    ];
+    return {
+        mcpConfigPath,
+        mcpConfigExists,
+        servers,
+        activeCount: servers.filter((s) => s.ready).length,
+        checkedAt: new Date().toISOString(),
+    };
+}
+function handleGetMcp(_req, res) {
+    const state = collectMcpState();
+    json(res, { ok: true, ...state });
+}
+function handleGetMcpConfigRaw(_req, res) {
+    const { mcpConfigPath, mcpConfigExists } = collectMcpState();
+    if (!mcpConfigExists || !(0, fs_1.existsSync)(mcpConfigPath)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('MCP config file does not exist yet.');
+        return;
+    }
+    const content = (0, fs_1.readFileSync)(mcpConfigPath, 'utf-8');
+    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end(content);
+}
+async function runMcpHealthCheck(serverId, entry) {
+    const started = Date.now();
+    const { sandboxHome } = readMcpConfigData();
+    const normalized = normalizeMcpEntryForHost(entry, sandboxHome);
+    if (!normalized.command) {
+        return { ok: false, message: 'Missing command in MCP entry.', durationMs: Date.now() - started, command: '', args: [] };
+    }
+    return await new Promise((resolveDone) => {
+        const child = (0, child_process_1.spawn)(normalized.command, normalized.args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...normalized.env },
+        });
+        let done = false;
+        let stdoutBuf = '';
+        let stderrBuf = '';
+        let initDone = false;
+        const timeout = setTimeout(() => finish(false, 'Timed out waiting for MCP handshake.'), 8_000);
+        function finish(ok, message, toolCount) {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timeout);
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* best effort */ }
+            resolveDone({
+                ok,
+                message,
+                toolCount,
+                durationMs: Date.now() - started,
+                stderr: stderrBuf.trim() || undefined,
+                command: normalized.command,
+                args: normalized.args,
+            });
+        }
+        function send(message) {
+            try {
+                child.stdin.write(JSON.stringify(message) + '\n');
+            }
+            catch {
+                finish(false, 'Failed to write to MCP process stdin.');
+            }
+        }
+        function handleRpcMessage(msg) {
+            if (done)
+                return;
+            if (msg && msg.id === 1) {
+                if (msg.error) {
+                    finish(false, `initialize failed: ${msg.error.message || JSON.stringify(msg.error)}`);
+                    return;
+                }
+                initDone = true;
+                send({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} });
+                send({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+                return;
+            }
+            if (msg && msg.id === 2) {
+                if (msg.error) {
+                    finish(false, `tools/list failed: ${msg.error.message || JSON.stringify(msg.error)}`);
+                    return;
+                }
+                const tools = Array.isArray(msg?.result?.tools) ? msg.result.tools : [];
+                finish(true, `MCP handshake successful (${tools.length} tools).`, tools.length);
+            }
+        }
+        child.on('error', (err) => {
+            finish(false, `Failed to spawn MCP server: ${err.message}`);
+        });
+        child.stdout.on('data', (chunk) => {
+            stdoutBuf += chunk.toString('utf-8');
+            let idx = stdoutBuf.indexOf('\n');
+            while (idx >= 0) {
+                const line = stdoutBuf.slice(0, idx).trim();
+                stdoutBuf = stdoutBuf.slice(idx + 1);
+                if (line) {
+                    try {
+                        const msg = JSON.parse(line);
+                        handleRpcMessage(msg);
+                    }
+                    catch {
+                        // Ignore non-JSON output lines.
+                    }
+                }
+                idx = stdoutBuf.indexOf('\n');
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrBuf += chunk.toString('utf-8');
+            if (stderrBuf.length > 4000)
+                stderrBuf = stderrBuf.slice(-4000);
+        });
+        child.on('exit', (code, signal) => {
+            if (done)
+                return;
+            const detail = initDone
+                ? `MCP process exited before tools/list response (code ${code ?? 'null'}, signal ${signal ?? 'none'}).`
+                : `MCP process exited before initialize response (code ${code ?? 'null'}, signal ${signal ?? 'none'}).`;
+            finish(false, detail);
+        });
+        send({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'labgate-ui', version: '1.0.0' },
+            },
+        });
+    });
+}
+async function handlePostMcpReregister(_req, res) {
+    try {
+        const config = (0, config_js_1.loadConfig)();
+        (0, container_js_1.prepareMcpServers)({
+            agent: 'claude',
+            workdir: process.cwd(),
+            config,
+            dryRun: false,
+        });
+        const state = collectMcpState();
+        json(res, { ok: true, message: 'MCP servers re-registered.', ...state });
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 500);
+    }
+}
+async function handlePostMcpTest(req, res) {
+    try {
+        const body = await readBody(req);
+        const parsed = JSON.parse(body || '{}');
+        const id = String(parsed.id || '').trim();
+        if (!id) {
+            json(res, { ok: false, error: 'Missing server id.' }, 400);
+            return;
+        }
+        const state = collectMcpState();
+        const server = state.servers.find((s) => s.id === id);
+        if (!server) {
+            json(res, { ok: false, error: `Unknown server id: ${id}` }, 404);
+            return;
+        }
+        if (!server.registered) {
+            json(res, { ok: false, error: `Server "${id}" is not registered.`, result: null }, 400);
+            return;
+        }
+        const { registeredServers } = readMcpConfigData();
+        const entry = registeredServers[id];
+        if (!entry || !entry.command) {
+            json(res, { ok: false, error: `Server "${id}" has invalid command config.`, result: null }, 400);
+            return;
+        }
+        const result = await runMcpHealthCheck(id, entry);
+        json(res, { ok: result.ok, server: id, result });
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 500);
+    }
+}
+// ── Results API handlers ────────────────────────────────────
+function parseResultPayload(raw, mode) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { ok: false, error: 'Body must be a JSON object.' };
+    }
+    if (mode === 'create' && typeof raw.title !== 'string') {
+        return { ok: false, error: 'title is required and must be a string.' };
+    }
+    const optionalStringFields = ['title', 'summary', 'source', 'session_id', 'workdir'];
+    for (const field of optionalStringFields) {
+        if (raw[field] !== undefined && raw[field] !== null && typeof raw[field] !== 'string') {
+            return { ok: false, error: `${field} must be a string or null.` };
+        }
+    }
+    if (raw.details !== undefined && raw.details !== null && typeof raw.details !== 'string') {
+        return { ok: false, error: 'details must be a string or null.' };
+    }
+    if (raw.tags !== undefined &&
+        (!Array.isArray(raw.tags) || raw.tags.some((v) => typeof v !== 'string'))) {
+        return { ok: false, error: 'tags must be an array of strings.' };
+    }
+    if (raw.artifacts !== undefined &&
+        (!Array.isArray(raw.artifacts) || raw.artifacts.some((v) => typeof v !== 'string'))) {
+        return { ok: false, error: 'artifacts must be an array of strings.' };
+    }
+    if (raw.metadata !== undefined &&
+        raw.metadata !== null &&
+        (typeof raw.metadata !== 'object' || Array.isArray(raw.metadata))) {
+        return { ok: false, error: 'metadata must be an object or null.' };
+    }
+    const payload = {
+        title: raw.title,
+        summary: raw.summary,
+        details: raw.details,
+        source: raw.source,
+        session_id: raw.session_id,
+        workdir: raw.workdir,
+        tags: raw.tags,
+        artifacts: raw.artifacts,
+        metadata: raw.metadata,
+    };
+    if (mode === 'update') {
+        const hasPatch = payload.title !== undefined ||
+            payload.summary !== undefined ||
+            payload.details !== undefined ||
+            payload.source !== undefined ||
+            payload.session_id !== undefined ||
+            payload.workdir !== undefined ||
+            payload.tags !== undefined ||
+            payload.artifacts !== undefined ||
+            payload.metadata !== undefined;
+        if (!hasPatch) {
+            return { ok: false, error: 'No update fields provided.' };
+        }
+    }
+    return { ok: true, payload };
+}
+function handleGetResults(reqUrl, res) {
+    const parsedLimit = parseInt(reqUrl.searchParams.get('limit') || '100', 10);
+    const parsedOffset = parseInt(reqUrl.searchParams.get('offset') || '0', 10);
+    const limit = Number.isFinite(parsedLimit) ? Math.min(500, Math.max(1, parsedLimit)) : 100;
+    const offset = Number.isFinite(parsedOffset) ? Math.max(0, parsedOffset) : 0;
+    const store = getResultsStore();
+    const listed = store.listResults({
+        search: reqUrl.searchParams.get('search') || undefined,
+        source: reqUrl.searchParams.get('source') || undefined,
+        tag: reqUrl.searchParams.get('tag') || undefined,
+        limit,
+        offset,
+    });
+    json(res, {
+        ok: true,
+        total: listed.total,
+        returned: listed.results.length,
+        limit,
+        offset,
+        results: listed.results,
+    });
+}
+function handleGetResult(pathname, res) {
+    const id = pathname.match(/\/api\/results\/([^/]+)$/)?.[1];
+    if (!id) {
+        json(res, { ok: false, error: 'Invalid result id' }, 400);
+        return;
+    }
+    const store = getResultsStore();
+    const result = store.getResult(decodeURIComponent(id));
+    if (!result) {
+        json(res, { ok: false, error: 'Result not found' }, 404);
+        return;
+    }
+    json(res, { ok: true, result });
+}
+async function handlePostResults(req, res) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        json(res, { ok: false, error: 'Invalid JSON' }, 400);
+        return;
+    }
+    const parsed = parseResultPayload(body, 'create');
+    if (!parsed.ok) {
+        json(res, { ok: false, error: parsed.error }, 400);
+        return;
+    }
+    try {
+        const store = getResultsStore();
+        const result = store.createResult(parsed.payload);
+        try {
+            const effective = (0, config_js_1.loadEffectiveConfig)();
+            (0, audit_js_1.writeAuditEvent)(effective.config, {
+                timestamp: new Date().toISOString(),
+                session: result.session_id || 'results-ui',
+                event: 'result_registered',
+                result_id: result.id,
+                title: result.title,
+                source: result.source,
+            }, { sharedAuditDir: effective.sharedAuditDir });
+        }
+        catch { /* best effort */ }
+        json(res, { ok: true, result }, 201);
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 400);
+    }
+}
+async function handlePutResult(pathname, req, res) {
+    const id = pathname.match(/\/api\/results\/([^/]+)$/)?.[1];
+    if (!id) {
+        json(res, { ok: false, error: 'Invalid result id' }, 400);
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        json(res, { ok: false, error: 'Invalid JSON' }, 400);
+        return;
+    }
+    const parsed = parseResultPayload(body, 'update');
+    if (!parsed.ok) {
+        json(res, { ok: false, error: parsed.error }, 400);
+        return;
+    }
+    try {
+        const store = getResultsStore();
+        const result = store.updateResult(decodeURIComponent(id), parsed.payload);
+        if (!result) {
+            json(res, { ok: false, error: 'Result not found' }, 404);
+            return;
+        }
+        try {
+            const effective = (0, config_js_1.loadEffectiveConfig)();
+            (0, audit_js_1.writeAuditEvent)(effective.config, {
+                timestamp: new Date().toISOString(),
+                session: result.session_id || 'results-ui',
+                event: 'result_updated',
+                result_id: result.id,
+                title: result.title,
+            }, { sharedAuditDir: effective.sharedAuditDir });
+        }
+        catch { /* best effort */ }
+        json(res, { ok: true, result });
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 400);
+    }
+}
+async function handleDeleteResult(pathname, res) {
+    const id = pathname.match(/\/api\/results\/([^/]+)$/)?.[1];
+    if (!id) {
+        json(res, { ok: false, error: 'Invalid result id' }, 400);
+        return;
+    }
+    const decodedId = decodeURIComponent(id);
+    const store = getResultsStore();
+    const existing = store.getResult(decodedId);
+    if (!existing) {
+        json(res, { ok: false, error: 'Result not found' }, 404);
+        return;
+    }
+    const ok = store.deleteResult(decodedId);
+    if (!ok) {
+        json(res, { ok: false, error: 'Result not found' }, 404);
+        return;
+    }
+    try {
+        const effective = (0, config_js_1.loadEffectiveConfig)();
+        (0, audit_js_1.writeAuditEvent)(effective.config, {
+            timestamp: new Date().toISOString(),
+            session: existing.session_id || 'results-ui',
+            event: 'result_deleted',
+            result_id: existing.id,
+            title: existing.title,
+        }, { sharedAuditDir: effective.sharedAuditDir });
+    }
+    catch { /* best effort */ }
+    json(res, { ok: true });
+}
 // ── SLURM API handlers ──────────────────────────────────────
 function handleGetSlurmJobs(reqUrl, res) {
     if (!slurmDB) {
@@ -2024,6 +2694,9 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/api/sessions/stop' && method === 'POST') {
                 await handleStopSession(req, res);
             }
+            else if (pathname === '/api/sessions/restart' && method === 'POST') {
+                await handleRestartSession(req, res);
+            }
             else if (pathname === '/api/validate-path' && method === 'POST') {
                 await handleValidatePath(req, res);
             }
@@ -2039,6 +2712,33 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/api/security' && method === 'GET') {
                 handleGetSecurity(req, res);
             }
+            else if (pathname === '/api/results' && method === 'GET') {
+                handleGetResults(reqUrl, res);
+            }
+            else if (pathname === '/api/results' && method === 'POST') {
+                await handlePostResults(req, res);
+            }
+            else if (/^\/api\/results\/([^/]+)$/.test(pathname) && method === 'GET') {
+                handleGetResult(pathname, res);
+            }
+            else if (/^\/api\/results\/([^/]+)$/.test(pathname) && method === 'PUT') {
+                await handlePutResult(pathname, req, res);
+            }
+            else if (/^\/api\/results\/([^/]+)$/.test(pathname) && method === 'DELETE') {
+                await handleDeleteResult(pathname, res);
+            }
+            else if (pathname === '/api/mcp' && method === 'GET') {
+                handleGetMcp(req, res);
+            }
+            else if (pathname === '/api/mcp/config/raw' && method === 'GET') {
+                handleGetMcpConfigRaw(req, res);
+            }
+            else if (pathname === '/api/mcp/reregister' && method === 'POST') {
+                await handlePostMcpReregister(req, res);
+            }
+            else if (pathname === '/api/mcp/test' && method === 'POST') {
+                await handlePostMcpTest(req, res);
+            }
             else if (pathname === '/api/events' && method === 'GET') {
                 handleSSE(req, res);
                 // ── SLURM API ──
@@ -2211,6 +2911,7 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             catch { }
             slurmDB = null;
         }
+        resultsStore = null;
     });
     return server;
 }