tickmarkr 1.70.0 → 1.71.0

package/dist/adapters/kimi.js

@@ -1,9 +1,10 @@
-import { spawnSync } from "node:child_process";
 import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
+import { runInteractiveSeed } from "../run/interactive-seed.js";
+import { sh } from "../run/git.js";
 import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
 // KIMI-03 → v1.58 T5: the "no harness-readable counter" block (research F-6, 2026-07-17) is
 // LIFTED for collectUsage — kimi 0.27.0 writes a wire journal per agent at
@@ -117,40 +118,18 @@ export function confirmKimiSeedBanner(banner, assignedModel) {
     }
     return { ok: true, sessionId: kimiBannerSessionId(banner) };
 }
-// Shared launch-then-seed surface (T6) + banner confirm helpers (T7). One definition so the
-// adapter property and runKimiInteractiveSeed cannot drift.
+// Shared launch-then-seed surface (T6) + banner confirm (T7/T2). One definition so the adapter
+// property and the daemon's generic runInteractiveSeed path cannot drift.
 const KIMI_SEED = {
     launch: (model) => `kimi -y -m ${shq(kimiAlias(model))}`,
     readinessMatch: "Send /help for help information.",
     seedLine: (promptFile) => `Read ${promptFile} and do exactly what it says.`,
+    confirmBanner: confirmKimiSeedBanner,
 };
-// v1.69 T7: kimi-local launch-then-seed that confirms the banner model and captures the session id
-// from the SAME pane text already present for the readiness match. No extra probe, no extra
-// dispatch — one read of the launch banner, then seed or fail closed.
+// v1.69 T7 / v1.71 T2: thin wrapper over the daemon's generic dispatch path for kimi-only tests.
 export async function runKimiInteractiveSeed(opts) {
-    await opts.driver.run(opts.slot, KIMI_SEED.launch(opts.assignment.model));
-    const ready = await opts.driver.waitOutput(opts.slot, KIMI_SEED.readinessMatch, opts.taskTimeoutMinutes * 60_000);
-    // Banner text already on the pane for the readiness match — the only text model/session use.
-    const banner = await opts.driver.read(opts.slot, 1000);
-    if (!ready) {
-        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${KIMI_SEED.readinessMatch}` };
-    }
-    const confirm = confirmKimiSeedBanner(banner, opts.assignment.model);
-    if (!confirm.ok) {
-        return { output: banner, seedFailed: true, seedError: confirm.error };
-    }
-    const seedText = KIMI_SEED.seedLine(opts.promptFile);
-    await opts.driver.run(opts.slot, seedText);
-    let output = "";
-    for (let attempt = 0; attempt < 5; attempt++) {
-        await new Promise((r) => setTimeout(r, 200));
-        output = await opts.driver.read(opts.slot, 1000);
-        const bottom = output.trimEnd().split("\n").pop() ?? "";
-        if (!bottom.includes(seedText)) {
-            return { output, seedFailed: false, sessionId: confirm.sessionId };
-        }
-    }
-    return { output, seedFailed: true, seedError: "seed line never left the input box", sessionId: confirm.sessionId };
+    const r = await runInteractiveSeed({ ...opts, adapter: kimi });
+    return { output: r.output, seedFailed: r.seedFailed, seedError: r.seedError, sessionId: r.sessionId };
 }
 export const kimi = {
     id: "kimi",
@@ -183,10 +162,8 @@ export const kimi = {
     // null → the daemon's print fallback (types.ts:101) keeps kimi workers visible without a TUI.
     interactiveCommand: () => null,
     // v1.69 T6/T7: launch the real TUI, wait for the cold-start readiness marker, then submit the
-    // prompt as one user turn. Banner model/session confirmation for seed mode lives in
-    // runKimiInteractiveSeed / confirmKimiSeedBanner (same pane text as the readiness match — no
-    // extra probe). Live-probed 2026-07-22 (kimi 0.28.1): `kimi -y` opens the TUI with yolo active
-    // and prints the model/session lines plus "Send /help for help information." before the input box.
+    // prompt as one user turn. Banner model/session confirmation runs on the daemon's generic
+    // runInteractiveSeed path via confirmBanner on KIMI_SEED (not a separate dispatch helper).
     interactiveSeed: KIMI_SEED,
     // v1.53 T3 resume — live-probed 2026-07-18: `-p` + `-S <id>` compose cleanly (no OBS-67-class
     // flag rejection) and the resumed session carries prior conversation state. `-S <id>` is the
@@ -298,7 +275,7 @@ export const kimi = {
         }
     },
     listModels: async () => {
-        const r = spawnSync("kimi", ["provider", "list", "--json"], { encoding: "utf8", timeout: 15000 });
-        return r.error || r.status !== 0 ? [] : parseKimiModels(r.stdout || "");
+        const r = await sh("kimi provider list --json", process.cwd(), 15000);
+        return r.code !== 0 ? [] : parseKimiModels(r.stdout || "");
     },
 };

package/dist/adapters/registry.d.ts

@@ -3,6 +3,28 @@ import { type RoutingProfile } from "../route/profile.js";
 import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
 export declare const CANDIDATE_CLI_CATALOG: readonly ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
 export declare const REGISTERED_ADAPTER_BINARIES: readonly ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+export declare function resolveShellBinary(bin: string, cwd?: string): {
+    resolved?: string;
+    all: string[];
+};
+export declare function probeVersionShell(bin: string, cwd?: string): AuthHealth & {
+    binaryPaths?: string[];
+};
+export declare function binaryShadowWarnings(adapters: WorkerAdapter[], health: Record<string, AuthHealth>, cwd?: string, resolve?: (bin: string, cwd: string) => {
+    resolved?: string;
+    all: string[];
+}): string[];
+export declare function invalidConfiguredModels(cfg: TickmarkrConfig, adapterId: string, h: AuthHealth | undefined): string[];
+export declare function modelAliasExclusions(cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
+    key: string;
+    adapter: string;
+    model: string;
+}[];
+export declare function modelAliasLine(excluded: {
+    key: string;
+    adapter: string;
+    model: string;
+}[]): string;
 export type CandidateCliDetection = {
     binary: string;
     version: string | undefined;
@@ -19,7 +41,9 @@ export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
 }): WorkerAdapter[];
 export declare function getAdapter(id: string, adapters: WorkerAdapter[]): WorkerAdapter;
-export declare function probeAll(adapters: WorkerAdapter[]): Promise<Record<string, AuthHealth>>;
+export declare function probeAll(adapters: WorkerAdapter[], opts?: {
+    cwd?: string;
+}): Promise<Record<string, AuthHealth>>;
 export type ProbeModelStatus = "ok" | "timeout" | "failed";
 export type ProbeModelProgress = (adapter: string, model: string, status: ProbeModelStatus, durationMs: number) => void;
 export interface AutoPreferDoc {

package/dist/adapters/registry.js

@@ -18,11 +18,89 @@ import { grok } from "./grok.js";
 import { kimi } from "./kimi.js";
 import { opencode } from "./opencode.js";
 import { pi } from "./pi.js";
-import { channelKey, modelAuthed, QUOTA_RE } from "./types.js";
+import { sealHerdrEnv } from "../drivers/subprocess.js";
+import { channelKey, modelAuthed, QUOTA_RE, shq } from "./types.js";
 // Agent-CLI binary names with no tickmarkr adapter — doctor sweeps these advisory-only (v1.48 T1).
 export const CANDIDATE_CLI_CATALOG = ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
 // Binaries probed by registered adapters — kept beside the catalog so a test can forbid overlap.
 export const REGISTERED_ADAPTER_BINARIES = ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+// OBS-117: worker panes run commands through `bash -lc` (SubprocessDriver + sh()), not bare spawnSync(bin).
+// Doctor must resolve adapter binaries the same way so a shadow install on PATH cannot disagree with dispatch.
+function shellSpawnSync(cmd, cwd, timeoutMs = 10000) {
+    const r = spawnSync("bash", ["-lc", cmd], {
+        encoding: "utf8",
+        cwd,
+        timeout: timeoutMs,
+        env: sealHerdrEnv(process.env),
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return { code: r.status ?? 1, stdout: (r.stdout || "").trim(), stderr: (r.stderr || "").trim() };
+}
+export function resolveShellBinary(bin, cwd = process.cwd()) {
+    const r = shellSpawnSync(`type -a ${shq(bin)} 2>/dev/null | sed -n 's/^.* is \\(.*\\)$/\\1/p'`, cwd);
+    const all = r.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    return { resolved: all[0], all };
+}
+export function probeVersionShell(bin, cwd = process.cwd()) {
+    const { resolved, all } = resolveShellBinary(bin, cwd);
+    if (!resolved)
+        return { installed: false, authed: false, models: [] };
+    const r = shellSpawnSync(`${shq(resolved)} --version`, cwd);
+    if (r.code !== 0)
+        return { installed: false, authed: false, models: [], binaryPaths: all };
+    return {
+        installed: true,
+        authed: true,
+        version: (r.stdout || r.stderr).trim().split("\n")[0],
+        models: [],
+        note: "auth assumed; verified at dispatch (failover on auth/quota errors)",
+        binaryPaths: all,
+    };
+}
+export function binaryShadowWarnings(adapters, health, cwd = process.cwd(), resolve) {
+    const resolveFn = resolve ?? resolveShellBinary;
+    const out = [];
+    for (const a of adapters) {
+        const bin = a.hardcodedFlags?.binary;
+        if (!bin || !health[a.id]?.installed)
+            continue;
+        const { resolved, all } = resolveFn(bin, cwd);
+        if (all.length <= 1)
+            continue;
+        out.push(`binary shadow: ${a.id} resolves to ${resolved ?? bin} but ${all.length} installs on PATH — ${all.join(", ")}`);
+    }
+    return out;
+}
+function modelListValidated(h) {
+    return !!h?.modelsDetectedAt && Array.isArray(h.models);
+}
+export function invalidConfiguredModels(cfg, adapterId, h) {
+    if (!modelListValidated(h))
+        return [];
+    const listed = new Set(h.models);
+    const configured = Object.keys(cfg.tiers[adapterId]?.models ?? {});
+    // Fail open until the CLI list intersects at least one configured model — proves the list is authoritative
+    // for this adapter's tier namespace (MODEL-04: unrelated detected ids must not invalidate routing).
+    if (!configured.some((m) => listed.has(m)))
+        return [];
+    return configured.filter((m) => !listed.has(m));
+}
+export function modelAliasExclusions(cfg, adapters, health) {
+    const out = [];
+    for (const a of adapters) {
+        const h = health[a.id];
+        if (!h?.installed || !h?.authed)
+            continue;
+        for (const model of invalidConfiguredModels(cfg, a.id, h)) {
+            out.push({ key: channelKey({ adapter: a.id, model }), adapter: a.id, model });
+        }
+    }
+    return out;
+}
+export function modelAliasLine(excluded) {
+    const parts = excluded.map(({ key, adapter }) => `${key} (not in ${adapter}'s reported model list)`);
+    return `model alias: ${excluded.length} channel(s) invalid — ${parts.join(", ")}`;
+}
 function candidateOnPath(bin, pathEnv) {
     const r = spawnSync("which", [bin], { encoding: "utf8", env: { ...process.env, PATH: pathEnv } });
     return r.status === 0 && r.stdout.trim().length > 0;
@@ -105,9 +183,20 @@ export function getAdapter(id, adapters) {
         throw new Error(`unknown adapter ${id} (have: ${adapters.map((a) => a.id).join(", ")})`);
     return a;
 }
-export async function probeAll(adapters) {
+export async function probeAll(adapters, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
     const out = {};
-    await Promise.all(adapters.map(async (a) => { out[a.id] = await a.probe(); }));
+    await Promise.all(adapters.map(async (a) => {
+        let h = await a.probe();
+        const bin = a.hardcodedFlags?.binary;
+        if (bin) {
+            const shell = probeVersionShell(bin, cwd);
+            h = { ...h, installed: shell.installed, version: shell.version ?? h.version };
+            if (!shell.installed)
+                h = { ...h, installed: false, authed: false };
+        }
+        out[a.id] = h;
+    }));
     return out;
 }
 const MODEL_PROBE_PROMPT = "Reply with exactly OK and nothing else.";
@@ -317,10 +406,12 @@ export function discoverChannels(cfg, adapters, health) {
         .flatMap((a) => {
         const h = health[a.id];
         const s = h?.servable;
+        const invalid = new Set(invalidConfiguredModels(cfg, a.id, h));
         // T2 (2026-07-13): only a model doctor marked authed (modelAuth[model].authed===true) advertises a
         // channel — routing an unknown or 403 into dispatch is fail-closed. Operators with pre-v1.21 doctor.json
         // can opt into the prior unknown-is-routable behavior with routing.allowUnverifiedModels.
-        return a.channels(cfg).filter((c) => modelAuthed(h, c.model, cfg.routing.allowUnverifiedModels) && (!s || s.includes(c.model)));
+        // OBS-117: configured aliases absent from the adapter CLI's own model list are not dispatchable.
+        return a.channels(cfg).filter((c) => !invalid.has(c.model) && modelAuthed(h, c.model, cfg.routing.allowUnverifiedModels) && (!s || s.includes(c.model)));
     });
     if (!cfg.routing.allow && !cfg.routing.deny)
         return base;

package/dist/adapters/types.d.ts

@@ -48,10 +48,18 @@ export interface WorkerResult {
     deviations: string[];
     raw: string;
 }
+export type SeedBannerConfirmResult = {
+    ok: true;
+    sessionId?: string;
+} | {
+    ok: false;
+    error: string;
+};
 export interface InteractiveSeed {
     launch(model: string): string;
     readinessMatch: string;
     seedLine(promptFile: string): string;
+    confirmBanner?(banner: string, assignedModel: string): SeedBannerConfirmResult;
 }
 export interface ContextUsage {
     tokens: number;

package/dist/cli/commands/doctor.js

@@ -1,12 +1,12 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, detectCandidateClis, flagDriftWarnings, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { BANNER, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
-import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
+import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
@@ -19,7 +19,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
     console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
     const probeProgressTTY = process.stderr.isTTY === true;
-    const health = await probeAll(adapters);
+    const health = await probeAll(adapters, { cwd });
     // MODEL-02: detect models where the adapter exposes a list surface, BEFORE writing doctor.json (write once, below).
     // Fail OPEN — the inverse of gates' fail-closed: detection is advisory, so a broken list surface NEVER fails doctor.
     for (const a of adapters) {
@@ -81,6 +81,11 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         rows.push(attentionRow(exclusionLine(excluded)));
+    rows.push(...denyPreferCollisions(cfg).map((c) => attentionRow(denyPreferCollisionLine(c))));
+    const aliasExcluded = modelAliasExclusions(cfg, adapters, health);
+    if (aliasExcluded.length)
+        rows.push(attentionRow(modelAliasLine(aliasExcluded)));
+    rows.push(...binaryShadowWarnings(adapters, health, cwd).map(attentionRow));
     // HYG-07(a): doctor just probed fresh (probeAll above), so servability attribution is current by construction.
     const servable = servableExclusions(cfg, adapters, health);
     if (servable.length)

package/dist/cli/commands/resume.js

@@ -2,6 +2,7 @@ import { loadConfig } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { formatJournalNarration } from "../../run/journal.js";
+import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
@@ -12,7 +13,12 @@ export async function resume(argv, cwd = process.cwd()) {
     // Fable F2) — the daemon refuses a mismatched/unbound journal unless this is set, then journals a
     // graph-rehash event naming both hashes. Strip the flag before runId resolution so a bare id still wins.
     const graphChanged = argv.includes("--graph-changed");
-    const s = await runDaemon(cwd, { runId, resume: true, graphChanged, driver: pickDriver(loadConfig(cwd)), narrate: (event) => console.log(formatJournalNarration(event)) });
+    const cfg = loadConfig(cwd);
+    const collisions = denyPreferCollisions(cfg);
+    if (collisions.length) {
+        throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
+    }
+    const s = await runDaemon(cwd, { runId, resume: true, graphChanged, driver: pickDriver(cfg), narrate: (event) => console.log(formatJournalNarration(event)) });
     const out = `resumed ${s.runId} — ${formatSummary(s)}`;
     return { out, code: summaryGreen(s) ? 0 : 2 };
 }

package/dist/cli/commands/status.js

@@ -2,7 +2,7 @@ import { BANNER, GLYPHS, dim, fail, legend, ok, rule, statusRow, title, warn } f
 import { blockedTasks, graphDefinitionHash, loadGraph } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
-import { Journal, engagementComparable } from "../../run/journal.js";
+import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
 // ponytail: fixed 2s refresh; promote to config.visibility.* only when an operator asks.
 const REFRESH_MS = 2000;
 const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states not comparable; run `tickmarkr run` to execute";
@@ -178,15 +178,23 @@ const renderFrame = (cwd) => {
     const divider = unicode ? " · " : " / ";
     const width = process.stdout.columns ?? 120;
     const done = effective.tasks.filter((t) => t.status === "done").length;
+    const ended = comparable && runHasEnded(events);
     const cells = g.tasks.map((t) => {
         const st = replayed?.get(t.id) ?? t.status;
+        const failureKind = comparable ? recordedTaskFailureKind(events, t.id) : undefined;
+        const terminal = st === "failed" || st === "human";
+        // Unknown legacy task-failed events stay red. Typed availability noise is warn-tier only while
+        // the run is live; verified quality parks and every unresolved task in an ended run are red.
+        const redTier = terminal && (ended
+            || (failureKind !== undefined && isQualityFailureParkKind(failureKind))
+            || (st === "failed" && failureKind === undefined));
         const isStarved = starved.has(t.id);
         const phrase = isStarved ? undefined : activity.cells.get(t.id);
         const label = isStarved ? " starved" : phrase ? ` ${phrase}` : "";
         const channel = assignments.get(t.id) ?? "-";
         const ctx = contexts.get(t.id);
         const assignCol = ctx !== undefined ? `${channel}${divider}ctx ${ctx}` : channel;
-        return { t, st, label, assignCol, isStarved, phrase, channel, ctx, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
+        return { t, st, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
     });
     if (!unicode) {
         // machine/CI surface — layout unchanged (pipes, greps, and the golden pins depend on it)
@@ -207,7 +215,7 @@ const renderFrame = (cwd) => {
     // rows (pad plain text FIRST, colorize after: ANSI has zero display width and would corrupt
     // padEnd math)
     const dot = dim(" · ");
-    const anyFailed = cells.some((c) => c.st === "failed");
+    const anyFailed = cells.some((c) => c.redTier);
     const gaugeCells = 10;
     const fill = g.tasks.length ? Math.round((done / g.tasks.length) * gaugeCells) : 0;
     const gauge = (fill ? (anyFailed ? fail : ok)("█".repeat(fill)) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
@@ -232,17 +240,20 @@ const renderFrame = (cwd) => {
     // id, goal at full width, and only SHORT status words. Line 2 carries the machinery, dim and
     // aligned under the goal: gate chain, live activity phrase (or channel), ctx. Long channel names
     // and activity phrases live on line 2 only, so they can never squeeze the goal or wrap line 1.
-    const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
+    const taskVerdict = (c) => c.st === "done" ? "pass" : c.redTier ? "fail" : c.st === "failed" || c.st === "human" ? "warn" : "neutral";
+    const statusWord = (c) => c.redTier ? "failed" : c.st === "failed" ? "warn" : String(c.st);
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
     // plain-text status suffixes for width math only — starved / failed gate names / approval hint
     const suffixPlain = (c) => (c.isStarved ? " · starved" : "") + failedSuffix(c.states) + humanGateSuffix(c.t, c.st, c.states);
-    const stW = Math.max(...cells.map((c) => String(c.st).length + suffixPlain(c).length));
+    const stW = Math.max(...cells.map((c) => statusWord(c).length + suffixPlain(c).length));
     const avail = Math.max(8, width - (5 + idW) - 2 - stW);
     const goals = cells.map((c) => shortGoal(c.t.goal, avail));
     const goalW = Math.max(8, ...goals.map((s) => s.length));
     const indent = " ".repeat(idW + 5); // line 2 starts under the goal column
-    const rows = cells.map(({ t, st, states, isStarved, phrase, channel, ctx }, i) => {
-        const stWord = st === "done" ? ok(String(st)) : st === "failed" ? fail(String(st)) : st === "human" ? warn(String(st)) : String(st);
+    const rows = cells.map((c, i) => {
+        const { t, st, failureKind, redTier, states, isStarved, phrase, channel, ctx } = c;
+        const word = statusWord(c);
+        const stWord = st === "done" ? ok(word) : redTier ? fail(word) : st === "failed" || st === "human" ? warn(word) : word;
         // a fail names its gate in words right here — the one moment gate identity is needed on a row
         const f = failedGates(states);
         const human = humanGateSuffix(t, st, states);
@@ -250,10 +261,11 @@ const renderFrame = (cwd) => {
             (isStarved ? dot + fail("starved") : "") +
             (f.length ? dot + fail(f.join(", ")) : "") +
             (human ? dot + warn("awaiting approval") : "");
-        const line1 = `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goals[i].padEnd(goalW)}  ${statusCell}`)}`;
+        const line1 = `  ${statusRow(taskVerdict(c), `${t.id.padEnd(idW)} ${goals[i].padEnd(goalW)}  ${statusCell}`)}`;
         // activity already names its channel for in-flight attempts — never repeat it
         const detail = [
             ...(phrase ? [phrase, ...(phrase.includes(channel) || channel === "-" ? [] : [channel])] : [channel]),
+            ...(failureKind && !phrase?.includes(failureKind) ? [failureKind] : []),
             ...(ctx !== undefined ? [`ctx ${ctx}`] : []),
         ].join(" · ");
         return [line1, `${indent}${gateChain(states, true)}  ${dim(detail)}`, ""];

package/dist/drivers/herdr.d.ts

@@ -11,11 +11,14 @@ export declare class HerdrDriver implements ExecutorDriver {
     interactive: boolean;
     private groups;
     private groupSerial;
+    private deliverySerial;
     private ws;
     private callerPane;
     private watches;
     constructor(bin?: string, workersPerTab?: number);
     private serial;
+    private deliveryQueue;
+    private deliveryMatches;
     static available(): boolean;
     private herdr;
     private namedPaneId;
@@ -29,6 +32,8 @@ export declare class HerdrDriver implements ExecutorDriver {
     private glyphFor;
     private joinGroup;
     run(slot: Slot, cmd: string): Promise<void>;
+    private deliver;
+    private deliveryReadMatches;
     private waitOk;
     waitOutput(slot: Slot, pattern: string, timeoutMs: number, opts?: {
         regex?: boolean;

package/dist/drivers/herdr.js

@@ -25,6 +25,8 @@ export class HerdrDriver {
     // grouped slot()/close() mutate shared group state across awaits — serialize them so two
     // concurrent first members can never both create the group tab (mergeSerial idiom, daemon.ts)
     groupSerial = Promise.resolve();
+    // OBS-119: concurrent deliveries contend on herdr's send path — one chain per driver (mergeSerial idiom)
+    deliverySerial = Promise.resolve();
     // VIS-10: the run's workspace id, captured once at construction (the daemon inherits it from the
     // operator's env before the driver is built). Required at slot() time, never in the constructor —
     // pickDriver and its unit test construct HerdrDriver without env, so slot() is the trust gate.
@@ -40,6 +42,18 @@ export class HerdrDriver {
         this.groupSerial = p.catch(() => undefined);
         return p;
     }
+    deliveryQueue(fn) {
+        const p = this.deliverySerial.then(fn, fn);
+        this.deliverySerial = p.catch(() => undefined);
+        return p;
+    }
+    // ponytail: narrow panes hard-wrap the input line — collapse whitespace before comparing.
+    deliveryMatches(transcript, cmd) {
+        const norm = (s) => s.replace(/\s+/g, "");
+        const hay = norm(transcript);
+        const needle = norm(cmd);
+        return needle.length > 0 && hay.includes(needle);
+    }
     static available() {
         return process.env.HERDR_ENV === "1";
     }
@@ -286,6 +300,9 @@ export class HerdrDriver {
     // cleared (C-u), and retyped, bounded; persistent corruption fails closed WITH the captured
     // transcript — the dispatch-time pincer the ledger asks for, not post-hoc `git:` archaeology.
     async run(slot, cmd) {
+        return this.deliveryQueue(() => this.deliver(slot, cmd));
+    }
+    async deliver(slot, cmd) {
         const pane = await this.paneId(slot);
         let transcript = "";
         for (let attempt = 0; attempt < DELIVERY_ATTEMPTS; attempt++) {
@@ -300,9 +317,7 @@ export class HerdrDriver {
             if (typed.code !== 0)
                 throw new Error(`herdr pane send-text failed: ${typed.stderr || typed.stdout}`);
             const back = await this.herdr(`wait output ${shq(pane)} --match ${shq(cmd)} --timeout ${DELIVERY_VERIFY_TIMEOUT_MS}`, slot.cwd, DELIVERY_VERIFY_TIMEOUT_MS + 15_000);
-            // ponytail: transcript containment (scrollback included); anchor to the prompt line if a
-            // prior echo of the same command ever false-verifies. Dead pane → error envelope → unverified.
-            if (this.waitOk(back.code, back.stdout)) {
+            if (this.waitOk(back.code, back.stdout) || await this.deliveryReadMatches(pane, cmd, slot.cwd)) {
                 const enter = await this.herdr(`pane send-keys ${shq(pane)} Enter`, slot.cwd);
                 if (enter.code !== 0)
                     throw new Error(`herdr pane send-keys Enter failed: ${enter.stderr || enter.stdout}`);
@@ -313,6 +328,10 @@ export class HerdrDriver {
         }
         throw new Error(`herdr delivery corrupted after ${DELIVERY_ATTEMPTS} attempts — enter never pressed (OBS-85); pane transcript:\n${transcript}`);
     }
+    async deliveryReadMatches(pane, cmd, cwd) {
+        const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
+        return read.code === 0 && this.deliveryMatches(read.stdout, cmd);
+    }
     waitOk(code, stdout) {
         if (code !== 0 || !stdout.trim())
             return code === 0; // herdr's successful waits may be silent

package/dist/route/preference.d.ts

@@ -25,3 +25,12 @@ export declare function disallowedBy(c: {
     adapter: string;
     model: string;
 }, routing: TickmarkrConfig["routing"]): Disallowed | null;
+export interface DenyPreferCollision {
+    kind: "prefer" | "pin";
+    shape: string;
+    detail: string;
+    disallowed: Disallowed;
+}
+export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig): Disallowed | null;
+export declare function denyPreferCollisions(cfg: TickmarkrConfig): DenyPreferCollision[];
+export declare function denyPreferCollisionLine({ kind, shape, detail, disallowed }: DenyPreferCollision): string;

package/dist/route/preference.js

@@ -1,4 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
+import { validateGraph } from "../graph/schema.js";
+import { route, RoutingError } from "./router.js";
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;
@@ -47,3 +49,62 @@ export function disallowedBy(c, routing) {
     }
     return null;
 }
+// Delegates to route()'s preflightPrefer — doctor/resume preflight reuses the router grammar,
+// not a second colon/tier/model parser of the same config.
+const PREFLIGHT_SHAPE = "chore";
+const preflightTask = validateGraph({
+    version: 1, spec: { source: "prd", paths: ["p"], hash: "h" },
+    tasks: [{ id: "T0", title: "preflight", goal: "preflight", shape: PREFLIGHT_SHAPE, complexity: 1, acceptance: ["preflight"] }],
+}).tasks[0];
+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) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return null;
+    const probe = structuredClone(cfg);
+    probe.routing.map = { ...probe.routing.map, [PREFLIGHT_SHAPE]: { prefer: [p] } };
+    try {
+        route(preflightTask, probe, []);
+        return null;
+    }
+    catch (e) {
+        if (e instanceof RoutingError)
+            return disallowedFromPreferError(e.message);
+        throw e;
+    }
+}
+export function denyPreferCollisions(cfg) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return [];
+    const out = [];
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        if (entry.pin) {
+            const d = disallowedBy({ adapter: entry.pin.via, model: entry.pin.model }, cfg.routing);
+            if (d) {
+                out.push({
+                    kind: "pin",
+                    shape,
+                    detail: `${entry.pin.via}:${entry.pin.model}`,
+                    disallowed: d,
+                });
+            }
+        }
+        const prefer = entry.prefer ?? [];
+        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg) !== null)) {
+            out.push({
+                kind: "prefer",
+                shape,
+                detail: prefer.join(" > "),
+                disallowed: preferEntryDenied(prefer[0], cfg),
+            });
+        }
+    }
+    return out;
+}
+export function denyPreferCollisionLine({ kind, shape, detail, disallowed }) {
+    const surface = kind === "pin" ? `routing.map.${shape}.pin` : `routing.map.${shape}.prefer`;
+    const verb = kind === "pin" ? "is disallowed" : "fully disallowed";
+    return `deny∩prefer: ${surface} ${detail} ${verb} by routing.${disallowed.by} (${disallowed.entry}) — remove the ${disallowed.by} entry or adjust ${kind === "pin" ? "pin" : "prefer"}`;
+}

package/dist/run/daemon.d.ts

@@ -41,4 +41,8 @@ export interface RunSummary {
     lastMergedTask?: string;
 }
 export declare function formatSummary(s: RunSummary): string;
+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;
+export declare function resetEarlyLaunchLivenessMsForTests(): void;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;

package/dist/run/daemon.js

@@ -74,6 +74,18 @@ const BLOCKED_POLL_MS = 30_000; // between trailer-wait slices, check whether th
 const PROVIDER_DEATH_REQUEUE_CAP = 2; // v1.46 T1: requeue same assignment twice, then fall through to the normal ladder
 const PROVIDER_DEATH_BACKOFF_MS = 500; // short backoff before provider-death requeue
 const NO_TRAILER_DEMOTION_STREAK = 2; // OBS-57: consecutive no-trailer windows demote a channel for the rest of the run
+// OBS-117 (v1.71 T6): a worker pane that never prints a byte by T+60s after dispatch is a dead
+// channel — don't burn the full stall window waiting for a silent launch failure. Checked on the
+// existing stall-wait poll cadence only (no new timer). Spinner/ANSI repaints count as output.
+export const EARLY_LAUNCH_LIVENESS_MS = 60_000;
+let earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+/** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
+export function setEarlyLaunchLivenessMsForTests(ms) {
+    earlyLaunchLivenessMs = ms;
+}
+export function resetEarlyLaunchLivenessMsForTests() {
+    earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+}
 async function commitsAheadOf(base, wt) {
     const head = await gitHead(wt);
     if (head === base)
@@ -217,6 +229,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // GATE-08 lesson at the humanGate guard: condition on the data, not the code path). Dead-code
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
+        const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
         if (opts.resume) {
             // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
             // two-concurrent-runs hazard supersession exists to prevent. Fail closed, naming the successor.
@@ -252,7 +265,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                     continue;
                 graph = setStatus(graph, id, st);
             }
-            journal.append("run-resume", undefined, { pid: process.pid }); // v1.13 (VIS-11): record the live daemon pid for status liveness
+            journal.append("run-resume", undefined, {
+                pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
+                ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
+            });
         }
         else {
             baseRef = await gitHead(repoRoot);
@@ -301,7 +317,8 @@ export async function runDaemon(repoRoot, opts = {}) {
         const keptSlots = [];
         const runTag = runId.replace(/^run-/, ""); // full date-time — cross-run unique even across days
         // OBS-57: per-run in-run demotion — channels that burn consecutive no-trailer windows route around for later attempts.
-        const demotedChannels = new Set();
+        // v1.71 OBS-119: on resume, re-seed from the journal fold (replayedExclusions) before any dispatch.
+        const demotedChannels = new Set(replayedExclusions);
         const noTrailerStreak = new Map();
         // OBS-17 T2: reconcile at every safe point — run start/resume (just journaled above), each task
         // terminal event, and run-end. The desired set is the pure journal fold (reconcile.ts); the driver
@@ -394,7 +411,9 @@ export async function runDaemon(repoRoot, opts = {}) {
             // fresh-budget release, prefer nextChannel over the surviving tried-list so burned channels are
             // not re-tried first (consult bans / prior failovers survive the release).
             const rs = resume.get(t.id);
-            if (rs?.lastAssignment && rs.attempts > 0 && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))) {
+            if (rs?.lastAssignment && rs.attempts > 0
+                && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))
+                && !demotedChannels.has(channelKey(rs.lastAssignment))) {
                 assignment = rs.lastAssignment; // restore the consult-chosen assignment (bypasses route()'s static re-pick)
             }
             else if (rs && rs.tried.length) {
@@ -690,6 +709,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let output;
                 let exitCode;
                 let timedOut = false;
+                let earlyLaunchDead = false;
                 let settleParsed;
                 let seedResult;
                 if (interactive) {
@@ -724,12 +744,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
                         // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
                         // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        let everHadOutput = output.length > 0;
                         let lastStallSnapshot = normalizeStallSnapshot(output);
                         let lastOutputAt = Date.now();
                         while (Date.now() - lastOutputAt < stallWindowMs) {
                             const sliceStart = Date.now();
                             const remaining = stallWindowMs - (sliceStart - lastOutputAt);
-                            const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (!everHadOutput) {
+                                const earlyLeft = earlyLaunchLivenessMs - (sliceStart - attemptStart);
+                                if (earlyLeft > 0)
+                                    slice = Math.min(slice, earlyLeft);
+                            }
                             if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                                 // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
                                 // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
@@ -743,11 +769,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     break;
                                 }
                             }
-                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            const paneText = await driver.read(slot, 1000);
+                            if (paneText.length > 0)
+                                everHadOutput = true;
+                            const currentStallSnapshot = normalizeStallSnapshot(paneText);
                             if (currentStallSnapshot !== lastStallSnapshot) {
                                 lastStallSnapshot = currentStallSnapshot;
                                 lastOutputAt = Date.now();
                             }
+                            // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
+                            if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                                earlyLaunchDead = true;
+                                output = paneText;
+                                break;
+                            }
                             // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
                             await sampleContext();
                             // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
@@ -828,21 +863,35 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // OBS-82: same normalized-snapshot compare as the interactive site — spinner-only repaints
                     // exhaust the budget here too; harvest below still reads the raw pane.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    let lastStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                    const initialPane = await driver.read(slot, 500);
+                    let everHadOutput = initialPane.length > 0;
+                    let lastStallSnapshot = normalizeStallSnapshot(initialPane);
                     let lastOutputAt = Date.now();
                     finished = false;
                     while (Date.now() - lastOutputAt < stallWindowMs) {
                         const remaining = stallWindowMs - (Date.now() - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        if (!everHadOutput) {
+                            const earlyLeft = earlyLaunchLivenessMs - (Date.now() - attemptStart);
+                            if (earlyLeft > 0)
+                                slice = Math.min(slice, earlyLeft);
+                        }
                         if (await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                             finished = true;
                             break;
                         }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                        const paneText = await driver.read(slot, 500);
+                        if (paneText.length > 0)
+                            everHadOutput = true;
+                        const currentStallSnapshot = normalizeStallSnapshot(paneText);
                         if (currentStallSnapshot !== lastStallSnapshot) {
                             lastStallSnapshot = currentStallSnapshot;
                             lastOutputAt = Date.now();
                         }
+                        if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                            earlyLaunchDead = true;
+                            break;
+                        }
                     }
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
@@ -940,10 +989,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // AFTER the quota check so quota behavior stays byte-identical (a quota hit returns/continues
                 // before reaching here); provider-outage lands here only once the v1.46 same-channel requeue
                 // cap above is spent, so a transient blip still recovers in place.
-                const dead = classifyDeadChannel(result);
+                // OBS-117 (v1.71 T6): a silent launch failure has no CLI signature to parse — the same
+                // setup-required typed dead-channel path a late-harvest "command not found" would take.
+                const dead = classifyDeadChannel(result) ?? (earlyLaunchDead ? "setup-required" : undefined);
                 if (dead) {
                     const from = channelKey(assignment);
                     demotedChannels.add(from); // excluded for later attempts AND later tasks in this run
+                    journal.append("channel-exclusion", t.id, { channel: from, reason: dead, kind: "dead-channel" });
                     const next = failover("dead-channel");
                     journal.append("dead-channel-failover", t.id, { reason: dead, from, to: next ? channelKey(next) : null });
                     if (next) {
@@ -1130,9 +1182,14 @@ export async function runDaemon(repoRoot, opts = {}) {
             for (const t of ready) {
                 const p = execTask(t)
                     .catch(async (err) => {
+                    const taskEvents = journal.read().filter((e) => e.taskId === t.id);
+                    const dispatch = [...taskEvents].reverse().find((e) => e.event === "task-dispatch");
+                    const verifiedFailure = taskEvents.some((e) => e.event === "gate-result" && e.data.pass === false);
+                    const kind = verifiedFailure ? "gate-fail" : dispatch ? "dispatch" : "infra";
+                    const attempts = dispatch && Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0;
                     graph = setStatus(graph, t.id, "failed");
                     saveGraph(repoRoot, graph);
-                    journal.append("task-failed", t.id, { error: String(err) });
+                    journal.append("task-failed", t.id, { error: String(err), kind, attempts });
                     journal.telemetry({ taskId: t.id, shape: t.shape, adapter: "-", model: "-", channel: "-", attempts: 0, outcome: "failed", durationMs: 0 });
                     await reconcile({ spareLiveLlm: true }); // task-failed is a terminal event
                 })

package/dist/run/interactive-seed.d.ts

@@ -4,6 +4,7 @@ export interface InteractiveSeedResult {
     output: string;
     seedFailed: boolean;
     seedError?: string;
+    sessionId?: string;
 }
 export declare function runInteractiveSeed(opts: {
     driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;

package/dist/run/interactive-seed.js

@@ -6,9 +6,17 @@ export async function runInteractiveSeed(opts) {
     const seed = opts.adapter.interactiveSeed;
     await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
     const ready = await opts.driver.waitOutput(opts.slot, seed.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    const banner = await opts.driver.read(opts.slot, 1000);
     if (!ready) {
-        const output = await opts.driver.read(opts.slot, 1000);
-        return { output, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+    }
+    let sessionId;
+    if (seed.confirmBanner) {
+        const confirm = seed.confirmBanner(banner, opts.assignment.model);
+        if (!confirm.ok) {
+            return { output: banner, seedFailed: true, seedError: confirm.error };
+        }
+        sessionId = confirm.sessionId;
     }
     const seedText = seed.seedLine(opts.promptFile);
     await opts.driver.run(opts.slot, seedText);
@@ -18,8 +26,8 @@ export async function runInteractiveSeed(opts) {
         output = await opts.driver.read(opts.slot, 1000);
         const bottom = output.trimEnd().split("\n").pop() ?? "";
         if (!bottom.includes(seedText)) {
-            return { output, seedFailed: false };
+            return { output, seedFailed: false, ...(sessionId ? { sessionId } : {}) };
         }
     }
-    return { output, seedFailed: true, seedError: "seed line never left the input box" };
+    return { output, seedFailed: true, seedError: "seed line never left the input box", ...(sessionId ? { sessionId } : {}) };
 }

package/dist/run/journal.d.ts

@@ -15,13 +15,18 @@ export interface ResumeState {
     tried: string[];
     lastAssignment?: Assignment;
 }
+export declare const CHANNEL_EXCLUSION_KINDS: readonly ["dead-channel"];
+export type ChannelExclusionKind = (typeof CHANNEL_EXCLUSION_KINDS)[number];
 export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
-export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
+export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh"];
 export type RetryMode = (typeof RETRY_MODES)[number];
 export declare const WORKER_RESULT_CAUSES: readonly ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
 export type WorkerResultCause = (typeof WORKER_RESULT_CAUSES)[number];
+export declare function isQualityFailureParkKind(kind: ParkKind): boolean;
+export declare function recordedTaskFailureKind(events: JournalEvent[], taskId: string): ParkKind | undefined;
+export declare function runHasEnded(events: JournalEvent[]): boolean;
 /** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
 export declare function classifyWorkerResultCause(opts: {
     output: string;
@@ -58,6 +63,8 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         stall: "stall";
         "merge-conflict": "merge-conflict";
         "tip-moved": "tip-moved";
+        infra: "infra";
+        dispatch: "dispatch";
     }>>;
     tokens: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         input: z.ZodNumber;
@@ -139,6 +146,7 @@ export declare class Journal {
     read(): JournalEvent[];
     replayStatuses(): Map<string, TaskStatus>;
     replayResumeState(): Map<string, ResumeState>;
+    replayExcludedChannels(): Set<string>;
     telemetry(row: TelemetryRow): void;
     readTelemetry(): TelemetryRow[];
 }

package/dist/run/journal.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { channelKey, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, tickmarkrDir } from "../graph/graph.js";
 import { TIERS } from "../graph/schema.js";
-import { buildProfile } from "../route/profile.js";
+import { buildProfile, classify } from "../route/profile.js";
 import { redactSecrets } from "./redact.js";
 export function formatJournalNarration({ event, taskId, data }) {
     const assignment = data.assignment;
@@ -26,6 +26,9 @@ export function formatJournalNarration({ event, taskId, data }) {
                             : String(direct);
     return [event, taskId, detail?.replace(/\s+/g, " ").slice(0, 120)].filter(Boolean).join(" — ");
 }
+// v1.71 OBS-119: run-wide channel exclusions derived from journal events — companion to
+// replayResumeState(), consumed by the daemon on resume to re-seed demotedChannels.
+export const CHANNEL_EXCLUSION_KINDS = ["dead-channel"];
 // v1.24 OBS-18: explicit data on task-approved when the operator releases an attempt-cap park.
 // Approve stamps this; replayResumeState zeros the attempt counter (fresh budget) while keeping
 // tried (consult bans / burned channels). Absent on pre-v1.24 events ⇒ inert (corpus outcome-identical).
@@ -40,9 +43,43 @@ const DispatchAssignmentSchema = z.object({
     tier: z.enum(TIERS),
 });
 export const PARK_KINDS = ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota",
-    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
+    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export const RETRY_MODES = ["resume", "fresh"];
 export const WORKER_RESULT_CAUSES = ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
+// Status consumes the routing profile's existing quality split directly: verified park kinds classify
+// to 0, while availability/recovery noise classifies to null. Keep the synthetic row here at the
+// run↔route seam so presentation code never grows a second list of "bad" park kinds.
+export function isQualityFailureParkKind(kind) {
+    return classify({
+        shape: "", adapter: "-", model: "-", channel: "-", attempts: 0,
+        outcome: "human", durationMs: 0, parkKind: kind,
+    }) === 0;
+}
+// The newest terminal event owns the cause. Unknown/malformed kinds fail toward undefined so a
+// task-failed row keeps the legacy red treatment instead of being mistaken for recoverable noise.
+export function recordedTaskFailureKind(events, taskId) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.taskId !== taskId || (e.event !== "task-human" && e.event !== "task-failed"))
+            continue;
+        return typeof e.data.kind === "string" && PARK_KINDS.includes(e.data.kind)
+            ? e.data.kind
+            : undefined;
+    }
+    return undefined;
+}
+// Runs can end and later resume in the same journal. The newest lifecycle marker decides whether
+// an unresolved task is still recoverable by this live daemon or belongs to an ended run.
+export function runHasEnded(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i].event;
+        if (event === "run-end" || event === "superseded")
+            return true;
+        if (event === "run-start" || event === "run-resume")
+            return false;
+    }
+    return false;
+}
 // OBS-53: provider-outage signatures in dead worker output ("Unable to reach the model provider" and kin).
 const PROVIDER_OUTAGE_RE = /Unable to reach the model provider|cannot reach the model provider|model provider.*(?:unavailable|unreachable)/i;
 /** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
@@ -424,6 +461,20 @@ export class Journal {
         }
         return m;
     }
+    // v1.71 OBS-119: run-wide exclusion fold — same replay discipline as replayResumeState().
+    // channel-exclusion is the typed event; dead-channel-failover.from is the pre-v1.71 compat seam.
+    replayExcludedChannels() {
+        const excluded = new Set();
+        for (const e of this.read()) {
+            if (e.event === "channel-exclusion" && typeof e.data.channel === "string") {
+                excluded.add(e.data.channel);
+            }
+            else if (e.event === "dead-channel-failover" && typeof e.data.from === "string") {
+                excluded.add(e.data.from);
+            }
+        }
+        return excluded;
+    }
     telemetry(row) {
         // T3 secret redaction: same persistence seam as append — credential-free rows are byte-identical.
         appendFileSync(join(this.dir, "telemetry.jsonl"), redactSecrets(JSON.stringify(row)) + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.70.0",
+  "version": "1.71.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",