tickmarkr 2.5.3 → 2.5.5

package/dist/drivers/types.d.ts

@@ -106,6 +106,7 @@ export interface ExecutorDriver {
     narrateWith?(narrate: (event: JournalEvent) => void): void;
     worktree(repo: string, branch: string, baseRef: string): Promise<string>;
     narrator?: (cwd: string, command: string, runId?: string) => Promise<Slot>;
+    retireLostWatch?: (slot: Slot) => Promise<void>;
     /** Best-effort projection of a task's lifecycle onto the execution host. */
     project?: (taskId: string, state: "in-progress" | "in-review" | "completed") => Promise<void>;
     reconcile?: (desired: Set<string>, runId: string, opts?: PanesToCloseOpts) => Promise<void>;

package/dist/gates/baseline.d.ts

@@ -37,6 +37,9 @@ export interface BaselineCommand {
     impliedParallelism?: number | null;
     /** The slowest per-file entry named by the runner; null when per-file timing is unavailable. */
     longestFile?: BaselineFileDuration | null;
+    /** VL-1: every per-file duration the runner named, so a later per-file hang budget (test-manifest.ts)
+     * can be derived per file rather than from one slowest-file number; null when unavailable. */
+    fileDurations?: BaselineFileDuration[] | null;
     /** The ceiling that measurement implies, persisted so every later battery uses the same number. */
     ceilingMs?: number;
     /**

package/dist/gates/baseline.js

@@ -230,13 +230,14 @@ function fileTiming(output, wallClockMs) {
             files.push({ file: match[1], durationMs });
     }
     if (!files.length)
-        return { fileDurationSumMs: null, impliedParallelism: null, longestFile: null };
+        return { fileDurationSumMs: null, impliedParallelism: null, longestFile: null, fileDurations: null };
     const fileDurationSumMs = files.reduce((sum, entry) => sum + entry.durationMs, 0);
     const longestFile = files.reduce((longest, entry) => entry.durationMs > longest.durationMs ? entry : longest);
     return {
         fileDurationSumMs,
         impliedParallelism: wallClockMs > 0 ? fileDurationSumMs / wallClockMs : null,
         longestFile,
+        fileDurations: files,
     };
 }
 // A failing command whose output holds no shape any runner here names. The marker is content-free and

package/dist/gates/cache.d.ts

@@ -0,0 +1,100 @@
+import type { Baseline } from "./baseline.js";
+import type { GateResult } from "./types.js";
+import { type RunCapacity } from "../run/git.js";
+export declare const DEFAULT_VERDICT_CACHE_BOUND = 128;
+export declare function setVerdictCacheBoundForTests(bound: number | undefined): void;
+export declare function resetVerdictCacheBoundForTests(): void;
+export declare const LOCKFILES: readonly ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
+export declare function lockfileHash(worktree: string): string;
+export declare function canonicalJson(obj: unknown): string;
+export declare function baselineIdentity(baseline?: Baseline): string;
+export declare function getWorktreeTree(worktree: string): Promise<string>;
+export interface GateEnvironmentInput {
+    nodeRuntime?: string;
+    lockfile?: string;
+    worktree?: string;
+    capacity?: RunCapacity;
+    selectedSet?: readonly string[];
+    scope?: VerificationScope;
+}
+export declare function environmentFingerprint(env: GateEnvironmentInput): {
+    fingerprint: string;
+    parts: {
+        nodeRuntime: string;
+        lockfile: string;
+        capacity: RunCapacity;
+        selectedSet?: readonly string[];
+    };
+};
+export type VerificationScope = "battery" | "tip" | "standalone";
+export interface VerificationIdentity {
+    /** the gate the verdict answers — build/lint/test may share one command and are still three verdicts */
+    gate?: string;
+    /** which verifier produced it: a battery gate row or an integration-tip row (own report, own forgiveness rule) */
+    scope?: VerificationScope;
+    /** Checkout location is diagnostic metadata; equal trees share verdicts across worktrees. */
+    worktree?: string;
+    tree: string;
+    command: string;
+    baseline: string;
+    environment: string;
+    envParts?: {
+        nodeRuntime: string;
+        lockfile: string;
+        capacity: RunCapacity;
+        selectedSet?: readonly string[];
+    };
+}
+export declare function computeVerificationIdentity(params: {
+    worktree: string;
+    gate: string;
+    scope?: VerificationScope;
+    command: string;
+    baseline?: Baseline;
+    selectedSet?: readonly string[];
+    capacity?: RunCapacity;
+    tree?: string;
+    lockfile?: string;
+    nodeRuntime?: string;
+}): Promise<VerificationIdentity | undefined>;
+export declare function verificationIdentityKey(id: VerificationIdentity): string;
+export declare function formatReusedDetails(originalDetails: string, id: VerificationIdentity): string;
+export interface CachedVerdict {
+    gate: string;
+    pass: boolean;
+    details: string;
+    exitCode?: number;
+    meta?: Record<string, unknown>;
+    capacity?: RunCapacity;
+}
+export declare function formatReusedRow(cached: CachedVerdict, id: VerificationIdentity): GateResult;
+export declare function reusedIdentity(id: VerificationIdentity): Record<string, unknown>;
+export declare function isInfraResult(result: GateResult | {
+    meta?: Record<string, unknown>;
+    details?: string;
+    cause?: string;
+    exitCode?: number;
+}): boolean;
+export declare function resolveStateDir(worktree: string, artifactDir?: string): string;
+export declare function resolveVerdictStoreDir(stateDir: string): string;
+export interface StoredVerdictRecord {
+    key: string;
+    identity: VerificationIdentity;
+    verdict: CachedVerdict;
+    timestamp: number;
+    sequence: number;
+}
+export declare function resetGlobalStoreSequenceForTests(): void;
+export declare class VerdictStore {
+    readonly dir: string;
+    constructor(dir: string);
+    private initSequenceFromDisk;
+    get(id?: VerificationIdentity): CachedVerdict | undefined;
+    set(id: VerificationIdentity | undefined, verdict: GateResult | CachedVerdict): boolean;
+    size(): number;
+    clear(): void;
+    evictOldest(bound?: number): number;
+}
+export declare function getVerdictStore(stateDir: string, options?: {
+    bound?: number;
+}): VerdictStore;

package/dist/gates/cache.js

@@ -0,0 +1,389 @@
+import { createHash } from "node:crypto";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { describeCapacity, resolvedCapacity, shGit } from "../run/git.js";
+import { shq } from "../adapters/types.js";
+export const DEFAULT_VERDICT_CACHE_BOUND = 128;
+let testCacheBound;
+export function setVerdictCacheBoundForTests(bound) {
+    testCacheBound = bound;
+}
+export function resetVerdictCacheBoundForTests() {
+    testCacheBound = undefined;
+    globalStoreSequence = 0;
+}
+export const LOCKFILES = [
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+];
+export function lockfileHash(worktree) {
+    const hash = createHash("sha256");
+    let found = false;
+    for (const file of LOCKFILES) {
+        const p = join(worktree, file);
+        if (existsSync(p)) {
+            found = true;
+            try {
+                hash.update(file).update("\0").update(readFileSync(p)).update("\0");
+            }
+            catch {
+                hash.update(file).update("\0unreadable\0");
+            }
+        }
+    }
+    return found ? hash.digest("hex").slice(0, 16) : "no-lockfile";
+}
+export function canonicalJson(obj) {
+    if (obj === null || typeof obj !== "object")
+        return JSON.stringify(obj);
+    if (Array.isArray(obj))
+        return "[" + obj.map(canonicalJson).join(",") + "]";
+    const keys = Object.keys(obj).sort();
+    return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalJson(obj[k])).join(",") + "}";
+}
+export function baselineIdentity(baseline) {
+    if (!baseline)
+        return "none";
+    // Measurements control execution budgets, not which failures the baseline forgives.
+    const commands = Object.fromEntries(Object.entries(baseline.commands).map(([gate, entry]) => {
+        const { durationMs: _duration, fileDurationSumMs: _sum, impliedParallelism: _parallelism, longestFile: _longest, fileDurations: _files, ceilingMs: _ceiling, ...evidence } = entry;
+        return [gate, evidence];
+    }));
+    return createHash("sha256").update(canonicalJson(commands)).digest("hex").slice(0, 16);
+}
+// The tree the command actually ran against: HEAD plus every tracked change and ordinary untracked
+// path (a fixture that flips an uncommitted package.json changes the verdict). Built through a
+// disposable index, as preserveWorktree does, so the checkout's real index is never touched.
+export async function getWorktreeTree(worktree) {
+    const scratch = mkdtempSync(join(tmpdir(), "tickmarkr-verdict-index-"));
+    const withIndex = (cmd) => `GIT_INDEX_FILE=${shq(join(scratch, "index"))} ${cmd}`;
+    try {
+        const read = await shGit(withIndex("git read-tree HEAD"), worktree);
+        if (read.code !== 0)
+            return "";
+        const add = await shGit(withIndex("git add -A -- ."), worktree);
+        if (add.code !== 0)
+            return "";
+        const tree = await shGit(withIndex("git write-tree"), worktree);
+        return tree.code === 0 ? tree.stdout.trim() : "";
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}
+export function environmentFingerprint(env) {
+    const nodeRuntime = env.nodeRuntime ?? process.version;
+    const lockfile = env.lockfile ?? (env.worktree ? lockfileHash(env.worktree) : "no-lockfile");
+    const cap = env.capacity ?? resolvedCapacity();
+    const capacity = { forkCap: cap.forkCap, cores: cap.cores };
+    const selectedSet = env.selectedSet ? [...env.selectedSet].sort() : undefined;
+    const payload = canonicalJson({
+        nodeRuntime,
+        lockfile,
+        capacity,
+        selectedSet: selectedSet ?? null,
+        scope: env.scope ?? "battery",
+    });
+    const fingerprint = createHash("sha256").update(payload).digest("hex").slice(0, 16);
+    return {
+        fingerprint,
+        parts: { nodeRuntime, lockfile, capacity, selectedSet },
+    };
+}
+export async function computeVerificationIdentity(params) {
+    const tree = params.tree ?? (await getWorktreeTree(params.worktree));
+    if (!tree)
+        return undefined;
+    const baseline = baselineIdentity(params.baseline);
+    const env = environmentFingerprint({
+        worktree: params.worktree,
+        selectedSet: params.selectedSet,
+        capacity: params.capacity,
+        lockfile: params.lockfile,
+        nodeRuntime: params.nodeRuntime,
+        scope: params.scope,
+    });
+    return {
+        gate: params.gate,
+        scope: params.scope ?? "battery",
+        worktree: realpathSync(params.worktree),
+        tree,
+        command: params.command,
+        baseline,
+        environment: env.fingerprint,
+        envParts: env.parts,
+    };
+}
+export function verificationIdentityKey(id) {
+    const cmdHash = createHash("sha256").update(id.command).digest("hex").slice(0, 16);
+    const gate = id.gate ?? "gate";
+    // Checkout location is diagnostic only. Scope separates each verifier's evidence policy.
+    const workingTree = createHash("sha256").update(id.tree).digest("hex");
+    return `${id.scope ?? "battery"}-${gate}-${workingTree}-${cmdHash}-${id.baseline}-${id.environment}`;
+}
+export function formatReusedDetails(originalDetails, id) {
+    const unadorned = originalDetails.replace(/^reused verdict \(identity: [^)]+\):\s*/, "");
+    const envDesc = id.envParts
+        ? ` [node=${id.envParts.nodeRuntime}, lockfile=${id.envParts.lockfile}, capacity=${describeCapacity(id.envParts.capacity)}${id.envParts.selectedSet ? `, selected=${id.envParts.selectedSet.join(",")}` : ""}]`
+        : "";
+    const gate = id.gate ?? "gate";
+    const prefix = `reused ${id.scope === "tip" ? "tip " : ""}verdict (identity: gate=${gate} tree=${id.tree}${id.worktree ? ` worktree=${id.worktree}` : ""} command=${id.command} baseline=${id.baseline} env=${id.environment}${envDesc})`;
+    return `${prefix}: ${unadorned}`;
+}
+// A reused GREEN names the reuse in its details. A reused RED keeps the fresh verdict's details
+// byte-for-byte: the daemon's fingerprint cap (identicalGateFailures) compares normalized details
+// across attempts, so a red whose details carried a reuse note would never read as the identical
+// failure it is and would buy a free retry — the reuse is named on the row's meta and on the
+// gate-reused-verdict note run-gates emits beside it, which the daemon journals as its own row.
+export function formatReusedRow(cached, id) {
+    const reusedDetails = formatReusedDetails(cached.details, id);
+    return {
+        gate: id.gate ?? cached.gate,
+        pass: cached.pass,
+        details: cached.pass ? reusedDetails : cached.details,
+        capacity: cached.capacity,
+        meta: {
+            ...cached.meta,
+            reused: true,
+            reusedDetails,
+            verificationIdentity: reusedIdentity(id),
+        },
+    };
+}
+export function reusedIdentity(id) {
+    return {
+        gate: id.gate ?? "gate",
+        scope: id.scope ?? "battery",
+        tree: id.tree,
+        ...(id.worktree ? { worktree: id.worktree } : {}),
+        command: id.command,
+        baseline: id.baseline,
+        environment: id.environment,
+        key: verificationIdentityKey(id),
+    };
+}
+export function isInfraResult(result) {
+    if (result.meta?.infra === true)
+        return true;
+    if (result.meta?.classification === "infra")
+        return true;
+    if (result.meta?.kind === "ceiling-kill" || result.meta?.kind === "hang")
+        return true;
+    if ("cause" in result && result.cause === "infra")
+        return true;
+    if (typeof result.details === "string") {
+        const d = result.details.toLowerCase();
+        if (d.startsWith("infra;") || d.startsWith("infra: ") || d.includes("infrastructure blocked execution")) {
+            return true;
+        }
+    }
+    return false;
+}
+export function resolveStateDir(worktree, artifactDir) {
+    if (artifactDir) {
+        const idx = artifactDir.lastIndexOf("/.tickmarkr");
+        if (idx !== -1) {
+            return artifactDir.slice(0, idx + "/.tickmarkr".length);
+        }
+    }
+    const idx = worktree.lastIndexOf("/.tickmarkr");
+    if (idx !== -1) {
+        return worktree.slice(0, idx + "/.tickmarkr".length);
+    }
+    if (existsSync(join(worktree, ".tickmarkr"))) {
+        return join(worktree, ".tickmarkr");
+    }
+    try {
+        const commonDir = execSync("git rev-parse --git-common-dir", { cwd: worktree, encoding: "utf8" }).trim();
+        const resolved = resolve(worktree, commonDir);
+        const commonRoot = realpathSync(dirname(resolved));
+        if (existsSync(join(commonRoot, ".tickmarkr"))) {
+            return join(commonRoot, ".tickmarkr");
+        }
+    }
+    catch {
+        // ignore
+    }
+    return join(worktree, ".tickmarkr");
+}
+export function resolveVerdictStoreDir(stateDir) {
+    mkdirSync(stateDir, { recursive: true });
+    const gi = join(stateDir, ".gitignore");
+    if (!existsSync(gi)) {
+        try {
+            writeFileSync(gi, "*\n");
+        }
+        catch {
+            // ignore
+        }
+    }
+    const dir = join(stateDir, "verdicts");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+let globalStoreSequence = 0;
+export function resetGlobalStoreSequenceForTests() {
+    globalStoreSequence = 0;
+}
+export class VerdictStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    initSequenceFromDisk() {
+        if (!existsSync(this.dir))
+            return;
+        try {
+            for (const f of readdirSync(this.dir)) {
+                if (f.startsWith("verdict-") && f.endsWith(".json")) {
+                    try {
+                        const raw = JSON.parse(readFileSync(join(this.dir, f), "utf8"));
+                        if (raw && typeof raw.sequence === "number" && raw.sequence > globalStoreSequence) {
+                            globalStoreSequence = raw.sequence;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    get(id) {
+        if (!id || !id.tree)
+            return undefined;
+        const key = verificationIdentityKey(id);
+        const p = join(this.dir, `verdict-${key}.json`);
+        if (existsSync(p)) {
+            try {
+                const raw = JSON.parse(readFileSync(p, "utf8"));
+                if (raw && raw.verdict)
+                    return raw.verdict;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    set(id, verdict) {
+        if (!id || !id.tree)
+            return false;
+        if (isInfraResult(verdict))
+            return false;
+        mkdirSync(this.dir, { recursive: true });
+        this.initSequenceFromDisk();
+        const key = verificationIdentityKey(id);
+        const bound = testCacheBound ?? DEFAULT_VERDICT_CACHE_BOUND;
+        const record = {
+            key,
+            identity: id,
+            verdict: {
+                gate: verdict.gate ?? id.gate ?? "gate",
+                pass: verdict.pass,
+                details: verdict.details,
+                ...("exitCode" in verdict ? { exitCode: verdict.exitCode } : {}),
+                ...(verdict.capacity ? { capacity: verdict.capacity } : {}),
+                ...(verdict.meta ? { meta: verdict.meta } : {}),
+            },
+            timestamp: Date.now(),
+            sequence: ++globalStoreSequence,
+        };
+        const finalPath = join(this.dir, `verdict-${key}.json`);
+        const tmpPath = join(this.dir, `verdict-${key}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+        writeFileSync(tmpPath, JSON.stringify(record, null, 2) + "\n");
+        try {
+            unlinkSync(finalPath);
+        }
+        catch {
+            // ignore
+        }
+        writeFileSync(finalPath, readFileSync(tmpPath));
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch {
+            // ignore
+        }
+        this.evictOldest(bound);
+        return true;
+    }
+    size() {
+        if (!existsSync(this.dir))
+            return 0;
+        return readdirSync(this.dir).filter((f) => f.startsWith("verdict-") && f.endsWith(".json")).length;
+    }
+    clear() {
+        globalStoreSequence = 0;
+        if (!existsSync(this.dir))
+            return;
+        for (const f of readdirSync(this.dir)) {
+            if (f.startsWith("verdict-")) {
+                try {
+                    unlinkSync(join(this.dir, f));
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    evictOldest(bound) {
+        const limit = bound ?? testCacheBound ?? DEFAULT_VERDICT_CACHE_BOUND;
+        const dir = this.dir;
+        if (!existsSync(dir))
+            return 0;
+        const files = readdirSync(dir).filter((f) => f.startsWith("verdict-") && f.endsWith(".json"));
+        if (files.length <= limit)
+            return 0;
+        const entries = [];
+        for (const file of files) {
+            const p = join(dir, file);
+            try {
+                const raw = JSON.parse(readFileSync(p, "utf8"));
+                entries.push({
+                    file,
+                    sequence: typeof raw.sequence === "number" ? raw.sequence : 0,
+                    timestamp: typeof raw.timestamp === "number" ? raw.timestamp : 0,
+                });
+            }
+            catch {
+                entries.push({ file, sequence: -1, timestamp: -1 });
+            }
+        }
+        entries.sort((a, b) => {
+            // Each write seeds its sequence from disk, including in a fresh process.
+            // Wall-clock corrections must not make the newest write the oldest entry.
+            if (a.sequence !== b.sequence)
+                return a.sequence - b.sequence;
+            return a.timestamp - b.timestamp;
+        });
+        let evicted = 0;
+        while (entries.length > limit) {
+            const oldest = entries.shift();
+            try {
+                unlinkSync(join(dir, oldest.file));
+                evicted++;
+            }
+            catch {
+                // ignore
+            }
+        }
+        return evicted;
+    }
+}
+export function getVerdictStore(stateDir, options) {
+    if (options?.bound !== undefined) {
+        setVerdictCacheBoundForTests(options.bound);
+    }
+    return new VerdictStore(resolveVerdictStoreDir(stateDir));
+}

package/dist/gates/review.d.ts

@@ -64,9 +64,42 @@ export declare function matchClosureId(candidate: unknown, fingerprints: Iterabl
  * all route through matchClosureId.
  */
 export declare function isReviewClosureInvalid(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly string[]): boolean;
+export type ReviewerFloorCause = "author-tier" | "task-floor" | "config" | "prior-reviewer";
+/**
+ * RF-1 (OBS-922 add.2/3): the tier a reviewer must meet is the maximum of the author's tier, the
+ * task-declared floor, a configured `review.floor` tier and, on a second round or a retry, the prior
+ * reviewer's tier. The cause names the input that reached the maximum (earlier inputs win a tie, so a
+ * floor the author's tier already satisfies is attributed to the author).
+ */
+export declare function resolveReviewerFloor(authorTier: Tier, taskFloor?: Tier, configFloor?: Tier, priorReviewerTier?: Tier): {
+    floor: Tier;
+    cause: ReviewerFloorCause;
+};
+/** A prior reviewer of THIS task: a channel key, or a journaled row's key plus the tier it was DISPATCHED at. */
+export type PriorReviewer = string | {
+    reviewer: string;
+    tier?: unknown;
+};
+/**
+ * The highest tier among the task's prior reviewers — the prior reviewer's tier for RF-1. A recorded
+ * dispatch tier is historical evidence and wins over the current pool; an unrecorded one falls back to
+ * the seat's channel; a seat neither establishes (it left the pool on resume, or the journal holds
+ * garbage) holds frontier — fail closed, never silently dropped.
+ */
+export declare function priorReviewerTier(channels: BillingChannel[], priorReviewers?: readonly PriorReviewer[]): Tier | undefined;
+/**
+ * The gate's floor: author tier, task floor, review.floor (a tier — `worker` names none) and the seats
+ * the caller names as THIS TASK's prior reviewers (earlier rounds' seats, a flaked seat). Eligibility
+ * exclusions are NOT evidence — a retry bans a flaked seat's whole adapter, and those sibling channels
+ * never reviewed — and neither is the run-scoped LRU rotation history, which names unrelated tasks' seats.
+ */
+export declare function gateReviewerFloor(task: Pick<Task, "routingHints">, cfg: TickmarkrConfig, author: Assignment, channels: BillingChannel[], priorReviewers?: readonly PriorReviewer[]): {
+    floor: Tier;
+    cause: ReviewerFloorCause;
+};
 export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[], // v1.1 failover: reviewer channels that already produced garbage for this task
 prefer?: string[], // v1.53 T2: review.prefer — reorders eligible channels, never changes eligibility
-floor?: Tier, // task-declared only; config floors govern workers and must not silently move review seats
+floor?: Tier, // task/config/prior floor from the caller; the author's own tier is ALWAYS applied here (RF-1)
 history?: string[], // run-scoped picks, oldest to newest; empty preserves the established ranking
 onSeat?: (seat: number, count: number) => void, demoted?: ReadonlySet<string>): BillingChannel | null;
 export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-started" | "truncated" | "silent";
@@ -76,4 +109,4 @@ export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-sta
  * judgement rather than a guarantee made by this renderer.
  */
 export declare function renderDeclaredWriteScope(files: ReadonlyArray<string>): string;
-export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string, reviewHistory?: string[], demotedReviewers?: ReadonlySet<string>, carriedFindings?: readonly StructuredFinding[]): Promise<GateResult>;
+export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string, reviewHistory?: string[], demotedReviewers?: ReadonlySet<string>, carriedFindings?: readonly StructuredFinding[], priorReviewers?: readonly PriorReviewer[]): Promise<GateResult>;