devcontour-harness 0.1.0-alpha.18 → 0.1.0-alpha.19

package/lib/contracts/ports.d.ts

@@ -16,6 +16,12 @@ export interface ExecutionView {
     works(graphId?: string): WorkState[];
     attempt(id: string): AttemptState | undefined;
     attempts(workId?: string): AttemptState[];
+    /**
+     * Только активные попытки. Необязательный быстрый путь: такт очереди ищет
+     * истёкшие среди активных, и адаптеру с длинной историей не нужно строить
+     * все прежние попытки. Без метода — `attempts()` с фильтром по статусу.
+     */
+    activeAttempts?(): AttemptState[];
     verification(id: string): JointVerificationState | undefined;
     verifications(): JointVerificationState[];
     /**

package/lib/contracts/primitives.d.ts

@@ -3,6 +3,19 @@ import { z } from 'zod';
 export declare const idSchema: z.ZodString;
 /** Ссылка на gate или на именованную группу gates (`@имя`). */
 export declare const gateRefSchema: z.ZodString;
+/**
+ * Предел ссылок на gates в одной области (задача, поручение, потребитель,
+ * основание ревью). Он равен пределу gates профиля стека: область задачи
+ * может назвать весь профиль, и включение каждого gate в задачу выполнимо
+ * одной задачей.
+ */
+export declare const GATE_SCOPE_LIMIT = 100;
+/** Превышение предела области gates — понятный отказ с величиной и исправлением. */
+export declare const gateScopeTooBig: (issue: {
+    input?: unknown;
+}) => string;
+/** Ссылки на gates одной области: не больше `GATE_SCOPE_LIMIT`. */
+export declare const gateScopeSchema: <T extends z.ZodType<string>>(item: T) => z.ZodArray<T>;
 export declare const roleIdSchema: z.ZodString;
 /** Полный SHA объекта Git (SHA-1 или SHA-256). */
 export declare const gitShaSchema: z.ZodString;

package/lib/contracts/primitives.js

@@ -5,6 +5,21 @@ export const idSchema = z
     .regex(/^[A-Za-z0-9_-]{1,80}$/, 'Ожидается ID [A-Za-z0-9_-]{1,80}');
 /** Ссылка на gate или на именованную группу gates (`@имя`). */
 export const gateRefSchema = z.string().regex(/^@?[A-Za-z0-9_-]{1,80}$/);
+/**
+ * Предел ссылок на gates в одной области (задача, поручение, потребитель,
+ * основание ревью). Он равен пределу gates профиля стека: область задачи
+ * может назвать весь профиль, и включение каждого gate в задачу выполнимо
+ * одной задачей.
+ */
+export const GATE_SCOPE_LIMIT = 100;
+/** Превышение предела области gates — понятный отказ с величиной и исправлением. */
+export const gateScopeTooBig = (issue) => {
+    const actual = Array.isArray(issue.input) ? issue.input.length : GATE_SCOPE_LIMIT + 1;
+    return (`область gates: ${actual} при пределе ${GATE_SCOPE_LIMIT}, лишних ${actual - GATE_SCOPE_LIMIT}. ` +
+        'Назовите группу gates (@имя) или уберите повторы');
+};
+/** Ссылки на gates одной области: не больше `GATE_SCOPE_LIMIT`. */
+export const gateScopeSchema = (item) => z.array(item).max(GATE_SCOPE_LIMIT, { error: gateScopeTooBig });
 export const roleIdSchema = z
     .string()
     .regex(/^[a-z][a-z0-9-]{1,30}$/, 'Идентификатор роли: строчные латинские буквы, цифры и дефис');

package/lib/contracts/profiles.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { idSchema, relativePathSchema, roleIdSchema } from "./primitives.js";
+import { GATE_SCOPE_LIMIT, idSchema, relativePathSchema, roleIdSchema } from "./primitives.js";
 import { environmentSchema, gateSchema, lifecycleSchema, stepSchema } from "./policy.js";
 import { toolchainSchema } from "./toolchain.js";
 /**
@@ -62,7 +62,7 @@ export const stackProfileSchema = z.strictObject({
     /** Встроенный ID или относительный `./file.json` внутри репозитория. */
     extends: z.array(z.string().min(1)).max(PROFILE_DEPTH_LIMIT).default([]),
     capabilities: z.array(z.string().min(1).max(100)).max(100).default([]),
-    gates: z.array(profileGateSchema).max(100).default([]),
+    gates: z.array(profileGateSchema).max(GATE_SCOPE_LIMIT).default([]),
     prepare: z.array(stepSchema).max(100).default([]),
     environment: environmentSchema.optional(),
     lifecycle: lifecycleSchema.optional(),

package/lib/contracts/published.d.ts

@@ -628,8 +628,8 @@ export declare const publishedSchemas: {
                 timeMs: z.ZodNumber;
             }, z.core.$strict>]>>;
             onUnknown: z.ZodDefault<z.ZodEnum<{
-                stop: "stop";
                 continue: "continue";
+                stop: "stop";
             }>>;
         }, z.core.$strict>>;
         prices: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1700,6 +1700,13 @@ export declare const publishedSchemas: {
             passed: z.ZodBoolean;
             evidenceId: z.ZodString;
             consumer: z.ZodOptional<z.ZodString>;
+            recheck: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                outcome: z.ZodEnum<{
+                    flaky: "flaky";
+                    confirmed: "confirmed";
+                }>;
+            }, z.core.$strict>>;
         }, z.core.$strict> | z.ZodObject<{
             phase: z.ZodEnum<{
                 candidate: "candidate";
@@ -1955,6 +1962,13 @@ export declare const publishedSchemas: {
             passed: z.ZodBoolean;
             evidenceId: z.ZodString;
             consumer: z.ZodOptional<z.ZodString>;
+            recheck: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                outcome: z.ZodEnum<{
+                    flaky: "flaky";
+                    confirmed: "confirmed";
+                }>;
+            }, z.core.$strict>>;
         }, z.core.$strict> | z.ZodObject<{
             phase: z.ZodEnum<{
                 candidate: "candidate";
@@ -2857,6 +2871,13 @@ export declare const publishedSchemas: {
                 digest: z.ZodString;
                 summary: z.ZodString;
                 consumer: z.ZodOptional<z.ZodString>;
+                recheck: z.ZodOptional<z.ZodObject<{
+                    of: z.ZodString;
+                    outcome: z.ZodEnum<{
+                        flaky: "flaky";
+                        confirmed: "confirmed";
+                    }>;
+                }, z.core.$strict>>;
                 inspection: z.ZodOptional<z.ZodObject<{
                     mode: z.ZodEnum<{
                         commands: "commands";
@@ -2948,9 +2969,9 @@ export declare const publishedSchemas: {
                     issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         path: z.ZodString;
                         reason: z.ZodEnum<{
+                            schema: "schema";
                             unknown: "unknown";
                             missing: "missing";
-                            schema: "schema";
                             duplicate: "duplicate";
                             "not-open": "not-open";
                             "approved-with-blocking": "approved-with-blocking";

package/lib/contracts/review.d.ts

@@ -239,9 +239,9 @@ export type ProtocolIssueReason = (typeof protocolIssueReasons)[number];
 export declare const protocolIssueSchema: z.ZodObject<{
     path: z.ZodString;
     reason: z.ZodEnum<{
+        schema: "schema";
         unknown: "unknown";
         missing: "missing";
-        schema: "schema";
         duplicate: "duplicate";
         "not-open": "not-open";
         "approved-with-blocking": "approved-with-blocking";
@@ -269,9 +269,9 @@ export declare const reviewRoundSchema: z.ZodObject<{
     issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         reason: z.ZodEnum<{
+            schema: "schema";
             unknown: "unknown";
             missing: "missing";
-            schema: "schema";
             duplicate: "duplicate";
             "not-open": "not-open";
             "approved-with-blocking": "approved-with-blocking";

package/lib/contracts/review.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { authorSchema, digestSchema, idSchema, isoTimeSchema, relativePathSchema, runtimeNameSchema, } from "./primitives.js";
+import { authorSchema, digestSchema, idSchema, isoTimeSchema, relativePathSchema, runtimeNameSchema, gateScopeSchema, } from "./primitives.js";
 import { digestOf } from "./digest.js";
 /**
  * Ответы исполнителей. Runtime возвращает сырой текст/JSON (`RuntimeResponse.output`
@@ -71,7 +71,7 @@ export const findingTransitionSchema = z.strictObject({
  */
 /** Основание «приёмка уже выполнена»: названные gates и что их evidence показывает. */
 export const alreadySatisfiedSchema = z.strictObject({
-    gates: z.array(z.string().min(1).max(200)).min(1).max(20),
+    gates: gateScopeSchema(z.string().min(1).max(200)).min(1),
     evidence: z.string().min(1).max(4000),
 });
 export const reviewResultSchema = z.object({

package/lib/contracts/work.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { API_VERSION } from "./version.js";
-import { digestSchema, gateRefSchema, gitShaSchema, idSchema, relativePathSchema, roleIdSchema, trimmedText, } from "./primitives.js";
+import { digestSchema, gateRefSchema, gitShaSchema, idSchema, relativePathSchema, roleIdSchema, trimmedText, gateScopeSchema, } from "./primitives.js";
 import { digestOf } from "./digest.js";
 /**
  * Откуда пришло поручение: коннектор, ключ записи в нём и её редакция.
@@ -31,7 +31,7 @@ export const contractRefSchema = z.strictObject({ id: idSchema, digest: digestSc
 /** Проверка потребителя: компонент и его gates против integration результата. */
 export const consumerSchema = z.strictObject({
     repositoryId: idSchema,
-    gates: z.array(gateRefSchema).min(1).max(20),
+    gates: gateScopeSchema(gateRefSchema).min(1),
 });
 /**
  * Исполняемое поручение. Это снимок постановки, а не редактируемая задача:
@@ -63,7 +63,7 @@ export const workOrderSchema = z.strictObject({
     }),
     dependsOn: z.array(idSchema).max(100).default([]),
     /** Область доказательства: подмножество gates/групп политики. Нет поля — все gates репозитория. */
-    gates: z.array(gateRefSchema).max(20).optional(),
+    gates: gateScopeSchema(gateRefSchema).optional(),
     consumers: z.array(consumerSchema).max(10).optional(),
     /** Свойства договора проверки, которые поручение подтверждает сейчас. */
     properties: z.array(propertyIdSchema).max(30).optional(),

package/lib/control/base-move.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { isAbsolute, join, resolve } from 'node:path';
-import { git } from "../environment/process.js";
+import { git, hostGitArgs } from "../environment/process.js";
 /**
  * Сдвиг ref внутри транзакции проверки владения операцией: проверка и
  * `git update-ref` неразделимы — отмена или перехват операции либо видны
@@ -11,7 +11,7 @@ import { git } from "../environment/process.js";
 export function fencedRefMove(store, fence, timeoutMs = fencedRefMove.timeoutMs) {
     return (repoPath, target, to, from) => store.transact('base.moved', (tx) => {
         fence(tx);
-        execFileSync('git', ['-c', 'core.hooksPath=/dev/null', 'update-ref', target, to, from], {
+        execFileSync('git', hostGitArgs(repoPath, ['update-ref', target, to, from]), {
             cwd: repoPath,
             timeout: timeoutMs,
             stdio: 'pipe',

package/lib/control/harness.d.ts

@@ -681,7 +681,7 @@ export declare class Harness {
     private repair;
     status(graphId?: string): {
         budgets: {
-            onUnknown: "stop" | "continue";
+            onUnknown: "continue" | "stop";
             budgets: {
                 reason?: string | undefined;
                 scope: import("../engine/budget.ts").BudgetScope;

package/lib/control/harness.js

@@ -16,7 +16,7 @@ import { WorkflowQueue } from "./workflow.js";
 import { technicalReview } from "./review.js";
 import { policySourceChanged } from "./provenance.js";
 import { JointRunner } from "../engine/joint-runner.js";
-import { git } from "../environment/process.js";
+import { git, hostGitArgs } from "../environment/process.js";
 import { analyzeRecovery, applyCases } from "./recovery.js";
 import { declarationProblems, referenceNote } from "../verification/checks.js";
 import { spikeOf, spikesOf } from "../verification/spike.js";
@@ -341,7 +341,12 @@ export class Harness {
                     return false;
                 try {
                     // Синхронная проверка: предпосылка доступна в целевой ветке.
-                    execFileSync('git', ['merge-base', '--is-ancestor', p.resultSha, repo.targetRef], {
+                    execFileSync('git', hostGitArgs(this.repoPath(repo.path), [
+                        'merge-base',
+                        '--is-ancestor',
+                        p.resultSha,
+                        repo.targetRef,
+                    ]), {
                         cwd: this.repoPath(repo.path),
                         stdio: 'ignore',
                     });

package/lib/control/workflow.js

@@ -217,6 +217,12 @@ export class WorkflowQueue {
             next.status = next.stage >= stages ? 'completed' : 'queued';
             if (next.status === 'completed')
                 next.finishedAt = iso(this.now());
+            // Счётчик попыток — бюджет текущей стадии, и следующая стадия начинает
+            // его с нуля. У завершённого задания следующей стадии нет: счётчик
+            // показывает, сколько попыток стадий задание израсходовало всего (захваты
+            // `running` в истории; захват стадии, ответившей «жду», из неё снят).
+            if (next.status === 'completed')
+                next.attempts = next.history.filter((h) => h.event === 'running').length;
             delete next.token;
             delete next.leaseUntil;
             delete next.error;

package/lib/engine/budget.d.ts

@@ -322,7 +322,7 @@ export declare function budgetView(b: BudgetStatus): {
 };
 /** Бюджеты установки: общий, группы с незавершённой работой, незавершённые поручения. */
 export declare function budgetOverview(c: BudgetContext, view: ExecutionView, records?: CallRecord[]): {
-    onUnknown: "stop" | "continue";
+    onUnknown: "continue" | "stop";
     budgets: {
         reason?: string | undefined;
         scope: BudgetScope;

package/lib/engine/engine.d.ts

@@ -34,6 +34,14 @@ export interface EngineOptions {
 export type Phase = 'running' | 'verifying' | 'reviewing' | 'integrating';
 /** Поручение исчерпало предел незасчитанных отказов: повтор — только со сбросом. */
 export declare const neutralExhausted: (w: Pick<WorkState, "neutralFailures">) => boolean;
+/**
+ * Провал, названный свойством или случаем корпуса, — найденный контрпример, а
+ * не сбой среды: генеративная проверка недетерминирована, и удачный повтор
+ * не отменяет найденного входа. Такой провал не повторяется.
+ */
+export declare function namesFailingCases(e: Pick<EvidenceRecord, 'property'>): boolean;
+/** Активные попытки снимка: быстрый путь адаптера или фильтр всех. */
+export declare function activeOf(v: ExecutionView): AttemptState[];
 export declare class Engine {
     readonly host: ExecutionHost;
     readonly policy: ExecutionPolicy;
@@ -372,7 +380,7 @@ export declare class Engine {
     pinLegacyCalls(): number;
     /** Обзор бюджетов для статуса; `undefined` — бюджеты не заданы. */
     budgets(): {
-        onUnknown: "stop" | "continue";
+        onUnknown: "continue" | "stop";
         budgets: {
             reason?: string | undefined;
             scope: import("./budget.ts").BudgetScope;
@@ -492,6 +500,10 @@ export declare class Engine {
         digest: string;
         summary: string;
         consumer?: string | undefined;
+        recheck?: {
+            of: string;
+            outcome: "flaky" | "confirmed";
+        } | undefined;
         inspection?: {
             mode: "commands" | "diff-only";
             source: "codex-events" | "unavailable" | "controller-probes" | "runtime-and-controller";
@@ -546,7 +558,7 @@ export declare class Engine {
             expected: string[];
             issues?: {
                 path: string;
-                reason: "unknown" | "missing" | "schema" | "duplicate" | "not-open" | "approved-with-blocking";
+                reason: "schema" | "unknown" | "missing" | "duplicate" | "not-open" | "approved-with-blocking";
                 message: string;
             }[] | undefined;
             transitions?: {

package/lib/engine/engine.js

@@ -33,6 +33,21 @@ const contentDigest = (order) => digestOf({ ...order, source: { connector: order
 const uncounted = (kind, blocked) => blocked || kind === 'environment' || kind === 'provider-auth';
 /** Поручение исчерпало предел незасчитанных отказов: повтор — только со сбросом. */
 export const neutralExhausted = (w) => (w.neutralFailures ?? 0) >= MAX_NEUTRAL_FAILURES;
+/**
+ * Провал, названный свойством или случаем корпуса, — найденный контрпример, а
+ * не сбой среды: генеративная проверка недетерминирована, и удачный повтор
+ * не отменяет найденного входа. Такой провал не повторяется.
+ */
+export function namesFailingCases(e) {
+    const report = e.property?.report;
+    return (!!report &&
+        (report.properties.some((p) => p.status === 'failed') ||
+            (report.corpus?.failed.length ?? 0) > 0));
+}
+/** Активные попытки снимка: быстрый путь адаптера или фильтр всех. */
+export function activeOf(v) {
+    return v.activeAttempts ? v.activeAttempts() : v.attempts().filter((a) => a.status === 'active');
+}
 export class Engine {
     host;
     policy;
@@ -1136,6 +1151,25 @@ export class Engine {
             // доказывала бы его (и названный testcase).
             if ((evidence.kind === 'review') !== (evidence.gate === 'independent-review'))
                 throw new HarnessError('INVALID_INPUT', `Evidence вида ${evidence.kind} не может относиться к gate ${evidence.gate}`);
+            // Повтор ссылается на провал того же gate этой попытки на том же SHA, и
+            // попытка повторяет не больше одного провала.
+            if (evidence.recheck) {
+                const of = evidence.recheck.of;
+                const first = a.evidence.find((e) => e.id === of);
+                if (evidence.kind !== 'test' ||
+                    !first ||
+                    first.passed ||
+                    first.kind !== 'test' ||
+                    first.gate !== evidence.gate ||
+                    first.phase !== evidence.phase ||
+                    first.sha !== evidence.sha ||
+                    first.consumer !== evidence.consumer ||
+                    namesFailingCases(first) ||
+                    a.evidence.some((e) => e.recheck))
+                    throw new HarnessError('INVALID_INPUT', 'Повтор gate не относится к провалу этой попытки');
+                if (evidence.recheck.outcome !== (evidence.passed ? 'flaky' : 'confirmed'))
+                    throw new HarnessError('INVALID_INPUT', 'Исход повтора gate не согласован с записью');
+            }
             const record = {
                 ...evidence,
                 ...(a.checks ? { checks: a.checks.effective } : {}),
@@ -1170,6 +1204,7 @@ export class Engine {
                         passed: record.passed,
                         evidenceId: record.id,
                         ...(record.consumer ? { consumer: record.consumer } : {}),
+                        ...(record.recheck ? { recheck: record.recheck } : {}),
                     },
                 });
             return record;
@@ -2215,9 +2250,13 @@ export class Engine {
      * момент в будущем, когда снимает всё владение восстановленной копии.
      */
     expire(at = this.now()) {
+        // Такт очереди вызывает истечение постоянно: без истёкших попыток
+        // транзакции записи (и её снимка состояния) нет.
+        if (!this.read((v) => activeOf(v).some((a) => a.leaseUntil <= at)))
+            return [];
         return this.tx('runs.expired', (tx) => {
             const ids = [];
-            for (const a of tx.attempts())
+            for (const a of activeOf(tx))
                 if (a.status === 'active' && a.leaseUntil <= at) {
                     const error = (a.error?.startsWith(HEARTBEAT_FAILED) ? a.error + '. ' : '') +
                         'Истёк срок владения. Повторите явно.';

package/lib/engine/runner.d.ts

@@ -1,6 +1,6 @@
 import { type ImplementationResult, type AttemptState, type ContextSnapshot, type ExecutionPolicy, type RuntimeAdapter, type RuntimeName, type WorkState } from '../contracts/index.ts';
 import { type FailureKind } from './failure.ts';
-import type { Engine } from './engine.ts';
+import { type Engine } from './engine.ts';
 import { CorpusStore } from '../verification/corpus.ts';
 type Repo = ExecutionPolicy['repositories'][number];
 export interface RunnerOptions {
@@ -197,6 +197,16 @@ export declare class Runner {
         receipts: string[];
     }>;
     private gate;
+    /**
+     * Gate интеграции с одним повтором на кандидата. Провал собственного gate на
+     * integration, когда тот же gate прошёл на кандидате, часто вызван средой
+     * (бюджет времени под конкуренцией за CPU), а не кодом; без повтора такой
+     * провал оплачивался новой реализацией. Повтор — тот же gate на том же
+     * integration SHA, один раз за интеграцию кандидата; обе записи остаются,
+     * у повтора — `recheck` со ссылкой на первую и исходом (`flaky` — повтор
+     * прошёл, `confirmed` — провал подтвердился и засчитывается как прежде).
+     */
+    private integrationGate;
     private runOneGate;
     /**
      * Ожидаемая проверка генеративного gate. Проверка потребителя исполняет

package/lib/engine/runner.js

@@ -2,9 +2,10 @@ import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, readdir, realpath, rm, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { roleBinding, selectReviewer, mcpEnvironment, HarnessError, digestOf, contextDigest, implementationResultSchema, codeReviewHistory, codeReviewScope, checkCodeReview, logicalReview, DEFAULT_REVIEW_PROTOCOL_RETRIES, reviewResultSchema, sha256, } from "../contracts/index.js";
-import { git } from "../environment/process.js";
+import { git, hostGitArgs } from "../environment/process.js";
+import { protectedChanges, protectedSnapshot } from "../environment/isolation.js";
 import { executionEnvironment, runSteps, withEnvironment } from "../environment/lifecycle.js";
 import { redactDeep } from "../environment/redaction.js";
 import { alreadySatisfiedReviewOutputSchema, implementationOutputSchema, reviewOutputSchema, } from "../agents/schemas.js";
@@ -20,6 +21,7 @@ import { defaultResourceDatabase, withResources } from "../environment/resources
 import { REQUIREMENT_GATE, assertRequirements } from "../verification/requirements.js";
 import { BlockedError, classifyFailure } from "./classify.js";
 import { TaskFailure } from "./failure.js";
+import { activeOf, namesFailingCases } from "./engine.js";
 import { prompt } from "./prompt.js";
 import { contractDocuments, orderCheckManifest, referenceCodeNote, referenceSetFiles, setFileReference, } from "../verification/checks.js";
 import { CorpusStore, localRoots } from "../verification/corpus.js";
@@ -271,7 +273,7 @@ export class Runner {
             this.engine.pinLegacyCalls();
         }
         const now = this.engine.clock();
-        const stale = this.engine.read((v) => v.attempts().filter((a) => a.status === 'active' && a.leaseUntil <= now));
+        const stale = this.engine.read((v) => activeOf(v).filter((a) => a.leaseUntil <= now));
         for (const a of stale) {
             if (!a.integrationSha)
                 continue;
@@ -761,6 +763,10 @@ export class Runner {
                             if (context)
                                 await writeFile(join(dir, 'context.json'), JSON.stringify(context, null, 2));
                             await this.prepareSelfCheck(attempt, repo, join(artifacts, 'self-check'));
+                            // Защищённые пути до работы исполнителя: перенос каталога,
+                            // собранного там, где запрет песочницы не действует, виден
+                            // только сверкой.
+                            const guarded = this.policy.isolation.mode === 'os' ? protectedSnapshot(cwd) : undefined;
                             const response = await this.call(this.adapter(attempt.runtime), {
                                 task: 'implement',
                                 attempt,
@@ -798,6 +804,13 @@ export class Runner {
                                     result.data.summary.slice(0, 500));
                             this.engine.heartbeat(attempt.id, attempt.token);
                             signal.throwIfAborted();
+                            const planted = guarded ? protectedChanges(guarded, cwd) : [];
+                            if (planted.length)
+                                throw new TaskFailure('scope-violation', 'Исполнитель создал или изменил защищённые пути (конфигурация IDE, shell, git или Claude): ' +
+                                    planted
+                                        .slice(0, 5)
+                                        .map((p) => relative(cwd, p))
+                                        .join(', '));
                             if ((await git(cwd, 'rev-parse', 'HEAD')) !== base)
                                 throw new TaskFailure('scope-violation', 'Исполнитель изменил HEAD; интеграцией владеет harness');
                             await git(cwd, 'add', '-A');
@@ -1047,15 +1060,63 @@ export class Runner {
                 JSON.parse(await readFile(file, 'utf8')).errors.join('; '));
         return { status: 'cleaned', receipts: cleaned };
     }
-    async gate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer) {
+    async gate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer, 
+    /** ID записи провала, которую повторяет этот запуск (`recheckIntegration`). */
+    recheck) {
         // Время проверок потребителя — отдельная стадия: в метриках области оно
-        // не смешивается с собственными gates поручения.
+        // не смешивается с собственными gates поручения. Повтор — тоже своя
+        // стадия: оценка длительности gate не удваивается из-за него.
         const stage = consumer
             ? `${phase}-consumer:${consumer.repositoryId}:${gate.id}`
-            : `${phase}-test:${gate.id}`;
-        await this.timed(attempt, stage, () => this.runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer));
+            : recheck
+                ? `${phase}-recheck:${gate.id}`
+                : `${phase}-test:${gate.id}`;
+        await this.timed(attempt, stage, () => this.runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer, recheck));
     }
-    async runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer) {
+    /**
+     * Gate интеграции с одним повтором на кандидата. Провал собственного gate на
+     * integration, когда тот же gate прошёл на кандидате, часто вызван средой
+     * (бюджет времени под конкуренцией за CPU), а не кодом; без повтора такой
+     * провал оплачивался новой реализацией. Повтор — тот же gate на том же
+     * integration SHA, один раз за интеграцию кандидата; обе записи остаются,
+     * у повтора — `recheck` со ссылкой на первую и исходом (`flaky` — повтор
+     * прошёл, `confirmed` — провал подтвердился и засчитывается как прежде).
+     */
+    async integrationGate(attempt, cwd, sha, gate, artifacts, signal, execution, budget) {
+        try {
+            await this.gate(attempt, cwd, sha, 'integration', gate, artifacts, signal, execution);
+        }
+        catch (error) {
+            if (!budget.recheck || signal.aborted || !(error instanceof TaskFailure))
+                throw error;
+            if (error.kind !== 'gate')
+                throw error;
+            const { failed, candidatePassed, spent } = this.engine.read((v) => {
+                const evidence = v.attempt(attempt.id)?.evidence ?? [];
+                const own = (e, phase, at) => e.kind === 'test' &&
+                    e.gate === gate.id &&
+                    e.phase === phase &&
+                    e.sha === at &&
+                    !e.consumer;
+                return {
+                    failed: evidence.findLast((e) => own(e, 'integration', sha)),
+                    candidatePassed: evidence.findLast((e) => own(e, 'candidate', attempt.candidateSha))?.passed === true,
+                    // Один повтор на кандидата: переиспользованный следующей попыткой
+                    // кандидат второго не получает.
+                    spent: v
+                        .attempts(attempt.workId)
+                        .some((x) => x.candidateSha === attempt.candidateSha && x.evidence.some((e) => e.recheck)),
+                };
+            });
+            // Контрпример свойства или провал случая корпуса не повторяется: удачный
+            // второй запуск недетерминированной проверки не отменяет найденного входа.
+            if (!failed || failed.passed || namesFailingCases(failed) || !candidatePassed || spent)
+                throw error;
+            budget.recheck = false;
+            await this.gate(attempt, cwd, sha, 'integration', gate, artifacts, signal, execution, undefined, failed.id);
+        }
+    }
+    async runOneGate(attempt, cwd, sha, phase, gate, artifacts, signal, execution, consumer, recheck) {
         // Генеративный gate — всегда; gate эталонных наборов — когда манифест
         // поручения ждёт от него отчёта (без договора — прежний уровень).
         const run = this.propertyRun(attempt, gate, consumer);
@@ -1067,9 +1128,14 @@ export class Runner {
             sha,
             phase,
             gate,
+            // Лог и отчёт повтора — в своём каталоге: первая запись ссылается на
+            // свой лог по digest, и повтор его не перезаписывает.
             artifactDir: consumer
                 ? join(artifacts, phase, 'consumer', consumer.repositoryId)
-                : join(artifacts, phase),
+                : recheck
+                    ? join(artifacts, phase, 'recheck')
+                    : join(artifacts, phase),
+            ...(recheck ? { recheck } : {}),
             signal,
             execution,
             boundary: this.boundary(consumer?.dependencies ?? attempt.dependencies),
@@ -1893,8 +1959,9 @@ export class Runner {
         const execution = this.environment(attempt, 'integration', cwd);
         await withEnvironment(repo.lifecycle ?? this.policy.lifecycle, cwd, join(artifacts, 'integration', 'environment'), execution, signal, async () => {
             await runSteps(repo.prepare, cwd, join(artifacts, 'integration', 'prepare'), execution, signal);
+            const budget = { recheck: true };
             for (const gate of gates)
-                await this.gate(attempt, cwd, sha, 'integration', gate, artifacts, signal, execution);
+                await this.integrationGate(attempt, cwd, sha, gate, artifacts, signal, execution, budget);
             await this.consumers(attempt, cwd, sha, artifacts, signal);
             this.requirements(attempt, work, repoPath, cwd, sha, 'integration');
             rearm();
@@ -1920,7 +1987,11 @@ export class Runner {
                     assertRequirements(work.order, repoPath);
                 // Внутри транзакции: без hooks репозитория (они исполнили бы чужой код
                 // под блокировкой записи) и с конечным пределом, короче lease.
-                execFileSync('git', ['-c', 'core.hooksPath=/dev/null', 'update-ref', repo.targetRef, sha, base], { cwd: repoPath, stdio: 'pipe', timeout: Runner.refTimeoutMs });
+                execFileSync('git', hostGitArgs(repoPath, ['update-ref', repo.targetRef, sha, base]), {
+                    cwd: repoPath,
+                    stdio: 'pipe',
+                    timeout: Runner.refTimeoutMs,
+                });
             });
         }
         catch (error) {

package/lib/environment/git-trust.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Git на хосте над деревом, в котором исполнялся чужой код.
+ *
+ * Исполнитель и проверки пишут в checkout. Git, запущенный потом на хосте,
+ * читает конфигурацию того репозитория, который найдёт от рабочего каталога,
+ * а она способна запускать программы (`core.fsmonitor`, hooks, драйверы
+ * фильтров и diff). Подменённый файл `.git` (`gitdir: <checkout>/evil`),
+ * `.git/commondir` в обычном checkout или вложенный `.git` уводили git в
+ * конфигурацию, которую написал чужой код, — и она исполнялась вне песочницы.
+ *
+ * Поэтому каждый вызов git хоста сначала сверяет, куда git придёт: файл
+ * `.git` рабочего дерева, созданного через `worktree add`, должен остаться
+ * тем же; gitdir и общий каталог репозитория лежат вне дерева и согласованы
+ * между собой; общий каталог — уже известный хосту репозиторий, если он
+ * известен; вложенный репозиторий внутри известного дерева и перенаправление
+ * обычного `.git` — отказ. Флаги `gitHardening` поверх этого снимают
+ * исполняемые настройки, которые git читает сам.
+ */
+export declare const gitHardening: string[];
+export declare class UntrustedCheckoutError extends Error {
+    name: string;
+}
+/**
+ * Сверяет репозиторий, который git найдёт от `cwd`. Возвращает его общий
+ * каталог или `undefined`, если репозитория нет (git откажет сам).
+ */
+export declare function assertTrustedCheckout(cwd: string): string | undefined;
+/** Рабочее дерево создано хостом: дальше его `.git` обязан остаться прежним. */
+export declare function rememberWorktree(path: string): void;
+/** Ключ дерева — настоящий путь (/var → /private/var). */
+export declare const worktreeKey: (path: string) => string;
+export declare function forgetWorktree(key: string): void;
+/** Путь, который `git worktree add` получит как каталог дерева. */
+export declare function worktreeAddPath(args: string[]): string | undefined;
+/** Только для тестов: забыть, что известно процессу. */
+export declare function resetGitTrust(): void;