tickmarkr 2.6.1 → 2.6.3

package/dist/gates/review.js

@@ -6,12 +6,12 @@ import { filesGlob } from "../graph/files-glob.js";
 import { renderAcceptanceItem, TIERS } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
-import { carryReviewFindings, observedReviewFingerprints, reviewFingerprintMatches, structuredFindings, UNIDENTIFIED } from "../run/journal.js";
+import { carryReviewFindings, isDeferredFinding, observedReviewFingerprints, reviewFingerprintMatches, structuredFindings, UNIDENTIFIED } from "../run/journal.js";
 import { redactSecrets } from "../run/redact.js";
 import { rankPreferredChannels, reviewPreferenceTieBreak } from "../route/role-pick.js";
 import { modelProvider } from "../route/preference.js";
 import { resolveStateDir } from "./cache.js";
-import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, parseAnchoredComments, runLlmDetailed, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, dewrapPaneVerdict, extractVerdictJson, generateVerdictNonce, parseAnchoredComments, runLlmDetailed, SeatLaunchError, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
 import { captureDiffCapFor, measureArtifactDiff, reviewableLogicDiff, } from "./artifact-manifest.js";
 export { isProtectedEvidence, PROTECTED_EVIDENCE_PREFIXES, REGENERABLE_CAPTURE_PATHS, setAsideReceiptPath, setAsideRegenerableCaptures, } from "./artifact-manifest.js";
@@ -164,6 +164,12 @@ export function checkTaskDiffCaps(gate, measured, logicCap, prefix = "") {
         },
     };
 }
+// C-12: a reviewer is excluded for garbage only on the typed malformed-verdict flag. A material finding whose
+// prose mentions the word "unparseable" is a delivered verdict; matching the prose dropped T7's only reviewer.
+export function isGarbageReview(result) {
+    return result.gate === "review" && !result.pass && result.meta?.unparseable === true
+        && typeof result.meta?.reviewer === "string";
+}
 export function isDiffCapPark(result) {
     return result.pass === false
         && result.meta?.parkKind === "diff-cap"
@@ -373,6 +379,50 @@ ${fingerprints}
 \`\`\`
 ${priorMaterials.map((finding, i) => `${i + 1}. ${finding.note}`).join("\n\n")}`;
 }
+/**
+ * OBS-1052(2): a seat that lost the top of a long brief, or believed it had already filed its review,
+ * answered in prose — and prose is no verdict. So the requirement, naming THIS call's nonce with a
+ * valid example, is both the first and the last instruction of the brief. It is best-effort wording:
+ * the parser stays the authority, and nothing here reads approval out of prose.
+ */
+export function reviewResponseExample(nonce) {
+    return JSON.stringify({
+        nonce, approve: false, resolved: [], reraised: [],
+        findings: [{ note: "path/to/file.ts:42 — the defect, in one line", severity: "material", defer: false, rationale: "" }],
+        comments: [],
+    });
+}
+export function reviewResponseRequirement(nonce) {
+    return `## Response requirement
+Your reply must end with exactly ONE JSON object whose "nonce" is "${nonce}" — this brief's nonce, never one from an earlier brief. A valid example (a rejection; replace every value with your own verdict):
+${reviewResponseExample(nonce)}
+This holds even if you already filed or posted a review of this task elsewhere (an earlier session or brief, a PR comment): that review is not on record here, so restate it now as this JSON with nonce "${nonce}". Prose saying a review was filed or approved is recorded as no verdict; approval is never inferred from it.`;
+}
+// The example parses by design, so an echo of the brief (a CLI printing its prompt, a pane showing it)
+// would otherwise read as the seat's own verdict — or as its participation when it wrote only prose.
+// Removed verbatim or hard-wrapped (renderer whitespace and chrome between any two characters) before
+// the verdict is extracted or its absence classified; the saved raw bytes keep it as evidence.
+function withoutExampleEcho(raw, nonce) {
+    const chars = [...reviewResponseExample(nonce).replace(/\s+/g, "")];
+    return raw.replace(new RegExp(chars.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\s│|]*"), "g"), "");
+}
+/**
+ * OBS-1195: the parent an anchored comment names in its own optional `finding` field — a 1-based
+ * index into this verdict's findings, or a carried prior's id. A deferred entry or a resolved prior
+ * settles the anchor; any other valid parent binds it open; anything else leaves it unbound.
+ */
+function anchorParent(binding, findings, priors, resolved) {
+    if (typeof binding === "number") {
+        const entry = Array.isArray(findings) && Number.isInteger(binding) && binding >= 1 ? findings[binding - 1] : undefined;
+        if (!entry || typeof entry !== "object" || typeof entry.note !== "string")
+            return {};
+        return entry.defer === true ? { settled: "deferred" } : { entry: entry.note };
+    }
+    const prior = matchClosureId(binding, priors);
+    if (prior === undefined)
+        return {};
+    return resolved.includes(prior) ? { settled: "resolved", parent: prior } : { parent: prior };
+}
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers, 
 // OBS-196: run dir for raw-output persistence on an unparseable verdict; absent (older callers,
 // direct tests) skips persistence and changes nothing else.
@@ -482,7 +532,10 @@ carriedAuthors = [], operatorContext) {
     const suiteBudget = ownTestFiles.length
         ? `You may run at most the task's own test files explicitly named in files[]; these are the only suites you may run: ${ownTestFiles.map((file) => `\`${file}\``).join(", ")}.`
         : "No suite may be run: files[] names no explicit test file owned by this task.";
+    const responseRequirement = reviewResponseRequirement(nonce);
     const prompt = `TICKMARKR-REVIEW
+${responseRequirement}
+
 You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
 Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
 
@@ -520,13 +573,23 @@ block the merge) or "minor" (style, naming, or preference that should not block)
 block approval. For a minor concern you have decided not to block on, set "defer": true and give a
 one-line "rationale" — it is recorded in the review, never dropped.
 A fix you prescribe that would break suites outside the task's declared write scope (files[]) is a scope finding, never a material one.
+Each material finding names the class of defect it belongs to and binds that class to the goal clause or
+acceptance criterion it violates (or to the regression this diff introduces), states its input → consequence,
+and marks its evidence executed (you ran the reproducer), static (you traced it by reading) or blocked (it
+could not run here). Blocked evidence never turns a finding into a pass, and a worker's own case table or
+enumeration never resolves a finding: judge the diff itself.
 
 Respond with ONLY this JSON:
-{"nonce": "${nonce}", "approve": true|false, "resolved": [], "reraised": [], "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback"}]}
+{"nonce": "${nonce}", "approve": true|false, "resolved": [], "reraised": [], "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback", "finding": 1}]}
 For every prior material, put its fingerprint in exactly one of resolved (verified fixed) or reraised
 (still a blocking defect). Use only the listed fingerprints; never omit one or put it in both lists.
 Approve iff no material finding remains and every prior material is resolved.
 The top-level comments array is optional. Use it only for actionable line-anchored feedback.
+A comment's optional "finding" names its parent: the 1-based index of its entry in findings, or a prior
+fingerprint copied from above. A comment anchored to a deferred entry or a resolved prior does not block;
+a comment naming no parent stays open.
+
+${responseRequirement}
 `;
     // Filenames are journaled (daemon.ts lifts meta.rawPath/briefPath onto the gate-result row), so they
     // must be reproducible from the same inputs — the verdict nonce is cryptographically random and would
@@ -558,18 +621,33 @@ The top-level comments array is optional. Use it only for actionable line-anchor
             savedBrief = undefined;
         }
     }
-    const llm = await runLlmDetailed(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
-        driver: via.driver,
-        keep: via.keep,
-        onSlot: via.onSlot,
-        name: via.nameFor("review", reviewer.adapter),
-        label: via.labelFor("review"),
-    } : undefined, 
-    // frontier reviewers routinely need >5min on a configured-cap-sized diff, and `claude -p` buffers all
-    // output until completion — runLlm's 300s default killed reviews mid-flight, returning empty
-    // stdout that read as "unparseable" and escalated to re-implementation of green code
-    // (run-20260709-104447 P87-09). The configured ceiling defaults to that measured 15 minutes.
-    cfg.review.timeoutMs);
+    const provider = modelProvider(reviewer.model, reviewer.vendor);
+    let llm;
+    try {
+        llm = await runLlmDetailed(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
+            driver: via.driver,
+            keep: via.keep,
+            onSlot: via.onSlot,
+            name: via.nameFor("review", reviewer.adapter),
+            label: via.labelFor("review"),
+        } : undefined, 
+        // frontier reviewers routinely need >5min on a configured-cap-sized diff, and `claude -p` buffers all
+        // output until completion — runLlm's 300s default killed reviews mid-flight, returning empty
+        // stdout that read as "unparseable" and escalated to re-implementation of green code
+        // (run-20260709-104447 P87-09). The configured ceiling defaults to that measured 15 minutes.
+        cfg.review.timeoutMs, reviewer.effort);
+    }
+    catch (error) {
+        if (!(error instanceof SeatLaunchError))
+            throw error;
+        // OBS-1168(b): the seat never launched, so there is no verdict and nothing about the WORK. A typed
+        // no-verdict re-routes to another seat in run-gates; an exhausted pool is an infra park.
+        return { gate: "review", pass: false,
+            details: `review dispatch failed — ${error.message} (reviewer ${reviewer.adapter}:${reviewer.model}; vendor: ${reviewer.vendor}; provider: ${provider}; cause: seat-launch-failed) — failing closed`,
+            meta: { ...policyMeta, ...rotationMeta, ...floorMeta, reviewer: channelKey(reviewer), reviewerTier: reviewer.tier,
+                vendor: reviewer.vendor, provider, noVerdict: true, classification: "infra", infra: true,
+                cause: "seat-launch-failed", ...(savedBrief ? { briefPath: savedBrief } : {}) } };
+    }
     const raw = llm.output;
     let saved;
     if (artifactDir) {
@@ -581,8 +659,11 @@ The top-level comments array is optional. Use it only for actionable line-anchor
             saved = undefined; // persistence is evidence, not a gate input — never fail the gate on it
         }
     }
-    const provider = modelProvider(reviewer.model, reviewer.vendor);
-    const v = extractVerdictJson(raw, nonce);
+    // A pane's own dewrap stops at the first parseable nonce-bound object; once the example's echo is gone
+    // a genuinely wrapped verdict behind it is reconstructed here, exactly as llm.ts would have.
+    const echoFree = withoutExampleEcho(raw, nonce);
+    const seat = via ? dewrapPaneVerdict(echoFree, nonce) : echoFree;
+    const v = extractVerdictJson(seat, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     const priorIds = priorMaterials;
     const closureInvalid = isReviewClosureInvalid(v, priorIds);
@@ -596,7 +677,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
             : llm.launchNeverStarted ? "launch-never-started"
                 : llm.silentAtBeat ? "silent"
                     : llm.timedOut ? (bytes > 0 ? "truncated" : "silent")
-                        : classifyVerdictCause(raw, nonce, "approve", llm);
+                        : classifyVerdictCause(seat, nonce, "approve", llm);
         const failure = cause === "malformed-verdict"
             ? "review output unparseable"
             : cause === "closure-mismatch"
@@ -617,6 +698,8 @@ The top-level comments array is optional. Use it only for actionable line-anchor
                 ...(cause === "malformed-verdict" ? { unparseable: true } : { noVerdict: true, classification: "infra", infra: true }),
                 cause,
                 ...(closureMismatch ? { resolved: v?.resolved, reraised: v?.reraised, carriedFingerprints: priorIds.flatMap(observedReviewFingerprints) } : {}),
+                // OBS-1196: a whole verdict that breaks the closure protocol was DELIVERED; only undelivered bytes are re-asked.
+                ...(closureInvalid ? { closureInvalid: true } : {}),
                 bytes, seatAuthoredBytes: bytes,
                 ...(saved ? { rawPath: saved } : {}),
                 ...(savedBrief ? { briefPath: savedBrief } : {}),
@@ -633,25 +716,24 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         if (decided.pass)
             decided.headline = "requested changes";
         decided.pass = false;
-        // A reviewer may also restate a re-raised material in findings. Preserve the original
-        // prose once so an unchanged defect keeps the same failure brief across repair rounds.
-        for (const finding of reraised) {
-            const line = `- [material] ${finding.note}`;
-            if (!decided.lines.includes(line))
-                decided.lines.push(line);
-        }
     }
-    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (vendor: ${reviewer.vendor}; provider: ${provider}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
-    const details = appendAnchoredReview(prose, v);
+    // OBS-1195: an anchor leaves the blocking set only through an explicit, unambiguous parent
+    // disposition: its own `finding` names a deferred entry of this verdict or a prior it resolved.
+    // Path coincidence binds nothing; an unbound or ambiguous anchor stays open exactly as before.
+    const comments = parseAnchoredComments(v);
+    const rawComments = (comments.length ? v.comments : []);
+    const resolvedIds = (v.resolved ?? []).map((id) => matchClosureId(id, priorIds));
+    const anchors = comments.map((comment, i) => ({ ...comment, ...anchorParent(rawComments[i]?.finding, v.findings, priorIds, resolvedIds) }));
+    const openAnchors = { comments: anchors.filter((a) => !a.settled) };
+    const settledAnchors = anchors.flatMap((a, i) => a.settled
+        ? [{ path: a.path, line: a.line, body: a.body, disposition: a.settled, finding: rawComments[i].finding }] : []);
     // Only the verdict's anchors may supply missing evidence, and only when unambiguous.
     // Reuse the journal's path normalization without changing legacy details-only parsing.
-    const anchoredPaths = new Set(parseAnchoredComments(v).map((comment) => {
-        const anchor = structuredFindings("review", `- ${comment.path}:${comment.line} — anchor`)
-            .find((finding) => finding.class === "review:anchored");
-        return anchor?.path ?? comment.path;
-    }));
+    const anchorRow = (comment) => structuredFindings("review", `- ${comment.path}:${comment.line} — ${comment.body}`)
+        .find((finding) => finding.class === "review:anchored");
+    const anchoredPaths = new Set(comments.map((comment) => anchorRow({ ...comment, body: "anchor" })?.path ?? comment.path));
     const anchoredPath = anchoredPaths.size === 1 ? [...anchoredPaths][0] : undefined;
-    const ownDetails = appendAnchoredReview(ownLines.join("\n"), v);
+    const ownDetails = appendAnchoredReview(ownLines.join("\n"), openAnchors);
     const currentRows = (ownDetails.trim() ? structuredFindings("review", ownDetails) : [])
         .map((finding) => finding.path === UNIDENTIFIED && anchoredPath
         ? { ...finding, path: anchoredPath, fingerprint: `${finding.class}|${anchoredPath}|${finding.symbol}` }
@@ -672,7 +754,50 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const unambiguousRows = linkedRows.map((finding) => finding.reraisedFrom
         && linkedRows.filter((row) => row.reraisedFrom === finding.reraisedFrom).length > 1
         ? { ...finding, reraisedFrom: undefined } : finding);
-    const carriedRows = carryReviewFindings(reraised, unambiguousRows);
+    // OBS-1195: a deferred entry echoing a prior's id names that prior as the concern it defers. The
+    // link rides the row for the journal's anchor fold only; a deferral never re-seats a material chain.
+    // A prior any material row restates — even ambiguously, its link cleared above — is claimed, not
+    // deferred: the deferral gets no link, so its bound anchors stay open (fail closed).
+    const claimed = new Set(linkedRows.map((row) => row.reraisedFrom).filter((id) => id !== undefined));
+    const rows = unambiguousRows.map((finding) => {
+        if (!isDeferredFinding(finding))
+            return finding;
+        const entry = v.findings?.find((entry) => entry && typeof entry === "object" && entry.note === finding.note);
+        const id = matchClosureId(entry?.reraised, reraised);
+        return id && !claimed.has(id) ? { ...finding, reraisedFrom: id } : finding;
+    });
+    // OBS-1195: current prose is rendered once. A prior's original wording is echoed only when no
+    // current finding positively binds it; a bound chain keeps that spelling as lineage instead.
+    for (const finding of reraised) {
+        const line = `- [material] ${finding.note}`;
+        const bound = unambiguousRows.some((row) => row.reraisedFrom === finding.fingerprint);
+        if (!bound && !decided.lines.includes(line))
+            decided.lines.push(line);
+    }
+    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (vendor: ${reviewer.vendor}; provider: ${provider}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
+    const details = appendAnchoredReview(prose, openAnchors);
+    // OBS-1195: a prior's `reraisedFrom` is the link an EARLIER verdict drew. Carried forward unrestated,
+    // it would read as this verdict's own material claim on that parent and block the anchor fold from
+    // honouring an explicit deferral of it. Lineage lives in observedFingerprints; drop the stale link.
+    const carried = carryReviewFindings(reraised.map(({ reraisedFrom: _stale, ...prior }) => prior), rows);
+    // An open anchor bound to a current entry names that entry's carried chain, only when unique.
+    const parentOf = (anchor) => {
+        if (anchor.entry === undefined)
+            return anchor.parent;
+        const owners = carried.filter((f) => f.class !== "review:anchored" && f.note === anchor.entry);
+        return owners.length === 1 ? owners[0].fingerprint : undefined;
+    };
+    const carriedRows = carried.map((finding) => {
+        if (finding.class !== "review:anchored")
+            return finding;
+        // Every comment spelling this row must name the same parent, else the anchor stays unbound.
+        const parents = new Set(anchors.filter((a) => {
+            const row = a.settled ? undefined : anchorRow(a);
+            return row?.path === finding.path && row.note === finding.note;
+        }).map(parentOf));
+        const [parent] = parents;
+        return parents.size === 1 && parent ? { ...finding, boundTo: parent } : finding;
+    });
     return {
         gate: "review",
         pass: decided.pass,
@@ -687,6 +812,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
                 reraisedMatches: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
             } : {}),
             ...(!decided.pass ? { findings: carriedRows } : {}),
+            ...(settledAnchors.length ? { settledAnchors } : {}),
             ...(saved ? { rawPath: saved } : {}),
             ...(savedBrief ? { briefPath: savedBrief } : {}),
         },

package/dist/gates/run-gates.d.ts

@@ -1,5 +1,5 @@
 import type { CommandReceiptAttribution } from "../run/protocol.js";
-import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
+import { type Assignment, type AuthHealth, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
 import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
 import { type Baseline, type GateEvidenceOptions } from "./baseline.js";
@@ -17,7 +17,8 @@ export declare function resetLoadProviderForTests(): void;
 /**
  * One gate's own measurement, taken WHERE THE GATE RUNS. `durationMs` sums that gate's execution
  * intervals and nothing between them, so the composite `test` gate (a selected screen, then other
- * gates, then the full suite) reports the two suites' cost rather than the span containing them —
+ * gates, then the full suite) reports the two suites' cost rather than the span containing them
+ * (split across the two rows when the screen is published before semantic gates, OBS-1176) —
  * and no consumer has to re-derive a duration by subtracting journal timestamps, which measures the
  * queue as well as the work. Load is sampled at each interval's endpoints and every second within it;
  * start preserves the scheduling input while max and mean retain sustained interior saturation.
@@ -59,18 +60,23 @@ export interface GateContext {
     baseline: Baseline;
     channels: BillingChannel[];
     judgeChannels?: BillingChannel[];
+    /** OBS-1186: doctor's cached verdict — the observed identity of the configured judge seat. Absent ⇒ unknown (conservative deny). */
+    health?: Record<string, AuthHealth> | null;
     adapters: WorkerAdapter[];
     cfg: TickmarkrConfig;
     via?: GateVia;
     carriedFindings?: readonly StructuredFinding[];
     /** Approval reason bound to this attempt; guidance, never criterion or closure authority. */
     operatorContext?: string;
+    /** OBS-1151: this task's earlier parsed judgments, newest first (the journal's, so they survive resume). */
+    priorJudgments?: readonly PriorJudgment[];
     excludeReviewers?: string[];
     demotedReviewers?: Set<string>;
     reviewNoVerdicts?: Map<string, string[]>;
     recheck?: boolean;
-    /** Explicit worker funding requires fresh red measurements, never a gate waiver. */
-    cachedRedBypass?: "operator-rerun";
+    /** Explicit worker funding requires fresh red measurements, never a gate waiver. OBS-1106: so does
+     * a retry that landed nothing on a timeout-class red — its one fresh re-observation. */
+    cachedRedBypass?: "operator-rerun" | "timeout-fresh";
     carriedAuthors?: readonly string[];
     /** The attempt whose worker last wrote the gated checkout; a dirty-tree refusal stamps it on the
      * preserve commit and its row. Absent (standalone verify, gate-only restores) preserves as "unknown". */
@@ -91,6 +97,52 @@ export interface GateContext {
  * a command that already has `--` takes them directly. Every path is quoted — config flows into a shell.
  */
 export declare function testCommandForFiles(testCmd: string, files: string[]): string;
+/** OBS-635: a screen costing at least this share of the full suite runs the full suite instead. */
+export declare const SCREEN_PROMOTION_RATIO = 0.75;
+/**
+ * The screen's share of the full suite's cost, from the per-file durations the harness measured at
+ * baseline capture — never a worker's timing. Undefined (unknown) unless every selected file has a
+ * measured duration and the measured total is positive; unknown keeps the conservative screen path.
+ */
+export declare function screenCostRatio(baseline: Baseline, selected: readonly string[]): number | undefined;
+/** A retry base no runner invocation parses. evaluateManifestedTest builds its stranded single-fork
+ * retry from the base it is handed, and one it cannot parse throws before any spawn — so this base
+ * disables that inner recovery: a worker-RPC-stranded re-observation comes back infra (the caller
+ * parks it as ambiguous) instead of launching a second execution. */
+export declare const REOBSERVATION_RETRY_BASE = "tickmarkr-reobservation-refuses-stranded-retry";
+/** OBS-1106 residual: ONE isolated re-observation of a timeout-shaped red's attributed failing files on
+ * the same checkout, narrowed exactly as a screen is. Never cached and never a verdict: the caller
+ * keeps the original red and reads this only to decide whether that red is chargeable. Exactly one
+ * execution — the bounded infra/host-starved retries and the stranded single-fork recovery are all
+ * refused, so a diagnostic never buys more. */
+export declare function reobserveTestFiles(worktree: string, testCmd: string, baseline: Baseline, files: string[], artifactDir?: string): Promise<GateResult>;
+/** OBS-1151: one parsed judgment as the journal keeps it — the judged commit, the seat, and per criterion
+ * its subject key, ruling and cited paths. Never a verdict to reuse: only a subject to compare against. */
+export interface PriorJudgment {
+    commit: string;
+    judge?: string;
+    criteria: ReadonlyArray<{
+        id: string;
+        key: string;
+        met: boolean;
+        paths: readonly string[];
+    }>;
+}
+/** OBS-1151: a criterion's comparable subject — its canonical text, the task's declared bounds and the
+ * operator context. The cited files' blobs are compared separately, over the union of both citations. */
+export declare function judgmentSubjectKey(task: Pick<Task, "files" | "outOfScope">, criterion: string, operatorContext?: string): string;
+export interface JudgeContradiction {
+    id: string;
+    met: boolean;
+    priorMet: boolean;
+    priorCommit: string;
+    paths: string[];
+}
+/** OBS-1151: the criteria whose fresh ruling reverses the newest prior ruling on the same subject key whose
+ * cited paths hold the identical blob at both commits (older comparable priors are still found behind a
+ * newer prior on different blobs). A citation-less side or an
+ * unreadable blob is unknown, never identical — that criterion's fresh ruling is simply fresh. */
+export declare function judgeContradictions(worktree: string, head: string, fresh: PriorJudgment["criteria"], priors: readonly PriorJudgment[]): Promise<JudgeContradiction[]>;
 export declare function runGates(task: Task, ctx: GateContext): Promise<{
     results: GateResult[];
     commits: string[];