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

package/lib/agents/review-probe.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { idSchema, relativePathSchema, sha256, } from "../contracts/index.js";
 import { redactor } from "../environment/redaction.js";
-import { freshnessEnv, junitSummary, runCheck, sandboxBlockedHosts, } from "../verification/gates.js";
+import { completedCheck, freshnessEnv, junitSummary, runCheck, sandboxBlockedHosts, } from "../verification/gates.js";
 /**
  * Пробные проверки reviewer под пределами harness.
  *
@@ -63,6 +63,19 @@ export const probeSpec = z.object({
     /** Фаза и SHA ревью: записываются в каждый запуск gate. */
     phase: z.string().optional(),
     sha: z.string().optional(),
+    /**
+     * Вызов reviewer, которому принадлежит журнал: попытка harness, фаза, SHA
+     * и номер вызова. Записывается в каждый исход — по нему итог ревью не
+     * присваивает себе запуски чужого вызова.
+     */
+    scope: z
+        .strictObject({
+        attempt: z.string().min(1),
+        phase: z.string().min(1),
+        sha: z.string().min(1),
+        call: z.number().int().positive(),
+    })
+        .optional(),
     /** Каталог controller для отчётов и журналов запусков gate; вне проверяемого дерева. */
     artifacts: z.string().optional(),
 });
@@ -201,10 +214,22 @@ export class ReviewProbes {
             limitMs,
             stdout: '',
             stderr: '',
+            started: false,
+            ...(this.spec.scope ? { scope: this.spec.scope } : {}),
         };
         const budgetLeft = () => Math.max(0, this.spec.budgetMs - this.spent);
         let result;
-        if (input.gate !== undefined && (!gate || gate.property))
+        if (signal.aborted)
+            // Отменённый до запуска вызов не исполняется и не резервирует бюджет.
+            result = {
+                ...base,
+                status: 'cancelled',
+                exitCode: null,
+                durationMs: 0,
+                budgetLeftMs: budgetLeft(),
+                note: 'Вызов отменён до запуска; команда не исполнялась.',
+            };
+        else if (input.gate !== undefined && (!gate || gate.property))
             // Неизвестный ID не исполняется и не тратит бюджет: модель не выбирает
             // команду, только объявленный gate.
             result = {
@@ -243,6 +268,9 @@ export class ReviewProbes {
             // засчитывает незавершённый запуск целиком (R3-F01). Без записи
             // проверка не запускается.
             const reserved = reserveProbe(this.spec.log, runId, limitMs, base.argv, gate?.id);
+            // Факт старта отмечается на границе исполнения и переживает исключение
+            // после неё: упавшее сохранение отчёта не делает запуск «не бывшим».
+            const launch = { started: false };
             let outcome;
             try {
                 if (reserved)
@@ -251,23 +279,53 @@ export class ReviewProbes {
                 // останавливает процессы проверки, пережившие controller.
                 const marked = { ...env, [probeRunEnv]: runId };
                 outcome = gate
-                    ? await this.gate(gate, runId, limitMs, marked, redact, signal)
-                    : await this.command(argv, runId, limitMs, marked, redact, signal);
+                    ? await this.gate(gate, runId, limitMs, marked, redact, signal, launch)
+                    : await this.command(argv, runId, limitMs, marked, redact, signal, launch);
             }
             catch (error) {
-                outcome = {
-                    status: 'error',
-                    exitCode: null,
-                    stdout: '',
-                    stderr: '',
-                    failure: 'environment',
-                    note: 'Команда не запустилась — это отказ среды, а не результат проверки: ' +
-                        redact(error instanceof Error ? error.message : String(error)),
-                };
+                const message = redact(error instanceof Error ? error.message : String(error));
+                // Проверка завершилась, а исключение пришло после (уборка): её код
+                // и вывод — исход, который не теряется.
+                const done = completedCheck(error);
+                outcome = done
+                    ? {
+                        status: 'error',
+                        failure: 'environment',
+                        exitCode: done.timedOut || signal.aborted ? null : done.code,
+                        stdout: tail(done.stdout),
+                        stderr: tail(done.stderr),
+                        note: 'Проверка завершилась, но controller не убрал её временные каталоги — отказ среды после исхода: ' +
+                            message,
+                    }
+                    : signal.aborted && !launch.started
+                        ? {
+                            status: 'cancelled',
+                            exitCode: null,
+                            stdout: '',
+                            stderr: '',
+                            note: 'Вызов отменён до запуска; команда не исполнялась.',
+                        }
+                        : {
+                            status: 'error',
+                            exitCode: null,
+                            stdout: '',
+                            stderr: '',
+                            failure: 'environment',
+                            note: launch.started
+                                ? 'Проверка запустилась, но её исход не получен — отказ среды, а не результат проверки: ' +
+                                    message
+                                : 'Команда не запустилась — это отказ среды, а не результат проверки: ' + message,
+                        };
             }
             const durationMs = this.now() - started;
             this.spent += durationMs - limitMs;
-            result = { ...base, ...outcome, durationMs, budgetLeftMs: budgetLeft() };
+            result = {
+                ...base,
+                ...outcome,
+                started: launch.started,
+                durationMs,
+                budgetLeftMs: budgetLeft(),
+            };
         }
         // Журнал — наблюдение controller, а не самоотчёт модели. Строка исхода
         // разрешает записанный ранее резерв фактической длительностью.
@@ -279,9 +337,10 @@ export class ReviewProbes {
         return { ...result, log: result.log ?? this.spec.log };
     }
     /** Исследовательская команда reviewer: исходники только для чтения, запись — в TMPDIR. */
-    async command(argv, runId, limitMs, env, redact, signal) {
+    async command(argv, runId, limitMs, env, redact, signal, launch) {
         const r = await runCheck({ config: { isolation: this.spec.isolation } }, {
             argv,
+            onStart: () => (launch.started = true),
             cwd: this.spec.cwd,
             env: { ...env, CI: '1' },
             redact,
@@ -339,7 +398,7 @@ export class ReviewProbes {
      * прежние `.reports/*.xml` дерева не читаются, не удаляются и не
      * перезаписываются.
      */
-    async gate(gate, runId, limitMs, env, redact, signal) {
+    async gate(gate, runId, limitMs, env, redact, signal, launch) {
         const meta = {
             id: gate.id,
             phase: this.spec.phase ?? null,
@@ -411,9 +470,11 @@ export class ReviewProbes {
         let outcome;
         let header = `# harness probe gate ${gate.id}: run=${runId} phase=${meta.phase ?? '-'} sha=${meta.sha ?? '-'} cwd=${relative(root, gateCwd) || '.'} argv=${JSON.stringify(meta.argv)} env=${meta.controllerEnv.join(',')}\n`;
         let output = '';
+        let finished;
         try {
             const r = await runCheck({ config: { isolation: this.spec.isolation } }, {
                 argv: gate.command,
+                onStart: () => (launch.started = true),
                 cwd: gateCwd,
                 env: { ...env, ...controllerEnv },
                 redact,
@@ -426,6 +487,7 @@ export class ReviewProbes {
                 controller: this.spec.controller,
                 settingsDir: join(this.spec.settingsDir, runId),
             });
+            finished = r;
             output = r.stdout + '\n' + r.stderr;
             // Отчёт читается и сохраняется до удаления scratch — при любом исходе.
             const read = gate.report
@@ -509,16 +571,51 @@ export class ReviewProbes {
                 };
         }
         catch (error) {
-            outcome = environment(`Gate не запустился: ${redact(error instanceof Error ? error.message : String(error))}.`);
+            const message = redact(error instanceof Error ? error.message : String(error));
+            // Сбой после старта (например, сохранения отчёта) не стирает исход
+            // процесса: код и вывод завершившейся проверки остаются в результате.
+            outcome = launch.started
+                ? {
+                    ...environment(`Gate запустился, но его evidence не сохранено: ${message}.`),
+                    ...((finished ??= completedCheck(error))
+                        ? {
+                            exitCode: finished.timedOut || signal.aborted ? null : finished.code,
+                            stdout: tail(finished.stdout),
+                            stderr: tail(finished.stderr),
+                        }
+                        : {}),
+                }
+                : signal.aborted
+                    ? {
+                        ...empty,
+                        status: 'cancelled',
+                        note: 'Вызов отменён до запуска gate; gate не исполнялся.',
+                    }
+                    : environment(`Gate не запустился: ${message}.`);
         }
         finally {
             meta.scratchRemoved = await removeScratch(scratch);
         }
         header += `# status=${outcome.status}${outcome.failure ? ` failure=${outcome.failure}` : ''} exit=${outcome.exitCode ?? '-'} report=${meta.report?.status ?? '-'}${meta.report?.digest ? ` digest=${meta.report.digest}` : ''} scratchRemoved=${meta.scratchRemoved}\n`;
-        await writeFile(logPath, redact(header + output + (outcome.note ? '\n' + outcome.note : '')), {
-            flag: 'wx',
-        });
-        await writeFile(join(runDir, 'run.json'), JSON.stringify({ runId, status: outcome.status, failure: outcome.failure, gate: meta }, null, 2), { flag: 'wx' });
+        try {
+            await writeFile(logPath, redact(header + output + (outcome.note ? '\n' + outcome.note : '')), { flag: 'wx' });
+            await writeFile(join(runDir, 'run.json'), JSON.stringify({
+                runId,
+                status: outcome.status,
+                failure: outcome.failure,
+                started: launch.started,
+                gate: meta,
+            }, null, 2), { flag: 'wx' });
+        }
+        catch (error) {
+            // Исход уже получен: отказ записи evidence не стирает код и вывод.
+            outcome = {
+                ...outcome,
+                status: 'error',
+                failure: 'environment',
+                note: `${outcome.note ?? ''} Evidence запуска не сохранено: ${redact(error instanceof Error ? error.message : String(error))}.`.trim(),
+            };
+        }
         return { ...outcome, gate: meta, log: logPath };
     }
 }
@@ -658,35 +755,102 @@ export function probeCommand(specPath) {
         args: [...(source ? ['--import', import.meta.resolve('tsx')] : []), entry, '--spec', specPath],
     };
 }
-/** Журнал проверок reviewer: по записи на запуск; нечитаемая строка — не запуск. */
-export async function probeRecords(log) {
-    const text = await readFile(log, 'utf8').catch(() => '');
-    return text
-        .split('\n')
-        .filter(Boolean)
-        .flatMap((line) => {
+const NOTE_LIMIT = 2000;
+/** Статусы исхода probe; иной статус — диагностика, а не исход. */
+export const probeStatuses = new Set([
+    'passed',
+    'failed',
+    'timeout',
+    'budget-exhausted',
+    'error',
+    'rejected',
+    'cancelled',
+]);
+const text = (v) => (typeof v === 'string' ? v : undefined);
+/**
+ * Журнал проверок reviewer: по записи на запуск. Нечитаемая строка, объект
+ * без формы исхода (`runId`, `argv`, `status`) и строки резерва/списания —
+ * не запуски; они не роняют чтение остальных строк.
+ */
+export async function readProbeJournal(log) {
+    const content = await readFile(log, 'utf8').catch(() => '');
+    const records = [];
+    const seen = new Set();
+    const starts = new Map();
+    let invalid = 0;
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        let p;
         try {
-            const p = JSON.parse(line);
-            // Строки резерва и списания — учёт бюджета, а не запуски.
-            if (p.type)
-                return [];
-            return [
-                {
-                    runId: String(p.runId),
-                    argv: p.argv,
-                    status: p.status,
-                    durationMs: p.durationMs,
-                    limitMs: p.limitMs,
-                    ...(p.failure ? { failure: p.failure } : {}),
-                    ...(p.gate ? { gate: p.gate } : {}),
-                    ...(p.log ? { log: p.log } : {}),
-                },
-            ];
+            const parsed = JSON.parse(line);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('not an object');
+            p = parsed;
         }
         catch {
-            return [];
+            invalid++;
+            continue;
         }
-    });
+        const runId = text(p.runId);
+        // Строки резерва и списания — учёт бюджета, а не запуски.
+        if (p.type !== undefined) {
+            if (runId && p.type === 'start' && !starts.has(runId))
+                starts.set(runId, false);
+            else if (runId && p.type === 'abandoned')
+                starts.set(runId, true);
+            else
+                invalid++;
+            continue;
+        }
+        const argv = Array.isArray(p.argv) && p.argv.every((a) => typeof a === 'string') ? p.argv : undefined;
+        const status = text(p.status);
+        if (!runId || !argv || !status) {
+            invalid++;
+            continue;
+        }
+        // Повтор runId — одна запись; запись с неизвестным статусом runId не
+        // занимает: следующий валидный исход того же запуска сохраняется.
+        if (seen.has(runId))
+            continue;
+        if (probeStatuses.has(status))
+            seen.add(runId);
+        const exitCode = p.exitCode === null || Number.isInteger(p.exitCode)
+            ? p.exitCode
+            : undefined;
+        records.push({
+            runId,
+            argv,
+            status: status,
+            durationMs: Number(p.durationMs) || 0,
+            limitMs: Number(p.limitMs) || 0,
+            ...(p.failure === 'environment' || p.failure === 'report' ? { failure: p.failure } : {}),
+            ...(p.gate && typeof p.gate === 'object' ? { gate: p.gate } : {}),
+            ...(text(p.log) ? { log: text(p.log) } : {}),
+            ...(exitCode !== undefined ? { exitCode } : {}),
+            ...(typeof p.started === 'boolean' ? { started: p.started } : {}),
+            ...(p.scope && typeof p.scope === 'object' ? { scope: p.scope } : {}),
+            ...(text(p.note) ? { note: text(p.note) } : {}),
+            ...(text(p.stdout) !== undefined ? { stdout: text(p.stdout) } : {}),
+            ...(text(p.stderr) !== undefined ? { stderr: text(p.stderr) } : {}),
+        });
+    }
+    const reservations = [...starts]
+        .filter(([runId]) => !seen.has(runId))
+        .map(([runId, abandoned]) => ({ runId, abandoned }));
+    return { records, invalid, reservations };
+}
+/** Запуск в виде `review.json.probes`: без потоков вывода, пояснение ограничено. */
+export function probeRecord(record) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { stdout, stderr, ...rest } = record;
+    return rest.note && rest.note.length > NOTE_LIMIT
+        ? { ...rest, note: rest.note.slice(0, NOTE_LIMIT) + '…' }
+        : rest;
+}
+/** Журнал проверок reviewer: по записи на запуск; нечитаемая строка — не запуск. */
+export async function probeRecords(log) {
+    return (await readProbeJournal(log)).records.map(probeRecord);
 }
 /** Переменная окружения с runId проверки: её наследуют все процессы запуска. */
 export const probeRunEnv = 'HARNESS_PROBE_RUN';
@@ -857,6 +1021,7 @@ export function observeReproductions(findings, probes, redact) {
         // Отказ среды (EPERM рецепта отчёта, песочница) — не запуск проверяемого
         // кода: на нём наблюдение не ставится.
         const ran = !!cited &&
+            cited.started !== false &&
             ['passed', 'failed', 'timeout'].includes(cited.status) &&
             cited.failure !== 'environment';
         return {

package/lib/contracts/execution.d.ts

@@ -162,7 +162,21 @@ export declare const propertyEvidenceSchema: z.ZodObject<{
     }, z.core.$strict>>;
     coverage: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-/** Что reviewer действительно выполнил — по событиям runtime, не по словам модели. */
+/** Происхождение подтверждённой команды: событие runtime или запуск probe controller. */
+export declare const inspectionOriginSchema: 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">;
+/**
+ * Что reviewer действительно выполнил — по событиям runtime и журналу
+ * проверок controller одного вызова reviewer, не по словам модели
+ * (docs/review-probes.md). Поля после `reason` появились в alpha.7 и
+ * необязательны: записи прежних версий читаются как есть.
+ */
 export declare const reviewInspectionSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         commands: "commands";
@@ -171,13 +185,61 @@ export declare const reviewInspectionSchema: z.ZodObject<{
     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>;
 export declare const evidenceFindingSchema: z.ZodObject<{
     severity: z.ZodString;
@@ -220,13 +282,61 @@ export declare const evidenceRecordSchema: z.ZodObject<{
         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;
@@ -708,13 +818,61 @@ export declare const attemptStateSchema: z.ZodObject<{
             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;
@@ -1375,8 +1533,8 @@ export declare const callRecordSchema: z.ZodObject<{
     outcome: z.ZodEnum<{
         error: "error";
         active: "active";
-        returned: "returned";
         abandoned: "abandoned";
+        returned: "returned";
     }>;
     process: z.ZodOptional<z.ZodObject<{
         id: z.ZodString;
@@ -1698,8 +1856,8 @@ export declare const localSchemas: {
         outcome: z.ZodEnum<{
             error: "error";
             active: "active";
-            returned: "returned";
             abandoned: "abandoned";
+            returned: "returned";
         }>;
         process: z.ZodOptional<z.ZodObject<{
             id: z.ZodString;
@@ -2891,13 +3049,61 @@ export declare const executionDocumentSchema: z.ZodObject<{
                 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;