micro-models-agent 0.54.1 → 0.55.1

package/dist/modules/context/manager.js

@@ -1,440 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-import { FactExtractor } from "./fact-extractor";
-const COMPACTION_INTERVAL = 15;
-const KEEP_LAST_N = 6;
-function summarizeArgs(args) {
-    if (!args)
-        return "";
-    if (typeof args === "string")
-        return args.slice(0, 80);
-    try {
-        const keys = Object.keys(args);
-        return keys.slice(0, 3).join(", ");
-    }
-    catch {
-        return String(args).slice(0, 80);
-    }
-}
-function truncate(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max - 3) + "...";
-}
-function looksLikeErrorPaste(text) {
-    // Error markers.
-    if (/(?:^|\s)ERROR|Error:|error TS\d+|Transform failed|\[plugin:|SyntaxError|Cannot find|Uncaught|exception/i.test(text)) {
-        return true;
-    }
-    // Structural signals of pasted compiler/runtime output: source frames
-    // ("270|  }_s(...)"), path:line:col references, and stack-trace lines.
-    if (/(?:^|\n)\s*\d+\s*\|/.test(text))
-        return true;
-    if (/[\w./\\-]+\.[a-z]{1,6}:\d+:\d+/.test(text))
-        return true;
-    if (/(?:^|\n)\s*at\s+\S+/.test(text))
-        return true;
-    return false;
-}
-export function extractTriedAndFailed(messages) {
-    const failures = new Map();
-    for (const msg of messages) {
-        if (msg.role === "tool" && msg.name && msg.success === false) {
-            const key = `${msg.name}:${summarizeArgs(msg.arguments)}`;
-            const existing = failures.get(key);
-            const errorText = truncate(typeof msg.content === "string" ? msg.content : getMessageText(msg.content), 100);
-            if (existing) {
-                existing.count++;
-            }
-            else {
-                failures.set(key, {
-                    tool: msg.name,
-                    args: summarizeArgs(msg.arguments),
-                    error: errorText,
-                    count: 1,
-                });
-            }
-        }
-    }
-    return Array.from(failures.values()).filter((f) => f.count >= 2);
-}
-export class ContextManager {
-    contextWindow;
-    messages = [];
-    compactedBlock = null;
-    iterationsSinceCompaction = 0;
-    compactionCount = 0;
-    peakTokens = 0;
-    budget;
-    compactionThreshold;
-    facts = new FactExtractor();
-    /** Latest real user instruction (skips <system-summary> blocks). */
-    lastUserTask = "";
-    /** First real user instruction of the session — survives resetUserTurn(). */
-    sessionMission = "";
-    /** Latest user message that looks like a pasted error/log (never a task). */
-    lastUserFeedback = "";
-    tokenCounter;
-    pendingImageParts = [];
-    toolTokens = 0;
-    onCompact = null;
-    /**
-     * Optional short line appended to the compaction summary so the model knows
-     * an active plan exists with progress. Wired from bootstrap to the execution
-     * module — without it, a 9B model re-creates a plan from scratch right after
-     * compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) was discarded for a
-     * fresh plan_xzq9xe the same iteration the old plan was still visible).
-     */
-    planSummaryProvider = null;
-    constructor(contextWindow, contextBudget, tokenCounter) {
-        this.contextWindow = contextWindow;
-        this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
-        this.budget = this.calculateBudget(contextWindow, contextBudget);
-        this.tokenCounter = tokenCounter ?? null;
-    }
-    /**
-     * Provide a short "current plan" line for the compaction summary, or null
-     * when no plan is active. Injected once at bootstrap (not per-turn state).
-     */
-    setPlanSummaryProvider(fn) {
-        this.planSummaryProvider = fn;
-    }
-    calculateBudget(window, contextBudget) {
-        if (contextBudget) {
-            const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
-            const responseReserve = Math.floor(window * contextBudget.responseReserve);
-            const history = Math.max(0, window - systemPrompt - responseReserve);
-            return { systemPrompt, responseReserve, history };
-        }
-        // Fallback for backwards compatibility (tests, subagents without explicit budget)
-        return {
-            systemPrompt: Math.floor(window * 0.25),
-            responseReserve: Math.floor(window * 0.12),
-            history: Math.floor(window * 0.63),
-        };
-    }
-    getBudget() {
-        return { ...this.budget };
-    }
-    getCompactionCount() {
-        return this.compactionCount;
-    }
-    getIterationsSinceCompaction() {
-        return this.iterationsSinceCompaction;
-    }
-    /** Files known from compaction summaries — for seeding the hallucination
-     *  checker's known-files set so bare filenames survive context resets. */
-    getKnownFiles() {
-        return this.facts.getKnownFiles();
-    }
-    noteIteration() {
-        this.iterationsSinceCompaction++;
-    }
-    /**
-     * Start a fresh user turn. The 15-iteration compaction interval must not
-     * leak across user messages — otherwise a turn that ends at iteration 14
-     * forces a compaction on the very first iteration of the next user message
-     * (observed: compaction fired on iteration 8 of a new turn, deleting the
-     * user's freshly-sent task alongside 40+ old turns). Facts are kept.
-     */
-    resetUserTurn() {
-        this.iterationsSinceCompaction = 0;
-        // A new user message begins a new turn — drop the previous turn's task
-        // so the fresh instruction becomes the one preserved at compaction. The
-        // session mission survives: an error/log paste in the new turn must not
-        // erase the original goal.
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-    }
-    getQuality() {
-        const usedTokens = this.getEstimatedTokens();
-        const tokenLoad = Math.max(0, 1 - usedTokens / this.budget.history);
-        // Recoverable penalty: each compaction loses some information, but the
-        // penalty is CAPPED so cumulative compactions can never permanently pin
-        // quality below the forced-compaction trigger (40%). Before this cap, a
-        // session with ~7+ compactions clamped the term to 0 forever; combined
-        // with heavy token load + error density, quality stuck below 40 and a
-        // compaction fired on EVERY iteration (observed: 56 compactions in 28 min).
-        const COMPACTION_PENALTY_FLOOR = 0.5;
-        const compactionLoss = Math.max(COMPACTION_PENALTY_FLOOR, 1 - this.compactionCount * 0.15);
-        const msgCount = this.messages.length || 1;
-        const errorDensity = Math.max(0, 1 - Math.min(1, this.facts.errorCount / msgCount));
-        const freshness = Math.max(0, 1 - this.iterationsSinceCompaction / COMPACTION_INTERVAL);
-        const score = tokenLoad * 0.4 + compactionLoss * 0.25 + errorDensity * 0.2 + freshness * 0.15;
-        return Math.round(Math.min(100, Math.max(0, score * 100)));
-    }
-    addMessage(msg) {
-        // Track the task the agent is working on so it survives compaction. The
-        // user's real instruction is the FIRST non-system-summary user message of
-        // the turn; everything after it (tool results, retry nudges) are injected
-        // `user` envelopes that must not overwrite it (observed: after compaction
-        // the model had forgotten "удали /bicycles, почини стили" and re-read
-        // files aimlessly for 40+ iterations).
-        if (msg.role === "user") {
-            const text = typeof msg.content === "string" ? msg.content : getMessageText(msg.content);
-            if (text.trim() && !text.startsWith("<system-summary>") && !text.includes("[Compressed:")) {
-                if (looksLikeErrorPaste(text) && (this.lastUserTask || this.sessionMission)) {
-                    this.lastUserFeedback = text.trim().slice(0, 400);
-                }
-                else if (!this.lastUserTask && !this.lastUserFeedback) {
-                    // No new task inside a turn that already captured an error/log paste:
-                    // the paste's follow-up messages are tool-result continuations, not a
-                    // fresh instruction, so the session mission must win at compaction.
-                    this.lastUserTask = text.trim();
-                    if (!this.sessionMission)
-                        this.sessionMission = text.trim();
-                }
-            }
-        }
-        // Auto-attach pending images to the next user message
-        if (msg.role === "user" && this.pendingImageParts.length > 0) {
-            const textPart = {
-                type: "text",
-                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
-            };
-            msg = {
-                ...msg,
-                content: [textPart, ...this.pendingImageParts],
-            };
-            this.pendingImageParts = [];
-        }
-        this.messages.push(msg);
-        const tokens = this.getEstimatedTokens();
-        if (tokens > this.peakTokens)
-            this.peakTokens = tokens;
-    }
-    /**
-     * Queue an image part to be attached to the next user message.
-     */
-    addPendingImage(part) {
-        this.pendingImageParts.push(part);
-    }
-    /**
-     * Check if there are pending images waiting to be attached.
-     */
-    hasPendingImages() {
-        return this.pendingImageParts.length > 0;
-    }
-    /**
-     * Get pending image parts without clearing them.
-     */
-    getPendingImages() {
-        return [...this.pendingImageParts];
-    }
-    /**
-     * Clear pending images (e.g., if user sends a text-only message).
-     */
-    clearPendingImages() {
-        this.pendingImageParts = [];
-    }
-    getMessageCount() {
-        return this.messages.length;
-    }
-    // Per-message token cache: messages are treated as immutable once added
-    // (compaction/updateSystemPrompt create new objects), so a WeakMap is safe
-    // and turns repeated full-history estimation from O(n) encodes into O(1).
-    tokenCache = new WeakMap();
-    estimateMessageTokensCached(m) {
-        let t = this.tokenCache.get(m);
-        if (t === undefined) {
-            t = this.estimateMessageTokens(m);
-            this.tokenCache.set(m, t);
-        }
-        return t;
-    }
-    estimateMessageTokens(m) {
-        const text = getMessageText(m.content);
-        if (this.tokenCounter) {
-            let t = this.tokenCounter.count(text);
-            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
-            if (Array.isArray(m.content)) {
-                for (const part of m.content) {
-                    if (part.type === "image_url" && part.image_url?.url) {
-                        const b64Len = part.image_url.url.includes(",")
-                            ? (part.image_url.url.split(",")[1]?.length ?? 0)
-                            : part.image_url.url.length;
-                        // ~130 tokens per 512 bytes of base64
-                        t += Math.ceil(b64Len / 512) * 130;
-                    }
-                }
-            }
-            if (m.tool_calls) {
-                for (const tc of m.tool_calls) {
-                    t += this.tokenCounter.count(tc.id);
-                    t += this.tokenCounter.count(tc.function.name);
-                    t += this.tokenCounter.count(tc.function.arguments);
-                    t += 4;
-                }
-            }
-            return t;
-        }
-        let t = Math.ceil(text.length / 2);
-        if (Array.isArray(m.content)) {
-            for (const part of m.content) {
-                if (part.type === "image_url" && part.image_url?.url) {
-                    const b64Len = part.image_url.url.includes(",")
-                        ? (part.image_url.url.split(",")[1]?.length ?? 0)
-                        : part.image_url.url.length;
-                    t += Math.ceil(b64Len / 512) * 130;
-                }
-            }
-        }
-        if (m.tool_calls) {
-            for (const tc of m.tool_calls) {
-                t += Math.ceil(tc.id.length / 2);
-                t += Math.ceil(tc.function.name.length / 2);
-                t += Math.ceil(tc.function.arguments.length / 2);
-                t += 4;
-            }
-        }
-        return t;
-    }
-    needsCompaction() {
-        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
-            return true;
-        const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0);
-        return totalTokens > this.budget.history * this.compactionThreshold;
-    }
-    compact() {
-        // Capture the pre-compaction state BEFORE any counters reset or rise —
-        // qualityBefore must reflect the context the model actually saw.
-        const tokensBefore = this.getEstimatedTokens();
-        const qualityBefore = this.getQuality();
-        const messagesBefore = this.messages.length;
-        // Reset the counter even when nothing to compact — otherwise
-        // needsCompaction() returns true forever after 15 iterations with few messages.
-        this.iterationsSinceCompaction = 0;
-        if (this.messages.length <= KEEP_LAST_N * 2)
-            return null;
-        this.compactionCount++;
-        const cutoff = this.messages.length - KEEP_LAST_N * 2;
-        const oldTurns = this.messages.slice(0, cutoff);
-        const recentTurns = this.messages.slice(cutoff);
-        this.facts.extract(oldTurns);
-        const parts = [];
-        parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        // Carry the user's actual instruction forward — the model must never lose
-        // the task it is working on just because 40 turns got compacted away. The
-        // per-turn task falls back to the session mission (first real instruction)
-        // so a pasted error/log in the current turn cannot erase the goal.
-        const task = (this.lastUserTask || this.sessionMission).slice(0, 400);
-        if (task)
-            parts.push(`[Task: ${task}]`);
-        if (this.lastUserFeedback && !task.startsWith(this.lastUserFeedback)) {
-            parts.push(`[User feedback: ${this.lastUserFeedback}]`);
-        }
-        // Orient the model after compaction: an active plan must not be re-created
-        // from scratch (see planSummaryProvider doc).
-        const planLine = this.planSummaryProvider?.();
-        if (planLine)
-            parts.push(`[Plan: ${planLine}]`);
-        const filesLine = this.facts.filesLine();
-        if (filesLine)
-            parts.push(filesLine);
-        const deletedLine = this.facts.deletedLine();
-        if (deletedLine)
-            parts.push(deletedLine);
-        const readLine = this.facts.readLine();
-        if (readLine)
-            parts.push(readLine);
-        const decisionsLine = this.facts.decisionsLine();
-        if (decisionsLine)
-            parts.push(decisionsLine);
-        const errorsLine = this.facts.errorsLine();
-        if (errorsLine)
-            parts.push(errorsLine);
-        const triedAndFailed = extractTriedAndFailed(oldTurns);
-        if (triedAndFailed.length > 0) {
-            const lines = triedAndFailed.map((t) => `- ${t.tool}(${t.args}): ${t.error} (failed ${t.count}x)`);
-            parts.push(`[Already tried & failed — do NOT repeat:]\n${lines.join("\n")}`);
-        }
-        this.compactedBlock = parts.join(" ");
-        const summary = {
-            role: "user",
-            content: `<system-summary>${this.compactedBlock}</system-summary>`,
-        };
-        const firstSystem = this.messages.find((m) => m.role === "system");
-        // Filter out stale system-summary messages from recent turns to prevent nesting
-        const freshRecent = recentTurns.filter((m) => {
-            if (m.role !== "user")
-                return true;
-            const text = getMessageText(m.content);
-            return !text.startsWith("<system-summary>");
-        });
-        this.messages = [...(firstSystem ? [firstSystem] : []), summary, ...freshRecent];
-        this.iterationsSinceCompaction = 0;
-        if (this.onCompact) {
-            this.onCompact(summary);
-        }
-        return {
-            removedTurns: oldTurns.length,
-            keptTurns: freshRecent.length,
-            tokensBefore,
-            tokensAfter: this.getEstimatedTokens(),
-            qualityBefore,
-            qualityAfter: this.getQuality(),
-            messagesBefore,
-            messagesAfter: this.messages.length,
-            summary: this.compactedBlock ?? "",
-        };
-    }
-    /**
-     * Snapshot of the current context state — used to log the initial context
-     * structure at session start and per-iteration context stats.
-     */
-    getSnapshot() {
-        return {
-            window: this.contextWindow,
-            budget: { ...this.budget },
-            tokens: this.getEstimatedTokens(),
-            toolTokens: this.toolTokens,
-            messageCount: this.messages.length,
-            quality: this.getQuality(),
-            compactionCount: this.compactionCount,
-            iterationsSinceCompaction: this.iterationsSinceCompaction,
-        };
-    }
-    /**
-     * Replace the system prompt in place (keeps it first) or prepend a new one.
-     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
-     */
-    updateSystemPrompt(content) {
-        const idx = this.messages.findIndex((m) => m.role === "system");
-        if (idx >= 0) {
-            this.messages[idx] = { ...this.messages[idx], content };
-        }
-        else {
-            this.messages.unshift({ role: "system", content });
-        }
-    }
-    getActiveHistory() {
-        return [...this.messages];
-    }
-    /**
-     * Reset everything that belongs to the current conversation turn.
-     * Fact lists (FactExtractor) intentionally survive clear() — they are
-     * session-scoped compaction state, not per-turn.
-     */
-    clear() {
-        this.messages = [];
-        this.compactedBlock = null;
-        this.iterationsSinceCompaction = 0;
-        this.compactionCount = 0;
-        this.peakTokens = 0;
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-        this.sessionMission = "";
-    }
-    getEstimatedTokens() {
-        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokensCached(m), 0) + this.toolTokens);
-    }
-    setToolTokens(tokens) {
-        this.toolTokens = tokens;
-    }
-    resize(contextWindow, contextBudget, tokenCounter) {
-        this.contextWindow = contextWindow;
-        this.budget = this.calculateBudget(contextWindow, contextBudget);
-        if (tokenCounter !== undefined) {
-            this.tokenCounter = tokenCounter ?? null;
-        }
-    }
-}

package/dist/modules/execution/audit-runners.js

@@ -1,206 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { detectTestResults } from "../../tools/bash";
-import { processRegistry } from "../processes";
-/** Directories never searched for test files. */
-export const SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    ".mma",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    ".nuxt",
-    "vendor",
-]);
-const TEST_EXT_RE = /\.(test|spec)\.[jt]sx?$/i;
-const PY_TEST_RE = /^test_.*\.py$|^.*_test\.py$/i;
-const TEST_STEP_RE = /\b(test(ing|s)?|тест(ы|ирование|ировать)?|провер\w*\s+тест|запустить\s+тест)\b|bun test|npm test|vitest|pytest|go test|jest|mocha/i;
-/**
- * Resolve the project's test command from its manifest, so the final audit
- * actually runs the runner the project uses instead of always assuming
- * `bun test` (a Python or Go project, or a vitest/jest setup, would fail or
- * silently produce no summary under bun test).
- *
- * Priority: package.json scripts.test → test-framework config files → Python
- * markers (pyproject/pytest.ini/conftest.py) → go.mod → Cargo.toml → bun.
- */
-export function resolveTestCommand(dir) {
-    const pkgPath = join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            const script = pkg?.scripts?.test;
-            if (typeof script === "string" && script.trim())
-                return script.trim();
-        }
-        catch {
-            /* invalid package.json — fall through */
-        }
-    }
-    for (const f of [
-        "vitest.config.ts",
-        "vitest.config.js",
-        "vitest.config.mjs",
-        "jest.config.js",
-        "jest.config.ts",
-        "jest.config.mjs",
-        "jest.config.cjs",
-        "bunfig.toml",
-    ]) {
-        if (existsSync(join(dir, f))) {
-            if (f.startsWith("vitest"))
-                return "bunx vitest run";
-            if (f.startsWith("jest"))
-                return "npx --no-install jest";
-            if (f === "bunfig.toml")
-                return "bun test";
-        }
-    }
-    if (existsSync(join(dir, "pyproject.toml")) ||
-        existsSync(join(dir, "pytest.ini")) ||
-        existsSync(join(dir, "conftest.py"))) {
-        return "python -m pytest -q";
-    }
-    if (existsSync(join(dir, "go.mod")))
-        return "go test ./...";
-    if (existsSync(join(dir, "Cargo.toml")))
-        return "cargo test";
-    return "bun test";
-}
-/** Recursive, depth-limited walk that stops early on the first test file. */
-export function findTestFile(dir, depth = 0) {
-    if (depth > 5)
-        return null;
-    let entries;
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const e of entries) {
-        const full = join(dir, e.name);
-        if (e.isDirectory()) {
-            if (SKIP_DIRS.has(e.name))
-                continue;
-            const found = findTestFile(full, depth + 1);
-            if (found)
-                return found;
-        }
-        else if (TEST_EXT_RE.test(e.name) || PY_TEST_RE.test(e.name)) {
-            return full;
-        }
-    }
-    return null;
-}
-/** The plan's step descriptions mention running/checking tests. */
-export function hasTestStep(plan) {
-    return plan.steps.some((s) => TEST_STEP_RE.test(s.description));
-}
-/** Extract failing test names from a runner's output (bun/vitest style). */
-function extractFailingNames(output, limit = 5) {
-    const names = [];
-    for (const m of output.matchAll(/\(fail\)\s*([^\n]+)/g)) {
-        const name = m[1].trim();
-        if (name && !names.includes(name))
-            names.push(name);
-        if (names.length >= limit)
-            break;
-    }
-    return names;
-}
-export async function runTests(baseDir) {
-    const command = resolveTestCommand(baseDir);
-    const entry = processRegistry.start(command, baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    if (!exited) {
-        // Timed out — we cannot claim success or failure from an unfinished run.
-        return {
-            checked: true,
-            passed: true, // don't block completion on an inconclusive run
-            failed: 0,
-            passedCount: 0,
-            detail: `test run timed out after 90s — result unknown`,
-            command,
-        };
-    }
-    const run = detectTestResults(output);
-    if (!run) {
-        // No recognizable runner summary. A non-zero exit means the test run
-        // (or its runner) failed — the audit must not pass on it; report a
-        // single "at least one failed" since we cannot count them. Exit 0
-        // with unrecognized output stays checked-but-inconclusive.
-        return {
-            checked: true,
-            passed: entry.exitCode === 0,
-            failed: entry.exitCode === 0 ? 0 : 1,
-            passedCount: 0,
-            detail: output.slice(0, 200).trim(),
-            command,
-        };
-    }
-    const names = extractFailingNames(output);
-    return {
-        checked: true,
-        passed: run.failed === 0,
-        failed: run.failed,
-        passedCount: run.passed,
-        detail: names.length
-            ? names.join("; ")
-            : run.summary || `${run.failed} failed / ${run.passed} passed`,
-        command,
-    };
-}
-/** First `error TS…` line in a tsc output, or null when none/inconclusive. */
-export function parseTypecheckErrors(output) {
-    const line = output.split("\n").find((l) => /error TS\d+/.test(l));
-    return line ? line.trim().slice(0, 300) : null;
-}
-/**
- * Locate the nearest project root that owns a tsconfig.json.
- *
- * The agent frequently creates the project in a nested subfolder of its
- * baseDir (e.g. `bicycle-shop/`), so the tsconfig lives at
- * `baseDir/bicycle-shop/` and the old `existsSync(baseDir/tsconfig.json)`
- * gate silently skipped the final typecheck — the audit passed even with
- * dozens of tsc errors (observed in both analyzed sessions). This walks each
- * candidate (baseDir plus the resolved step files) upward to the nearest
- * tsconfig.json, preferring the shallowest hit so the baseDir project wins
- * over a stray tsconfig further up. Returns null when no tsconfig exists in
- * any reachable subtree. `existingFiles` must contain resolved absolute paths
- * (relative tokens would resolve against the process cwd, not baseDir).
- */
-export function findTypecheckRoot(baseDir, existingFiles = []) {
-    const candidates = [baseDir, ...existingFiles];
-    let best = null;
-    for (const start of candidates) {
-        let dir = resolve(start);
-        for (let depth = 0; depth <= 10; depth++) {
-            if (existsSync(join(dir, "tsconfig.json"))) {
-                if (!best || depth < best.depth)
-                    best = { depth, root: dir };
-                break;
-            }
-            const parent = dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    return best?.root ?? null;
-}
-export async function runTypecheck(baseDir) {
-    const entry = processRegistry.start("npx --no-install tsc --noEmit --skipLibCheck", baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    // A timeout, or output with no `error TS` lines (missing typescript / wrong
-    // working dir) is inconclusive — never block completion on those.
-    if (!exited)
-        return null;
-    return parseTypecheckErrors(output);
-}