@mintlify/cli 4.0.1466 → 4.0.1468

package/__test__/mintTestFilePreview.test.ts

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PREVIEW_BYTE_LIMIT, readFilePreview } from '../src/mintTestFilePreview.js';
+
+let temporaryDirectory: string;
+
+beforeEach(async () => {
+  temporaryDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-preview-'));
+});
+
+afterEach(async () => {
+  await fs.rm(temporaryDirectory, { recursive: true });
+});
+
+it('reads at most the preview limit plus the truncation marker byte', async () => {
+  const filePath = path.join(temporaryDirectory, 'large.txt');
+  await fs.writeFile(filePath, 'a'.repeat(PREVIEW_BYTE_LIMIT + 10_000));
+
+  const preview = await readFilePreview(filePath);
+
+  expect(preview).toEqual({
+    binary: false,
+    text: 'a'.repeat(PREVIEW_BYTE_LIMIT),
+    truncated: true,
+  });
+});
+
+it('rejects binary previews', async () => {
+  const filePath = path.join(temporaryDirectory, 'binary.dat');
+  await fs.writeFile(filePath, new Uint8Array([1, 0, 2]));
+
+  await expect(readFilePreview(filePath)).resolves.toEqual({ binary: true });
+});

package/__test__/mintTestOutput.test.ts

@@ -0,0 +1,194 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { executeCodeBlocks } from '../src/agent-harness/executeCodeBlocks.js';
+import { generateTestCode } from '../src/agent-harness/generateTestCode.js';
+import type { GeneratedTask, TaskUpdate } from '../src/agent-harness/types.js';
+
+const agentMocks = vi.hoisted(() => ({ codexRun: vi.fn() }));
+
+vi.mock('../src/agent-harness/loadAgentSdk.js', () => ({
+  loadCodexSdk: vi.fn(async () => ({
+    Codex: class {
+      startThread() {
+        return { run: agentMocks.codexRun };
+      }
+    },
+  })),
+}));
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  vi.clearAllMocks();
+  await Promise.all(
+    temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true }))
+  );
+});
+
+it('includes absolute generated file paths in updates and results', async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
+  temporaryDirectories.push(directory);
+  const generatedFile = path.join(directory, 'tests', 'generated.test.ts');
+  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
+  await fs.writeFile(generatedFile, 'export const generated = true;\n');
+  const task: GeneratedTask = {
+    id: 'claude:guide.mdx',
+    agent: 'claude',
+    docsRoot: directory,
+    file: 'guide.mdx',
+    directory,
+    attempts: 1,
+    tokens: 10,
+    testable: true,
+    manifest: {
+      version: 1,
+      generatedFiles: ['tests/generated.test.ts'],
+      setupCommands: [],
+      testCommands: [],
+    },
+  };
+  const updates: TaskUpdate[] = [];
+
+  const results = await executeCodeBlocks({
+    tasks: [task],
+    docsRoot: directory,
+    concurrency: 1,
+    commandTimeoutMs: 1_000,
+    signal: new AbortController().signal,
+    onTaskUpdate: (update) => updates.push(update),
+  });
+
+  expect(results).toHaveLength(1);
+  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
+  expect(updates.map((update) => update.generatedFiles)).toEqual([
+    [generatedFile],
+    [generatedFile],
+  ]);
+});
+
+it('includes partial generated files when generation fails', async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
+  temporaryDirectories.push(directory);
+  const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
+  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
+  await fs.writeFile(path.join(directory, 'package.json'), '{}\n');
+  agentMocks.codexRun.mockImplementation(async () => {
+    await fs.writeFile(generatedFile, 'export const partial = true;\n');
+    throw new Error('generation failed');
+  });
+  const updates: TaskUpdate[] = [];
+
+  const generated = await generateTestCode({
+    tasks: [generatedTask(directory)],
+    docsRoot: directory,
+    model: 'unused',
+    concurrency: 1,
+    signal: new AbortController().signal,
+    onTaskUpdate: (update) => updates.push(update),
+  });
+
+  expect(updates.at(-1)).toMatchObject({
+    phase: 'agent_error',
+    generatedFiles: [generatedFile],
+  });
+  const results = await executeCodeBlocks({
+    tasks: generated,
+    docsRoot: directory,
+    concurrency: 1,
+    commandTimeoutMs: 1_000,
+    signal: new AbortController().signal,
+    onTaskUpdate: (update) => updates.push(update),
+  });
+  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
+  expect(updates.at(-1)).toMatchObject({
+    phase: 'agent_error',
+    generatedFiles: [generatedFile],
+  });
+});
+
+it('includes partial generated files when generation is cancelled', async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
+  temporaryDirectories.push(directory);
+  const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
+  await fs.mkdir(path.dirname(generatedFile), { recursive: true });
+  const controller = new AbortController();
+  agentMocks.codexRun.mockImplementation(async () => {
+    await fs.writeFile(generatedFile, 'export const partial = true;\n');
+    controller.abort();
+    throw new Error('cancelled');
+  });
+  const updates: TaskUpdate[] = [];
+
+  const generated = await generateTestCode({
+    tasks: [generatedTask(directory)],
+    docsRoot: directory,
+    model: 'unused',
+    concurrency: 1,
+    signal: controller.signal,
+    onTaskUpdate: (update) => updates.push(update),
+  });
+
+  expect(updates.at(-1)).toMatchObject({
+    phase: 'cancelled',
+    generatedFiles: [generatedFile],
+  });
+  const results = await executeCodeBlocks({
+    tasks: generated,
+    docsRoot: directory,
+    concurrency: 1,
+    commandTimeoutMs: 1_000,
+    signal: controller.signal,
+    onTaskUpdate: (update) => updates.push(update),
+  });
+  expect(results[0]?.generatedFiles).toEqual([generatedFile]);
+  expect(updates.at(-1)).toMatchObject({
+    phase: 'cancelled',
+    generatedFiles: [generatedFile],
+  });
+});
+
+it.each([
+  { outcome: 'fails', aborted: false, status: 'agent_error', error: 'generation failed' },
+  { outcome: 'is cancelled', aborted: true, status: 'cancelled', error: 'run cancelled' },
+] as const)(
+  'forwards partial generated files through execution when generation $outcome',
+  async ({ aborted, status, error }) => {
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-output-'));
+    temporaryDirectories.push(directory);
+    const generatedFile = path.join(directory, 'tests', 'partial.test.ts');
+    const controller = new AbortController();
+    if (aborted) controller.abort();
+    const updates: TaskUpdate[] = [];
+
+    const results = await executeCodeBlocks({
+      tasks: [{ ...generatedTask(directory), error, generatedFiles: [generatedFile] }],
+      docsRoot: directory,
+      concurrency: 1,
+      commandTimeoutMs: 1_000,
+      signal: controller.signal,
+      onTaskUpdate: (update) => updates.push(update),
+    });
+
+    expect(results).toEqual([
+      expect.objectContaining({ status, error, generatedFiles: [generatedFile], commands: [] }),
+    ]);
+    expect(updates).toEqual([
+      expect.objectContaining({ phase: status, generatedFiles: [generatedFile] }),
+    ]);
+  }
+);
+
+function generatedTask(directory: string): GeneratedTask {
+  return {
+    id: 'codex:guide.mdx',
+    agent: 'codex',
+    docsRoot: directory,
+    file: 'guide.mdx',
+    directory,
+    attempts: 0,
+    tokens: 0,
+    testable: true,
+  };
+}

package/__test__/runHistory.test.ts

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  loadLatestTestRun,
+  loadTestRuns,
+  recordTestRun,
+  testRunReportPath,
+  testRunsIndexPath,
+  writeTestRunHistory,
+} from '../src/agent-harness/runHistory.js';
+import type { CodeTestReport } from '../src/agent-harness/types.js';
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories.splice(0).map((directory) => fs.rm(directory, { recursive: true }))
+  );
+});
+
+function makeReport(docsRoot: string, runId: string, completedAt: string): CodeTestReport {
+  return {
+    version: 1,
+    runId,
+    status: 'passed',
+    docsRoot,
+    outputDirectory: path.join(docsRoot, 'tests', 'mint-test', runId),
+    reportPath: testRunReportPath(docsRoot, runId),
+    agents: ['claude'],
+    model: 'claude-opus-4-8',
+    selectedFiles: ['guide.mdx'],
+    startedAt: '2026-09-01T12:00:00.000Z',
+    completedAt,
+    durationMs: 1_000,
+    tasks: [
+      {
+        id: 'claude:guide.mdx',
+        agent: 'claude',
+        file: 'guide.mdx',
+        directory: path.join(docsRoot, 'tests', 'mint-test', runId, 'claude', '001-guide'),
+        generatedFiles: [
+          path.join(
+            docsRoot,
+            'tests',
+            'mint-test',
+            runId,
+            'claude',
+            '001-guide',
+            'tests',
+            'guide.test.ts'
+          ),
+        ],
+        testable: true,
+        attempts: 1,
+        tokens: 100,
+        status: 'passed',
+        commands: [],
+      },
+    ],
+  };
+}
+
+it('stores each result and tracks every run in newest-first order', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const first = makeReport(docsRoot, '20260901120000-first', '2026-09-01T12:00:01.000Z');
+  const second = makeReport(docsRoot, '20260901130000-second', '2026-09-01T13:00:01.000Z');
+
+  await writeTestRunHistory(docsRoot, first);
+  await writeTestRunHistory(docsRoot, second);
+
+  expect(JSON.parse(await fs.readFile(testRunReportPath(docsRoot, first.runId), 'utf8'))).toEqual(
+    first
+  );
+  const index = await loadTestRuns(docsRoot);
+  expect(index.runs.map((run) => run.runId)).toEqual([second.runId, first.runId]);
+  expect(index.runs[0]?.counts).toEqual({
+    passed: 1,
+    failed: 0,
+    cancelled: 0,
+    agentErrors: 0,
+  });
+  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(second);
+});
+
+it('rebuilds testRuns.json data from saved run results', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, '20260901120000-rebuild', '2026-09-01T12:00:01.000Z');
+  await writeTestRunHistory(docsRoot, report);
+  await fs.unlink(testRunsIndexPath(docsRoot));
+
+  const rebuilt = await loadTestRuns(docsRoot);
+
+  expect(rebuilt.runs).toHaveLength(1);
+  expect(rebuilt.runs[0]?.runId).toBe(report.runId);
+});
+
+it('keeps every run when history writes overlap', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const reports = Array.from({ length: 12 }, (_, index) =>
+    makeReport(
+      docsRoot,
+      `20260901120000-concurrent-${index}`,
+      `2026-09-01T12:00:${String(index).padStart(2, '0')}.000Z`
+    )
+  );
+
+  await Promise.all(reports.map((report) => writeTestRunHistory(docsRoot, report)));
+
+  const index = JSON.parse(await fs.readFile(testRunsIndexPath(docsRoot), 'utf8')) as {
+    runs: Array<{ runId: string }>;
+  };
+  expect(index.runs.map((run) => run.runId).sort()).toEqual(
+    reports.map((report) => report.runId).sort()
+  );
+});
+
+it('recovers a stale history lock left by an interrupted process', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const historyDirectory = path.join(docsRoot, '.mintlify', 'test');
+  const lockPath = path.join(historyDirectory, 'testRuns.lock');
+  await fs.mkdir(historyDirectory, { recursive: true });
+  await fs.writeFile(lockPath, 'interrupted-process');
+  const staleTime = new Date(Date.now() - 31_000);
+  await fs.utimes(lockPath, staleTime, staleTime);
+  const report = makeReport(docsRoot, '20260901120000-after-crash', '2026-09-01T12:00:01.000Z');
+
+  await writeTestRunHistory(docsRoot, report);
+
+  await expect(fs.access(lockPath)).rejects.toMatchObject({ code: 'ENOENT' });
+  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(report);
+});
+
+it('returns the report as-is when history is saved', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  const report = makeReport(docsRoot, '20260901120000-saved', '2026-09-01T12:00:01.000Z');
+  const fallbackReportPath = path.join(report.outputDirectory, 'report.json');
+
+  await expect(recordTestRun(docsRoot, report, fallbackReportPath)).resolves.toBe(report);
+  await expect(loadLatestTestRun(docsRoot)).resolves.toEqual(report);
+});
+
+it('keeps a finished run usable when history cannot be saved', async () => {
+  const docsRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-test-history-'));
+  temporaryDirectories.push(docsRoot);
+  await fs.mkdir(path.join(docsRoot, '.mintlify'), { recursive: true });
+  await fs.writeFile(path.join(docsRoot, '.mintlify', 'test'), 'blocks the history directory\n');
+  const report = makeReport(docsRoot, '20260901120000-unsaved', '2026-09-01T12:00:01.000Z');
+  const fallbackReportPath = path.join(report.outputDirectory, 'report.json');
+
+  const recorded = await recordTestRun(docsRoot, report, fallbackReportPath);
+
+  expect(recorded).toEqual({
+    ...report,
+    reportPath: fallbackReportPath,
+    historyError: expect.stringContaining('run history could not be saved: '),
+  });
+});

package/bin/agent-harness/agentPreflight.js

@@ -0,0 +1,24 @@
+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 { loadClaudeAgentSdk, loadCodexSdk } from './loadAgentSdk.js';
+/**
+ * Fail fast, before any page is checked, when an agent SDK is not installed. Without this every
+ * page reports the same missing-dependency error minutes later as "test could not be generated".
+ */
+export function ensureAgentSdks(agents) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const agent of new Set(agents)) {
+            if (agent === 'claude')
+                yield loadClaudeAgentSdk();
+            else
+                yield loadCodexSdk();
+        }
+    });
+}

package/bin/agent-harness/buildTaskPrompt.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
+import { SAFE_EXECUTABLES } from './manifest.js';
 export const SYSTEM_PROMPT = `# Mint test generator
 
-You will be provided a markdown page guide that contians codeblocks. Follow the guide and implement
-the code as instrucuted by the guide into a given output directory.
+You will be given a markdown documentation page that contains code blocks. Follow the page and
+implement the code as the page instructs, inside the given output directory.
 
 Once finished, create a mint-test.json file in the current working directory with this shape:
 
@@ -12,12 +13,14 @@ Once finished, create a mint-test.json file in the current working directory wit
   "setupCommands": [],
   "testCommands": [
     {
+      "id": "node-tests",
       "executable": "node",
-      "args": ["--test", "tests/"],
+      "args": ["--test"],
       "cwd": ".",
       "timeoutMs": 120000
     },
     {
+      "id": "python-tests",
       "executable": "python3",
       "args": ["-m", "unittest", "discover", "-s", "tests"],
       "cwd": ".",
@@ -26,11 +29,18 @@ Once finished, create a mint-test.json file in the current working directory wit
   ]
 }
 
-Command cwd values must be relative to the current working directory. Finish with a short plain-text summary.
+Manifest rules:
+- "generatedFiles" lists every file you wrote, as paths relative to the current working directory. Each one must exist.
+- Every command has a unique "id" (letters, digits, dashes). Command "cwd" values are relative to the current working directory.
+- "executable" must be one of: ${[...SAFE_EXECUTABLES].join(', ')}, or a "./" script inside the current working directory. Do not use a shell, pipes, or "&&".
+- Do not add any other keys to the manifest.
+
+Finish with a short plain-text summary of what you tested and anything you could not test.
 
 Rules:
 - Read only the page named in the task. You may also read docs.json and an OpenAPI file referenced by that page.
-- The output directory is already scaffolded: package.json exists with "npm test" wired to "node --test tests/", and a tests/ directory is ready. Do not recreate or rewrite this scaffolding.
+- The output directory is already scaffolded: package.json exists with "npm test" wired to "node --test", and a tests/ directory is ready. Do not recreate or rewrite this scaffolding.
+- Run JavaScript tests with "node" and args ["--test"] from the task directory (no directory argument: on Node 21+ a path like "tests/" is treated as a glob and finds nothing). Node discovers tests/*.test.js on its own.
 - Write JavaScript and TypeScript tests as ES modules named tests/*.test.js using the Node built-in test runner (node:test and node:assert). Write Python tests as tests/test_*.py using the standard library unittest module, run with python3 -m unittest discover -s tests.
 - Prefer the standard library over installing dependencies; add a setup command only when a test truly cannot run without one.
 - Never write README, docs, or explanation files.
@@ -67,10 +77,10 @@ export const CHECK_JSON_INSTRUCTION = `
 
 Respond with only this JSON object and nothing else:
 { "version": 1, "testable": false, "reason": "expected output, not runnable code" }`;
-export function buildCheckPrompt(file, fileContnet) {
+export function buildCheckPrompt(file, fileContent) {
     return `Report if the file at filePath ${JSON.stringify(file)} is testable
 
 <file>
-${fileContnet}
+${fileContent}
 </file>`;
 }

package/bin/agent-harness/countReport.js

@@ -0,0 +1,10 @@
+export function countReport(tasks) {
+    const counts = { passed: 0, failed: 0, cancelled: 0, agentErrors: 0 };
+    for (const task of tasks) {
+        if (task.status === 'agent_error')
+            counts.agentErrors++;
+        else
+            counts[task.status]++;
+    }
+    return counts;
+}

package/bin/agent-harness/executeCodeBlocks.js

@@ -48,6 +48,44 @@ function outputCollector() {
         value: () => output,
     };
 }
+const MAX_FAILURE_LINE_LENGTH = 200;
+const TAP_SUMMARY_PATTERN = /^#\s*(tests|suites|pass|fail|cancelled|skipped|todo|duration_ms)\b|^1\.\.\d+$|^TAP version/;
+const ERROR_LINE_PATTERN = /\b(?:[A-Za-z]*Error|Traceback|FAILED|ModuleNotFoundError)\b/;
+const TAP_METADATA_PATTERN = /^(name|code|failureType|location|stack)\s*:/;
+/**
+ * The most useful single line from a failed command's output: the first thrown error, else the
+ * first failing TAP assertion, else the last line that is not a TAP summary.
+ */
+export function pickFailureLine(text) {
+    var _a, _b, _c, _d, _e, _f;
+    const lines = text
+        .split(/\r?\n/)
+        .map((raw) => raw.trim())
+        .filter((raw) => raw.length > 0 && !raw.startsWith('[mint test:'))
+        .map((raw) => ({ raw, text: raw.replace(/^#\s?/, '').trim() }))
+        .filter((line) => line.text.length > 0);
+    const thrown = lines.find(({ text: candidate }) => ERROR_LINE_PATTERN.test(candidate) &&
+        !candidate.startsWith('at ') &&
+        !/^(ok|Traceback)\b/.test(candidate) &&
+        !TAP_METADATA_PATTERN.test(candidate));
+    const assertion = lines.find(({ text: candidate }) => candidate.startsWith('not ok'));
+    const informative = lines.filter(({ raw }) => !TAP_SUMMARY_PATTERN.test(raw));
+    const line = (_f = (_d = (_b = (_a = thrown === null || thrown === void 0 ? void 0 : thrown.text) !== null && _a !== void 0 ? _a : assertion === null || assertion === void 0 ? void 0 : assertion.text) !== null && _b !== void 0 ? _b : (_c = informative[informative.length - 1]) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : (_e = lines[lines.length - 1]) === null || _e === void 0 ? void 0 : _e.text) !== null && _f !== void 0 ? _f : '';
+    return line.length > MAX_FAILURE_LINE_LENGTH
+        ? `${line.slice(0, MAX_FAILURE_LINE_LENGTH - 1)}…`
+        : line;
+}
+/** One line explaining the first command that did not pass, for the UI and the report. */
+export function summarizeCommandFailure(commands) {
+    var _a;
+    const failed = commands.find((command) => command.status !== 'passed');
+    if (!failed)
+        return undefined;
+    const invocation = [failed.executable, ...failed.args].join(' ');
+    const reason = (_a = failed.error) !== null && _a !== void 0 ? _a : (failed.exitCode === null ? 'did not exit cleanly' : `exited with code ${failed.exitCode}`);
+    const detail = pickFailureLine(failed.stderr) || pickFailureLine(failed.stdout);
+    return `${failed.phase} command \`${invocation}\` ${reason}${detail ? `: ${detail}` : ''}`;
+}
 function unrunCommandResult(command, phase, cwd, status, error) {
     return {
         id: command.id,
@@ -137,12 +175,15 @@ function spawnCommand({ command, phase, cwd, timeoutMs, signal, docsRootForComma
 export function executeCodeBlocks(_a) {
     return __awaiter(this, arguments, void 0, function* ({ tasks, docsRoot, concurrency, commandTimeoutMs, signal, onTaskUpdate, }) {
         return mapWithConcurrency(tasks, concurrency, (task) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c, _d;
+            const generatedFiles = (_c = (_b = (_a = task.manifest) === null || _a === void 0 ? void 0 : _a.generatedFiles.map((file) => path.resolve(task.directory, file))) !== null && _b !== void 0 ? _b : task.generatedFiles) !== null && _c !== void 0 ? _c : [];
             const base = {
                 id: task.id,
                 agent: task.agent,
                 file: task.file,
                 directory: task.directory,
+                generatedFiles,
+                testable: task.testable === true,
                 attempts: task.attempts,
                 tokens: task.tokens,
             };
@@ -153,6 +194,8 @@ export function executeCodeBlocks(_a) {
                         id: task.id,
                         agent: task.agent,
                         file: task.file,
+                        directory: task.directory,
+                        generatedFiles,
                         phase: 'not_testable',
                         tokens: task.tokens,
                     });
@@ -163,8 +206,11 @@ export function executeCodeBlocks(_a) {
                     id: task.id,
                     agent: task.agent,
                     file: task.file,
+                    directory: task.directory,
+                    generatedFiles,
                     phase: status,
                     tokens: task.tokens,
+                    error: task.error,
                 });
                 return Object.assign(Object.assign({}, base), { status, error: task.error, commands: [] });
             }
@@ -172,6 +218,8 @@ export function executeCodeBlocks(_a) {
                 id: task.id,
                 agent: task.agent,
                 file: task.file,
+                directory: task.directory,
+                generatedFiles,
                 phase: 'running',
                 tokens: task.tokens,
             });
@@ -206,15 +254,10 @@ export function executeCodeBlocks(_a) {
             for (const command of manifest.testCommands) {
                 commands.push(yield run(command, 'test'));
             }
-            const status = (_a = FAILURE_PRECEDENCE.find((candidate) => commands.some((command) => command.status === candidate))) !== null && _a !== void 0 ? _a : 'passed';
-            onTaskUpdate({
-                id: task.id,
-                agent: task.agent,
-                file: task.file,
-                phase: status,
-                tokens: task.tokens,
-            });
-            return Object.assign(Object.assign({}, base), { status, commands });
+            const status = (_d = FAILURE_PRECEDENCE.find((candidate) => commands.some((command) => command.status === candidate))) !== null && _d !== void 0 ? _d : 'passed';
+            const error = status === 'passed' ? undefined : summarizeCommandFailure(commands);
+            onTaskUpdate(Object.assign({ id: task.id, agent: task.agent, file: task.file, directory: task.directory, generatedFiles, phase: status, tokens: task.tokens }, (error ? { error } : {})));
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, base), { status }), (error ? { error } : {})), { commands });
         }));
     });
 }