devcontour-harness 0.1.0-alpha.6 → 0.1.0-alpha.7

package/lib/contracts/execution.js

@@ -136,12 +136,76 @@ export const propertyEvidenceSchema = z.strictObject({
         .optional(),
     coverage: z.array(z.string().max(1000)).optional(),
 });
-/** Что reviewer действительно выполнил — по событиям runtime, не по словам модели. */
+/** Происхождение подтверждённой команды: событие runtime или запуск probe controller. */
+export const inspectionOriginSchema = z.discriminatedUnion('type', [
+    z.strictObject({
+        type: z.literal('runtime'),
+        /** Имя runtime reviewer (`codex`, `claude`, …). */
+        runtime: z.string().min(1).max(100),
+        /** ID item в потоке событий runtime; `null` — runtime его не дал. */
+        item: z.string().min(1).max(200).nullable(),
+    }),
+    z.strictObject({
+        type: z.literal('controller'),
+        /** runId запуска probe в журнале controller (не runId попытки). */
+        runId: z.string().min(1).max(200),
+    }),
+]);
+/**
+ * Что reviewer действительно выполнил — по событиям runtime и журналу
+ * проверок controller одного вызова reviewer, не по словам модели
+ * (docs/review-probes.md). Поля после `reason` появились в alpha.7 и
+ * необязательны: записи прежних версий читаются как есть.
+ */
 export const reviewInspectionSchema = z.strictObject({
     mode: z.enum(['commands', 'diff-only']),
-    source: z.enum(['codex-events', 'unavailable']),
-    commands: z.array(z.strictObject({ command: z.string(), exitCode: z.number().int(), output: z.string() })),
+    source: z.enum(['codex-events', 'unavailable', 'controller-probes', 'runtime-and-controller']),
+    commands: z.array(z.strictObject({
+        command: z.string(),
+        /** `null` — код неизвестен: таймаут/отмена после старта, старая проекция без кода. */
+        exitCode: z.number().int().nullable(),
+        output: z.string(),
+        origins: z.array(inspectionOriginSchema).min(1).max(8).optional(),
+        /** Исход: `completed`/`failed` — runtime; остальные — статус probe controller. */
+        status: z.enum(['completed', 'passed', 'failed', 'timeout', 'cancelled', 'error']).optional(),
+        /** Неуспех не в проверяемом коде: среда или отчёт (как у probe). */
+        failure: z.enum(['environment', 'report']).optional(),
+        /** ID объявленного gate, запущенного через probe. */
+        gate: z.string().min(1).max(200).optional(),
+        note: z.string().max(2000).optional(),
+    })),
     reason: z.string().nullable(),
+    /** Вызов reviewer, которому принадлежит итог. */
+    context: z
+        .strictObject({
+        /** ID попытки harness (runId evidence). */
+        attempt: z.string().min(1).max(200),
+        phase: z.enum(['candidate', 'integration']),
+        sha: gitShaSchema,
+        call: z.number().int().positive(),
+    })
+        .optional(),
+    /** Число всех подтверждённых операций, в том числе не вошедших в `commands`. */
+    total: z.number().int().min(0).optional(),
+    /** Записи журнала, не засчитанные выполнением: почему (не более 100). */
+    excluded: z
+        .array(z.strictObject({
+        runId: z.string().min(1).max(200),
+        status: z.string().max(40).nullable(),
+        reason: z.enum([
+            'not-started',
+            'legacy-unconfirmed',
+            'foreign-scope',
+            'unknown-status',
+            'unfinished',
+            'abandoned',
+        ]),
+    }))
+        .max(100)
+        .optional(),
+    excludedTotal: z.number().int().min(0).optional(),
+    /** Строки журнала без формы исхода (битый JSON, `{}`): не запуски. */
+    invalid: z.number().int().min(0).optional(),
 });
 export const evidenceFindingSchema = z.strictObject({
     severity: z.string().min(1).max(40),

package/lib/contracts/published.d.ts

@@ -2812,13 +2812,61 @@ export declare const publishedSchemas: {
                     source: z.ZodEnum<{
                         "codex-events": "codex-events";
                         unavailable: "unavailable";
+                        "controller-probes": "controller-probes";
+                        "runtime-and-controller": "runtime-and-controller";
                     }>;
                     commands: z.ZodArray<z.ZodObject<{
                         command: z.ZodString;
-                        exitCode: z.ZodNumber;
+                        exitCode: z.ZodNullable<z.ZodNumber>;
                         output: z.ZodString;
+                        origins: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            type: z.ZodLiteral<"runtime">;
+                            runtime: z.ZodString;
+                            item: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strict>, z.ZodObject<{
+                            type: z.ZodLiteral<"controller">;
+                            runId: z.ZodString;
+                        }, z.core.$strict>], "type">>>;
+                        status: z.ZodOptional<z.ZodEnum<{
+                            error: "error";
+                            passed: "passed";
+                            failed: "failed";
+                            cancelled: "cancelled";
+                            completed: "completed";
+                            timeout: "timeout";
+                        }>>;
+                        failure: z.ZodOptional<z.ZodEnum<{
+                            report: "report";
+                            environment: "environment";
+                        }>>;
+                        gate: z.ZodOptional<z.ZodString>;
+                        note: z.ZodOptional<z.ZodString>;
                     }, z.core.$strict>>;
                     reason: z.ZodNullable<z.ZodString>;
+                    context: z.ZodOptional<z.ZodObject<{
+                        attempt: z.ZodString;
+                        phase: z.ZodEnum<{
+                            candidate: "candidate";
+                            integration: "integration";
+                        }>;
+                        sha: z.ZodString;
+                        call: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    total: z.ZodOptional<z.ZodNumber>;
+                    excluded: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        runId: z.ZodString;
+                        status: z.ZodNullable<z.ZodString>;
+                        reason: z.ZodEnum<{
+                            "not-started": "not-started";
+                            "legacy-unconfirmed": "legacy-unconfirmed";
+                            "foreign-scope": "foreign-scope";
+                            "unknown-status": "unknown-status";
+                            unfinished: "unfinished";
+                            abandoned: "abandoned";
+                        }>;
+                    }, z.core.$strict>>>;
+                    excludedTotal: z.ZodOptional<z.ZodNumber>;
+                    invalid: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
                 findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     severity: z.ZodString;

package/lib/control/review.js

@@ -3,6 +3,7 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { HarnessError, WORKSPACE_OWNER, contextDigest, findingId, mcpEnvironment, reviewIssues, reviewResultSchema, selectReviewer, } from "../contracts/index.js";
 import { reviewOutputSchema } from "../agents/schemas.js";
+import { redactInspection } from "../agents/inspect.js";
 import { executionEnvironment } from "../environment/lifecycle.js";
 import { redactDeep } from "../environment/redaction.js";
 import { TaskFailure } from "../engine/failure.js";
@@ -165,11 +166,14 @@ export async function technicalReview(engine, policy, adapters, input) {
     };
     // Сохраняемые представления маскируются полным окружением вызова: сырой
     // структурированный ответ адаптера может нести значение секрета профиля.
-    await writeFile(record.artifact, JSON.stringify(redactDeep({
-        response: parsed.success ? parsed.data : null,
-        issues,
-        inspection: response.inspection ?? null,
-    }, execution.redact), null, 2));
+    const artifact = redactDeep({ response: parsed.success ? parsed.data : null, issues, inspection: null }, execution.redact);
+    // Inspection маскируется по полям: служебные значения не текст reviewer.
+    await writeFile(record.artifact, JSON.stringify({
+        ...artifact,
+        inspection: response.inspection
+            ? redactInspection(response.inspection, execution.redact)
+            : null,
+    }, null, 2));
     // Снимок, который видел reviewer, хранится по digest: согласование этого
     // раунда делает его действующим контекстом графа.
     if (context && contextKey)

package/lib/engine/budget.d.ts

@@ -47,7 +47,7 @@ export declare function scopeRecords(c: BudgetContext, view: ExecutionView, reco
     model: string | null;
     runtimeVersion: string | null;
     startedAt: string;
-    outcome: "error" | "active" | "returned" | "abandoned";
+    outcome: "error" | "active" | "abandoned" | "returned";
     promptBytes: number;
     promptDigest: string;
     usage: {
@@ -133,7 +133,7 @@ export declare function workBudgets(c: BudgetContext, view: ExecutionView, workI
     model: string | null;
     runtimeVersion: string | null;
     startedAt: string;
-    outcome: "error" | "active" | "returned" | "abandoned";
+    outcome: "error" | "active" | "abandoned" | "returned";
     promptBytes: number;
     promptDigest: string;
     usage: {
@@ -227,7 +227,7 @@ export declare function callBudgets(c: BudgetContext, view: ExecutionView, meta:
     model: string | null;
     runtimeVersion: string | null;
     startedAt: string;
-    outcome: "error" | "active" | "returned" | "abandoned";
+    outcome: "error" | "active" | "abandoned" | "returned";
     promptBytes: number;
     promptDigest: string;
     usage: {

package/lib/engine/engine.d.ts

@@ -492,13 +492,39 @@ export declare class Engine {
         consumer?: string | undefined;
         inspection?: {
             mode: "commands" | "diff-only";
-            source: "codex-events" | "unavailable";
+            source: "codex-events" | "unavailable" | "controller-probes" | "runtime-and-controller";
             commands: {
                 command: string;
-                exitCode: number;
+                exitCode: number | null;
                 output: string;
+                origins?: ({
+                    type: "runtime";
+                    runtime: string;
+                    item: string | null;
+                } | {
+                    type: "controller";
+                    runId: string;
+                })[] | undefined;
+                status?: "error" | "passed" | "failed" | "cancelled" | "completed" | "timeout" | undefined;
+                failure?: "report" | "environment" | undefined;
+                gate?: string | undefined;
+                note?: string | undefined;
             }[];
             reason: string | null;
+            context?: {
+                attempt: string;
+                phase: "candidate" | "integration";
+                sha: string;
+                call: number;
+            } | undefined;
+            total?: number | undefined;
+            excluded?: {
+                runId: string;
+                status: string | null;
+                reason: "not-started" | "legacy-unconfirmed" | "foreign-scope" | "unknown-status" | "unfinished" | "abandoned";
+            }[] | undefined;
+            excludedTotal?: number | undefined;
+            invalid?: number | undefined;
         } | undefined;
         findings?: {
             severity: string;

package/lib/engine/runner.js

@@ -8,9 +8,9 @@ import { git } from "../environment/process.js";
 import { executionEnvironment, runSteps, withEnvironment } from "../environment/lifecycle.js";
 import { redactDeep } from "../environment/redaction.js";
 import { implementationOutputSchema, reviewOutputSchema } from "../agents/schemas.js";
-import { unobservedReview } from "../agents/inspect.js";
+import { reviewInspection } from "../agents/inspect.js";
 import { reviewerRunsChecks } from "../agents/cli-adapter.js";
-import { gateProbePrompt, observeReproductions, probeCommand, probeGates, probeLimits, probeRecords, recoverProbeLog, probeTool, } from "../agents/review-probe.js";
+import { gateProbePrompt, observeReproductions, probeCommand, probeGates, probeLimits, probeRecord, readProbeJournal, recoverProbeLog, probeTool, } from "../agents/review-probe.js";
 import { runGate } from "../verification/gates.js";
 import { assertDependencies, dependencyFreshness, removeSnapshots, snapshotDependencies, } from "../verification/dependencies.js";
 import { CleanupFailure, cleanupEnvironment } from "../environment/lifecycle.js";
@@ -1148,6 +1148,8 @@ export class Runner {
      * переменных окружения CLI передаёт серверу по имени, на диск они не пишутся.
      */
     async reviewProbe(attempt, work, cwd, dir, phase, sha, gates, 
+    /** Номер вызова reviewer логического ревью: записывается в каждый запуск probe. */
+    call, 
     /**
      * Повтор reviewer того же логического ревью: срок и остаток бюджета
      * проверок переходят от первого вызова, а не выдаются заново.
@@ -1186,6 +1188,7 @@ export class Runner {
             gates: probeGates(gates),
             phase,
             sha,
+            scope: { attempt: attempt.id, phase, sha, call },
             artifacts: join(dir, 'probe-runs'),
         };
         const specPath = join(dir, 'probe.json');
@@ -1316,7 +1319,7 @@ export class Runner {
             }
             const callDir = call === 1 ? dir : join(dir, `call-${call}`);
             await mkdir(callDir, { recursive: true });
-            const probe = await this.reviewProbe(attempt, work, cwd, callDir, phase, sha, gates, shared);
+            const probe = await this.reviewProbe(attempt, work, cwd, callDir, phase, sha, gates, call, shared);
             const response = await this.call(this.adapter(attempt.reviewer), {
                 task: 'review-code',
                 attempt,
@@ -1357,9 +1360,17 @@ export class Runner {
                 }
                 : checkCodeReview(response.output, history, { runId: attempt.id, phase, sha }, { legacy });
             const result = verdict.result;
-            const inspection = response.inspection ?? unobservedReview();
             // Проверки reviewer — по журналу controller, а не по самоотчёту модели.
-            const probes = probe ? await probeRecords(probe.log) : undefined;
+            const journal = probe ? await readProbeJournal(probe.log) : undefined;
+            const probes = journal?.records.map(probeRecord);
+            // Один итог вызова: события runtime и журнал controller этого вызова,
+            // уже замаскированный; он же — в review.json и во всех ветках evidence.
+            const inspection = reviewInspection({
+                runtime: response.inspection,
+                journal,
+                context: { attempt: attempt.id, phase, sha, call },
+                redact,
+            });
             const protocol = !clean
                 ? 'unsafe'
                 : verdict.valid
@@ -1388,13 +1399,10 @@ export class Runner {
                 ...(result ? {} : { raw: response.output ?? null }),
                 ...(probes ? { probes } : {}),
             }, redact);
-            // Служебные значения записи — перечисления контура, а не текст reviewer:
-            // короткий секрет, совпавший с их частью, их не маскирует.
-            record.inspection = {
-                ...record.inspection,
-                mode: inspection.mode,
-                source: inspection.source,
-            };
+            // Итог уже замаскирован до обрезки; его перечисления и идентификаторы
+            // controller — не текст reviewer: короткий секрет, совпавший с их
+            // частью, их не маскирует.
+            record.inspection = inspection;
             if (result)
                 record.findings = record.findings.map((f, i) => ({
                     ...f,

package/lib/environment/process.d.ts

@@ -14,6 +14,14 @@ export declare function command(argv: string[], cwd: string, options?: {
     env?: NodeJS.ProcessEnv;
     redact?: Redactor;
     onOutput?: (stream: 'stdout' | 'stderr', text: string) => void;
+    /**
+     * Немаскированный stdout — только в памяти вызывающего, для разбора
+     * структуры (события runtime): маска по всему потоку портила бы и
+     * служебные строки JSON. Сохранять его нельзя.
+     */
+    onRawStdout?: (text: string) => void;
+    /** Процесс запущен (событие `spawn`): до него команда не исполнялась. */
+    onSpawn?: () => void;
     /**
      * Владеть всеми потомками, включая сменивших группу или сессию: после
      * завершения они останавливаются, и результат не возвращается, пока

package/lib/environment/process.js

@@ -28,6 +28,8 @@ export async function command(argv, cwd, options = {}) {
             detached: process.platform !== 'win32',
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        if (options.onSpawn)
+            child.once('spawn', options.onSpawn);
         let stdout = '', stderr = '', timedOut = false, killTimer;
         const stdoutDecoder = new StringDecoder('utf8'), stderrDecoder = new StringDecoder('utf8');
         const maskOut = outputRedactor(options.redact), maskErr = outputRedactor(options.redact);
@@ -49,7 +51,9 @@ export async function command(argv, cwd, options = {}) {
         };
         child.stdout.on('data', (d) => {
             lastOutputAt = new Date().toISOString();
-            append('stdout', maskOut(stdoutDecoder.write(d)));
+            const text = stdoutDecoder.write(d);
+            options.onRawStdout?.(text);
+            append('stdout', maskOut(text));
         });
         child.stderr.on('data', (d) => {
             lastOutputAt = new Date().toISOString();
@@ -152,7 +156,9 @@ export async function command(argv, cwd, options = {}) {
                     child.stderr.destroy();
                 }
             }
-            append('stdout', maskOut(stdoutDecoder.end(), true));
+            const rest = stdoutDecoder.end();
+            options.onRawStdout?.(rest);
+            append('stdout', maskOut(rest, true));
             append('stderr', maskErr(stderrDecoder.end(), true));
             if (outputError) {
                 reject(outputError);

package/lib/storage/document.d.ts

@@ -490,13 +490,39 @@ export declare class DocumentView {
             consumer?: string | undefined;
             inspection?: {
                 mode: "commands" | "diff-only";
-                source: "codex-events" | "unavailable";
+                source: "codex-events" | "unavailable" | "controller-probes" | "runtime-and-controller";
                 commands: {
                     command: string;
-                    exitCode: number;
+                    exitCode: number | null;
                     output: string;
+                    origins?: ({
+                        type: "runtime";
+                        runtime: string;
+                        item: string | null;
+                    } | {
+                        type: "controller";
+                        runId: string;
+                    })[] | undefined;
+                    status?: "error" | "passed" | "failed" | "cancelled" | "completed" | "timeout" | undefined;
+                    failure?: "report" | "environment" | undefined;
+                    gate?: string | undefined;
+                    note?: string | undefined;
                 }[];
                 reason: string | null;
+                context?: {
+                    attempt: string;
+                    phase: "candidate" | "integration";
+                    sha: string;
+                    call: number;
+                } | undefined;
+                total?: number | undefined;
+                excluded?: {
+                    runId: string;
+                    status: string | null;
+                    reason: "not-started" | "legacy-unconfirmed" | "foreign-scope" | "unknown-status" | "unfinished" | "abandoned";
+                }[] | undefined;
+                excludedTotal?: number | undefined;
+                invalid?: number | undefined;
             } | undefined;
             findings?: {
                 severity: string;
@@ -755,13 +781,39 @@ export declare class DocumentView {
             consumer?: string | undefined;
             inspection?: {
                 mode: "commands" | "diff-only";
-                source: "codex-events" | "unavailable";
+                source: "codex-events" | "unavailable" | "controller-probes" | "runtime-and-controller";
                 commands: {
                     command: string;
-                    exitCode: number;
+                    exitCode: number | null;
                     output: string;
+                    origins?: ({
+                        type: "runtime";
+                        runtime: string;
+                        item: string | null;
+                    } | {
+                        type: "controller";
+                        runId: string;
+                    })[] | undefined;
+                    status?: "error" | "passed" | "failed" | "cancelled" | "completed" | "timeout" | undefined;
+                    failure?: "report" | "environment" | undefined;
+                    gate?: string | undefined;
+                    note?: string | undefined;
                 }[];
                 reason: string | null;
+                context?: {
+                    attempt: string;
+                    phase: "candidate" | "integration";
+                    sha: string;
+                    call: number;
+                } | undefined;
+                total?: number | undefined;
+                excluded?: {
+                    runId: string;
+                    status: string | null;
+                    reason: "not-started" | "legacy-unconfirmed" | "foreign-scope" | "unknown-status" | "unfinished" | "abandoned";
+                }[] | undefined;
+                excludedTotal?: number | undefined;
+                invalid?: number | undefined;
             } | undefined;
             findings?: {
                 severity: string;

package/lib/verification/gates.d.ts

@@ -79,14 +79,36 @@ export declare function runCheck(h: {
     readable: string[];
     controller: string[];
     settingsDir: string;
+    /**
+     * Запуск проверки подтверждён: без песочницы — порождён её процесс, в
+     * песочнице — обёртка создала метку старта перед exec. Запуск самой
+     * обёртки песочницы запуском проверки не считается. Вызывается не более
+     * одного раза, в том числе когда проверка затем завершилась исключением.
+     */
+    onStart?: () => void;
 }): Promise<{
     attempts: number;
+    started: boolean;
     code: number;
     stdout: string;
     stderr: string;
     timedOut: boolean;
     diagnostics: import("../contracts/execution.ts").RuntimeDiagnostics;
 }>;
+/** Исход проверки, завершившейся до исключения (например, отказа уборки), если он есть. */
+export declare function completedCheck(error: unknown): {
+    attempts: number;
+    started: boolean;
+    code: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    diagnostics: import("../contracts/execution.ts").RuntimeDiagnostics;
+} | undefined;
+/** Уборка каталогов проверки; тест подменяет её, чтобы проверить отказ после исхода. */
+export declare const checkCleanup: {
+    remove: (dir: string) => Promise<void>;
+};
 /** Проверка механизма песочницы; тест подменяет её, чтобы проверить отказ. */
 export declare const isolationBackend: {
     check: typeof isolationSupport;

package/lib/verification/gates.js

@@ -251,7 +251,14 @@ export async function prepareReportPath(root, path, escape) {
 export async function runCheck(
 // Нужна только политика изоляции: проверки ревьюера исполняются вне сервера.
 h, options) {
-    let argv = options.argv, env = options.env, started;
+    let launched = false;
+    const confirm = () => {
+        if (launched)
+            return;
+        launched = true;
+        options.onStart?.();
+    };
+    let argv = options.argv, env = options.env, started, result, attempts = 1;
     const scratch = await realpath(await mkdtemp(join(tmpdir(), 'dc-gate-')));
     // Метка старта — вне TMPDIR команды: проверка, чистящая свой временный
     // каталог, не должна стирать признак того, что она уже начиналась.
@@ -275,39 +282,73 @@ h, options) {
             argv = wrapped.argv;
             env = { ...env, ...wrapped.env };
         }
-        const execute = () => command(argv, options.cwd, {
-            signal: options.signal,
-            timeoutMs: options.timeoutMs,
-            env,
-            redact: options.redact,
-            // Отсоединившийся потомок проверки не переживает её: и при успехе,
-            // и по таймауту, отмене или падению.
-            // Каталоги проверки принадлежат только ей: процесс, запущенный в них
-            // во время проверки, — её потомок, даже без метки и родства.
-            contain: { dirs: [...options.write, scratch, marks] },
-        });
-        let result = await execute(), attempts = 1;
-        // sandbox-runtime ищет shell через `which` с таймаутом в секунду и под
-        // нагрузкой отказывает до запуска команды. Повтор допустим, только если
-        // команда точно не начиналась: метки старта нет.
-        for (; attempts < 3 && sandboxNotStarted(result, started); attempts++) {
-            await new Promise((r) => setTimeout(r, 500 * attempts));
+        const execute = () => {
+            // Уже отменённый вызов не запускается: слушатель отмены на отменённом
+            // сигнале не срабатывает, и команда шла бы до таймаута.
+            if (options.signal.aborted)
+                throw Object.assign(new Error('Проверка отменена до запуска'), { name: 'AbortError' });
+            return command(argv, options.cwd, {
+                signal: options.signal,
+                ...(started === undefined ? { onSpawn: confirm } : {}),
+                timeoutMs: options.timeoutMs,
+                env,
+                redact: options.redact,
+                // Отсоединившийся потомок проверки не переживает её: и при успехе,
+                // и по таймауту, отмене или падению.
+                // Каталоги проверки принадлежат только ей: процесс, запущенный в них
+                // во время проверки, — её потомок, даже без метки и родства.
+                contain: { dirs: [...options.write, scratch, marks] },
+            });
+        };
+        try {
             result = await execute();
+            // sandbox-runtime ищет shell через `which` с таймаутом в секунду и под
+            // нагрузкой отказывает до запуска команды. Повтор допустим, только если
+            // команда точно не начиналась: метки старта нет.
+            for (; attempts < 3 && sandboxNotStarted(result, started); attempts++) {
+                await new Promise((r) => setTimeout(r, 500 * attempts));
+                result = await execute();
+            }
+        }
+        finally {
+            // Факт старта читается до удаления метки — и при исключении после него.
+            if (started !== undefined && existsSync(started))
+                confirm();
         }
-        return { ...result, attempts };
+        // Без песочницы завершившийся процесс точно порождался.
+        if (started === undefined)
+            confirm();
+        return { ...result, attempts, started: launched };
     }
     finally {
         // Каждый каталог убирается независимо: отказ уборки временного каталога
         // проверки (она могла снять с него права) не должен оставлять и метки.
         const removed = await Promise.allSettled([
-            rm(scratch, { recursive: true, force: true }),
-            rm(marks, { recursive: true, force: true }),
+            checkCleanup.remove(scratch),
+            checkCleanup.remove(marks),
         ]);
         const failed = removed.find((r) => r.status === 'rejected');
-        if (failed)
-            throw failed.reason;
+        if (failed) {
+            // Отказ уборки после завершения не стирает исход проверки: код и
+            // вывод доступны вызывающему через ошибку (`completedCheck`).
+            const error = failed.reason instanceof Error ? failed.reason : new Error(String(failed.reason));
+            throw result
+                ? Object.assign(error, { [checkResult]: { ...result, attempts, started: launched } })
+                : error;
+        }
     }
 }
+const checkResult = Symbol('runCheck.result');
+/** Исход проверки, завершившейся до исключения (например, отказа уборки), если он есть. */
+export function completedCheck(error) {
+    return error && typeof error === 'object' && checkResult in error
+        ? error[checkResult]
+        : undefined;
+}
+/** Уборка каталогов проверки; тест подменяет её, чтобы проверить отказ после исхода. */
+export const checkCleanup = {
+    remove: (dir) => rm(dir, { recursive: true, force: true }),
+};
 /** Проверка механизма песочницы; тест подменяет её, чтобы проверить отказ. */
 export const isolationBackend = { check: isolationSupport };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devcontour-harness",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Headless execution harness: work graph, isolated attempts, gates, independent reviews and accepted results.",
   "type": "module",
   "license": "MIT",