neurain 0.1.0-alpha.0

package/src/mcp/server.mjs

@@ -0,0 +1,865 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { scanAdoption } from '../core/adopt.mjs';
+import { evaluateAnswerQuality } from '../core/answer_eval.mjs';
+import { listCapabilities } from '../core/capabilities.mjs';
+import { curatorStatus, runCurator } from '../core/curator.mjs';
+import { doctorCommand } from '../core/doctor.mjs';
+import { absPath, compactStamp, ensureDir, safeResolve, timestamp } from '../core/fs.mjs';
+import { listJournalEvents, verifyJournal } from '../core/journal.mjs';
+import { evaluateLessonCandidateDetection, lessonCandidates, listLessons } from '../core/lessons.mjs';
+import { buildLifecycleReport, evaluateLifecycleAutomation } from '../core/lifecycle.mjs';
+import { buildLiveCaseScaffold } from '../core/live_cases.mjs';
+import { buildRecap } from '../core/recap.mjs';
+import { evaluateCrossHostRecall, evaluateSemanticRecall, hybridSearchRecall, rebuildRecall, recallStatus, searchRecall, semanticSearchRecall, verifyRecall } from '../core/recall.mjs';
+import { buildReviewWorkerReport } from '../core/review_worker.mjs';
+import { statusCommand } from '../core/status.mjs';
+import { digestCommand } from '../core/digest.mjs';
+import { queueCommand } from '../core/queue.mjs';
+import { reviewQueueCommand } from '../core/review_queue.mjs';
+import { routeCommand } from '../core/route.mjs';
+import { planWritebackCommand } from '../core/plan_writeback.mjs';
+import { flushCommand, sessionFlushCommand } from '../core/flush.mjs';
+import { compileCommand } from '../core/compile_desk.mjs';
+import { secretLike } from '../core/safety.mjs';
+import { buildSchedulerTick, evaluateSchedulerTriggering } from '../core/scheduler.mjs';
+import { searchRoot } from '../core/search.mjs';
+import { buildWatchReport } from '../core/watch.mjs';
+import { wrapCommand } from '../core/wrap.mjs';
+
+export async function startMcpServer(args) {
+  const root = absPath(args.root || process.env.NEURAIN_ROOT || process.cwd());
+  const pkg = await import('../../package.json', { with: { type: 'json' } });
+  const server = new Server(
+    { name: 'neurain', version: pkg.default.version },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: 'neurain_status',
+        description: 'Read-only Neurain vault status and health summary.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string', description: 'Optional Neurain root folder. Defaults to server root.' },
+          },
+        },
+      },
+      {
+        name: 'neurain_search',
+        description: 'Read-only source-grounded local markdown search.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string' },
+            root: { type: 'string' },
+            top: { type: 'number' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'neurain_capture',
+        description: 'Append-only raw capture. Secret-like input is refused.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            text: { type: 'string' },
+            source: { type: 'string' },
+            root: { type: 'string' },
+          },
+          required: ['text'],
+        },
+      },
+      {
+        name: 'neurain_adopt_scan',
+        description: 'Read-only existing-folder adoption scan with risk recommendation.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            folder: { type: 'string' },
+          },
+          required: ['folder'],
+        },
+      },
+      {
+        name: 'neurain_journal_list',
+        description: 'Read-only event journal list. MCP cannot append journal events.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            type: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_journal_verify',
+        description: 'Read-only event journal integrity check.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_lifecycle_eval',
+        description: 'Read-only native lifecycle automation eval. Proves host lifecycle hook payloads map safely without storing prompt bodies, transcript paths, tool output, secrets, or private payloads. MCP cannot emit lifecycle events.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            fixtureSize: { type: 'number' },
+            minCases: { type: 'number' },
+            caseFile: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_lifecycle_report',
+        description: 'Read-only host lifecycle and session lineage report. MCP cannot emit lifecycle events.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            host: { type: 'string' },
+            sessionId: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_lessons_list',
+        description: 'Read-only cover-level lesson list. Alpha never returns lesson bodies.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            includeBodies: { type: 'boolean' },
+          },
+        },
+      },
+      {
+        name: 'neurain_lessons_candidates',
+        description: 'Read-only lesson candidate preview. Does not promote or write receipts.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_lessons_eval',
+        description: 'Read-only lesson candidate detection evaluation for precision, recall, false positives, and unsafe blocking.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            fixtureSize: { type: 'number' },
+            minCases: { type: 'number' },
+            caseFile: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_capabilities',
+        description: 'Read-only capability router with reason traces.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recap',
+        description: 'Read-only deterministic session recap from local logs and area briefs.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_watch_report',
+        description: 'Read-only local signal watch report. Does not start a daemon or write events.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            top: { type: 'number' },
+            sinceMinutes: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_review_worker',
+        description: 'Read-only review worker report from watch, journal, recap, and lesson signals. Does not call models or write.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            top: { type: 'number' },
+            sinceMinutes: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_scheduler_tick',
+        description: 'Read-only one-shot scheduler tick. It decides whether review should run but does not install daemons or write.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            top: { type: 'number' },
+            sinceMinutes: { type: 'number' },
+            minTriggers: { type: 'number' },
+            minEvents: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_scheduler_eval',
+        description: 'Read-only scheduler trigger evaluation for background review precision, recall, no-recursion, and private boundaries.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            fixtureSize: { type: 'number' },
+            minCases: { type: 'number' },
+            caseFile: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_curator_status',
+        description: 'Read-only lesson curator lifecycle status. Does not mutate lessons.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            staleDays: { type: 'number' },
+            archiveDays: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_curator_run_preview',
+        description: 'Read-only curator dry-run preview. Does not write snapshots, receipts, or lesson changes.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            staleDays: { type: 'number' },
+            archiveDays: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recall_status',
+        description: 'Read-only recall index status. Markdown remains canonical.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recall_rebuild_preview',
+        description: 'Read-only recall rebuild dry-run. Does not write SQLite DB or receipts.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recall_search',
+        description: 'Read-only source-grounded recall search using SQLite FTS5 when available, otherwise markdown fallback.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            query: { type: 'string' },
+            top: { type: 'number' },
+            host: { type: 'string' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'neurain_recall_verify',
+        description: 'Read-only recall index manifest verification against current markdown, events, and receipts.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recall_cross_host_eval',
+        description: 'Read-only cross-host recall evaluation using safe host-tagged journal events, fixtures, or reviewed case files.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            top: { type: 'number' },
+            minCases: { type: 'number' },
+            fixtureSize: { type: 'number' },
+            privateProbes: { type: 'number' },
+            caseFile: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_recall_semantic_search',
+        description: 'Read-only local lexical-semantic recall search (stemming, synonyms, fuzzy). Default provider is deterministic and needs no model call; markdown stays canonical.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            query: { type: 'string' },
+            top: { type: 'number' },
+            host: { type: 'string' },
+            provider: { type: 'string' },
+            minScore: { type: 'number' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'neurain_recall_hybrid_search',
+        description: 'Read-only hybrid recall search: exact-token union local lexical-semantic. Never worse than exact-token, plus paraphrase catches. top is per-branch candidate depth, so returned union can exceed top. Deterministic default provider, no model call.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            query: { type: 'string' },
+            top: { type: 'number' },
+            host: { type: 'string' },
+            provider: { type: 'string' },
+            minScore: { type: 'number' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'neurain_recall_semantic_eval',
+        description: 'Read-only semantic recall quality evaluation. Proves the local lexical-semantic layer recalls paraphrased queries that exact-token misses, with host isolation, private exclusion, no-answer abstention, rebuild equivalence, and target-root non-write.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            top: { type: 'number' },
+            minCases: { type: 'number' },
+            fixtureSize: { type: 'number' },
+            caseFile: { type: 'string' },
+            provider: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_answer_quality_eval',
+        description: 'Read-only answer-quality evaluation for faithfulness, citations, conflicts, abstention, private boundaries, and stale-source handling.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            fixtureSize: { type: 'number' },
+            minCases: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_live_cases_scaffold',
+        description: 'Read-only redacted E23 live-case scaffold. Returns hash-only source refs, stores no raw source text, and does not claim human-reviewed evidence.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            sampleSize: { type: 'number' },
+            label: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_wrap_preview',
+        description: 'Read-only wrap dry-run preview. No lesson promotion or durable wiki write.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            area: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_session_status',
+        description: 'Read-only session status (boot summary, a single session, or all sessions). Never advances the digest pointer or runs maintenance.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            sessionId: { type: 'string', description: 'Optional session id for per-session detail.' },
+            all: { type: 'boolean' },
+            staleDays: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_digest_preview',
+        description: "Read-only 'since your last visit' digest for a session. Computes only; never advances the ack pointer.",
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            session: { type: 'string' },
+            windowHours: { type: 'number' },
+          },
+          required: ['session'],
+        },
+      },
+      {
+        name: 'neurain_queue_view',
+        description: 'Read-only unified writeback queue view (list, stats, or lossless-check).',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            queue: { type: 'string' },
+            status: { type: 'string' },
+            pending: { type: 'boolean' },
+            stats: { type: 'boolean' },
+            losslessCheck: { type: 'boolean' },
+          },
+        },
+      },
+      {
+        name: 'neurain_review_queue',
+        description: 'Read-only review desk: safe vs needs-confirmation grouping, conflicts, and deep-compile candidates. Private items redact their paths.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            sessionId: { type: 'string' },
+            top: { type: 'number' },
+          },
+        },
+      },
+      {
+        name: 'neurain_route',
+        description: 'Read-only source classification: area / domain / entity candidates, sensitivity, write intent, and a requires-user-decision flag. Writes nothing.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            text: { type: 'string', description: 'Source text to classify.' },
+            sessionId: { type: 'string' },
+            area: { type: 'string' },
+            sensitivity: { type: 'string' },
+            intent: { type: 'string' },
+            title: { type: 'string' },
+            type: { type: 'string' },
+          },
+          required: ['text'],
+        },
+      },
+      {
+        name: 'neurain_plan_writeback',
+        description: 'Read-only writeback plan: target layers, confirmation gates, Light/Standard/Full scope, and queue metadata for a source (by --source-id or text). Writes nothing.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            sourceId: { type: 'string', description: 'Existing raw-inbox envelope id to plan for.' },
+            text: { type: 'string', description: 'Source text to plan for when no sourceId is given.' },
+            sessionId: { type: 'string' },
+            area: { type: 'string' },
+            sensitivity: { type: 'string' },
+            intent: { type: 'string' },
+            title: { type: 'string' },
+            type: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_flush',
+        description: 'Read-only flush plan: pending writeback-queue items grouped by Light/Standard/Full scope. Writes nothing.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            queue: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'neurain_session_flush',
+        description: 'Read-only session-scoped flush plan at a level (light/standard/full): allowed vs blocked items and target conflicts. Writes nothing.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            sessionId: { type: 'string' },
+            level: { type: 'string', description: 'light | standard | full (default standard).' },
+            queue: { type: 'string' },
+          },
+          required: ['sessionId'],
+        },
+      },
+      {
+        name: 'neurain_compile',
+        description: 'Read-only compile desk (the !compile picker): priority-ranked candidates from the pending queue + source-digest manifest. Excludes private / needs-confirmation, reads no raw bodies, writes nothing.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            root: { type: 'string' },
+            target: { type: 'string', description: 'Optional target query to select a single source.' },
+            sessionId: { type: 'string' },
+            top: { type: 'number' },
+            manifest: { type: 'string' },
+            queue: { type: 'string' },
+          },
+        },
+      },
+    ],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    const input = request.params.arguments || {};
+    if (name === 'neurain_status') {
+      const out = await doctorCommand({ _: [scopedRoot(input.root, root)], json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_search') {
+      const out = searchRoot(scopedRoot(input.root, root), String(input.query || ''), { top: Number(input.top || 10) });
+      return textResult(out);
+    }
+    if (name === 'neurain_capture') {
+      const out = capture(scopedRoot(input.root, root), String(input.text || ''), String(input.source || 'mcp'));
+      return textResult(out);
+    }
+    if (name === 'neurain_adopt_scan') {
+      const out = scanAdoption(scopedRoot(input.folder, root), { dryRun: true });
+      return textResult(out);
+    }
+    if (name === 'neurain_journal_list') {
+      return textResult(listJournalEvents(scopedRoot(input.root, root), { limit: Number(input.top || 20), type: input.type || '' }));
+    }
+    if (name === 'neurain_journal_verify') {
+      return textResult(verifyJournal(scopedRoot(input.root, root)));
+    }
+    if (name === 'neurain_lifecycle_eval') {
+      const caseFile = input.caseFile || '';
+      return textResult(evaluateLifecycleAutomation(scopedRoot(input.root, root), {
+        fixtureSize: positiveInteger(input.fixtureSize, 100, 'fixtureSize'),
+        minCases: positiveInteger(input.minCases, caseFile ? 1 : 100, 'minCases'),
+        caseFile,
+      }));
+    }
+    if (name === 'neurain_lifecycle_report') {
+      return textResult(buildLifecycleReport(scopedRoot(input.root, root), {
+        host: input.host || '',
+        sessionId: input.sessionId || '',
+        limit: Number(input.top || 500),
+      }));
+    }
+    if (name === 'neurain_lessons_list') {
+      const out = {
+        ok: true,
+        durable_write: false,
+        body_request_ignored: Boolean(input.includeBodies),
+        lessons: listLessons(scopedRoot(input.root, root), { includeBodies: false, area: input.area || '' }),
+      };
+      return textResult(out);
+    }
+    if (name === 'neurain_lessons_candidates') {
+      const out = {
+        ok: true,
+        durable_write: false,
+        candidates: lessonCandidates(scopedRoot(input.root, root), { limit: Number(input.top || 5), area: input.area || '' }),
+      };
+      return textResult(out);
+    }
+    if (name === 'neurain_lessons_eval') {
+      const fixtureSize = Number(input.fixtureSize || 100);
+      const counts = lessonEvalScaledCounts(fixtureSize);
+      return textResult(evaluateLessonCandidateDetection(scopedRoot(input.root, root), {
+        ...counts,
+        minCases: Number(input.minCases || 100),
+      }));
+    }
+    if (name === 'neurain_capabilities') {
+      const out = {
+        ok: true,
+        durable_write: false,
+        capabilities: listCapabilities({ query: String(input.query || ''), limit: Number(input.top || 10) }),
+      };
+      return textResult(out);
+    }
+    if (name === 'neurain_recap') {
+      return textResult(buildRecap(scopedRoot(input.root, root), { area: input.area || '' }));
+    }
+    if (name === 'neurain_watch_report') {
+      return textResult(buildWatchReport(scopedRoot(input.root, root), {
+        area: input.area || '',
+        top: Number(input.top || 10),
+        sinceMinutes: Number(input.sinceMinutes || 1440),
+        pollOnce: true,
+      }));
+    }
+    if (name === 'neurain_review_worker') {
+      return textResult(buildReviewWorkerReport(scopedRoot(input.root, root), {
+        area: input.area || '',
+        top: Number(input.top || 10),
+        sinceMinutes: Number(input.sinceMinutes || 1440),
+      }));
+    }
+    if (name === 'neurain_scheduler_tick') {
+      return textResult(buildSchedulerTick(scopedRoot(input.root, root), {
+        area: input.area || '',
+        top: Number(input.top || 10),
+        sinceMinutes: Number(input.sinceMinutes || 1440),
+        minTriggers: Number(input.minTriggers || 1),
+        minEvents: Number(input.minEvents || 1),
+      }));
+    }
+    if (name === 'neurain_scheduler_eval') {
+      const caseFile = input.caseFile || '';
+      return textResult(await evaluateSchedulerTriggering(scopedRoot(input.root, root), {
+        fixtureSize: positiveInteger(input.fixtureSize, 100, 'fixtureSize'),
+        minCases: positiveInteger(input.minCases, caseFile ? 1 : 100, 'minCases'),
+        caseFile,
+      }));
+    }
+    if (name === 'neurain_curator_status') {
+      return textResult(curatorStatus(scopedRoot(input.root, root), {
+        staleDays: Number(input.staleDays || 30),
+        archiveDays: Number(input.archiveDays || 90),
+      }));
+    }
+    if (name === 'neurain_curator_run_preview') {
+      return textResult(runCurator(scopedRoot(input.root, root), {
+        dryRun: true,
+        staleDays: Number(input.staleDays || 30),
+        archiveDays: Number(input.archiveDays || 90),
+      }));
+    }
+    if (name === 'neurain_recall_status') {
+      return textResult(await recallStatus(scopedRoot(input.root, root)));
+    }
+    if (name === 'neurain_recall_rebuild_preview') {
+      return textResult(await rebuildRecall(scopedRoot(input.root, root), { dryRun: true }));
+    }
+    if (name === 'neurain_recall_search') {
+      return textResult(await searchRecall(scopedRoot(input.root, root), String(input.query || ''), {
+        top: Number(input.top || 10),
+        host: input.host || '',
+      }));
+    }
+    if (name === 'neurain_recall_verify') {
+      return textResult(await verifyRecall(scopedRoot(input.root, root)));
+    }
+    if (name === 'neurain_recall_cross_host_eval') {
+      return textResult(await evaluateCrossHostRecall(scopedRoot(input.root, root), {
+        top: Number(input.top || 5),
+        minCases: Number(input.minCases || (input.caseFile ? 1 : 2)),
+        fixtureSize: Number(input.fixtureSize || 0),
+        privateProbeCount: Number(input.privateProbes || 20),
+        caseFile: input.caseFile || '',
+      }));
+    }
+    if (name === 'neurain_recall_semantic_search') {
+      return textResult(await semanticSearchRecall(scopedRoot(input.root, root), String(input.query || ''), {
+        top: Number(input.top || 10),
+        host: input.host || '',
+        provider: input.provider || 'local-lexical',
+        minScore: input.minScore !== undefined ? Number(input.minScore) : 0.34,
+      }));
+    }
+    if (name === 'neurain_recall_hybrid_search') {
+      return textResult(await hybridSearchRecall(scopedRoot(input.root, root), String(input.query || ''), {
+        top: Number(input.top || 10),
+        host: input.host || '',
+        provider: input.provider || 'local-lexical',
+        minScore: input.minScore !== undefined ? Number(input.minScore) : 0.34,
+      }));
+    }
+    if (name === 'neurain_recall_semantic_eval') {
+      const caseFile = input.caseFile || '';
+      return textResult(await evaluateSemanticRecall(scopedRoot(input.root, root), {
+        top: Number(input.top || 5),
+        minCases: Number(input.minCases || (caseFile ? 1 : 50)),
+        fixtureSize: Number(input.fixtureSize || 60),
+        caseFile,
+        provider: input.provider || 'local-lexical',
+      }));
+    }
+    if (name === 'neurain_answer_quality_eval') {
+      const fixtureSize = Number(input.fixtureSize || 120);
+      const counts = answerEvalScaledCounts(fixtureSize);
+      return textResult(await evaluateAnswerQuality(scopedRoot(input.root, root), {
+        ...(input.caseFile ? {} : counts),
+        caseFile: input.caseFile || '',
+        minCases: Number(input.minCases || (input.caseFile ? 1 : 50)),
+      }));
+    }
+    if (name === 'neurain_live_cases_scaffold') {
+      return textResult(buildLiveCaseScaffold(scopedRoot(input.root, root), {
+        sampleSize: Number(input.sampleSize || 12),
+        label: input.label || 'mcp-live-case',
+        write: false,
+      }));
+    }
+    if (name === 'neurain_wrap_preview') {
+      const out = await wrapCommand({ _: [scopedRoot(input.root, root)], top: input.top, area: input.area || '', json: true, 'dry-run': true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_session_status') {
+      const out = await statusCommand({ _: [scopedRoot(input.root, root)], 'session-id': input.sessionId, all: input.all, 'stale-days': input.staleDays, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_digest_preview') {
+      const out = await digestCommand({ _: [scopedRoot(input.root, root)], session: input.session, 'window-hours': input.windowHours, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_queue_view') {
+      const out = await queueCommand({ _: [scopedRoot(input.root, root)], queue: input.queue, status: input.status, pending: input.pending, stats: input.stats, 'lossless-check': input.losslessCheck, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_review_queue') {
+      const out = await reviewQueueCommand({ _: [scopedRoot(input.root, root)], 'session-id': input.sessionId, top: input.top, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_route') {
+      const out = await routeCommand({ _: [scopedRoot(input.root, root)], text: input.text, 'session-id': input.sessionId, area: input.area, sensitivity: input.sensitivity, intent: input.intent, title: input.title, type: input.type, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_plan_writeback') {
+      const out = await planWritebackCommand({ _: [scopedRoot(input.root, root)], 'source-id': input.sourceId, text: input.text, 'session-id': input.sessionId, area: input.area, sensitivity: input.sensitivity, intent: input.intent, title: input.title, type: input.type, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_flush') {
+      const out = await flushCommand({ _: [scopedRoot(input.root, root)], queue: input.queue, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_session_flush') {
+      const out = await sessionFlushCommand({ _: [scopedRoot(input.root, root)], 'session-id': input.sessionId, level: input.level, queue: input.queue, json: true });
+      return textResult(out.payload);
+    }
+    if (name === 'neurain_compile') {
+      const out = await compileCommand({ _: [scopedRoot(input.root, root)], target: input.target, 'session-id': input.sessionId, top: input.top, manifest: input.manifest, queue: input.queue, json: true });
+      return textResult(out.payload);
+    }
+    throw new Error(`Unknown Neurain tool: ${name}`);
+  });
+
+  await server.connect(new StdioServerTransport());
+}
+
+function scopedRoot(requested, serverRoot) {
+  const base = absPath(serverRoot);
+  const target = requested ? path.resolve(base, String(requested)) : base;
+  if (target !== base && !target.startsWith(`${base}${path.sep}`)) {
+    throw new Error(`Path is outside configured Neurain root: ${requested}`);
+  }
+  return target;
+}
+
+function positiveInteger(value, fallback, label) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) throw new Error(`${label} must be a positive integer.`);
+  return parsed;
+}
+
+function capture(root, text, source) {
+  if (!text.trim()) throw new Error('capture text is empty');
+  const secret = secretLike(text);
+  if (secret) {
+    return {
+      ok: false,
+      refused: true,
+      reason: `secret-like content detected: ${secret}`,
+      durable_write: false,
+    };
+  }
+  const date = new Date().toISOString().slice(0, 10);
+  const rel = `raw/_inbox/mcp-${date}-${compactStamp()}.json`;
+  const abs = safeResolve(root, rel);
+  ensureDir(path.dirname(abs));
+  const envelope = {
+    source_type: 'mcp_capture',
+    source,
+    captured_at: timestamp(),
+    sensitivity: 'internal',
+    text,
+  };
+  fs.writeFileSync(abs, `${JSON.stringify(envelope, null, 2)}\n`);
+  return {
+    ok: true,
+    path: rel,
+    durable_write: false,
+    note: 'Captured as append-only raw source. No wiki or durable knowledge write was performed.',
+  };
+}
+
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(value, null, 2),
+      },
+    ],
+  };
+}
+
+function answerEvalScaledCounts(total) {
+  const count = Math.max(10, Math.min(Number(total || 120), 500));
+  const supportedCases = Math.max(1, Math.round(count * 0.42));
+  const conflictCases = Math.max(1, Math.round(count * 0.17));
+  const privateCases = Math.max(1, Math.round(count * 0.17));
+  const staleCases = Math.max(1, Math.round(count * 0.17));
+  const used = supportedCases + conflictCases + privateCases + staleCases;
+  return {
+    supportedCases,
+    conflictCases,
+    privateCases,
+    staleCases,
+    noAnswerCases: Math.max(1, count - used),
+  };
+}
+
+function lessonEvalScaledCounts(total) {
+  const count = Math.max(10, Math.min(Number(total || 100), 500));
+  const positiveCases = Math.max(1, Math.round(count * 0.4));
+  const unsafeCases = Math.max(1, Math.round(count * 0.1));
+  return {
+    positiveCases,
+    negativeCases: Math.max(1, count - positiveCases - unsafeCases),
+    unsafeCases,
+  };
+}