micro-models-agent 0.57.0 → 0.57.1

package/dist/modules/context/manager.js

@@ -0,0 +1,440 @@
+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

@@ -0,0 +1,206 @@
+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);
+}