tickmarkr 2.6.2 → 2.6.3

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";
@@ -60,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". */
@@ -92,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[];