tickmarkr 2.6.1 → 2.6.3

package/dist/gates/test-manifest.d.ts

@@ -80,11 +80,49 @@ export declare function verifyManifestReport(opts: {
     report: TestReport | undefined;
     killedFile?: string;
     hangBudgetMs?: number;
+    /** Active elapsed time (detected suspend subtracted) versus raw wall service at the kill. */
+    hangActiveMs?: number;
+    hangWallMs?: number;
 }): ManifestVerdict;
 /** How much longer than its baseline measurement one file may legitimately run before it is a hang. */
 export declare const FILE_HANG_SLACK = 3;
 export declare const DEFAULT_FILE_HANG_BUDGET_MS = 60000;
 export declare function fileHangBudgetMs(file: string, baselineDurations?: readonly BaselineFileDuration[] | null, ceilingMs?: number, longestFile?: BaselineFileDuration | null): number;
+/**
+ * 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 declare const CLOCK_JUMP_SLACK_MS = 1000;
+export interface HostInterruption {
+    kind: "host-suspend" | "unknown";
+    /** Wall time of the previous poll and of the poll that observed the gap. */
+    from: number;
+    to: number;
+    wallMs: number;
+    monoMs: number;
+    /** The wall-over-monotonic offset of a detected suspend; 0 for an unknown gap. */
+    subtractedMs: number;
+}
+export interface HangClocks {
+    wall: () => number;
+    mono: () => number;
+}
+export declare const setHangClocksForTests: (clocks: HangClocks) => void;
+export declare const resetHangClocksForTests: () => void;
+/** A poll gap worth recording, or undefined for an on-time poll. */
+export declare function classifyPollGap(prev: {
+    wall: number;
+    mono: number;
+}, now: {
+    wall: number;
+    mono: number;
+}, pollMs: number): HostInterruption | undefined;
+export declare const runWithInterruptionSink: <T>(sink: (interruption: HostInterruption) => void, run: () => Promise<T>) => Promise<T>;
 export interface ManifestRunResult {
     evidenceReceipt: GateEvidenceReceipt;
     evidenceReceipts: GateEvidenceReceipt[];
@@ -94,6 +132,10 @@ export interface ManifestRunResult {
     report: TestReport | undefined;
     killedFile?: string;
     hangBudgetMs?: number;
+    /** A hang's active elapsed time (suspend subtracted) and its raw wall service, kept apart. */
+    hangActiveMs?: number;
+    hangWallMs?: number;
+    interruptions: HostInterruption[];
     /** The child's own pid (its process GROUP id too, since it is spawned detached) — for a caller
      * that wants to prove the group is really gone after a hang kill (`process.kill(-pid, 0)` throws). */
     pid?: number;
@@ -151,7 +193,9 @@ export declare function manifestFileCount(cmd: string, cwd: string): Promise<num
  * selection (OBS-1166: a selected screen's retry rediscovered the whole selection and refused). So the
  * retry is built from the UN-narrowed base command, its own `--` rule, the stranded files as the only
  * positional filters, and an `--exclude` of every completed file; the caller then requires discovery
- * to prove the exact retry set before launch. */
+ * to prove the exact retry set before launch. OBS-1180: Vitest matches an absolute filter against the
+ * module path it resolved through every symlink, so the filters are rooted at the canonical realpath of
+ * `cwd` — a symlinked worktree root otherwise filters to an empty discovery. */
 export declare function singleForkRetryCommand(base: string, cwd: string, stranded: readonly string[], completed: readonly string[]): string;
 /** One configured runner execution, and its own collection under the same arguments and environment.
  * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */

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) {
@@ -492,10 +543,17 @@ function strandedSingleForkFiles(files, nonce, run) {
  * selection (OBS-1166: a selected screen's retry rediscovered the whole selection and refused). So the
  * retry is built from the UN-narrowed base command, its own `--` rule, the stranded files as the only
  * positional filters, and an `--exclude` of every completed file; the caller then requires discovery
- * to prove the exact retry set before launch. */
+ * to prove the exact retry set before launch. OBS-1180: Vitest matches an absolute filter against the
+ * module path it resolved through every symlink, so the filters are rooted at the canonical realpath of
+ * `cwd` — a symlinked worktree root otherwise filters to an empty discovery. */
 export function singleForkRetryCommand(base, cwd, stranded, completed) {
+    let root = cwd;
+    try {
+        root = realpathSync(cwd);
+    }
+    catch { /* unreadable cwd — the exact rediscovery below fails closed */ }
     const excluded = completed.map(f => `--exclude=${shq(f.replace(/[\\*?[\]{}()!+@]/g, "\\$&"))}`).join(" ");
-    return `${base}${runnerInvocation(base, cwd).separator} ${stranded.map(f => shq(join(cwd, f))).join(" ")} ${excluded}`;
+    return `${base}${runnerInvocation(base, cwd).separator} ${stranded.map(f => shq(join(root, f))).join(" ")} ${excluded}`;
 }
 /** One configured runner execution, and its own collection under the same arguments and environment.
  * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */
@@ -532,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;
@@ -556,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) {
@@ -589,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/graph/schema.d.ts

@@ -4,12 +4,14 @@ export declare const GRAPH_ROUTING_MODES: readonly ["partner-led", "risk-based",
 export declare const STATUSES: readonly ["pending", "running", "gated", "failed", "done", "human"];
 export declare const GATE_NAMES: readonly ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 export declare const TIERS: readonly ["cheap", "mid", "frontier"];
+export declare const EFFORTS: readonly ["low", "medium", "high"];
 export declare const SPEC_SOURCES: readonly ["speckit", "gsd", "prd", "native"];
 export declare const ORACLES: readonly ["command", "test", "judge"];
 export type Shape = (typeof SHAPES)[number];
 export type TaskStatus = (typeof STATUSES)[number];
 export type GateName = (typeof GATE_NAMES)[number];
 export type Oracle = (typeof ORACLES)[number];
+export type Effort = (typeof EFFORTS)[number];
 export type SpecSource = (typeof SPEC_SOURCES)[number];
 export declare const AcceptanceItemSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     oracle: z.ZodLiteral<"command">;

package/dist/graph/schema.js

@@ -7,6 +7,8 @@ export const STATUSES = ["pending", "running", "gated", "failed", "done", "human
 export const GATE_NAMES = ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 const MANDATORY_GATES = ["build", "test", "lint", "evidence", "scope"];
 export const TIERS = ["cheap", "mid", "frontier"];
+// OBS-1182: launch effort — channel metadata beside tier, never part of model identity or channelKey.
+export const EFFORTS = ["low", "medium", "high"];
 export const SPEC_SOURCES = ["speckit", "gsd", "prd", "native"];
 // v1.19 acceptance oracles: command (exit code), test (named test), judge (LLM, free-text rubric).
 // A plain string is the read-old/write-new compat form — semantically a judge oracle (spec §2).

package/dist/plan/scope.js

@@ -169,7 +169,7 @@ function bindCandidate(candidate, channels) {
             `(doctor found: ${channels.map((ch) => `${ch.adapter}:${ch.model}`).join(", ") || "(nothing)"}) — ` +
             "re-run scope --preview and confirm again");
     }
-    return { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier };
+    return { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier, ...(c.effort ? { effort: c.effort } : {}) };
 }
 // Adapter-level probes establish the current installation/auth state, but shipped adapters do not
 // return per-model verdicts from probe(). Preserve cached verdicts only where that fresh snapshot is
@@ -202,7 +202,7 @@ export async function scopeIntent(intentFile, repoRoot, options) {
             driver, name: `scope-${name}-${attempts}-${adapter.id}`, label: "SCOPE",
             keep: options.cfg.visibility.keepPanes === "forever",
         } : undefined;
-        const draft = extractDraft(await runLlm(adapter, assignment.model, prompt, repoRoot, via));
+        const draft = extractDraft(await runLlm(adapter, assignment.model, prompt, repoRoot, via, undefined, assignment.effort));
         let tasks;
         try {
             tasks = validateDraft(draft);

package/dist/route/preference.d.ts

@@ -11,6 +11,16 @@ export declare const routingModelProvider: typeof modelProvider;
 export declare const modelRouteIdentity: (model: string, fallback?: string) => string;
 export declare const channelRouteIdentity: (key: string, fallback?: string) => string;
 export declare function routingEntrySeatLines(cfg: TickmarkrConfig): string[];
+export declare const observedIdentity: (health: Record<string, AuthHealth> | null | undefined, adapter: string, model: string) => string | undefined;
+export declare const observedSeat: (health: Record<string, AuthHealth> | null | undefined, adapter: string, model: string) => {
+    adapter: string;
+    model: string;
+    identity: string;
+} | {
+    adapter: string;
+    model: string;
+    identity?: undefined;
+};
 export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {
@@ -59,6 +69,14 @@ export interface DenyPreferCollision {
     detail: string;
     disallowed: Disallowed;
 }
-export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig): Disallowed | null;
-export declare function denyPreferCollisions(cfg: TickmarkrConfig, shapes?: Iterable<string>): DenyPreferCollision[];
+export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig, health?: Record<string, AuthHealth> | null): Disallowed | null;
+export declare function denyPreferCollisions(cfg: TickmarkrConfig, shapes?: Iterable<string>, health?: Record<string, AuthHealth> | null): DenyPreferCollision[];
+export interface DeadPoolEntry {
+    shape: string;
+    entry: string;
+    disallowed: Disallowed;
+    admitted: string[];
+}
+export declare function deadPoolEntries(cfg: TickmarkrConfig, shapes?: Iterable<string>, health?: Record<string, AuthHealth> | null): DeadPoolEntry[];
+export declare function deadPoolEntryLine({ shape, entry, disallowed, admitted }: DeadPoolEntry): string;
 export declare function denyPreferCollisionLine({ kind, shape, detail, disallowed }: DenyPreferCollision): string;

package/dist/route/preference.js

@@ -47,6 +47,13 @@ export function routingEntrySeatLines(cfg) {
     add("routing.deny.workers.models", cfg.routing.deny?.workers?.models, ["worker"]);
     return lines;
 }
+// OBS-1143: the probed identity doctor cached for adapter:model — the one discoverChannels routes
+// with. Absent ⇒ unknown, and the deny matcher stays conservative (alias-family match).
+export const observedIdentity = (health, adapter, model) => health?.[adapter]?.modelAuth?.[model]?.identity ?? health?.[adapter]?.modelIdentities?.[model];
+export const observedSeat = (health, adapter, model) => {
+    const identity = observedIdentity(health, adapter, model);
+    return identity ? { adapter, model, identity } : { adapter, model };
+};
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;
@@ -57,9 +64,7 @@ export function excludedChannels(cfg, adapters, health) {
         if (!health[id]?.installed || !health[id]?.authed)
             continue;
         for (const c of channelsFromConfig(id, cfg)) {
-            const identity = health[id]?.modelAuth?.[c.model]?.identity ?? health[id]?.modelIdentities?.[c.model];
-            const chan = identity ? { ...c, identity } : c;
-            const d = disallowedBy(chan, cfg.routing);
+            const d = disallowedBy(observedSeat(health, c.adapter, c.model), cfg.routing);
             if (d)
                 out.push({ key: channelKey(c), d });
         }
@@ -175,13 +180,20 @@ const disallowedFromPreferError = (msg) => {
     const m = msg.match(/prefer entry .+ is disallowed by routing\.(deny|allow) \(([^)]+)\)/);
     return m ? { by: m[1], entry: m[2] } : null;
 };
-export function preferEntryDenied(p, cfg) {
+// OBS-1143: `health` is doctor's CACHED verdict (never a probe); its identities ride the channels
+// route() reads them from, so the preflight answers exactly as the router would.
+export function preferEntryDenied(p, cfg, health) {
     if (!cfg.routing.allow && !cfg.routing.deny)
         return null;
     const probe = structuredClone(cfg);
     probe.routing.map = { ...probe.routing.map, [PREFLIGHT_SHAPE]: { prefer: [p] } };
+    const observed = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg))
+        .flatMap((c) => {
+        const identity = observedIdentity(health, c.adapter, c.model);
+        return identity ? [{ ...c, identity }] : [];
+    });
     try {
-        route(preflightTask, probe, []);
+        route(preflightTask, probe, observed);
         return null;
     }
     catch (e) {
@@ -194,7 +206,9 @@ export function preferEntryDenied(p, cfg) {
 // route — resume hands it the loaded graph's shape set, so a collision on a shape no resumed task
 // uses can no longer refuse the only crash-recovery path. Omitted ⇒ the whole routing map: doctor
 // audits the config itself, which has no graph to be scoped by.
-export function denyPreferCollisions(cfg, shapes) {
+// OBS-1143: `health` (doctor's cached verdict) supplies each alias's observed identity; omitted or
+// unrecorded ⇒ unknown, which stays conservative.
+export function denyPreferCollisions(cfg, shapes, health) {
     if (!cfg.routing.allow && !cfg.routing.deny)
         return [];
     const inGraph = shapes === undefined ? undefined : new Set(shapes);
@@ -203,7 +217,7 @@ export function denyPreferCollisions(cfg, shapes) {
         if (inGraph && !inGraph.has(shape))
             continue;
         if (entry.pin) {
-            const d = disallowedBy({ adapter: entry.pin.via, model: entry.pin.model }, cfg.routing);
+            const d = disallowedBy(observedSeat(health, entry.pin.via, entry.pin.model), cfg.routing);
             if (d) {
                 out.push({
                     kind: "pin",
@@ -214,20 +228,17 @@ export function denyPreferCollisions(cfg, shapes) {
             }
         }
         const prefer = entry.prefer ?? [];
-        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg) !== null)) {
+        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg, health) !== null)) {
             out.push({
                 kind: "prefer",
                 shape,
                 detail: prefer.join(" > "),
-                disallowed: preferEntryDenied(prefer[0], cfg),
+                disallowed: preferEntryDenied(prefer[0], cfg, health),
             });
         }
         const pool = entry.pool;
         if (pool) {
-            const denied = pool.channels.map((p) => {
-                const i = p.indexOf(":");
-                return disallowedBy({ adapter: p.slice(0, i), model: p.slice(i + 1) }, cfg.routing);
-            });
+            const denied = pool.channels.map((p) => poolEntryDisallowed(p, cfg, health));
             // only a FULLY dead pool collides — a partial deny still leaves live members to route
             if (denied.every((d) => d !== null)) {
                 out.push({ kind: "pool", shape, detail: pool.channels.join(" > "), disallowed: denied[0] });
@@ -236,6 +247,30 @@ export function denyPreferCollisions(cfg, shapes) {
     }
     return out;
 }
+const poolEntryDisallowed = (p, cfg, health) => {
+    const i = p.indexOf(":");
+    return disallowedBy(observedSeat(health, p.slice(0, i), p.slice(i + 1)), cfg.routing);
+};
+// OBS-1144: every disallowed entry a pool carries, beside the admitted remainder the router routes
+// instead — the router skips the entry; an empty remainder is the exhausted pool it refuses.
+export function deadPoolEntries(cfg, shapes, health) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return [];
+    const inGraph = shapes === undefined ? undefined : new Set(shapes);
+    return Object.entries(cfg.routing.map).flatMap(([shape, entry]) => {
+        if (!entry.pool || (inGraph && !inGraph.has(shape)))
+            return [];
+        const judged = entry.pool.channels.map((p) => ({ p, d: poolEntryDisallowed(p, cfg, health) }));
+        const admitted = judged.filter(({ d }) => d === null).map(({ p }) => p);
+        return judged.flatMap(({ p, d }) => (d ? [{ shape, entry: p, disallowed: d, admitted }] : []));
+    });
+}
+export function deadPoolEntryLine({ shape, entry, disallowed, admitted }) {
+    const verdict = admitted.length
+        ? `skipped — routes the admitted remainder ${admitted.join(" > ")}`
+        : "the pool is exhausted — no admitted entry remains, so the shape is unroutable";
+    return `routing.map.${shape}.pool entry ${entry} is disallowed by routing.${disallowed.by} (${disallowed.entry}) — ${verdict}`;
+}
 export function denyPreferCollisionLine({ kind, shape, detail, disallowed }) {
     const verb = kind === "pin" ? "is disallowed" : "fully disallowed";
     return `deny∩prefer: routing.map.${shape}.${kind} ${detail} ${verb} by routing.${disallowed.by} (${disallowed.entry}) — remove the ${disallowed.by} entry or adjust ${kind}`;

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,17 @@ 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;
 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 & {