devcontour-harness 0.0.0-stage → 0.1.0-alpha.6

package/lib/integrations/relay-v2/process.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Один вызов Relay-2 CLI: argv-массив без shell, ограниченные вывод и время,
+ * завершение всей группы процессов при таймауте, отмене или переполнении.
+ * Результат возвращается только после `close`: дочерний процесс к этому
+ * моменту завершён и собран (нет зомби), pipes закрыты.
+ */
+export interface CliRun {
+    /** Процесс так и не стартовал (нет binary, нет прав): запрос не ушёл. */
+    spawnError?: NodeJS.ErrnoException;
+    /** Процесс стартовал (запрос мог дойти до backend). */
+    started: boolean;
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    aborted: boolean;
+    /** Суммарный вывод превысил лимит; процесс остановлен. */
+    oversized: boolean;
+    durationMs: number;
+    pid?: number;
+}
+export interface CliRunOptions {
+    cwd: string;
+    env: Record<string, string>;
+    timeoutMs: number;
+    maxOutputBytes: number;
+    /** Пауза между SIGTERM и SIGKILL группе. */
+    killGraceMs: number;
+    signal?: AbortSignal;
+}
+export declare function runCli(file: string, args: string[], options: CliRunOptions): Promise<CliRun>;

package/lib/integrations/relay-v2/process.js

@@ -0,0 +1,112 @@
+import { spawn } from 'node:child_process';
+export function runCli(file, args, options) {
+    const startedAt = Date.now();
+    if (options.signal?.aborted)
+        return Promise.resolve({
+            started: false,
+            code: null,
+            signal: null,
+            stdout: '',
+            stderr: '',
+            timedOut: false,
+            aborted: true,
+            oversized: false,
+            durationMs: 0,
+        });
+    return new Promise((resolve) => {
+        const posix = process.platform !== 'win32';
+        const child = spawn(file, args, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: false,
+            // Своя группа: сигнал `-pid` достаёт и потомков binary.
+            detached: posix,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        const out = [];
+        const err = [];
+        let bytes = 0;
+        let timedOut = false;
+        let aborted = false;
+        let oversized = false;
+        let stopping = false;
+        let spawnError;
+        let killTimer;
+        const signalGroup = (sig) => {
+            try {
+                if (child.pid && posix)
+                    process.kill(-child.pid, sig);
+                else
+                    child.kill(sig);
+            }
+            catch {
+                /* Группа уже завершилась. */
+            }
+        };
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            signalGroup('SIGTERM');
+            killTimer = setTimeout(() => signalGroup('SIGKILL'), options.killGraceMs);
+        };
+        const take = (chunks) => (d) => {
+            if (oversized)
+                return;
+            bytes += d.length;
+            if (bytes > options.maxOutputBytes) {
+                oversized = true;
+                stop();
+                return;
+            }
+            chunks.push(d);
+        };
+        child.stdout.on('data', take(out));
+        child.stderr.on('data', take(err));
+        const onAbort = () => {
+            aborted = true;
+            stop();
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            stop();
+        }, options.timeoutMs);
+        let done = false;
+        child.once('error', (e) => {
+            // `error` без pid — процесс не стартовал (ENOENT/EACCES): запрос не ушёл.
+            if (child.pid)
+                return;
+            spawnError = e;
+            finish(null, null);
+        });
+        child.once('close', (code, sig) => finish(code, sig));
+        const finish = (code, sig) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+            // Лидер группы вышел; оставшиеся потомки (если были) получают SIGKILL
+            // сразу, а не по таймеру.
+            if (stopping || code !== 0)
+                signalGroup('SIGKILL');
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({
+                ...(spawnError ? { spawnError } : {}),
+                started: Boolean(child.pid) && !spawnError,
+                code,
+                signal: sig,
+                stdout: Buffer.concat(out).toString('utf8'),
+                stderr: Buffer.concat(err).toString('utf8'),
+                timedOut,
+                aborted,
+                oversized,
+                durationMs: Date.now() - startedAt,
+                ...(child.pid ? { pid: child.pid } : {}),
+            });
+        };
+    });
+}

package/lib/integrations/relay-v2/protocol.d.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import type { TransportErrorKind } from '../connector/transport.ts';
+/**
+ * Договор вывода Relay-2 CLI (`--format json`), проверенный на сборке
+ * a3ee804: успех — одна JSON-строка `{ok:true,data,meta?}` в stdout и exit 0;
+ * отказ — `{ok:false,error:{code,message,details?}}` в stderr и ненулевой exit.
+ * Схемы проверяют только поля, которые читает адаптер; лишние поля допустимы.
+ */
+export declare const successSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodUnknown;
+    meta: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const failureSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const columnSchema: z.ZodEnum<{
+    ready: "ready";
+    review: "review";
+    cancelled: "cancelled";
+    done: "done";
+    "in-progress": "in-progress";
+    inbox: "inbox";
+}>;
+export declare const criterionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    description: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    completed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const commentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    body: z.ZodString;
+    createdAt: z.ZodString;
+    createdBy: z.ZodString;
+}, z.core.$strip>;
+export declare const taskSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<string>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+        column: z.ZodEnum<{
+            ready: "ready";
+            review: "review";
+            cancelled: "cancelled";
+            done: "done";
+            "in-progress": "in-progress";
+            inbox: "inbox";
+        }>;
+        parentId: z.ZodNullable<z.ZodString>;
+        dependencies: z.ZodArray<z.ZodString>;
+        acceptanceCriteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            summary: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+            description: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+            completed: z.ZodBoolean;
+        }, z.core.$strip>>;
+        comments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+            body: z.ZodString;
+            createdAt: z.ZodString;
+            createdBy: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const progressSchema: z.ZodObject<{
+    completed: z.ZodBoolean;
+    canComplete: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const documentSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<string>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        name: z.ZodString;
+        body: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const sessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<string>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+        status: z.ZodEnum<{
+            open: "open";
+            cancelled: "cancelled";
+            pending: "pending";
+            completed: "completed";
+            paused: "paused";
+        }>;
+        currentRunId: z.ZodNullable<z.ZodString>;
+        parentSessionId: z.ZodNullable<z.ZodString>;
+        result: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string, string | null | undefined>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const checkpointSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<string>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        kind: z.ZodEnum<{
+            result: "result";
+            cancel: "cancel";
+            intent: "intent";
+            progress: "progress";
+        }>;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        intentId: z.ZodNullable<z.ZodString>;
+        title: z.ZodString;
+        body: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const storageStatusSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    databasePath: z.ZodString;
+    generation: z.ZodNumber;
+}, z.core.$strip>;
+export declare const projectSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<string>;
+    key: z.ZodString;
+    revision: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodString>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const doctorSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    generation: z.ZodNumber;
+    valid: z.ZodBoolean;
+    issues: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const pageMetaSchema: z.ZodObject<{
+    page: z.ZodObject<{
+        nextCursor: z.ZodNullable<z.ZodString>;
+        consistency: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const itemsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+/** Стабильный код Relay-2 → класс отказа транспорта. Exit code — только грубый класс. */
+export declare function classifyCode(code: string, exit: number | null, mutation: boolean): TransportErrorKind;

package/lib/integrations/relay-v2/protocol.js

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+/**
+ * Договор вывода Relay-2 CLI (`--format json`), проверенный на сборке
+ * a3ee804: успех — одна JSON-строка `{ok:true,data,meta?}` в stdout и exit 0;
+ * отказ — `{ok:false,error:{code,message,details?}}` в stderr и ненулевой exit.
+ * Схемы проверяют только поля, которые читает адаптер; лишние поля допустимы.
+ */
+export const successSchema = z.object({
+    ok: z.literal(true),
+    data: z.unknown(),
+    meta: z.unknown().optional(),
+});
+export const failureSchema = z.object({
+    ok: z.literal(false),
+    error: z.object({
+        code: z.string().min(1),
+        message: z.string(),
+        details: z.record(z.string(), z.unknown()).optional(),
+    }),
+});
+const nullableText = z
+    .string()
+    .nullable()
+    .optional()
+    .transform((v) => v ?? '');
+export const columnSchema = z.enum([
+    'inbox',
+    'ready',
+    'in-progress',
+    'review',
+    'done',
+    'cancelled',
+]);
+/** Общий envelope записи: `{id, kind, key, revision, …, data}`. */
+const envelope = (kind, data) => z.object({
+    id: z.string().min(1),
+    kind: z.literal(kind),
+    key: z.string().min(1),
+    revision: z.number().int().positive(),
+    createdAt: z.string().optional(),
+    createdBy: z.string().optional(),
+    data,
+});
+export const criterionSchema = z.object({
+    id: z.string().min(1),
+    title: z.string(),
+    summary: nullableText,
+    description: nullableText,
+    completed: z.boolean(),
+});
+export const commentSchema = z.object({
+    id: z.string().min(1),
+    title: nullableText,
+    body: z.string(),
+    createdAt: z.string(),
+    createdBy: z.string(),
+});
+export const taskSchema = envelope('task', z.object({
+    title: z.string(),
+    description: nullableText,
+    column: columnSchema,
+    parentId: z.string().nullable(),
+    dependencies: z.array(z.string()),
+    acceptanceCriteria: z.array(criterionSchema),
+    comments: z.array(commentSchema).optional(),
+}));
+export const progressSchema = z.object({
+    completed: z.boolean(),
+    canComplete: z.boolean(),
+    blockers: z.array(z.string()),
+});
+export const documentSchema = envelope('document', z.object({ name: z.string(), body: z.string() }));
+export const sessionSchema = envelope('work-session', z.object({
+    title: z.string(),
+    description: nullableText,
+    status: z.enum(['pending', 'open', 'paused', 'completed', 'cancelled']),
+    currentRunId: z.string().nullable(),
+    parentSessionId: z.string().nullable(),
+    result: nullableText,
+}));
+export const checkpointSchema = envelope('work-checkpoint', z.object({
+    kind: z.enum(['intent', 'progress', 'result', 'cancel']),
+    sessionId: z.string().min(1),
+    runId: z.string().min(1),
+    intentId: z.string().nullable(),
+    title: z.string(),
+    body: z.string(),
+}));
+export const storageStatusSchema = z.object({
+    projectId: z.string().min(1),
+    databasePath: z.string().min(1),
+    generation: z.number().int().nonnegative(),
+});
+export const projectSchema = envelope('project', z.object({ name: z.string() }));
+export const doctorSchema = z.object({
+    projectId: z.string().min(1),
+    generation: z.number().int().nonnegative(),
+    valid: z.boolean(),
+    issues: z.array(z.unknown()),
+});
+export const pageMetaSchema = z.object({
+    page: z.object({
+        nextCursor: z.string().min(1).nullable(),
+        consistency: z.string().optional(),
+    }),
+});
+export const itemsSchema = z.object({ items: z.array(z.unknown()) });
+/** Стабильный код Relay-2 → класс отказа транспорта. Exit code — только грубый класс. */
+export function classifyCode(code, exit, mutation) {
+    switch (code) {
+        case 'REVISION_CONFLICT':
+        case 'SNAPSHOT_CONFLICT':
+        case 'CONFLICT':
+        case 'STORAGE_BUSY':
+            return 'conflict';
+        case 'TASK_INCOMPLETE':
+        case 'TASK_DONE':
+        case 'TASK_CYCLE':
+        case 'ACTOR_REQUIRED':
+        case 'CONFLICTING_OPTIONS':
+        case 'PROJECT_REQUIRED':
+        case 'WORKSPACE_REQUIRED':
+        case 'INVALID_CONFIG':
+            return 'refused';
+        case 'NOT_FOUND':
+        case 'PROJECT_NOT_FOUND':
+        case 'CONFIG_NOT_FOUND':
+            return 'not-found';
+    }
+    if (code.startsWith('INVALID_') || code === 'VALIDATION_ERROR')
+        return 'refused';
+    // Неизвестный код: класс по exit. 2 — вход, 3 — нет записи, 4 — состояние;
+    // все три — проверенный отказ до записи. Иное (1, сигнал) — сбой backend:
+    // для мутации исход неизвестен.
+    if (exit === 2)
+        return 'refused';
+    if (exit === 3)
+        return 'not-found';
+    if (exit === 4)
+        return 'conflict';
+    return mutation ? 'uncertain' : 'unavailable';
+}

package/lib/package.d.ts

@@ -0,0 +1,2 @@
+/** Версия пакета читается из его собственного package.json, а не из cwd. */
+export declare const HARNESS_VERSION: string;

package/lib/package.js

@@ -0,0 +1,3 @@
+import { readFileSync } from 'node:fs';
+/** Версия пакета читается из его собственного package.json, а не из cwd. */
+export const HARNESS_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;

package/lib/profiles/resolve.d.ts

@@ -0,0 +1,190 @@
+import { z } from 'zod';
+import { repositoryPolicySchema, type ProfilePin, type ResolvedProfile } from '../contracts/index.ts';
+/** Встроенные профили пакета: `profiles/<id>.json` рядом с `lib/`. */
+export declare const builtinProfilesRoot: string;
+export interface ResolveProfileOptions {
+    /** Корень репозитория, внутри которого лежат локальные профили (`./file.json`). */
+    repository?: string;
+    /** ID репозитория в политике; записывается в источник локального профиля. */
+    repositoryId?: string;
+    /** Каталог встроенных профилей; по умолчанию — профили пакета. */
+    builtinRoot?: string;
+}
+/** ID встроенных профилей пакета. */
+export declare function builtinProfiles(root?: string): string[];
+/**
+ * Разрешение профиля: встроенный ID или относительный `./file.json` внутри
+ * репозитория, слои `extends` в глубину, без циклов и не больше 32 файлов.
+ * Только чтение манифестов — ни одна команда проекта не исполняется.
+ *
+ * Слои складываются: gates, подготовка, возможности, защищённые и
+ * генерируемые пути — объединением; окружение и lifecycle — только из одного
+ * слоя (иначе конфликт); параллельность — наименьшая, время попытки —
+ * наибольшее; роли и инструкции стека — по ID, надстройка уточняет базу.
+ * Итоговый профиль обязан иметь test gate с JUnit: зелёный выход без отчёта
+ * ничего не доказывает. Файлы локальных слоёв становятся защищёнными путями.
+ */
+export declare function resolveProfile(ref: string, options?: ResolveProfileOptions): ResolvedProfile;
+export declare const profilePin: (p: ResolvedProfile) => ProfilePin;
+type RepositoryInput = z.input<typeof repositoryPolicySchema>;
+/**
+ * Описание репозитория политики из профиля. Явные значения `own` сильнее
+ * профиля и ничего не дополняют молча: `shadowed` называет поля, которые
+ * профиль задаёт иначе, а `own` переопределяет, — иначе обновлённый профиль с
+ * новым gate «применялся бы», не доходя до политики.
+ */
+export declare function repositoryFromProfile(profile: ResolvedProfile, own: Pick<RepositoryInput, 'id' | 'path' | 'targetRef'> & Partial<RepositoryInput>): {
+    repository: {
+        id: string;
+        path: string;
+        kind: "product" | "library";
+        targetRef: string;
+        dependsOn: string[];
+        gates: ({
+            kind: "test";
+            report: {
+                type: "junit";
+                path: string;
+            };
+            id: string;
+            command: string[];
+            timeoutMs: number;
+            property?: {
+                path?: string | undefined;
+            } | undefined;
+            dependsOn?: string[] | undefined;
+            cwd?: string | undefined;
+            resources?: string[] | undefined;
+        } | {
+            kind: "check";
+            id: string;
+            command: string[];
+            timeoutMs: number;
+            report?: {
+                type: "junit";
+                path: string;
+            } | undefined;
+            property?: {
+                path?: string | undefined;
+            } | undefined;
+            dependsOn?: string[] | undefined;
+            cwd?: string | undefined;
+            resources?: string[] | undefined;
+        })[];
+        protectedPaths: string[];
+        generatedPaths: string[];
+        prepare: {
+            id: string;
+            command: string[];
+            timeoutMs: number;
+        }[];
+        dependencyBuild: {
+            id: string;
+            command: string[];
+            timeoutMs: number;
+        }[];
+        dependencyArtifacts: string[];
+        preflight: {
+            id: string;
+            command: string[];
+            timeoutMs: number;
+        }[];
+        roles?: Record<string, {
+            writer: {
+                runtime: "codex" | "claude" | "fixture";
+                model?: string | undefined;
+                effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                toolProfile?: string | undefined;
+            };
+            requiresContract: boolean;
+            writePaths?: string[] | undefined;
+            review?: {
+                reviewer: {
+                    runtime: "codex" | "claude" | "fixture";
+                    model?: string | undefined;
+                    effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                    toolProfile?: string | undefined;
+                };
+                vendor: "different-vendor" | "same-vendor-allowed";
+                alternates?: {
+                    runtime: "codex" | "claude" | "fixture";
+                    model?: string | undefined;
+                    effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                    toolProfile?: string | undefined;
+                }[] | undefined;
+            } | undefined;
+        }> | undefined;
+        review?: {
+            reviewer: {
+                runtime: "codex" | "claude" | "fixture";
+                model?: string | undefined;
+                effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                toolProfile?: string | undefined;
+            };
+            vendor: "different-vendor" | "same-vendor-allowed";
+            alternates?: {
+                runtime: "codex" | "claude" | "fixture";
+                model?: string | undefined;
+                effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                toolProfile?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        gateGroups?: Record<string, string[]> | undefined;
+        environment?: {
+            inherit: string[];
+            values: Record<string, string>;
+            secrets: Record<string, string>;
+        } | undefined;
+        lifecycle?: {
+            setup: {
+                id: string;
+                command: string[];
+                timeoutMs: number;
+            }[];
+            ready: {
+                id: string;
+                command: string[];
+                timeoutMs: number;
+            }[];
+            teardown: {
+                id: string;
+                command: string[];
+                timeoutMs: number;
+            }[];
+        } | undefined;
+        toolchain?: {
+            tools: Record<string, string>;
+            packageManagers: Record<string, "npm" | "pnpm">;
+        } | undefined;
+    };
+    shadowed: ("gates" | "prepare" | "protectedPaths" | "generatedPaths" | "environment" | "lifecycle" | "toolchain")[];
+};
+/** Роли профиля в форме политики: writer, область записи и правило ревью кода роли. */
+export declare function profileRoles(profile: ResolvedProfile): {
+    [k: string]: {
+        writer: {
+            runtime: "codex" | "claude" | "fixture";
+            model?: string | undefined;
+            effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+            toolProfile?: string | undefined;
+        };
+        requiresContract: boolean;
+        writePaths?: string[] | undefined;
+        review?: {
+            reviewer: {
+                runtime: "codex" | "claude" | "fixture";
+                model?: string | undefined;
+                effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                toolProfile?: string | undefined;
+            };
+            vendor: "different-vendor" | "same-vendor-allowed";
+            alternates?: {
+                runtime: "codex" | "claude" | "fixture";
+                model?: string | undefined;
+                effort?: "low" | "medium" | "high" | "xhigh" | undefined;
+                toolProfile?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+    };
+};
+export {};