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

package/lib/agents/inspect.js

@@ -1,4 +1,14 @@
 import { z } from 'zod';
+import { probeStatuses, } from "./review-probe.js";
+/** Пределы итога: число команд и длины сохраняемых строк (docs/review-probes.md). */
+export const inspectionLimits = {
+    commands: 100,
+    command: 12000,
+    output: 4000,
+    note: 2000,
+    excluded: 100,
+};
+const noExecution = 'Нет подтверждённого выполнения команд: ни события runtime, ни журнал проверок controller этого вызова reviewer не содержат запущенной команды.';
 export const unobservedReview = () => ({
     mode: 'diff-only',
     source: 'unavailable',
@@ -8,39 +18,279 @@ export const unobservedReview = () => ({
 const completedCommand = z.object({
     type: z.literal('item.completed'),
     item: z.object({
+        id: z.string().min(1).max(200).optional(),
         type: z.literal('command_execution'),
-        command: z.string().min(1).max(12000),
+        command: z.string().min(1),
         exit_code: z.number().int(),
         aggregated_output: z.string().default(''),
         status: z.enum(['completed', 'failed']),
     }),
 });
-/** Что reviewer действительно выполнил — по событиям runtime, а не по словам модели. */
-export function inspectReview(runtime, output) {
+const identity = (text) => text;
+/**
+ * Что reviewer действительно выполнил — по событиям runtime, а не по словам
+ * модели. Завершённая команда — выполнение при любом коде выхода: ненулевой
+ * код — исход проверки, а не признак того, что её не было. Повтор события
+ * того же item ID — одна команда.
+ */
+export function inspectReview(runtime, output, redact = identity) {
     if (runtime !== 'codex')
         return unobservedReview();
     const commands = [];
+    const items = new Set();
     for (const line of output.split('\n')) {
         try {
             const event = completedCommand.safeParse(JSON.parse(line));
-            if (event.success) {
-                const item = event.data.item;
-                commands.push({
-                    command: item.command,
-                    exitCode: item.exit_code,
-                    output: item.aggregated_output.slice(-4000),
-                });
+            if (!event.success)
+                continue;
+            const item = event.data.item;
+            if (item.id !== undefined) {
+                if (items.has(item.id))
+                    continue;
+                items.add(item.id);
             }
+            commands.push({
+                // Маскирование — до обрезки: иначе обрезка разрезала бы секрет.
+                command: redact(item.command).slice(0, inspectionLimits.command),
+                exitCode: item.exit_code,
+                output: redact(item.aggregated_output).slice(-inspectionLimits.output),
+                origins: [{ type: 'runtime', runtime, item: item.id ?? null }],
+                status: item.status,
+            });
         }
         catch {
             /* Обрезанная или не-JSON строка не подтверждает выполнения команды. */
         }
     }
-    const observed = commands.some((c) => c.exitCode === 0);
     return {
-        mode: observed ? 'commands' : 'diff-only',
+        mode: commands.length ? 'commands' : 'diff-only',
         source: 'codex-events',
-        commands: commands.slice(-100),
-        reason: observed ? null : 'Нет подтверждённой успешной команды в событиях Codex.',
+        commands: commands.slice(-inspectionLimits.commands),
+        reason: commands.length ? null : noExecution,
+        ...(commands.length > inspectionLimits.commands ? { total: commands.length } : {}),
+    };
+}
+const statuses = ['passed', 'failed', 'timeout', 'cancelled', 'error'];
+const known = new Set([...statuses, 'budget-exhausted', 'rejected']);
+/** argv как одна строка: аргументы с пробелами и кавычками — в одинарных кавычках. */
+const argvText = (argv) => argv.map((a) => (/^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`)).join(' ');
+/** stdout и stderr в одном ограниченном output; при нехватке места — хвосты поровну. */
+function joinOutput(stdout, stderr, limit) {
+    const both = stdout && stderr;
+    const joined = both ? `${stdout}\n${stderr}` : stdout || stderr;
+    if (joined.length <= limit)
+        return joined;
+    if (!both)
+        return '…' + joined.slice(-(limit - 1));
+    const half = Math.floor((limit - 3) / 2);
+    const cut = (t, n) => (t.length > n ? '…' + t.slice(-(n - 1)) : t);
+    const out = cut(stdout, Math.max(half, limit - 3 - Math.min(stderr.length, half)));
+    return `${out}\n${cut(stderr, limit - 1 - out.length)}`.slice(-limit);
+}
+/** Почему запись журнала не засчитана выполнением этого вызова. */
+function exclusion(record, context) {
+    if (!known.has(record.status))
+        return 'unknown-status';
+    // Явно чужие вызов, фаза или SHA — не наблюдение этого ревью.
+    const s = record.scope;
+    if (s &&
+        (s.attempt !== context.attempt ||
+            s.phase !== context.phase ||
+            s.sha !== context.sha ||
+            s.call !== context.call))
+        return 'foreign-scope';
+    const g = record.gate;
+    if (g && ((g.phase && g.phase !== context.phase) || (g.sha && g.sha !== context.sha)))
+        return 'foreign-scope';
+    // Явный признак старта главнее правила старых записей.
+    if (record.started === false)
+        return 'not-started';
+    if (record.started === true)
+        return null;
+    // В alpha.6 и ранее признака старта не было: passed/failed — исход завершившейся
+    // команды; error/timeout/cancelled без подтверждения старта не засчитываются.
+    return record.status === 'passed' || record.status === 'failed' ? null : 'legacy-unconfirmed';
+}
+function controllerCommand(record, redact) {
+    return {
+        command: redact(argvText(record.argv)).slice(0, inspectionLimits.command),
+        // Неизвестный код остаётся неизвестным: из `passed` не выводится 0.
+        exitCode: record.exitCode ?? null,
+        output: joinOutput(redact(record.stdout ?? ''), redact(record.stderr ?? ''), inspectionLimits.output),
+        origins: [{ type: 'controller', runId: record.runId }],
+        status: record.status,
+        ...(record.failure ? { failure: record.failure } : {}),
+        ...(record.gate?.id ? { gate: record.gate.id } : {}),
+        ...(record.note ? { note: redact(record.note).slice(0, inspectionLimits.note) } : {}),
+    };
+}
+/**
+ * Итог `inspection` одного вызова reviewer: события runtime этого вызова и
+ * журнал проверок controller этого вызова. Самоотчёт модели (`execution`,
+ * `reproduction.executed`, runId в тексте) сюда не входит.
+ *
+ * Операция одна, если совпадает надёжная идентичность: runId запуска
+ * controller, item ID runtime внутри его потока или явная структурированная
+ * связь наблюдения runtime с runId controller (origin `controller` у команды
+ * runtime). Совпадение текста, вывода или замаскированных аргументов
+ * операции не склеивает.
+ *
+ * Порядок: команды runtime в порядке потока, затем запуски controller в
+ * порядке журнала; при превышении предела сохраняются последние
+ * {@link inspectionLimits.commands}, `total` — число всех подтверждённых.
+ * Mode — по всему набору. Пользовательский текст маскируется до обрезки;
+ * перечисления и идентификаторы controller не маскируются.
+ */
+export function reviewInspection(input) {
+    const redact = input.redact ?? identity;
+    const commands = [];
+    const excluded = [];
+    const byItem = new Map();
+    const byRun = new Map();
+    for (const c of input.runtime?.commands ?? []) {
+        const origins = c.origins?.length
+            ? c.origins
+            : [
+                {
+                    type: 'runtime',
+                    runtime: input.runtime?.source === 'codex-events' ? 'codex' : 'unknown',
+                    item: null,
+                },
+            ];
+        const runtimeOrigin = origins.find((o) => o.type === 'runtime');
+        const item = runtimeOrigin?.type === 'runtime' && runtimeOrigin.item
+            ? `${runtimeOrigin.runtime}\0${runtimeOrigin.item}`
+            : undefined;
+        const existing = item ? byItem.get(item) : undefined;
+        if (existing) {
+            // Повтор того же item: связь с запуском controller, пришедшая лишь в
+            // повторном наблюдении, — тоже связь этой операции.
+            merge(existing, origins);
+            for (const o of origins)
+                if (o.type === 'controller')
+                    byRun.set(o.runId, existing);
+            continue;
+        }
+        const command = {
+            ...c,
+            command: redact(c.command).slice(0, inspectionLimits.command),
+            output: redact(c.output).slice(-inspectionLimits.output),
+            origins: [...origins],
+        };
+        commands.push(command);
+        if (item)
+            byItem.set(item, command);
+        for (const o of origins)
+            if (o.type === 'controller')
+                byRun.set(o.runId, command);
+    }
+    for (const record of input.journal?.records ?? []) {
+        const reason = exclusion(record, input.context);
+        if (reason) {
+            excluded.push({ runId: record.runId, status: record.status, reason });
+            continue;
+        }
+        const linked = byRun.get(record.runId);
+        const own = controllerCommand(record, redact);
+        if (linked) {
+            // Связанная операция: данные controller, происхождение обоих.
+            const runtimeOrigins = linked.origins?.filter((o) => o.type === 'runtime') ?? [];
+            Object.assign(linked, own, { origins: [...runtimeOrigins, ...own.origins] });
+            byRun.delete(record.runId);
+            continue;
+        }
+        commands.push(own);
+    }
+    // Связь с runId, которого нет среди засчитанных запусков, не подтверждает
+    // запуск controller: остаётся только наблюдение runtime.
+    for (const [runId, linked] of byRun)
+        linked.origins = linked.origins?.filter((o) => o.type !== 'controller' || o.runId !== runId);
+    for (const r of input.journal?.reservations ?? [])
+        excluded.push({
+            runId: r.runId,
+            status: null,
+            reason: r.abandoned ? 'abandoned' : 'unfinished',
+        });
+    const runtimeSeen = commands.some((c) => c.origins?.some((o) => o.type === 'runtime'));
+    const controllerSeen = commands.some((c) => c.origins?.some((o) => o.type === 'controller'));
+    const source = runtimeSeen && controllerSeen
+        ? 'runtime-and-controller'
+        : controllerSeen
+            ? 'controller-probes'
+            : (input.runtime?.source ?? 'unavailable');
+    // Команды runtime, не вошедшие в его ограниченный список, — тоже
+    // подтверждённые операции: они учитываются в total и mode.
+    const dropped = Math.max(0, (input.runtime?.total ?? 0) - (input.runtime?.commands.length ?? 0));
+    const total = commands.length + dropped;
+    const observed = total > 0;
+    return {
+        mode: observed ? 'commands' : 'diff-only',
+        source,
+        commands: commands.slice(-inspectionLimits.commands),
+        reason: observed ? null : noExecution,
+        context: input.context,
+        total,
+        ...(input.journal?.invalid ? { invalid: input.journal.invalid } : {}),
+        ...(excluded.length
+            ? {
+                excluded: excluded.slice(0, inspectionLimits.excluded),
+                ...(excluded.length > inspectionLimits.excluded
+                    ? { excludedTotal: excluded.length }
+                    : {}),
+            }
+            : {}),
+    };
+}
+/**
+ * Маскирование сохранённого inspection: только свободный текст (`command`,
+ * `output`, `note`, `reason`) и с обрезкой до пределов после маски — замена
+ * секрета может удлинить строку. Перечисления, origins, контекст и
+ * идентификаторы controller не маскируются — короткий секрет, совпавший с
+ * их частью, не делает запись невалидной.
+ */
+export function redactInspection(inspection, redact) {
+    return {
+        ...inspection,
+        commands: inspection.commands.map((c) => ({
+            ...c,
+            command: redact(c.command).slice(0, inspectionLimits.command),
+            output: redact(c.output).slice(-inspectionLimits.output),
+            ...(c.note !== undefined ? { note: redact(c.note).slice(0, inspectionLimits.note) } : {}),
+        })),
+        reason: inspection.reason === null ? null : redact(inspection.reason),
     };
 }
+function merge(target, origins) {
+    const key = (o) => o.type === 'runtime' ? `r\0${o.runtime}\0${o.item}` : `c\0${o.runId}`;
+    const have = new Set((target.origins ?? []).map(key));
+    target.origins = [...(target.origins ?? []), ...origins.filter((o) => !have.has(key(o)))];
+}
+/**
+ * Сохранённая проекция `review.json.probes` (alpha.6 и ранее: без кода, вывода и
+ * признака старта) как журнал для {@link reviewInspection}. Пересчёт старого
+ * состояния не выполняется: это вход для отдельной агрегации старых данных.
+ */
+export function journalFromProjection(probes) {
+    const records = [];
+    const seen = new Set();
+    let invalid = 0;
+    for (const p of Array.isArray(probes) ? probes : []) {
+        const r = p;
+        if (!r ||
+            typeof r !== 'object' ||
+            typeof r.runId !== 'string' ||
+            !r.runId ||
+            typeof r.status !== 'string' ||
+            !Array.isArray(r.argv) ||
+            !r.argv.every((a) => typeof a === 'string')) {
+            invalid++;
+            continue;
+        }
+        if (seen.has(r.runId))
+            continue;
+        if (probeStatuses.has(r.status))
+            seen.add(r.runId);
+        records.push({ ...r });
+    }
+    return { records, invalid, reservations: [] };
+}

package/lib/agents/review-probe.d.ts

@@ -74,6 +74,12 @@ export declare const probeSpec: z.ZodObject<{
     }, z.core.$strict>>>;
     phase: z.ZodOptional<z.ZodString>;
     sha: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+        attempt: z.ZodString;
+        phase: z.ZodString;
+        sha: z.ZodString;
+        call: z.ZodNumber;
+    }, z.core.$strict>>;
     artifacts: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ProbeSpec = z.infer<typeof probeSpec>;
@@ -152,6 +158,15 @@ export type ProbeResult = {
     gate?: ProbeGateRun;
     /** Журнал controller, в котором записан этот запуск. */
     log?: string;
+    /**
+     * Запуск проверки подтверждён на границе исполнения (`runCheck`): процесс
+     * порождён или обёртка песочницы создала метку старта. `false` — команда
+     * не начиналась (отказ до старта, бюджет, неизвестный gate, отмена до
+     * запуска). У записей alpha.6 и ранее поля нет.
+     */
+    started: boolean;
+    /** Вызов reviewer, которому принадлежит запуск (из спецификации probe). */
+    scope?: ProbeSpec['scope'];
 };
 /** Как сделать gate пригодным для probe: путь отчёта — из переменной controller. */
 export declare const reportRecipe = "\u0420\u0435\u0446\u0435\u043F\u0442: \u043A\u043E\u043C\u0430\u043D\u0434\u0430 gate \u0431\u0435\u0440\u0451\u0442 \u043F\u0443\u0442\u044C JUnit \u0438\u0437 HARNESS_REPORT_PATH (\u0438\u043B\u0438 DEVCONTOUR_REPORT_PATH) \u0441 \u043F\u0440\u0435\u0436\u043D\u0438\u043C \u043F\u0443\u0442\u0451\u043C \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E \u2014 \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 `sh -c 'gotestsum --junitfile \"${HARNESS_REPORT_PATH:-.reports/junit.xml}\" -- ./...'`, `pytest --junitxml=\"${HARNESS_REPORT_PATH:-.reports/junit.xml}\"`, `--test-reporter-destination=${HARNESS_REPORT_PATH:-.reports/junit.xml}` \u0432 package script (\u0441\u043C. docs/review-probes.md).";
@@ -236,7 +251,42 @@ export interface ProbeRecord {
     gate?: ProbeGateRun;
     /** Журнал controller, где записан запуск (у gate — собственный файл). */
     log?: string;
+    /** Код процесса; `null` — неизвестен (таймаут, отмена, не запускался). */
+    exitCode?: number | null;
+    /** Подтверждённый старт; нет у записей alpha.6 и ранее. */
+    started?: boolean;
+    /** Вызов reviewer, которому принадлежит запуск. */
+    scope?: ProbeResult['scope'];
+    /** Пояснение controller (ограничено). */
+    note?: string;
+}
+/** Запись журнала с выводом команды — вход итога `inspection`. */
+export interface ProbeJournalRecord extends ProbeRecord {
+    stdout?: string;
+    stderr?: string;
 }
+/** Журнал проверок вызова reviewer, как его читает controller. */
+export interface ProbeJournal {
+    /** Строки исхода в порядке журнала; повтор одного runId — одна запись (первая). */
+    records: ProbeJournalRecord[];
+    /** Строки, не являющиеся ни исходом, ни учётом бюджета: битый JSON, `{}`, чужая форма. */
+    invalid: number;
+    /** Резервы без строки исхода: учёт бюджета и recovery, не запуски. */
+    reservations: {
+        runId: string;
+        abandoned: boolean;
+    }[];
+}
+/** Статусы исхода probe; иной статус — диагностика, а не исход. */
+export declare const probeStatuses: ReadonlySet<string>;
+/**
+ * Журнал проверок reviewer: по записи на запуск. Нечитаемая строка, объект
+ * без формы исхода (`runId`, `argv`, `status`) и строки резерва/списания —
+ * не запуски; они не роняют чтение остальных строк.
+ */
+export declare function readProbeJournal(log: string): Promise<ProbeJournal>;
+/** Запуск в виде `review.json.probes`: без потоков вывода, пояснение ограничено. */
+export declare function probeRecord(record: ProbeJournalRecord): ProbeRecord;
 /** Журнал проверок reviewer: по записи на запуск; нечитаемая строка — не запуск. */
 export declare function probeRecords(log: string): Promise<ProbeRecord[]>;
 /** Переменная окружения с runId проверки: её наследуют все процессы запуска. */