@polymorphism-tech/morph-spec 8.42.0 → 8.43.0

package/src/lib/mutation/schemata.js

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { applyRegions } from './manifest.js';
+
+export const SWITCH_ENV = 'MORPH_MUTANT';
+
+export function switchClassName(csprojRel) {
+  return `MorphMutationSwitch_${createHash('md5').update(csprojRel).digest('hex').slice(0, 6)}`;
+}
+
+export function switchSource(className) {
+  return [
+    '// <auto-generated/>',
+    '#nullable enable',
+    '#pragma warning disable',
+    `internal static class ${className}`,
+    '{',
+    `    private static readonly string? Active = System.Environment.GetEnvironmentVariable("${SWITCH_ENV}");`,
+    '    internal static bool On(string id) => Active == id;',
+    '}',
+    '',
+  ].join('\n');
+}
+
+const wrap = (className, region) =>
+  `(${className}.On("${region.id}") ? (${region.replaceText}) : (${region.findText}))`;
+
+/**
+ * A C# file with every region behind its switch; the original text stays as the else branch.
+ * Each patched span comes back so a compiler error can be pinned on its mutant.
+ */
+export function patchFile(text, regions, className) {
+  return applyRegions(text, regions, (region) => wrap(className, region));
+}
+
+const MSBUILD_ERROR = /^(?<file>.+?)\((?<line>\d+),(?<col>\d+)\): error (?<code>[A-Z]+\d+): (?<msg>.*?)(?: \[.*\])?\s*$/gm;
+
+export function parseCompilerErrors(output) {
+  return [...String(output).matchAll(MSBUILD_ERROR)].map((m) => ({
+    file: m.groups.file.trim(), line: Number(m.groups.line), code: m.groups.code, message: m.groups.msg.trim(),
+  }));
+}
+
+/**
+ * An error inside a patched span names its mutant; one elsewhere in a patched file
+ * (an `out` variable the switch left unassigned) names every mutant of that file.
+ */
+export function blame(errors, patched) {
+  const blamed = new Set();
+  const unmapped = [];
+  for (const err of errors) {
+    const file = patched.find((p) => samePath(p.abs, err.file));
+    if (!file) { unmapped.push(err); continue; }
+    const inSpan = [...file.spans].find(([, s]) => err.line >= s.from && err.line <= s.to);
+    if (inSpan) blamed.add(inSpan[0]);
+    else for (const id of file.spans.keys()) blamed.add(id);
+  }
+  return { blamed: [...blamed], unmapped };
+}
+
+const samePath = (a, b) => a.replace(/\\/g, '/').toLowerCase() === b.replace(/\\/g, '/').toLowerCase();

package/src/lib/mutation/snapshot.js

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export const md5Of = (bytes) => createHash('md5').update(bytes).digest('hex');
+export const md5OfFile = (abs) => md5Of(readFileSync(abs));
+
+/**
+ * Copies of the original bytes, kept outside the working tree, plus a journal
+ * that survives the process: a run killed halfway is undone by the next
+ * `--restore` from the journal alone.
+ */
+export function openSnapshot({ dir, root, files, runId }) {
+  mkdirSync(dir, { recursive: true });
+  const entries = files.map((file, index) => {
+    const abs = join(root, file);
+    const bytes = readFileSync(abs);
+    const backup = join(dir, `${index}.bak`);
+    writeFileSync(backup, bytes);
+    return { file, md5: md5Of(bytes), backup, created: false };
+  });
+  const snapshot = { runId, root, dir, entries, generated: [], state: 'open' };
+  writeJournal(snapshot);
+  return snapshot;
+}
+
+export function trackGenerated(snapshot, file) {
+  if (!snapshot.generated.includes(file)) snapshot.generated.push(file);
+  writeJournal(snapshot);
+}
+
+export function writeJournal(snapshot) {
+  writeFileSync(join(snapshot.dir, 'journal.json'), JSON.stringify(snapshot, null, 2));
+}
+
+export function readJournal(dir) {
+  const path = join(dir, 'journal.json');
+  return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : null;
+}
+
+/**
+ * Writes the original bytes back — a fresh write, so the file is NEWER than
+ * any binary built from a mutant. Restoring the old mtime would let the build
+ * consider the mutant binary up to date and never recompile the source.
+ */
+export function restoreSnapshot(snapshot, { rewrite = true } = {}) {
+  const report = [];
+  for (const entry of snapshot.entries) {
+    const abs = join(snapshot.root, entry.file);
+    const before = existsSync(abs) ? md5OfFile(abs) : null;
+    if (rewrite || before !== entry.md5) {
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, readFileSync(entry.backup));
+    }
+    const after = md5OfFile(abs);
+    report.push({ file: entry.file, md5Original: entry.md5, md5Before: before, md5After: after, ok: after === entry.md5 });
+  }
+  for (const file of snapshot.generated) {
+    const abs = join(snapshot.root, file);
+    if (existsSync(abs)) unlinkSync(abs);
+  }
+  snapshot.state = report.every((r) => r.ok) ? 'restored' : 'restore-failed';
+  writeJournal(snapshot);
+  return report;
+}
+
+export function discardSnapshot(snapshot) {
+  rmSync(snapshot.dir, { recursive: true, force: true });
+}

package/src/lib/mutation/subset.js

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { csharpClasses } from '../tasks/dotnet-test-introspection.js';
+import { relatedCommand } from './commands.js';
+
+const SKIP_DIRS = new Set(['bin', 'obj', 'node_modules', '.git', 'worktrees', 'TestResults']);
+const SAFE_CLASS = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const MIN_TYPE_LENGTH = 4;
+
+const posix = (p) => p.replace(/\\/g, '/');
+
+function walkCs(dir, out = []) {
+  let entries = [];
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) walkCs(join(dir, e.name), out);
+    } else if (e.name.endsWith('.cs')) {
+      out.push(join(dir, e.name));
+    }
+  }
+  return out;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * The tests to run FIRST, chosen by the tool: files the feature changed, and files naming a
+ * type the mutated files declare. A mutant the subset does not kill goes to the whole suite.
+ */
+export function dotnetSubset({ root, testProjectDirs, mutatedFiles, changed = [] }) {
+  const changedSet = new Set(changed.map(posix));
+  const mutatedTypes = new Set();
+  for (const file of mutatedFiles) {
+    for (const t of csharpClasses(resolve(root, file)).types) if (t.length >= MIN_TYPE_LENGTH) mutatedTypes.add(t);
+  }
+  const mention = mutatedTypes.size > 0
+    ? new RegExp(`\\b(?:${[...mutatedTypes].map(escapeRe).join('|')})\\b`) : null;
+
+  const byChange = new Set();
+  const byMention = new Set();
+  const classes = new Set();
+  for (const dir of testProjectDirs) {
+    for (const abs of walkCs(resolve(root, dir))) {
+      const info = csharpClasses(abs);
+      if (!info.scannable || !info.hasTestAttribute || info.names.length === 0) continue;
+      const rel = posix(relative(root, abs));
+      const viaChange = changedSet.has(rel);
+      const viaMention = !viaChange && mention !== null && mention.test(readFileSync(abs, 'utf8'));
+      if (!viaChange && !viaMention) continue;
+      (viaChange ? byChange : byMention).add(rel);
+      for (const name of info.names) classes.add(name);
+    }
+  }
+  const unsafe = [...classes].find((c) => !SAFE_CLASS.test(c));
+  if (unsafe) return { usable: false, reason: `nome de classe "${unsafe}" não é seguro num filtro` };
+  if (classes.size === 0) return { usable: false, reason: 'nenhum arquivo de teste alterado pela feature nem citando os tipos mutados' };
+  return {
+    usable: true,
+    classes: [...classes].sort(),
+    filter: [...classes].sort().map((c) => `FullyQualifiedName~${c}`).join('|'),
+    files: { changed: [...byChange].sort(), mentions: [...byMention].sort() },
+  };
+}
+
+export function jsSubset({ runner, command, root, mutatedFiles }) {
+  const files = mutatedFiles.filter((f) => existsSync(resolve(root, f)) && statSync(resolve(root, f)).isFile());
+  const cmd = relatedCommand(runner, command, files);
+  if (cmd === null) return { usable: false, reason: `runner "${runner}" sem seleção por arquivo relacionado neste formato de comando` };
+  return { usable: true, command: cmd, files: { related: files } };
+}
+
+export function testProjectDirsOf(root, csprojs) {
+  return [...new Set(csprojs.map((c) => posix(relative(root, dirname(resolve(root, c))))))];
+}

package/src/lib/mutation/trx.js

@@ -0,0 +1,51 @@
+const ENTITIES = { '&lt;': '<', '&gt;': '>', '&amp;': '&', '&quot;': '"', '&apos;': "'" };
+
+export function decodeXml(text) {
+  return text
+    .replace(/&(?:lt|gt|amp|quot|apos);/g, (m) => ENTITIES[m])
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec)));
+}
+
+const attr = (attrs, name) => new RegExp(`\\b${name}="([^"]*)"`).exec(attrs)?.[1] ?? null;
+const count = (attrs, name) => Number(attr(attrs, name) ?? 0);
+
+/**
+ * What a VSTest TRX says about a run: the counters, and for every failed test
+ * its name and the FIRST message line — the literal reason a mutation report
+ * quotes. Linear over the text: a full suite writes several MB.
+ */
+export function parseTrx(xml) {
+  const counters = /<Counters\b([^>]*)\/?>/.exec(xml)?.[1] ?? null;
+  const summary = /<ResultSummary\b([^>]*)>/.exec(xml)?.[1] ?? '';
+  const failedTests = [];
+  const tag = /<UnitTestResult\b([^>]*?)(\/?)>/g;
+  for (let m = tag.exec(xml); m; m = tag.exec(xml)) {
+    if (attr(m[1], 'outcome') !== 'Failed') continue;
+    let message = '';
+    if (m[2] !== '/') {
+      const close = xml.indexOf('</UnitTestResult>', tag.lastIndex);
+      const body = xml.slice(tag.lastIndex, close === -1 ? undefined : close);
+      const raw = /<Message>([\s\S]*?)<\/Message>/.exec(body)?.[1] ?? '';
+      message = decodeXml(raw.replace(/^<!\[CDATA\[|\]\]>$/g, '')).trim();
+    }
+    failedTests.push({ name: decodeXml(attr(m[1], 'testName') ?? '?'), message });
+  }
+  return {
+    parsed: counters !== null,
+    total: counters ? count(counters, 'total') : 0,
+    executed: counters ? count(counters, 'executed') : 0,
+    passed: counters ? count(counters, 'passed') : 0,
+    failed: counters ? count(counters, 'failed') : failedTests.length,
+    aborted: counters ? count(counters, 'aborted') + count(counters, 'timeout') : 0,
+    runOutcome: attr(summary, 'outcome'),
+    failedTests,
+  };
+}
+
+export const methodOf = (testName) => String(testName).replace(/\s*\(.*$/s, '').trim();
+
+export function firstLines(message, max = 2, width = 240) {
+  const lines = String(message).split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, max).join(' ⏎ ');
+  return lines.length > width ? `${lines.slice(0, width)}…` : lines;
+}

package/src/lib/procs/classify.js

@@ -0,0 +1,91 @@
+export const MIN_ORPHAN_AGE_MS = 15 * 60 * 1000;
+
+const PLAIN_CANDIDATES = new Set(['node', 'dotnet', 'testhost', 'esbuild']);
+const CHROME_NAMES = new Set(['chrome', 'chromium', 'msedge', 'chrome-headless-shell']);
+const BUILD_SERVER_NAMES = new Set(['vbcscompiler', 'msbuild']);
+const BUILD_SERVER_CMD = /vbcscompiler|\/nodemode:\d|msbuild(?:taskhost)?\.dll|razorserver/i;
+const AUTOMATION_CHROME = /--headless|--remote-debugging-pipe|playwright|puppeteer/i;
+const CLAUDE_CLI = /@anthropic-ai[\\/]claude-code/i;
+
+export function normalizeCmd(cmd) {
+  return String(cmd ?? '').toLowerCase().replace(/\\/g, '/');
+}
+
+export function categorize(proc) {
+  const cmd = proc.cmd ?? '';
+  if (BUILD_SERVER_NAMES.has(proc.name)) return 'build-server';
+  if (proc.name === 'dotnet' && BUILD_SERVER_CMD.test(cmd)) return 'build-server';
+  if (CHROME_NAMES.has(proc.name)) {
+    return AUTOMATION_CHROME.test(cmd) && !/--type=/.test(cmd) ? 'chrome-headless' : null;
+  }
+  return PLAIN_CANDIDATES.has(proc.name) ? proc.name : null;
+}
+
+export function isClaudeSession(proc) {
+  return proc.name === 'claude' || CLAUDE_CLI.test(proc.cmd ?? '');
+}
+
+function protectionReason(proc, { mcpTokens, holderPids }) {
+  if (holderPids.has(proc.pid)) return 'segura slot do semáforo pesado';
+  const cmd = normalizeCmd(proc.cmd);
+  if (/graph-refresh\.js/.test(cmd) && /--run\b/.test(cmd)) return 'worker de refresh do grafo';
+  const token = mcpTokens.find((t) => cmd.includes(t));
+  if (token) return `linha de comando de MCP configurado (${token})`;
+  return null;
+}
+
+export function classifyProcs(procs, { now = Date.now(), mcpTokens = [], holderPids = [], minAgeMs = MIN_ORPHAN_AGE_MS } = {}) {
+  const byPid = new Map(procs.map((p) => [p.pid, p]));
+  const tokens = mcpTokens.map((t) => String(t).toLowerCase());
+  const holders = new Set(holderPids);
+
+  const liveParent = (p) => {
+    const parent = byPid.get(p.ppid);
+    if (!parent) return null;
+    if (parent.startedMs !== null && p.startedMs !== null && parent.startedMs > p.startedMs) return null;
+    return parent;
+  };
+
+  const rows = [];
+  for (const proc of procs) {
+    const category = categorize(proc);
+    if (!category) continue;
+    const orphan = proc.ppid > 4 && liveParent(proc) === null;
+    const ageMs = proc.startedMs === null ? null : Math.max(0, now - proc.startedMs);
+    const row = {
+      pid: proc.pid,
+      ppid: proc.ppid,
+      name: proc.name,
+      category,
+      cmd: proc.cmd,
+      rssMb: Math.round(proc.rss / (1024 * 1024)),
+      startedMs: proc.startedMs,
+      ageMs,
+      orphan,
+      verdict: 'alive-parent',
+      reason: null,
+    };
+    if (orphan) {
+      const protectedBy = category === 'build-server' ? null : protectionReason(proc, { mcpTokens: tokens, holderPids: holders });
+      if (category === 'build-server') {
+        row.verdict = 'build-server';
+        row.reason = 'nó de build reutilizável pode servir outra sessão; encerre com `dotnet build-server shutdown` quando ocioso';
+      } else if (protectedBy) {
+        row.verdict = 'protected';
+        row.reason = protectedBy;
+      } else if (ageMs === null) {
+        row.verdict = 'protected';
+        row.reason = 'idade desconhecida';
+      } else if (ageMs < minAgeMs) {
+        row.verdict = 'protected';
+        row.reason = `mais novo que ${Math.round(minAgeMs / 60000)} min`;
+      } else {
+        row.verdict = 'orphan';
+      }
+    }
+    rows.push(row);
+  }
+
+  const sessions = procs.filter(isClaudeSession).length;
+  return { rows, sessions };
+}

package/src/lib/procs/list.js

@@ -0,0 +1,124 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+
+const PS_PROJECTION = "[pscustomobject]@{ pid = $_.ProcessId; ppid = $_.ParentProcessId; name = $_.Name; cmd = $_.CommandLine; rss = [int64]$_.WorkingSetSize; started = if ($_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('o') } else { $null } }";
+const PS_PREFIX = '[Console]::OutputEncoding = [Text.Encoding]::UTF8; ';
+
+export function defaultProcExec(file, args, { timeout = 30000 } = {}) {
+  try {
+    const output = execFileSync(file, args, {
+      encoding: 'utf8',
+      timeout,
+      windowsHide: true,
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return { code: 0, output };
+  } catch (err) {
+    return {
+      code: err.status ?? 1,
+      output: `${err.stdout ?? ''}${err.stderr ?? ''}`,
+      missing: err.code === 'ENOENT',
+    };
+  }
+}
+
+export function normalizeProcName(name) {
+  return String(name ?? '').toLowerCase().replace(/\.exe$/, '');
+}
+
+function toProc(p) {
+  const startedMs = typeof p.startedMs === 'number' ? p.startedMs : p.started ? Date.parse(p.started) : null;
+  return {
+    pid: Number(p.pid),
+    ppid: Number(p.ppid ?? 0),
+    name: normalizeProcName(p.name),
+    cmd: typeof p.cmd === 'string' && p.cmd.length ? p.cmd : null,
+    rss: Number(p.rss ?? 0),
+    startedMs: Number.isFinite(startedMs) ? startedMs : null,
+  };
+}
+
+export function parseWindowsProcs(text) {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed) return [];
+  const raw = JSON.parse(trimmed);
+  return (Array.isArray(raw) ? raw : [raw]).filter((p) => p && Number.isInteger(p.pid)).map(toProc);
+}
+
+export function parseEtime(etime) {
+  const m = /^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/.exec(String(etime).trim());
+  if (!m) return null;
+  const [, d = 0, h = 0, min, s] = m;
+  return ((Number(d) * 24 + Number(h)) * 60 + Number(min)) * 60 + Number(s);
+}
+
+export function parsePosixProcs(text, now = Date.now()) {
+  const procs = [];
+  for (const line of String(text ?? '').split(/\r?\n/)) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\d+)\s+(\S+)\s*(.*)$/.exec(line);
+    if (!m) continue;
+    const seconds = parseEtime(m[3]);
+    procs.push(toProc({
+      pid: Number(m[1]),
+      ppid: Number(m[2]),
+      name: m[5].split('/').pop(),
+      cmd: m[6] || m[5],
+      rss: Number(m[4]) * 1024,
+      startedMs: seconds === null ? null : now - seconds * 1000,
+    }));
+  }
+  return procs;
+}
+
+function fromFixture(path) {
+  const raw = JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''));
+  return (Array.isArray(raw) ? raw : []).map(toProc);
+}
+
+function windowsScript(filter) {
+  const query = filter ? `Get-CimInstance Win32_Process -Filter "${filter}"` : 'Get-CimInstance Win32_Process';
+  return `${PS_PREFIX}${query} | ForEach-Object { ${PS_PROJECTION} } | ConvertTo-Json -Compress`;
+}
+
+const POSIX_COLUMNS = 'pid=,ppid=,etime=,rss=,comm=,args=';
+
+function runList({ pid = null, exec, platform, now }) {
+  if (platform === 'win32') {
+    const filter = pid === null ? '' : `ProcessId=${Number(pid)}`;
+    const res = exec('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', windowsScript(filter)]);
+    if (res.code !== 0) return { procs: null, reason: `PowerShell falhou (exit ${res.code})` };
+    try {
+      return { procs: parseWindowsProcs(res.output), reason: null };
+    } catch {
+      return { procs: null, reason: 'saída do PowerShell ilegível' };
+    }
+  }
+  if (platform === 'linux' || platform === 'darwin') {
+    const args = pid === null ? ['-eo', POSIX_COLUMNS] : ['-p', String(Number(pid)), '-o', POSIX_COLUMNS];
+    const res = exec('ps', args);
+    if (res.code !== 0 && pid === null) return { procs: null, reason: `ps falhou (exit ${res.code})` };
+    return { procs: parsePosixProcs(res.output, now), reason: null };
+  }
+  return { procs: null, reason: `plataforma ${platform} sem listador de processos` };
+}
+
+export function listProcesses({ exec = defaultProcExec, platform = process.platform, now = Date.now(), env = process.env } = {}) {
+  if (env.MORPH_PROCS_FIXTURE) {
+    try {
+      return { procs: fromFixture(env.MORPH_PROCS_FIXTURE), reason: null };
+    } catch {
+      return { procs: null, reason: 'MORPH_PROCS_FIXTURE ilegível' };
+    }
+  }
+  return runList({ exec, platform, now });
+}
+
+export function readProcess(pid, { exec = defaultProcExec, platform = process.platform, now = Date.now(), env = process.env } = {}) {
+  if (env.MORPH_PROCS_FIXTURE) {
+    const { procs } = listProcesses({ env });
+    return procs?.find((p) => p.pid === pid) ?? null;
+  }
+  const { procs } = runList({ pid, exec, platform, now });
+  return procs?.find((p) => p.pid === pid) ?? null;
+}

package/src/lib/procs/mcp-config.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { jsoncToJson } from '../../../framework/hooks/shared/comment-stripper.js';
+import { readEnabledPlugins } from '../detectors/claude-config-detector.js';
+
+const GENERIC_TOKENS = new Set([
+  'cmd', 'cmd.exe', 'npx', 'npx.cmd', 'npm', 'node', 'node.exe', 'python', 'python3', 'uv', 'uvx',
+  'dotnet', 'docker', 'run', 'exec', 'bash', 'sh', 'powershell', 'pwsh',
+]);
+
+const toolNamePart = (s) => String(s).replace(/[^A-Za-z0-9_-]/g, '_');
+
+function readJsonc(file, unreadable) {
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(jsoncToJson(readFileSync(file, 'utf8').replace(/^/, '')));
+  } catch {
+    unreadable.push(file);
+    return null;
+  }
+}
+
+function sameDir(a, b) {
+  const norm = (p) => resolve(p).replace(/\\/g, '/').replace(/\/$/, '');
+  const [x, y] = [norm(a), norm(b)];
+  return process.platform === 'win32' ? x.toLowerCase() === y.toLowerCase() : x === y;
+}
+
+function toServers(map, scope, extra = {}) {
+  return Object.entries(map && typeof map === 'object' ? map : {}).map(([name, cfg]) => ({
+    name,
+    scope,
+    command: cfg?.command ?? null,
+    args: Array.isArray(cfg?.args) ? cfg.args.map(String) : [],
+    url: cfg?.url ?? null,
+    ...extra,
+  }));
+}
+
+function pluginMcpServers(installPath, plugin, unreadable) {
+  const doc = readJsonc(join(installPath, '.mcp.json'), unreadable);
+  if (!doc || typeof doc !== 'object') return [];
+  const map = doc.mcpServers && typeof doc.mcpServers === 'object' ? doc.mcpServers : doc;
+  return toServers(map, 'plugin', { plugin });
+}
+
+function pickInstall(entries, projectDir) {
+  const list = Array.isArray(entries) ? entries.filter((e) => e?.installPath) : [];
+  return list.find((e) => e.projectPath && sameDir(e.projectPath, projectDir)) ?? list.find((e) => e.scope === 'user') ?? list[0] ?? null;
+}
+
+export function readMcpConfig({ projectDir, home = homedir() }) {
+  const unreadable = [];
+  const servers = [];
+
+  const project = readJsonc(join(projectDir, '.mcp.json'), unreadable);
+  servers.push(...toServers(project?.mcpServers, 'project'));
+
+  const userDoc = readJsonc(join(home, '.claude.json'), unreadable);
+  servers.push(...toServers(userDoc?.mcpServers, 'user'));
+  const projectKey = Object.keys(userDoc?.projects ?? {}).find((k) => sameDir(k, projectDir));
+  if (projectKey) servers.push(...toServers(userDoc.projects[projectKey]?.mcpServers, 'local'));
+
+  const enabledPlugins = readEnabledPlugins(projectDir, home);
+  const installed = readJsonc(join(home, '.claude', 'plugins', 'installed_plugins.json'), unreadable)?.plugins ?? {};
+  const pluginServers = [];
+  for (const id of enabledPlugins) {
+    const install = pickInstall(installed[id], projectDir);
+    if (install) pluginServers.push(...pluginMcpServers(install.installPath, id.split('@')[0], unreadable));
+  }
+
+  return { servers, pluginServers, enabledPlugins, unreadable };
+}
+
+export function findDuplicateMcps({ servers, pluginServers }) {
+  const duplicates = [];
+  for (const ps of pluginServers) {
+    const declared = servers.filter((s) => s.name === ps.name);
+    if (!declared.length) continue;
+    duplicates.push({
+      server: ps.name,
+      plugin: ps.plugin,
+      declaredIn: [...new Set(declared.map((s) => s.scope))],
+      toolNames: [`mcp__${ps.name}`, `mcp__plugin_${toolNamePart(ps.plugin)}_${toolNamePart(ps.name)}`],
+    });
+  }
+  return duplicates;
+}
+
+export function mcpCommandTokens({ servers, pluginServers }) {
+  const tokens = new Set();
+  for (const s of [...servers, ...pluginServers]) {
+    if (s.url && !s.command) continue;
+    for (const raw of [s.command, ...s.args]) {
+      if (typeof raw !== 'string') continue;
+      const token = raw.toLowerCase().replace(/\\/g, '/');
+      if (token.length < 4 || /^[-/]/.test(token) || token.includes('${') || GENERIC_TOKENS.has(token)) continue;
+      tokens.add(token);
+    }
+  }
+  return [...tokens];
+}

package/src/lib/procs/prune.js

@@ -0,0 +1,25 @@
+import { readProcess } from './list.js';
+
+export function pruneOrphans(rows, { read = readProcess, kill = (pid) => process.kill(pid) } = {}) {
+  const results = [];
+  for (const row of rows) {
+    if (row.verdict !== 'orphan') continue;
+    const fresh = read(row.pid);
+    const base = { pid: row.pid, name: row.name };
+    if (!fresh) {
+      results.push({ ...base, outcome: 'skipped', reason: 'já encerrado' });
+      continue;
+    }
+    if (fresh.startedMs !== row.startedMs || fresh.cmd !== row.cmd || fresh.name !== row.name) {
+      results.push({ ...base, outcome: 'skipped', reason: 'o PID foi reaproveitado por outro processo' });
+      continue;
+    }
+    try {
+      kill(row.pid);
+      results.push({ ...base, outcome: 'killed' });
+    } catch (err) {
+      results.push({ ...base, outcome: 'failed', reason: err?.code ?? err?.message ?? 'erro desconhecido' });
+    }
+  }
+  return results;
+}

package/src/lib/procs/wslconfig.js

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, totalmem } from 'node:os';
+
+const GB = 1024 ** 3;
+
+export function parseWslConfig(text) {
+  const sections = {};
+  let current = null;
+  for (const raw of String(text).replace(/^/, '').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+    const header = /^\[([^\]]+)\]$/.exec(line);
+    if (header) {
+      current = header[1].trim().toLowerCase();
+      sections[current] ??= {};
+      continue;
+    }
+    const eq = line.indexOf('=');
+    if (eq < 0 || current === null) continue;
+    sections[current][line.slice(0, eq).trim().toLowerCase()] = line.slice(eq + 1).trim();
+  }
+  return sections;
+}
+
+export function suggestedMemoryGb(totalMemBytes) {
+  return Math.max(4, Math.floor((totalMemBytes / GB) * 0.4));
+}
+
+function suggestion({ memory, reclaim, totalMemBytes }) {
+  const lines = [];
+  if (!memory) lines.push('[wsl2]', `memory=${suggestedMemoryGb(totalMemBytes)}GB`);
+  if (!reclaim) lines.push('[experimental]', 'autoMemoryReclaim=gradual');
+  return lines.length ? lines.join('\n') : null;
+}
+
+export function inspectWslConfig({
+  home = homedir(),
+  platform = process.platform,
+  totalMemBytes = totalmem(),
+  exists = existsSync,
+  read = (p) => readFileSync(p, 'utf8'),
+} = {}) {
+  if (platform !== 'win32') return { status: 'skip', reason: 'WSL só existe no Windows' };
+  const path = join(home, '.wslconfig');
+  if (!exists(path)) {
+    return {
+      status: 'missing',
+      path,
+      memory: null,
+      autoMemoryReclaim: null,
+      suggestion: suggestion({ memory: null, reclaim: null, totalMemBytes }),
+    };
+  }
+  let sections;
+  try {
+    sections = parseWslConfig(read(path));
+  } catch {
+    return { status: 'skip', reason: `${path} ilegível` };
+  }
+  const memory = sections.wsl2?.memory ?? null;
+  const autoMemoryReclaim = sections.experimental?.automemoryreclaim ?? null;
+  return {
+    status: 'present',
+    path,
+    memory,
+    autoMemoryReclaim,
+    suggestion: suggestion({ memory, reclaim: autoMemoryReclaim, totalMemBytes }),
+  };
+}