tickmarkr 2.6.1 → 2.6.3

package/dist/route/router.js

@@ -44,6 +44,7 @@ export function marginalCostRank(c) {
 }
 const toAssignment = (c) => ({
     adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier,
+    ...(c.effort ? { effort: c.effort } : {}),
 });
 function resolvePin(pin, channels) {
     const c = channels.find((c) => c.adapter === pin.via && c.model === pin.model);
@@ -64,6 +65,24 @@ export function rankPreferredChannels(channels, prefer = [], opts = {}) {
 }
 /** Review preserves its established tier-then-cost order inside a preference band. */
 export const reviewPreferenceTieBreak = (a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || Number(a.channel === "api") - Number(b.channel === "api");
+// OBS-1185: the floor route() resolves, shared with plan's display — a task hint at or above the
+// configured (or mode-compiled) floor wins; otherwise the configured floor stands.
+export function resolvedFloor(task, cfg) {
+    const taskFloor = task.routingHints?.floor;
+    const configFloor = cfg.routing.floors[task.shape];
+    if (taskFloor && (!configFloor || TIER_RANK[taskFloor] >= TIER_RANK[configFloor]))
+        return { tier: taskFloor, source: "task" };
+    return configFloor ? { tier: configFloor, source: "config" } : undefined;
+}
+// OBS-1187: a declared map pool is the shape's closed candidate set for EVERY dispatch — demotion,
+// retry-ban failover, tier climb, recycling and resume draw inside it, never from the open fleet.
+export const taskPool = (task, cfg) => cfg.routing.map[task.shape]?.pool;
+/** Park-reason suffix naming the pool an exhausted re-dispatch stayed inside; empty when unpooled. */
+export const poolExhaustion = (task, cfg) => {
+    const pool = taskPool(task, cfg);
+    return pool ? ` — routing.map.${task.shape}.pool (${pool.mode}: ${pool.channels.join(", ")}) is exhausted` : "";
+};
+export const inTaskPool = (task, cfg, key) => taskPool(task, cfg)?.channels.includes(key) ?? true;
 function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
@@ -150,6 +169,13 @@ const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
     lints.push(`${task.id} (${task.shape}): median ${medianMin}m exceeds sla ${slaMinutes}m — learned perf term references sla ${slaMinutes}m ref`);
 };
 export function route(task, cfg, channels, profile, preferCtx, exclude, exploreCtx) {
+    // OBS-1143: deny checks below read the probed identity the offered channels carry — the identity
+    // discovery admitted them under. A seat no channel vouches for stays unknown (conservative).
+    const observed = new Map(channels.flatMap((c) => (c.identity ? [[channelKey(c), c.identity]] : [])));
+    const seat = (adapter, model) => {
+        const identity = observed.get(channelKey({ adapter, model }));
+        return identity ? { adapter, model, identity } : { adapter, model };
+    };
     channels = withoutExcluded(channels, exclude);
     const lints = [];
     const advisoryFloor = cfg.routing.floors[task.shape];
@@ -161,7 +187,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     const prefer = effectivePrefer(entry);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
-        const d = disallowedBy({ adapter: via, model }, cfg.routing);
+        const d = disallowedBy(seat(via, model), cfg.routing);
         if (d) {
             throw new RoutingError(`${task.id}: ${kind} ${via}:${model} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
         }
@@ -174,8 +200,8 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
         if (cfg.tiers[p]) {
             const expanded = channelsFromConfig(p, cfg);
-            if (expanded.length && expanded.every((c) => disallowedBy(c, cfg.routing) !== null)) {
-                const d = disallowedBy(expanded[0], cfg.routing);
+            if (expanded.length && expanded.every((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null)) {
+                const d = disallowedBy(seat(expanded[0].adapter, expanded[0].model), cfg.routing);
                 throw new RoutingError(`${task.id}: prefer entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
             }
             return;
@@ -191,9 +217,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
     };
     const taskFloor = task.routingHints?.floor;
-    const mapPinFloor = taskFloor && (!advisoryFloor || TIER_RANK[taskFloor] >= TIER_RANK[advisoryFloor])
-        ? { tier: taskFloor, source: "task" }
-        : advisoryFloor ? { tier: advisoryFloor, source: "config" } : undefined;
+    const mapPinFloor = resolvedFloor(task, cfg);
     const lintMapPinFloor = (tier, what = "pin") => {
         if (mapPinFloor && TIER_RANK[tier] < TIER_RANK[mapPinFloor.tier]) {
             lints.push(`${task.id} (${task.shape}): map ${what} routes ${tier}, below ${mapPinFloor.source} floor ${mapPinFloor.tier} — map ${what}s are supreme`);
@@ -228,21 +252,28 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     // single-channel pool) and the open floor/auto path. Exhaustion stays fail-loud (pin precedent).
     if (entry?.pool) {
         const pool = entry.pool;
-        if (prefActive) {
-            for (const p of pool.channels) {
-                const i = p.indexOf(":");
-                const d = disallowedBy({ adapter: p.slice(0, i), model: p.slice(i + 1) }, cfg.routing);
-                if (d) {
-                    throw new RoutingError(`${task.id}: pool entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or drop it from the pool`);
-                }
-            }
+        // OBS-1144: a disallowed entry is skipped, named in provenance, never fatal for the pool; only an
+        // empty admitted remainder refuses. Filtering keeps declaration order, so ordered stays ordered.
+        const skipped = [];
+        const admitted = pool.channels.filter((p) => {
+            if (!prefActive)
+                return true;
+            const i = p.indexOf(":");
+            const d = disallowedBy(seat(p.slice(0, i), p.slice(i + 1)), cfg.routing);
+            if (d)
+                skipped.push(`${p} (disallowed by routing.${d.by} (${d.entry}))`);
+            return d === null;
+        });
+        const skippedNote = skipped.length ? `; skipped ${skipped.join(", ")}` : "";
+        if (!admitted.length) {
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool is exhausted — no admitted entry remains: ${skipped.join(", ")} — remove the deny/allow entry or add an admitted channel to the pool`);
         }
         // live preserves pool declaration order — ordered mode and any-mode stable-sort ties depend on it
-        const live = pool.channels
+        const live = admitted
             .map((id) => channels.find((c) => channelKey(c) === id))
             .filter((c) => c !== undefined && (!taskFloor || TIER_RANK[c.tier] >= TIER_RANK[taskFloor]));
         if (!live.length) {
-            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}${skippedNote}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
         }
         // No learned/explore inside pools: any spreads deterministically; ordered keeps declaration order.
         const chosen = pool.mode === "ordered"
@@ -250,7 +281,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
             : rankAnyPool(live, task)[0];
         lintMapPinFloor(chosen.tier, "pool");
         maybeSlaLint(lints, task, profile, slaMinutes, chosen);
-        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map)` };
+        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map${skippedNote})` };
     }
     const baseTier = floor ?? "cheap";
     // A task floor is hard on pool and floor/auto paths; the map-pin branch above stays supreme.
@@ -268,7 +299,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         let msg = `${task.id}: no channel at tier>=${minTier}; available: ${channels.map(channelKey).join(", ") || "(none)"}`;
         if (prefActive) {
             const excluded = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg))
-                .filter((c) => disallowedBy(c, cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
+                .filter((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
                 .map(channelKey);
             if (excluded.length)
                 msg += `; ${excluded.length} channel(s) excluded by routing.allow/deny: ${excluded.join(", ")}`;
@@ -349,8 +380,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         eligible = spreadStatic(sortedStatic);
         spreadDecided = channelKey(eligible[0]) !== channelKey(sortedStatic[0]);
     }
-    const bound = taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
-        floor ? `floor ${floor} (config floors)` :
+    const resolved = resolvedFloor(task, cfg);
+    const bound = resolved?.source === "task" ? `floor ${resolved.tier} (task hint${src})` :
+        resolved ? `floor ${resolved.tier} (config floors)` :
             "tier cheap (default)";
     // name the key that actually broke the tie: prefer outranks the marginal-cost/tier keys, so if the
     // winner matched a prefer entry, prefer decided it — not "cheapest sufficient tier" (ROUTE-03, WR-01)
@@ -361,8 +393,8 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     maybeSlaLint(lints, task, profile, slaMinutes, eligible[0]);
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
-function candidatePool(current, channels, tried, tierPredicate, exclude) {
-    channels = withoutExcluded(channels, exclude);
+function candidatePool(current, task, cfg, channels, tried, tierPredicate, exclude) {
+    channels = withoutExcluded(channels, exclude).filter((c) => inTaskPool(task, cfg, channelKey(c)));
     const triedKeys = new Set(tried);
     const triedIdentities = new Set(tried.map((key) => {
         const channel = channels.find((c) => channelKey(c) === key);
@@ -391,7 +423,7 @@ export function nextChannel(current, task, cfg, channels, tried, profile, exclud
     // profile-dependent filter. NO exploration bonus here (route():110 has one; a probe on the
     // failure path would spend a real retry). Absent profile ⇒ every score is 0 ⇒ third key
     // all-ties ⇒ the stable sort preserves the exact v1.7 candidate ORDER.
-    const pool = candidatePool(current, channels, tried, (tier) => TIER_RANK[tier] >= TIER_RANK[current.tier], exclude);
+    const pool = candidatePool(current, task, cfg, channels, tried, (tier) => TIER_RANK[tier] >= TIER_RANK[current.tier], exclude);
     const candidates = rankFailoverCandidates(pool, task, cfg, profile);
     return candidates.length ? toAssignment(candidates[0]) : null;
 }
@@ -434,7 +466,7 @@ export function climbChannel(current, task, cfg, channels, tried, profile, exclu
         const pick = nextChannel(current, task, cfg, channels, tried, profile, exclude);
         return pick ? makeClimbPick(pick, false, "no higher tier") : null;
     }
-    const higherPool = candidatePool(current, channels, tried, (tier) => TIER_RANK[tier] > TIER_RANK[current.tier], exclude);
+    const higherPool = candidatePool(current, task, cfg, channels, tried, (tier) => TIER_RANK[tier] > TIER_RANK[current.tier], exclude);
     if (higherPool.length > 0) {
         const candidates = rankFailoverCandidates(higherPool, task, cfg, profile);
         return makeClimbPick(toAssignment(candidates[0]), true);

package/dist/run/consult.d.ts

@@ -1,5 +1,6 @@
-import type { WorkerAdapter } from "../adapters/types.js";
+import { type AuthHealth, type WorkerAdapter } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
+import type { Effort } from "../graph/schema.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 import type { GateResult } from "../gates/types.js";
 import { type VerdictUnparseableCause } from "../gates/verdict-cause.js";
@@ -13,6 +14,16 @@ export interface ConsultVerdict {
     adapter?: string;
     model?: string;
     vendor?: string;
+    effort?: Effort;
+    invocations?: ConsultInvocation[];
+}
+export interface ConsultInvocation {
+    adapter: string;
+    model: string;
+    vendor: string;
+    effort?: Effort;
+    outcome: "completed" | "failed";
+    reason: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -37,6 +48,7 @@ export declare function buildDossierPrompt(d: Dossier, nonce: string): string;
 export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
     keep?: boolean;
     onSlot?: (slot: Slot) => void;
+    onInvocation?: (inv: ConsultInvocation) => void;
     runId?: string;
     channels?: Array<{
         adapter: string;
@@ -44,5 +56,7 @@ export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: Work
         vendor?: string;
         channel?: "sub" | "api";
         tier?: string;
+        identity?: string;
     }>;
+    health?: Record<string, AuthHealth> | null;
 }): Promise<ConsultVerdict>;

package/dist/run/consult.js

@@ -1,11 +1,12 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAdapter } from "../adapters/registry.js";
+import { configuredEffort } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
 import { rankPreferredChannels } from "../route/role-pick.js";
-import { disallowedBy, routingModelProvider } from "../route/preference.js";
+import { disallowedBy, observedSeat, routingModelProvider } from "../route/preference.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
 import { filterLlmTranscript } from "./stall.js";
@@ -145,6 +146,9 @@ export async function consult(d, cfg, adapters, driver, cwd, runDir,
 // via SlotOpts.owned; without it the legacy gatePaneName shape survives (non-daemon callers/tests).
 // v1.54 T1: channels — the daemon's doctor-filtered live channel list; prefer-seat liveness is
 // judged against it only (never rebuilt from config, which would select installed-but-unauthed seats).
+// OBS-1182: onInvocation hears every launched seat — its identity, effort and outcome — failed seats
+// included, so a seat that never produced the verdict still reaches the journal.
+// OBS-1186: health — doctor's cached verdict, the observed identity of the pinned seat (absent ⇒ unknown, conservative).
 opts = {}) {
     const n = ++consultSeq;
     const nonce = generateVerdictNonce();
@@ -157,11 +161,11 @@ opts = {}) {
     // One seat = the WHOLE invoke-and-parse unit, both visibility branches (OBS-69 class: a headless-only
     // failover would leave the production pane path hard-failing on seat one). A null verdict retains
     // the classifier's cause when extraction failed; parsed content rejections deliberately have none.
-    const invokeSeat = async (seatAdapter, seatModel, seatIdx) => {
+    const invokeSeat = async (seatAdapter, seatModel, seatIdx, effort) => {
         const adapter = getAdapter(seatAdapter, adapters);
         let out;
         if (cfg.visibility.llm === "headless") {
-            const r = await sh(adapter.headlessCommand(promptFile, seatModel), cwd, cfg.consult.stallMinutes * 60_000);
+            const r = await sh(adapter.headlessCommand(promptFile, seatModel, effort), cwd, cfg.consult.stallMinutes * 60_000);
             out = r.stdout + r.stderr;
         }
         else {
@@ -169,7 +173,7 @@ opts = {}) {
             // but never exits, so the exit trailer after it never runs, the wait runs to the stall cap and
             // the 300-line read is a TUI frame. The headless command exits, the trailer prints, and the
             // pane is harvested through dewrap exactly like a judge or review seat.
-            const command = adapter.headlessCommand(promptFile, seatModel);
+            const command = adapter.headlessCommand(promptFile, seatModel, effort);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,
@@ -216,8 +220,9 @@ opts = {}) {
     // Rank only exact live models from the daemon's role-scoped discovery pool.
     // The explicit pin remains a caller-owned fallback, outside strict preference selection.
     const live = (opts.channels ?? []).filter((c) => typeof c.model === "string");
+    // Ranking keeps each live channel's observed identity; the pin carries its cached identity too.
     const seats = rankPreferredChannels(live.filter((c) => disallowedBy(c, cfg.routing, "consult") === null), cfg.consult.prefer);
-    seats.push({ adapter: cfg.consult.adapter, model: cfg.consult.model });
+    seats.push(observedSeat(opts.health, cfg.consult.adapter, cfg.consult.model));
     // v1.87 T2: a consult seat reads the code, so it passes through the operator's policy exactly like
     // a worker does. The filter runs AFTER the pin is pushed, so the final pinned seat is checked by
     // the same rule as every prefer entry — and disallowedBy carries the full deny grammar (adapter,
@@ -242,8 +247,12 @@ opts = {}) {
         };
     }
     for (const [i, seat] of allowedSeats.entries()) {
+        // OBS-1182: each seat launches at its own configured effort, never the worker's.
+        const effort = configuredEffort(cfg, seat);
+        const record = (outcome, reason) => opts.onInvocation?.({ ...seatIdentity(seat), ...(effort ? { effort } : {}), outcome, reason });
         try {
-            const parsed = await invokeSeat(seat.adapter, seat.model, i);
+            const parsed = await invokeSeat(seat.adapter, seat.model, i, effort);
+            record(parsed.verdict ? "completed" : "failed", parsed.verdict ? "verdict" : `verdict unparseable${parsed.cause ? ` (${parsed.cause})` : ""}`);
             if (parsed.verdict) {
                 const excludeProvider = parsed.verdict.excludeAdapter
                     ? excludedProviderFromDossier(d, parsed.verdict.excludeAdapter)
@@ -255,11 +264,13 @@ opts = {}) {
                         notes: `${parsed.verdict.notes} — excluded provider ${excludeProvider}`,
                     } : {}),
                     ...seatIdentity(seat),
+                    ...(effort ? { effort } : {}),
                 };
             }
         }
-        catch {
+        catch (e) {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
+            record("failed", `seat error: ${e instanceof Error ? e.message : String(e)}`.slice(0, 200));
         }
     }
     return {

package/dist/run/daemon.d.ts

@@ -2,12 +2,14 @@ import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
-import { type Baseline } from "../gates/baseline.js";
+import { type Baseline, type BaselineProvenance, type GateEvidenceOptions } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
 import { type RunGraph } from "../graph/schema.js";
 import { type PreserveProducer } from "./git.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export declare function closeLiveSlot(liveSlots: Set<Slot>, driver: Pick<ExecutorDriver, "close">, slot: Slot): Promise<void>;
+export declare function setContactUnreadableDeadlineMsForTests(ms: number): void;
+export declare function resetContactUnreadableDeadlineMsForTests(): void;
 /** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
 export interface DispatchObservation {
     slotId: string;
@@ -67,7 +69,34 @@ export interface RunSummary {
     approvalDisposition?: "complete" | "outstanding";
     /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
     outstandingApprovals?: string[];
+    /** OBS-1123: every baseline-recorded red a standing green carried, with the capture that recorded it */
+    forgiven?: ForgivenFingerprints[];
 }
+/** OBS-1123: one forgiveness — the fingerprints a green carried and the capture that recorded them. */
+export interface ForgivenFingerprints {
+    /** the task whose gate forgave them; absent for the integration tip */
+    taskId?: string;
+    gate: string;
+    /** absent: a legacy row that named no fingerprints */
+    fingerprints?: string[];
+    /** absent: a legacy capture or row that recorded no provenance — rendered unknown, never dated */
+    baseline?: BaselineProvenance;
+}
+/** Journal rows are untrusted input: a malformed field reads as not recorded, never as a value. */
+export declare const fingerprintsOf: (v: unknown) => string[] | undefined;
+export declare const baselineProvenanceOf: (v: unknown) => BaselineProvenance | undefined;
+/** A forgiven battery green: the structured field, or the battery's own "(forgiven)" wording on a legacy row. */
+export declare const forgivenGateRow: (data: Record<string, unknown>) => boolean;
+/**
+ * OBS-1123: the forgiveness standing at this point in the journal — each task gate's LATEST verdict
+ * where it is a forgiven green, then the latest verification cycle's forgiven tip rows. A legacy row
+ * keeps what it never recorded absent, so the reader says "unknown" instead of borrowing a date.
+ */
+export declare function forgivenFingerprints(events: readonly JournalEvent[]): ForgivenFingerprints[];
+/** The capture a forgiveness rests on, or an explicit unknown — never a time read off another clock. */
+export declare function formatBaselineProvenance(p: BaselineProvenance | undefined): string;
+export declare function formatFingerprints(fingerprints: string[] | undefined): string;
+export declare function formatForgiven(f: ForgivenFingerprints): string;
 export declare function pendingDaemonApprovalActions(events: JournalEvent[]): Map<string, import("./journal.js").PendingApprovalAction>;
 /**
  * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
@@ -131,6 +160,9 @@ export declare const resetApprovalWindowForTests: () => void;
 /** Test seam — shrink the capacity backoff without minute-long sleeps. */
 export declare function setCapacityBackoffMsForTests(ms: number): void;
 export declare function resetCapacityBackoffMsForTests(): void;
+/** Test seam — shrink the bootstrap backoff. */
+export declare function setBootstrapBackoffMsForTests(ms: number): void;
+export declare function resetBootstrapBackoffMsForTests(): void;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -154,8 +186,11 @@ export interface StartupFailureEvidence {
 /** One seat, one startup prefix. Once execution or its input box is seen, later panes are ineligible. */
 export declare class StartupFailureDetector {
     private readonly adapter;
+    private readonly pattern;
+    private readonly wholePrefix;
     private closed;
-    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">);
+    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">, pattern?: RegExp, // OBS-1169: or known bootstrap text
+    wholePrefix?: boolean);
     sample(output: string, launchedAt: number | undefined): StartupFailureEvidence | undefined;
 }
 /** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */
@@ -209,6 +244,7 @@ export declare function verifyIntegrationTipCached(intWt: string, commands: Reco
     lastMergedTask?: string;
     baseline?: Baseline;
     signal?: AbortSignal;
+    evidence?: GateEvidenceOptions;
 }): Promise<boolean>;
 type SuitePidProbe = (pid: number) => number | undefined;
 /** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership