tickmarkr 2.6.2 → 2.6.4

package/dist/gates/test-manifest.js

@@ -1,7 +1,9 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { performance } from "node:perf_hooks";
 import { TEST_REPORTER_SOURCE } from "./test-reporter.js";
 import { shq } from "../adapters/types.js";
 import { beginGateEvidence, redactGateOutput } from "./baseline.js";
@@ -175,13 +177,16 @@ export function readTestReport(path) {
  * module killed for a per-file hang never reaches its report.
  */
 export function verifyManifestReport(opts) {
-    const { manifest, nonce, exitCode, report, killedFile, hangBudgetMs } = opts;
+    const { manifest, nonce, exitCode, report, killedFile, hangBudgetMs, hangActiveMs, hangWallMs } = opts;
     if (killedFile !== undefined) {
+        const service = hangActiveMs !== undefined && hangWallMs !== undefined
+            ? ` (${Math.round(hangActiveMs)}ms active of ${Math.round(hangWallMs)}ms wall)` : "";
         return {
             kind: "infra",
             pass: false,
-            details: `infra hang: "${killedFile}" started and did not complete within its ${hangBudgetMs}ms budget — killed, its process group is gone`,
-            meta: { classification: "infra", infra: true, kind: "hang", file: killedFile, hangBudgetMs },
+            details: `infra hang: "${killedFile}" started and did not complete within its ${hangBudgetMs}ms budget${service} — killed, its process group is gone`,
+            meta: { classification: "infra", infra: true, kind: "hang", file: killedFile, hangBudgetMs,
+                ...(hangActiveMs !== undefined ? { activeMs: hangActiveMs, wallMs: hangWallMs } : {}) },
         };
     }
     if (!report) {
@@ -334,6 +339,36 @@ export function fileHangBudgetMs(file, baselineDurations, ceilingMs = DEFAULT_FI
     const known = timings.find((d) => d.file === file)?.durationMs;
     return Math.min(ceiling, known === undefined ? FILE_HANG_SLACK * longest : Math.max(FILE_HANG_SLACK * known, longest));
 }
+/**
+ * OBS-953 (+add): a per-file hang budget counted in raw wall time charged a lid-close to the file that
+ * was running. Each poll compares how far the wall clock and the monotonic clock advanced since the
+ * last one. Wall advancing more than monotonic by over CLOCK_JUMP_SLACK_MS is a DETECTED discontinuity
+ * (`host-suspend`): its offset is subtracted from the active elapsed time of every file started before
+ * it ended. A poll that arrives overdue while both clocks advanced together is recorded as `unknown`
+ * and subtracts nothing — an ambiguous gap never excuses an active hang. Whether the host really slept
+ * is not provable from these clocks (a manually set clock jumps the same way); only the offset is.
+ */
+export const CLOCK_JUMP_SLACK_MS = 1_000;
+const systemClocks = { wall: () => Date.now(), mono: () => performance.now() };
+let hangClocks = systemClocks;
+export const setHangClocksForTests = (clocks) => { hangClocks = clocks; };
+export const resetHangClocksForTests = () => { hangClocks = systemClocks; };
+/** A poll gap worth recording, or undefined for an on-time poll. */
+export function classifyPollGap(prev, now, pollMs) {
+    const wallMs = now.wall - prev.wall;
+    const monoMs = now.mono - prev.mono;
+    const gap = { from: prev.wall, to: now.wall, wallMs, monoMs };
+    if (wallMs - monoMs > CLOCK_JUMP_SLACK_MS)
+        return { kind: "host-suspend", ...gap, subtractedMs: wallMs - monoMs };
+    if (monoMs > pollMs + CLOCK_JUMP_SLACK_MS)
+        return { kind: "unknown", ...gap, subtractedMs: 0 };
+    return undefined;
+}
+/** The detected suspend a file started at `startedAt` sat through. */
+const suspendedSince = (interruptions, startedAt) => interruptions.reduce((sum, i) => sum + Math.min(i.subtractedMs, Math.max(0, i.to - Math.max(i.from, startedAt))), 0);
+// The daemon journals each interruption where it ran (task gate, tip verify); no sink, no journal row.
+const interruptionSink = new AsyncLocalStorage();
+export const runWithInterruptionSink = (sink, run) => interruptionSink.run(sink, run);
 /** Supervise the configured command and poll the runner's atomic lifecycle snapshots. Every
  * timeout kills the detached process group, including descendants holding the output pipes. */
 export function runManifestedTest(cmd, cwd, opts) {
@@ -345,20 +380,35 @@ export function runManifestedTest(cmd, cwd, opts) {
     let pid;
     let killedFile;
     let hangBudgetMs;
+    let hangActiveMs;
+    let hangWallMs;
     let poll;
+    const interruptions = [];
+    const sink = interruptionSink.getStore();
+    let last = { wall: hangClocks.wall(), mono: hangClocks.mono() };
     const checkHang = (atCeiling = false) => {
+        const at = { wall: hangClocks.wall(), mono: hangClocks.mono() };
+        const gap = classifyPollGap(last, at, pollMs);
+        last = at;
+        if (gap) {
+            interruptions.push(gap);
+            sink?.(gap);
+        }
         const report = readTestReport(opts.reportPath);
         if (!report || report.nonce !== opts.nonce)
             return;
-        const now = Date.now();
         for (const file of opts.manifest) {
             const startedAt = report.started[file];
             if (startedAt === undefined || file in report.completed)
                 continue;
             const budget = fileHangBudgetMs(file, opts.baselineDurations, overallCeilingMs, opts.longestFile);
-            if (now - startedAt >= budget || (atCeiling && budget === overallCeilingMs)) {
+            const wallMs = at.wall - startedAt;
+            const activeMs = wallMs - suspendedSince(interruptions, startedAt);
+            if (activeMs >= budget || (atCeiling && budget === overallCeilingMs)) {
                 killedFile = file;
                 hangBudgetMs = budget;
+                hangActiveMs = activeMs;
+                hangWallMs = wallMs;
                 if (!atCeiling)
                     controller.abort();
                 return;
@@ -372,6 +422,7 @@ export function runManifestedTest(cmd, cwd, opts) {
             pid = childPid;
             // Neither the per-file clocks nor the command ceiling includes lease queue time.
             clearInterval(poll);
+            last = { wall: hangClocks.wall(), mono: hangClocks.mono() };
             poll = setInterval(checkHang, pollMs);
         },
     }).then((result) => {
@@ -380,7 +431,7 @@ export function runManifestedTest(cmd, cwd, opts) {
             evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt],
             exitCode: result.signalExit ? undefined : result.code,
             stdout: result.stdout, stderr: result.stderr,
-            report: readTestReport(opts.reportPath), killedFile, hangBudgetMs, pid,
+            report: readTestReport(opts.reportPath), killedFile, hangBudgetMs, hangActiveMs, hangWallMs, interruptions, pid,
         };
     }).catch((error) => {
         if (error instanceof Error) {
@@ -539,8 +590,10 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
             pollMs: 20,
         });
         let verdict = verifyManifestReport({ manifest: files, nonce, exitCode: invoked.exitCode,
-            report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs });
+            report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs,
+            hangActiveMs: invoked.hangActiveMs, hangWallMs: invoked.hangWallMs });
         evidenceReceipts.push(...invoked.evidenceReceipts);
+        const interruptions = [...invoked.interruptions];
         const stranded = strandedSingleForkFiles(files, nonce, invoked);
         if (stranded) {
             const first = invoked.report;
@@ -563,8 +616,10 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
                 longestFile: opts.longestFile, overallCeilingMs: opts.overallCeilingMs ?? DEFAULT_FILE_HANG_BUDGET_MS, pollMs: 20,
             });
             evidenceReceipts.push(...invoked.evidenceReceipts);
+            interruptions.push(...invoked.interruptions);
             verdict = verifyManifestReport({ manifest: stranded, nonce, exitCode: invoked.exitCode,
-                report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs });
+                report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs,
+                hangActiveMs: invoked.hangActiveMs, hangWallMs: invoked.hangWallMs });
             // An all-skipped retry may contribute lifecycle accounting, but only the combined manifest
             // can establish executed success. Never rewrite either invocation's persisted certificate.
             if (verdict.pass || verdict.meta.noExecutedModules) {
@@ -596,11 +651,15 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
                 + [...runnerErrors,
                     stdoutTail.toString(), stderrTail.toString()].filter(Boolean).map(text => `\n${text}`).join("")
             : "";
+        // The interruption is reported beside the verdict, never folded into it or into raw wall service.
+        const interrupted = interruptions.length
+            ? `\nhost interruptions: ${interruptions.map(i => `${i.kind} ${Math.round(i.wallMs)}ms wall / ${Math.round(i.monoMs)}ms monotonic, ${Math.round(i.subtractedMs)}ms subtracted`).join("; ")}`
+            : "";
         return { evidenceReceipt, evidenceReceipts, pass: verdict.pass, kind: verdict.kind,
-            details: verdict.details + diagnostics,
+            details: verdict.details + interrupted + diagnostics,
             classification: verdict.meta.classification,
             meta: { ...verdict.meta, nonce, manifest: files, manifestPath, listingCommand: invocation.listing, verification,
-                ...(recovery ? { recovery, retryable: false } : {}),
+                ...(recovery ? { recovery, retryable: false } : {}), ...(interruptions.length ? { interruptions } : {}),
                 spawnedCommand, processExit: invoked.exitCode, pid: invoked.pid, stdoutPath, stderrPath },
             exitCode: invoked.exitCode ?? -1, reportPath };
     }

package/dist/route/router.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel } from "../adapters/types.js";
-import { type TickmarkrConfig } from "../config/config.js";
+import { type TickmarkrConfig, type Tier } from "../config/config.js";
 import type { Task } from "../graph/schema.js";
 import { type RoutingProfile } from "./profile.js";
 export type LadderStep = "retry" | "escalate" | "consult" | "human";
@@ -44,6 +44,28 @@ export declare function rankPreferredChannels<C extends ChannelSeat>(channels: r
 }): C[];
 /** Review preserves its established tier-then-cost order inside a preference band. */
 export declare const reviewPreferenceTieBreak: (a: BillingChannel, b: BillingChannel) => number;
+export declare function resolvedFloor(task: Task, cfg: TickmarkrConfig): {
+    tier: Tier;
+    source: "task" | "config";
+} | undefined;
+export declare const taskPool: (task: Task, cfg: TickmarkrConfig) => {
+    mode: "any" | "ordered";
+    channels: string[];
+} | undefined;
+/** Park-reason suffix naming the pool an exhausted re-dispatch stayed inside; empty when unpooled. */
+export declare const poolExhaustion: (task: Task, cfg: TickmarkrConfig) => string;
+export declare const inTaskPool: (task: Task, cfg: TickmarkrConfig, key: string) => boolean;
+/**
+ * F (D-718): the one exclusion meaning route(), nextChannel() and climbChannel() share — explicit
+ * exclusions, demotions, tried and escalation history, and climb skips — exported so resume can test a
+ * restored assignment the same way. An excluded raw channel key always excludes itself (the fallback).
+ * The exclusion extends to another offered channel only when BOTH offered channels carry a probed
+ * identity and the two are equal. A missing identity is neutral: it never matches and never blocks.
+ * Residual, by ruling: an unprobed alias of an excluded model stays eligible by its raw key — this is
+ * not complete alias exclusion; reopen on an executed re-dispatch of a tried model through an alias
+ * with no probed identity. The daemon's nextChannel-null exhaustion fallback is not this policy's.
+ */
+export declare function channelExclusion(offered: readonly BillingChannel[], excluded: Iterable<string>): (seat: ChannelSeat) => boolean;
 export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>, exploreCtx?: ExploreContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;
 export type ClimbPick = Assignment & {

package/dist/route/router.js

@@ -1,6 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
-import { channelRouteIdentity, disallowedBy, modelRouteIdentity, routingModelProvider } from "./preference.js";
+import { disallowedBy, routingModelProvider } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
 export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
 // OBS-89 (v1.60): the TICKMARKR_QUALITY variable is RETIRED — nothing in src reads it anymore and
@@ -65,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"];
@@ -106,11 +124,33 @@ function spreadFrontierTies(sorted, task, prefer, tied) {
     }
     return out;
 }
+/**
+ * F (D-718): the one exclusion meaning route(), nextChannel() and climbChannel() share — explicit
+ * exclusions, demotions, tried and escalation history, and climb skips — exported so resume can test a
+ * restored assignment the same way. An excluded raw channel key always excludes itself (the fallback).
+ * The exclusion extends to another offered channel only when BOTH offered channels carry a probed
+ * identity and the two are equal. A missing identity is neutral: it never matches and never blocks.
+ * Residual, by ruling: an unprobed alias of an excluded model stays eligible by its raw key — this is
+ * not complete alias exclusion; reopen on an executed re-dispatch of a tried model through an alias
+ * with no probed identity. The daemon's nextChannel-null exhaustion fallback is not this policy's.
+ */
+export function channelExclusion(offered, excluded) {
+    const keys = new Set(excluded);
+    const identityOf = new Map(offered.flatMap((c) => (c.identity ? [[channelKey(c), c.identity]] : [])));
+    const identities = new Set([...keys].flatMap((k) => identityOf.get(k) ?? []));
+    return (seat) => {
+        const key = channelKey(seat);
+        const identity = identityOf.get(key);
+        return keys.has(key) || (identity !== undefined && identities.has(identity));
+    };
+}
 function withoutExcluded(channels, exclude) {
     if (!exclude?.size)
         return channels;
     // OBS-57: in-run demotion after consecutive no-trailer windows — route around poisoned channels for the rest of the run.
-    return channels.filter((c) => !exclude.has(channelKey(c)));
+    // D-718: a demoted channel's probed-identical alias is routed around too; an unprobed one is not.
+    const excluded = channelExclusion(channels, exclude);
+    return channels.filter((c) => !excluded(c));
 }
 // Pools spread providers before tier, independently within each marginal-cost run. Stable
 // cost sorting preserves declaration order when forming groups; gateways share the served
@@ -199,9 +239,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`);
@@ -364,8 +402,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)
@@ -376,20 +415,19 @@ 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) {
+    // D-718: tried/escalated/demoted keys share channelExclusion's meaning, resolved against every offered
+    // channel; the provider-outage rule below still reads the raw-key remainder exactly as before.
+    const excluded = channelExclusion(channels, [...(exclude ?? []), ...tried]);
+    channels = channels.filter((c) => !exclude?.has(channelKey(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);
-        return channel ? modelRouteIdentity(channel.model, channel.vendor) : channelRouteIdentity(key);
-    }));
     // excludeAdapter is expanded by the daemon into every channel key of the failed adapter. Once that
     // complete set is present, the outage follows the current served provider across gateway aliases.
     const currentAdapterExcluded = channels.some((c) => c.adapter === current.adapter)
         && channels.filter((c) => c.adapter === current.adapter).every((c) => triedKeys.has(channelKey(c)));
     const currentChannel = channels.find((c) => c.adapter === current.adapter && c.model === current.model);
     const excludedProvider = currentAdapterExcluded ? routingModelProvider(current.model, currentChannel?.vendor) : undefined;
-    return channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
+    return channels.filter((c) => !excluded(c)
         && (!excludedProvider || routingModelProvider(c.model, c.vendor) !== excludedProvider)
         && tierPredicate(c.tier));
 }
@@ -406,7 +444,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;
 }
@@ -449,7 +487,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,4 +1,4 @@
-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";
@@ -56,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

@@ -6,7 +6,7 @@ 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";
@@ -148,6 +148,7 @@ export async function consult(d, cfg, adapters, driver, cwd, runDir,
 // 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();
@@ -219,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,

package/dist/run/daemon.d.ts

@@ -2,7 +2,7 @@ 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, type BaselineProvenance } 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";
@@ -244,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