@mintlify/cli 4.0.1466 → 4.0.1467

package/bin/agent-harness/generateTestCode.js

@@ -18,39 +18,11 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { SYSTEM_PROMPT, buildTaskPrompt } from './buildTaskPrompt.js';
 import { loadClaudeAgentSdk, loadCodexSdk } from './loadAgentSdk.js';
+import { MANIFEST_FILENAME, SAFE_EXECUTABLES, appendAgentReply, readManifest, writeErrorDetails, } from './manifest.js';
 import { mapWithConcurrency } from './mapWithConcurrency.js';
 import { checkFileTestability } from './tasks/checkTestability.js';
-import { manifestSchema, } from './types.js';
-const MANIFEST_FILENAME = 'mint-test.json';
-const SAFE_EXECUTABLES = new Set([
-    'bun',
-    'bunx',
-    'bundle',
-    'cargo',
-    'composer',
-    'deno',
-    'dotnet',
-    'go',
-    'gradle',
-    'java',
-    'javac',
-    'mvn',
-    'node',
-    'npm',
-    'npx',
-    'php',
-    'pip',
-    'pip3',
-    'pnpm',
-    'python',
-    'python3',
-    'pytest',
-    'ruby',
-    'rustc',
-    'uv',
-    'vitest',
-    'yarn',
-]);
+const SCAFFOLD_FILENAMES = new Set([MANIFEST_FILENAME, 'package.json']);
+const IGNORED_GENERATED_DIRECTORIES = new Set(['.git', 'node_modules']);
 function promptClaude(_a) {
     return __awaiter(this, arguments, void 0, function* ({ prompt, systemPrompt, model, workingDirectory, docsRoot, tools, signal, }) {
         var _b, e_1, _c, _d;
@@ -188,7 +160,7 @@ function validateManifest(manifest, directory) {
 function readValidManifest(directory) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const manifest = manifestSchema.parse(JSON.parse(yield fs.readFile(path.join(directory, MANIFEST_FILENAME), 'utf8')));
+            const manifest = yield readManifest(directory);
             const errors = yield validateManifest(manifest, directory);
             return errors.length === 0 ? manifest : null;
         }
@@ -197,15 +169,47 @@ function readValidManifest(directory) {
         }
     });
 }
+function discoverGeneratedFiles(directory) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const realDirectory = yield fs.realpath(directory);
+        const files = [];
+        function walk(currentDirectory) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const entries = yield fs.readdir(currentDirectory, { withFileTypes: true }).catch(() => []);
+                for (const entry of entries) {
+                    if (files.length >= 1000)
+                        return;
+                    if (currentDirectory === directory && SCAFFOLD_FILENAMES.has(entry.name))
+                        continue;
+                    const candidate = path.join(currentDirectory, entry.name);
+                    if (entry.isDirectory()) {
+                        if (IGNORED_GENERATED_DIRECTORIES.has(entry.name))
+                            continue;
+                        yield walk(candidate);
+                        continue;
+                    }
+                    if (!entry.isFile())
+                        continue;
+                    const realPath = yield fs.realpath(candidate).catch(() => undefined);
+                    if (realPath && isPathInside(realDirectory, realPath))
+                        files.push(path.resolve(candidate));
+                }
+            });
+        }
+        yield walk(directory);
+        return files.sort((left, right) => left.localeCompare(right));
+    });
+}
 export const CHECK_CONCURRENCY = 20;
 export function checkTestability(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ tasks, signal, onTaskUpdate, }) {
+    return __awaiter(this, arguments, void 0, function* ({ tasks, runDirectory, signal, onTaskUpdate, }) {
         const folderOrdered = [...tasks].sort((left, right) => path.dirname(left.file).localeCompare(path.dirname(right.file)) ||
             left.file.localeCompare(right.file) ||
             left.agent.localeCompare(right.agent));
         return mapWithConcurrency(folderOrdered, CHECK_CONCURRENCY, checkFileTestability, {
             signal,
             onTaskUpdate,
+            runDirectory,
         });
     });
 }
@@ -214,13 +218,16 @@ export function generateTestCode(_a) {
         const generateTask = (task) => __awaiter(this, void 0, void 0, function* () {
             if (task.error || !task.testable)
                 return task;
-            const emit = (phase, tokens) => onTaskUpdate({ id: task.id, agent: task.agent, file: task.file, phase, tokens });
+            const emit = (phase, tokens, generatedFiles = [], error) => onTaskUpdate(Object.assign({ id: task.id, agent: task.agent, file: task.file, directory: task.directory, generatedFiles,
+                phase,
+                tokens }, (error ? { error } : {})));
             let attempts = task.attempts;
             let tokens = task.tokens;
             let lastError = 'run cancelled';
+            const attemptErrors = [];
             const existing = yield readValidManifest(task.directory);
             if (existing) {
-                emit('generated', tokens);
+                emit('generated', tokens, existing.generatedFiles.map((file) => path.resolve(task.directory, file)));
                 return Object.assign(Object.assign({}, task), { manifest: existing });
             }
             for (let attempt = 1; attempt <= 2 && !signal.aborted; attempt++) {
@@ -247,23 +254,31 @@ export function generateTestCode(_a) {
                             signal,
                         });
                     tokens += reply.tokens;
-                    const manifest = manifestSchema.parse(JSON.parse(yield fs.readFile(path.join(task.directory, MANIFEST_FILENAME), 'utf8')));
+                    yield appendAgentReply(task.directory, attempt, reply.result);
+                    const manifest = yield readManifest(task.directory);
                     const errors = yield validateManifest(manifest, task.directory);
-                    if (errors.length > 0)
-                        throw new Error(errors.join('\n'));
-                    emit('generated', tokens);
+                    if (errors.length > 0) {
+                        const [first = '', ...rest] = errors;
+                        throw new Error([`${MANIFEST_FILENAME} has problems: ${first}`, ...rest].join('\n'));
+                    }
+                    emit('generated', tokens, manifest.generatedFiles.map((file) => path.resolve(task.directory, file)));
                     return Object.assign(Object.assign({}, task), { attempts, tokens, manifest });
                 }
                 catch (error) {
                     lastError = error instanceof Error ? error.message : String(error);
+                    attemptErrors.push(`Attempt ${attempt}: ${lastError}`);
                 }
             }
             if (signal.aborted) {
-                emit('cancelled', tokens);
-                return Object.assign(Object.assign({}, task), { attempts, tokens, error: 'run cancelled' });
+                const generatedFiles = yield discoverGeneratedFiles(task.directory);
+                emit('cancelled', tokens, generatedFiles, 'run cancelled');
+                return Object.assign(Object.assign({}, task), { attempts, tokens, generatedFiles, error: 'run cancelled' });
             }
-            emit('agent_error', tokens);
-            return Object.assign(Object.assign({}, task), { attempts, tokens, error: lastError });
+            const generatedFiles = yield discoverGeneratedFiles(task.directory);
+            const detailsPath = yield writeErrorDetails(task.directory, attemptErrors);
+            const error = detailsPath ? `${lastError}\nDetails: ${detailsPath}` : lastError;
+            emit('agent_error', tokens, generatedFiles, error);
+            return Object.assign(Object.assign({}, task), { attempts, tokens, generatedFiles, error });
         });
         return mapWithConcurrency(tasks, concurrency, generateTask);
     });

package/bin/agent-harness/index.js

@@ -8,15 +8,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import fs from 'node:fs/promises';
+import { ensureAgentSdks } from './agentPreflight.js';
 import { discoverCodeBlocks } from './discoverCodeBlocks.js';
 import { executeCodeBlocks } from './executeCodeBlocks.js';
 import { filterSelectedPages } from './filterSelectedPages.js';
 import { checkTestability, generateTestCode } from './generateTestCode.js';
+import { recordTestRun, testRunReportPath } from './runHistory.js';
 import { clearRunSave, writeRunSave } from './runSave.js';
-import { setupFolders } from './setupFolders.js';
+import { scaffoldTaskDirectories, setupFolders } from './setupFolders.js';
 export const DEFAULT_CONCURRENCY = 5;
 export const DEFAULT_COMMAND_TIMEOUT_MS = 2 * 60 * 1000;
 export { discoverCodeBlocks } from './discoverCodeBlocks.js';
+export { countReport } from './countReport.js';
+export { loadLatestTestRun, loadTestRuns } from './runHistory.js';
 export { clearRunSave, loadRunSave } from './runSave.js';
 export function runCodeTests(_a) {
     return __awaiter(this, arguments, void 0, function* ({ path: docsPath, agents, model, selectedFiles, outputDirectory, runId: savedRunId, concurrency, commandTimeoutMs, signal, onTaskUpdate, }) {
@@ -24,13 +28,16 @@ export function runCodeTests(_a) {
         const uniqueAgents = [...new Set(agents)];
         const { docsRoot, pages: allPages } = yield discoverCodeBlocks(docsPath);
         const pages = filterSelectedPages(allPages, selectedFiles);
-        const { runId, runDirectory, reportPath, tasks } = yield setupFolders({
+        if (pages.length > 0)
+            yield ensureAgentSdks(uniqueAgents);
+        const { runId, runDirectory, reportPath: legacyReportPath, tasks, } = yield setupFolders({
             pages,
             agents: uniqueAgents,
             docsRoot,
             outputDirectory,
             runId: savedRunId,
         });
+        const reportPath = testRunReportPath(docsRoot, runId);
         yield writeRunSave(outputDirectory, {
             version: 1,
             runId,
@@ -39,7 +46,8 @@ export function runCodeTests(_a) {
             selectedFiles: pages.map((page) => page.file),
             createdAt: startedAt.toISOString(),
         });
-        const checked = yield checkTestability({ tasks, signal, onTaskUpdate });
+        const checked = yield checkTestability({ tasks, runDirectory, signal, onTaskUpdate });
+        yield scaffoldTaskDirectories(checked.filter((task) => task.testable === true));
         const generated = yield generateTestCode({
             tasks: checked,
             docsRoot,
@@ -71,15 +79,16 @@ export function runCodeTests(_a) {
             outputDirectory: runDirectory,
             reportPath,
             agents: uniqueAgents,
+            model,
             selectedFiles: pages.map((page) => page.file),
             startedAt: startedAt.toISOString(),
             completedAt: completedAt.toISOString(),
             durationMs: completedAt.getTime() - startedAt.getTime(),
             tasks: results,
         };
-        yield fs.writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+        yield fs.writeFile(legacyReportPath, `${JSON.stringify(report, null, 2)}\n`);
         if (!signal.aborted)
             yield clearRunSave(outputDirectory);
-        return report;
+        return recordTestRun(docsRoot, report, legacyReportPath);
     });
 }

package/bin/agent-harness/manifest.js

@@ -0,0 +1,113 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { manifestSchema } from './types.js';
+export const MANIFEST_FILENAME = 'mint-test.json';
+export const AGENT_REPLY_FILENAME = 'mint-test-agent.md';
+export const ERROR_FILENAME = 'mint-test-error.txt';
+export const SAFE_EXECUTABLES = new Set([
+    'bun',
+    'bunx',
+    'bundle',
+    'cargo',
+    'composer',
+    'deno',
+    'dotnet',
+    'go',
+    'gradle',
+    'java',
+    'javac',
+    'mvn',
+    'node',
+    'npm',
+    'npx',
+    'php',
+    'pip',
+    'pip3',
+    'pnpm',
+    'python',
+    'python3',
+    'pytest',
+    'ruby',
+    'rustc',
+    'uv',
+    'vitest',
+    'yarn',
+]);
+function isMissingFile(error) {
+    return (typeof error === 'object' && error !== null && error.code === 'ENOENT');
+}
+/** Turn a schema failure into one readable line per problem, e.g. `testCommands.0.id: expected string`. */
+export function formatManifestIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.map(String).join('.');
+        return `${location || MANIFEST_FILENAME}: ${issue.message}`;
+    })
+        .join('\n');
+}
+/**
+ * Read and schema-check the manifest an agent wrote. Every failure mode has a message a
+ * documentation author can act on, because it is what `mint test` shows for the page.
+ */
+export function readManifest(directory) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const manifestPath = path.join(directory, MANIFEST_FILENAME);
+        let raw;
+        try {
+            raw = yield fs.readFile(manifestPath, 'utf8');
+        }
+        catch (error) {
+            if (isMissingFile(error)) {
+                throw new Error(`The agent finished without writing ${MANIFEST_FILENAME}`);
+            }
+            throw error;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`${MANIFEST_FILENAME} is not valid JSON: ${reason}`);
+        }
+        const result = manifestSchema.safeParse(parsed);
+        if (!result.success) {
+            const [first = '', ...rest] = formatManifestIssues(result.error).split('\n');
+            throw new Error([`${MANIFEST_FILENAME} does not match the expected shape: ${first}`, ...rest].join('\n'));
+        }
+        return result.data;
+    });
+}
+/** Keep the agent's final message next to its output so a failure can be traced later. */
+export function appendAgentReply(directory, attempt, reply) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const body = reply.trim() || '(no summary)';
+        yield fs
+            .appendFile(path.join(directory, AGENT_REPLY_FILENAME), `## Attempt ${attempt}\n\n${body}\n\n`)
+            .catch(() => { });
+    });
+}
+/** Persist every attempt's failure reason. Returns the file path, or undefined if it could not be written. */
+export function writeErrorDetails(directory, errors) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (errors.length === 0)
+            return undefined;
+        const errorPath = path.join(directory, ERROR_FILENAME);
+        try {
+            yield fs.writeFile(errorPath, `${errors.join('\n\n')}\n`);
+            return errorPath;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    });
+}

package/bin/agent-harness/runHistory.js

@@ -0,0 +1,252 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { z } from 'zod';
+import { countReport } from './countReport.js';
+const RUN_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+const INDEX_LOCK_FILENAME = 'testRuns.lock';
+const LOCK_RETRY_MS = 20;
+const STALE_LOCK_MS = 30000;
+const LOCK_TIMEOUT_MS = STALE_LOCK_MS + 10000;
+const commandResultSchema = z
+    .object({
+    id: z.string(),
+    phase: z.enum(['setup', 'test']),
+    status: z.enum(['passed', 'failed', 'cancelled']),
+    executable: z.string(),
+    args: z.array(z.string()),
+    cwd: z.string(),
+    durationMs: z.number().nonnegative(),
+    exitCode: z.number().int().nullable(),
+    stdout: z.string(),
+    stderr: z.string(),
+    error: z.string().optional(),
+})
+    .strict();
+const taskResultSchema = z
+    .object({
+    id: z.string(),
+    agent: z.enum(['claude', 'codex']),
+    file: z.string(),
+    directory: z.string(),
+    generatedFiles: z.array(z.string()),
+    testable: z.boolean(),
+    attempts: z.number().int().nonnegative(),
+    tokens: z.number().nonnegative(),
+    status: z.enum(['passed', 'failed', 'agent_error', 'cancelled']),
+    error: z.string().optional(),
+    commands: z.array(commandResultSchema),
+})
+    .strict();
+const codeTestReportSchema = z
+    .object({
+    version: z.literal(1),
+    runId: z.string().regex(RUN_ID_PATTERN),
+    status: z.enum(['passed', 'completed', 'failed', 'cancelled']),
+    docsRoot: z.string(),
+    outputDirectory: z.string(),
+    reportPath: z.string(),
+    agents: z.array(z.enum(['claude', 'codex'])).min(1),
+    model: z.string().min(1),
+    selectedFiles: z.array(z.string()),
+    startedAt: z.string(),
+    completedAt: z.string(),
+    durationMs: z.number().nonnegative(),
+    tasks: z.array(taskResultSchema),
+    historyError: z.string().optional(),
+})
+    .strict();
+const countsSchema = z
+    .object({
+    passed: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    cancelled: z.number().int().nonnegative(),
+    agentErrors: z.number().int().nonnegative(),
+})
+    .strict();
+const testRunSummarySchema = z
+    .object({
+    runId: z.string().regex(RUN_ID_PATTERN),
+    status: z.enum(['passed', 'completed', 'failed', 'cancelled']),
+    agents: z.array(z.enum(['claude', 'codex'])).min(1),
+    model: z.string().min(1),
+    selectedFiles: z.array(z.string()),
+    startedAt: z.string(),
+    completedAt: z.string(),
+    durationMs: z.number().nonnegative(),
+    reportPath: z.string(),
+    outputDirectory: z.string(),
+    counts: countsSchema,
+})
+    .strict();
+const testRunsIndexSchema = z
+    .object({ version: z.literal(1), runs: z.array(testRunSummarySchema) })
+    .strict();
+function historyDirectory(docsRoot) {
+    return path.join(docsRoot, '.mintlify', 'test');
+}
+function runsDirectory(docsRoot) {
+    return path.join(historyDirectory(docsRoot), 'runs');
+}
+export function testRunReportPath(docsRoot, runId) {
+    if (!RUN_ID_PATTERN.test(runId))
+        throw new Error(`Invalid mint test run ID: ${runId}`);
+    return path.join(runsDirectory(docsRoot), `${runId}.json`);
+}
+export function testRunsIndexPath(docsRoot) {
+    return path.join(historyDirectory(docsRoot), 'testRuns.json');
+}
+function summarizeReport(report) {
+    return {
+        runId: report.runId,
+        status: report.status,
+        agents: report.agents,
+        model: report.model,
+        selectedFiles: report.selectedFiles,
+        startedAt: report.startedAt,
+        completedAt: report.completedAt,
+        durationMs: report.durationMs,
+        reportPath: report.reportPath,
+        outputDirectory: report.outputDirectory,
+        counts: countReport(report.tasks),
+    };
+}
+function errorCode(error) {
+    return typeof error === 'object' && error !== null && 'code' in error
+        ? String(error.code)
+        : undefined;
+}
+function writeJsonAtomically(filePath, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+        try {
+            yield fs.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+            yield fs.rename(temporaryPath, filePath);
+        }
+        finally {
+            yield fs.unlink(temporaryPath).catch(() => undefined);
+        }
+    });
+}
+function acquireIndexLock(docsRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lockPath = path.join(historyDirectory(docsRoot), INDEX_LOCK_FILENAME);
+        const token = `${process.pid}:${randomUUID()}`;
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            try {
+                const lock = yield fs.open(lockPath, 'wx');
+                try {
+                    yield lock.writeFile(token);
+                }
+                finally {
+                    yield lock.close();
+                }
+                return () => __awaiter(this, void 0, void 0, function* () {
+                    const owner = yield fs.readFile(lockPath, 'utf8').catch(() => undefined);
+                    if (owner === token)
+                        yield fs.unlink(lockPath).catch(() => undefined);
+                });
+            }
+            catch (error) {
+                if (errorCode(error) !== 'EEXIST')
+                    throw error;
+            }
+            const stats = yield fs.stat(lockPath).catch(() => undefined);
+            if (stats && Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+                yield fs.unlink(lockPath).catch(() => undefined);
+                continue;
+            }
+            yield delay(LOCK_RETRY_MS);
+        }
+        throw new Error('Timed out updating mint test run history');
+    });
+}
+function readReport(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return codeTestReportSchema.parse(JSON.parse(yield fs.readFile(filePath, 'utf8')));
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+function rebuildIndex(docsRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = yield fs
+            .readdir(runsDirectory(docsRoot), { withFileTypes: true })
+            .catch(() => []);
+        const reports = yield Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+            .map((entry) => readReport(path.join(runsDirectory(docsRoot), entry.name))));
+        return {
+            version: 1,
+            runs: reports
+                .filter((report) => report !== null)
+                .map(summarizeReport)
+                .sort((left, right) => right.completedAt.localeCompare(left.completedAt)),
+        };
+    });
+}
+export function loadTestRuns(docsRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return testRunsIndexSchema.parse(JSON.parse(yield fs.readFile(testRunsIndexPath(docsRoot), 'utf8')));
+        }
+        catch (_a) {
+            return rebuildIndex(docsRoot);
+        }
+    });
+}
+export function loadLatestTestRun(docsRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const index = yield loadTestRuns(docsRoot);
+        for (const run of index.runs) {
+            const report = yield readReport(testRunReportPath(docsRoot, run.runId));
+            if (report)
+                return report;
+        }
+        return null;
+    });
+}
+export function writeTestRunHistory(docsRoot, report) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs.mkdir(runsDirectory(docsRoot), { recursive: true });
+        yield writeJsonAtomically(report.reportPath, report);
+        const releaseLock = yield acquireIndexLock(docsRoot);
+        try {
+            yield writeJsonAtomically(testRunsIndexPath(docsRoot), yield rebuildIndex(docsRoot));
+        }
+        finally {
+            yield releaseLock();
+        }
+    });
+}
+/**
+ * Saves a finished run to history without letting a history failure fail the run.
+ * On failure the returned report points at `fallbackReportPath` (the report that was
+ * already written) and carries the problem in `historyError`.
+ */
+export function recordTestRun(docsRoot, report, fallbackReportPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield writeTestRunHistory(docsRoot, report);
+            return report;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return Object.assign(Object.assign({}, report), { reportPath: fallbackReportPath, historyError: `run history could not be saved: ${message}` });
+        }
+    });
+}

package/bin/agent-harness/setupFolders.js

@@ -14,14 +14,30 @@ const PACKAGE_JSON = `${JSON.stringify({
     name: 'mint-test-task',
     private: true,
     type: 'module',
-    scripts: { test: 'node --test tests/' },
+    // No positional path: Node 21+ treats --test arguments as globs, so a bare
+    // directory such as `tests/` fails with MODULE_NOT_FOUND. The default patterns
+    // pick up tests/*.test.js on every supported Node version.
+    scripts: { test: 'node --test' },
 }, null, 2)}\n`;
+function isExistingFile(error) {
+    return (typeof error === 'object' && error !== null && error.code === 'EEXIST');
+}
 function scaffoldTaskDirectory(directory) {
     return __awaiter(this, void 0, void 0, function* () {
         yield fs.mkdir(path.join(directory, 'tests'), { recursive: true });
-        yield fs
-            .writeFile(path.join(directory, 'package.json'), PACKAGE_JSON, { flag: 'wx' })
-            .catch(() => { });
+        try {
+            yield fs.writeFile(path.join(directory, 'package.json'), PACKAGE_JSON, { flag: 'wx' });
+        }
+        catch (error) {
+            if (!isExistingFile(error))
+                throw error;
+        }
+    });
+}
+export function scaffoldTaskDirectories(tasks) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const task of tasks)
+            yield scaffoldTaskDirectory(task.directory);
     });
 }
 export function setupFolders(_a) {
@@ -52,8 +68,6 @@ export function setupFolders(_a) {
                 });
             }
         }
-        for (const task of tasks)
-            yield scaffoldTaskDirectory(task.directory);
         return { runId, runDirectory, reportPath, tasks };
     });
 }

package/bin/agent-harness/tasks/checkTestability.js

@@ -47,9 +47,8 @@ function parseJsonReply(reply) {
     return JSON.parse(raw.slice(start, end + 1));
 }
 function runTestabilityCheck(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ file, content, agent, outputPath, signal, }) {
+    return __awaiter(this, arguments, void 0, function* ({ file, content, agent, workingDirectory, signal, }) {
         const prompt = buildCheckPrompt(file, content);
-        const workingDirectory = path.dirname(outputPath);
         let tokens = 0;
         let raw;
         if (agent === 'claude') {
@@ -73,15 +72,16 @@ function runTestabilityCheck(_a) {
         const errors = validateCheck(check);
         if (errors.length > 0)
             throw new Error(errors.join('\n'));
-        yield fs.writeFile(outputPath, `${JSON.stringify(check, null, 2)}\n`);
         return { tokens, check };
     });
 }
-export const checkFileTestability = (task_1, _a) => __awaiter(void 0, [task_1, _a], void 0, function* (task, { onTaskUpdate, signal }) {
+export const checkFileTestability = (task_1, _a) => __awaiter(void 0, [task_1, _a], void 0, function* (task, { onTaskUpdate, signal, runDirectory, }) {
     const emit = (phase, tokens) => onTaskUpdate({
         id: task.id,
         agent: task.agent,
         file: task.file,
+        directory: task.directory,
+        generatedFiles: [],
         phase,
         tokens,
     });
@@ -99,7 +99,7 @@ export const checkFileTestability = (task_1, _a) => __awaiter(void 0, [task_1, _
                     file: task.file,
                     content,
                     agent: task.agent,
-                    outputPath: path.join(task.directory, CHECK_FILENAME),
+                    workingDirectory: runDirectory,
                     signal,
                 });
                 tokens += reply.tokens;
@@ -122,6 +122,8 @@ export const checkFileTestability = (task_1, _a) => __awaiter(void 0, [task_1, _
         emit('not_testable', tokens);
         return Object.assign(Object.assign({}, task), { attempts, tokens, testable: false });
     }
+    yield fs.mkdir(task.directory, { recursive: true });
+    yield fs.writeFile(path.join(task.directory, CHECK_FILENAME), `${JSON.stringify(check, null, 2)}\n`);
     emit('checked', tokens);
     return Object.assign(Object.assign({}, task), { attempts, tokens, testable: true });
 });