tickmarkr 1.45.0 → 1.46.0

package/dist/adapters/fake.js

@@ -37,7 +37,7 @@ export class FakeAdapter {
         let isJudge = false;
         try {
             prompt = readFileSync(promptFile, "utf8");
-            isJudge = /TICKMARKR-JUDGE/.test(prompt);
+            isJudge = /TICKMARKR-(?:JUDGE|SCOPE)/.test(prompt);
         }
         catch {
             // unreadable promptFile: can't detect role; serve static values (legacy headless-call behavior)
@@ -61,7 +61,7 @@ export class FakeAdapter {
             writeFileSync(p, JSON.stringify(val ?? {}, null, 1));
             return p;
         };
-        return `bash -c 'grep -q TICKMARKR-JUDGE ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q TICKMARKR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q TICKMARKR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
+        return `bash -c 'grep -Eq "TICKMARKR-(JUDGE|SCOPE)" ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q TICKMARKR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q TICKMARKR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
     }
     resumeCommand(_sessionId, promptFile, model) {
         return this.interactiveCommand(promptFile, model) ?? this.headlessCommand(promptFile, model);

package/dist/adapters/registry.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { overlayPreferShapes, TIER_RANK } from "../config/config.js";
@@ -178,7 +178,13 @@ async function mapLimit(items, limit, fn) {
 }
 const doctorPath = (repoRoot) => join(repoRoot, stateDirName(repoRoot), "doctor.json");
 function readDoctorFile(repoRoot) {
-    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    try {
+        return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    }
+    catch {
+        // A torn cache is disposable: callers already re-probe when this returns null.
+        return null;
+    }
 }
 export function writeDoctor(repoRoot, health) {
     tickmarkrDir(repoRoot);
@@ -187,7 +193,10 @@ export function writeDoctor(repoRoot, health) {
     delete payload[pendingAutoPreferKey];
     if (pending)
         payload.autoPrefer = pending;
-    writeFileSync(doctorPath(repoRoot), JSON.stringify(payload, null, 2) + "\n");
+    const path = doctorPath(repoRoot);
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(payload, null, 2) + "\n");
+    renameSync(tmp, path);
 }
 export function readDoctor(repoRoot) {
     const raw = readDoctorFile(repoRoot);

package/dist/brand.js

@@ -1,3 +1,4 @@
+import { shq } from "./adapters/types.js";
 // TTY-only pixel-tick logo (assets/mark.svg is the image twin — same block geometry).
 // Never printed to pipes — the non-TTY stdout surface is byte-pinned by tests and consumed by machines.
 const B = "\x1b[1m", R = "\x1b[0m";
@@ -26,5 +27,5 @@ export function paneDispatchScript(body) {
 }
 /** OBS-50: one short herdr pane-run line; bootstrap lives in the script file beside the prompt. */
 export function paneDispatchCommand(scriptPath) {
-    return `bash ${JSON.stringify(scriptPath)}`;
+    return `bash ${shq(scriptPath)}`;
 }

package/dist/cli/commands/approve.js

@@ -6,10 +6,10 @@ import { ATTEMPT_CAP_RELEASE, Journal } from "../../run/journal.js";
 // append-only journal. Writing it into tickmarkr's compiled graph artifact would be silently erased by
 // the next recompile (which re-emits humanGate:true from the plan frontmatter) — Phase 42 D-02.
 //
-// v1.24 OBS-18: when the park was attempt-cap (not a humanGate pre-dispatch park), the event also
-// carries `release: "attempt-cap"`. replayResumeState zeros the attempt budget on that marker so
-// resume dispatches instead of re-parking in the same tick; tried-list is preserved. humanGate
-// parks (attempts 0, reason starts with "humanGate:") stamp no release — byte-identical to GATE-08.
+// v1.24 OBS-18: when the park kind is attempt-cap (not a humanGate pre-dispatch park), the event
+// also carries `release: "attempt-cap"`. replayResumeState zeros the attempt budget on that marker so
+// resume dispatches instead of re-parking in the same tick; tried-list is preserved. Unknown kinds
+// receive no release and remain fail-closed to a human rather than being inferred from prose.
 //
 // Fail-closed (D-05): unknown runId, unknown taskId, a not-parked task, and a double-approve are all
 // LOUD refusals that name the reason and append NO event — never a silent no-op. A handler throw
@@ -30,10 +30,9 @@ export async function approve(argv, cwd = process.cwd()) {
         throw new Error(`task ${taskId} is ${status}, not a parked human gate — refusing (a silent no-op would be worse)`);
     }
     // OBS-18: only the most recent task-human for this task decides whether this approval grants a
-    // fresh attempt budget. Match the daemon's park reason literally (`attempt cap (N) reached`).
+    // fresh attempt budget. The closed daemon-issued kind, never a human prose string, controls release.
     const lastHuman = journal.read().filter((e) => e.event === "task-human" && e.taskId === taskId).at(-1);
-    const capPark = typeof lastHuman?.data.reason === "string"
-        && /attempt cap \(\d+\) reached/.test(lastHuman.data.reason);
+    const capPark = lastHuman?.data.kind === ATTEMPT_CAP_RELEASE;
     journal.append("task-approved", taskId, {
         by,
         ...(reason ? { reason } : {}),

package/dist/cli/commands/init.js

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
@@ -7,7 +7,59 @@ import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
 import { BANNER } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
+import { Journal } from "../../run/journal.js";
 import { doctor } from "./doctor.js";
+const SCAFFOLD_SPEC = "tickmarkr.spec.md";
+// Operator-approved (2026-07-17) environments footer — three rows; no npm install for herdr
+// (npm package "herdr" is a reserved 0.0.0 placeholder as of that date).
+const ENVIRONMENTS_FOOTER = [
+    "environments:",
+    "  herdr — the full cockpit — every worker, judge, and consult is a visible pane you can watch and unblock · https://herdr.dev",
+    "  claude code — tickmarkr init --agent installs the /tkr skills + AGENTS.md so Claude Code (or any agent CLI) drives the loop natively",
+    "  anywhere — no herdr? same fail-closed gates, headless subprocess driver",
+].join("\n");
+/** Latest journal without a run-end event, if any. */
+function activeRunId(cwd) {
+    const runId = Journal.latestRunId(cwd, { withJournal: true });
+    if (!runId)
+        return null;
+    try {
+        const events = Journal.open(cwd, runId).read();
+        if (events.some((e) => e.event === "run-end"))
+            return null;
+        return runId;
+    }
+    catch {
+        return null;
+    }
+}
+/** Relative paths of specs/*.spec.md already in the repo. */
+function existingSpecs(cwd) {
+    const dir = join(cwd, "specs");
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".spec.md"))
+            .sort()
+            .map((f) => `specs/${f}`);
+    }
+    catch {
+        return [];
+    }
+}
+/** Context-aware next-steps line (operator-approved 2026-07-17). */
+function nextSteps(cwd, scaffoldedSpec) {
+    const runId = activeRunId(cwd);
+    if (runId)
+        return `run ${runId} active — tickmarkr status`;
+    const specs = existingSpecs(cwd);
+    if (specs.length > 0) {
+        const listed = specs.length <= 3 ? specs.join(", ") : `${specs.slice(0, 3).join(", ")}, …`;
+        return `next: existing specs under specs/ (${listed}) — tickmarkr compile <spec> && tickmarkr plan && tickmarkr run`;
+    }
+    return `next: edit ${scaffoldedSpec}, then tickmarkr compile ${scaffoldedSpec} && tickmarkr plan && tickmarkr run`;
+}
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
 const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
@@ -173,7 +225,7 @@ export async function init(argv, cwd = process.cwd()) {
     const repoConfigExists = existsSync(repoConfigPath);
     if (repoConfigExists)
         notes.push(`kept existing ${repoConfigPath}`);
-    const specPath = join(cwd, "tickmarkr.spec.md");
+    const specPath = join(cwd, SCAFFOLD_SPEC);
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
     }
@@ -210,7 +262,7 @@ export async function init(argv, cwd = process.cwd()) {
     }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
-    const body = `${notes.join("\n")}\n${doc}\nnext: edit tickmarkr.spec.md, then tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run`;
+    const body = `${notes.join("\n")}\n${doc}\n${nextSteps(cwd, SCAFFOLD_SPEC)}\n${ENVIRONMENTS_FOOTER}`;
     if (visual() && !bannerEmitted)
         return BANNER + body;
     return body;

package/dist/cli/commands/profile.js

@@ -1,13 +1,21 @@
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../../config/config.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
-import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
-import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
-// tickmarkr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
-// Read-only class like plan/status/report: no run lock. `reset` writes ONE cursor scalar, nothing else.
+import { cellOf, cellSummary, explorationBonus, EXPLORE_CAP, learnedScore, learnedScoreTerms, MIN_SAMPLES, PRIOR_K, REF_MS, cellsOf, } from "../../route/profile.js";
+import { Journal, loadRoutingProfile, parseRunId, readProfileCursor, readProfileDiscounts, appendProfileDiscount, profileDiscountsPath, RUNS_WINDOW, } from "../../run/journal.js";
+// tickmarkr profile — inspect (show), forget (reset), and discount poisoned evidence (v1.46 T5).
+// Read-only class like plan/status/report except discount append. `reset` writes ONE cursor scalar.
 export async function profile(argv, cwd = process.cwd()) {
-    return argv[0] === "reset" ? reset(cwd) : show(cwd);
+    if (argv[0] === "reset")
+        return reset(cwd);
+    if (argv[0] === "discount")
+        return discount(argv.slice(1), cwd);
+    if (argv[0] === "discounts")
+        return listDiscounts(cwd);
+    if (argv[0] === "--explain" || argv.includes("--explain"))
+        return explain(argv, cwd);
+    return show(cwd);
 }
 // Non-destructive reset (T-13-06): a one-line runId cutoff at .tickmarkr/profile-since. NEVER deletes,
 // truncates, or rotates any telemetry — the profile is derived (PROF-01), so there is nothing to delete;
@@ -26,6 +34,119 @@ function reset(cwd) {
         `  to un-reset: delete ${stateDir}/profile-since.`,
     ].join("\n");
 }
+function parseDiscountArgs(argv) {
+    let runId;
+    let taskId;
+    let weight;
+    let reason;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--weight" && argv[i + 1]) {
+            const w = argv[++i];
+            if (w !== "0" && w !== "0.5")
+                throw new Error(`profile discount --weight must be 0 or 0.5 (got ${w})`);
+            weight = w === "0" ? 0 : 0.5;
+        }
+        else if (argv[i] === "--reason" && argv[i + 1]) {
+            reason = argv[++i];
+        }
+        else if (!argv[i].startsWith("--") && runId === undefined) {
+            runId = parseRunId(argv[i]);
+        }
+        else if (!argv[i].startsWith("--") && taskId === undefined) {
+            taskId = argv[i];
+        }
+    }
+    if (!runId)
+        throw new Error("profile discount requires <runId>");
+    if (weight === undefined)
+        throw new Error("profile discount requires --weight 0|0.5");
+    if (!reason?.trim())
+        throw new Error("profile discount requires --reason (a discount is an evidence claim)");
+    return { runId, taskId, weight, reason: reason.trim() };
+}
+function discount(argv, cwd) {
+    const mark = parseDiscountArgs(argv);
+    appendProfileDiscount(cwd, mark);
+    const stateDir = stateDirName(cwd);
+    const scope = mark.taskId ? `${mark.runId} task ${mark.taskId}` : mark.runId;
+    return [
+        `profile discount — marked ${scope} at weight ${mark.weight}.`,
+        `  reason: ${mark.reason}`,
+        `  wrote ${stateDir}/profile-discounts (append-only).`,
+        `  list: tickmarkr profile discounts`,
+    ].join("\n");
+}
+function listDiscounts(cwd) {
+    const marks = readProfileDiscounts(cwd);
+    const path = profileDiscountsPath(cwd);
+    if (!marks.length) {
+        return existsDiscountsFile(cwd)
+            ? `profile discounts — ${path}\n  (no valid marks)`
+            : `profile discounts — no ${stateDirName(cwd)}/profile-discounts file yet.`;
+    }
+    const lines = marks.map((m) => {
+        const scope = m.taskId ? `${m.runId} ${m.taskId}` : m.runId;
+        return `  ${scope.padEnd(28)} weight=${m.weight}  # ${m.reason}`;
+    });
+    return [`profile discounts — ${path}`, ...lines].join("\n");
+}
+function existsDiscountsFile(cwd) {
+    try {
+        readFileSync(profileDiscountsPath(cwd));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const fmtSigned = (n) => (n >= 0 ? `+${n.toFixed(3)}` : n.toFixed(3));
+function explain(argv, cwd) {
+    const rest = argv[0] === "--explain" ? argv.slice(1) : argv.filter((a) => a !== "--explain");
+    const shape = rest[0];
+    const chKey = rest[1];
+    const channel = rest[2] ?? "sub";
+    if (!shape || !chKey)
+        throw new Error("profile --explain requires <shape> <channel>");
+    const cfg = loadConfig(cwd);
+    const p = loadRoutingProfile(cwd, cfg, { preview: true });
+    const tuning = { availWeight: cfg.routing.learnedTuning?.availWeight };
+    const cell = cellOf(p, shape, chKey, channel);
+    const terms = learnedScoreTerms(p, shape, chKey, channel, tuning);
+    const score = learnedScore(p, shape, chKey, channel, tuning);
+    const header = `${shape} × ${chKey} (${channel})`;
+    if (!cell) {
+        return [
+            header,
+            `  quality   ${fmtSigned(terms.quality)}   (no cell — neutral)`,
+            `  perf      ${fmtSigned(terms.perf)}`,
+            `  avail     ${fmtSigned(terms.avail)}`,
+            `  overrun   ${fmtSigned(terms.overrun)}`,
+            `  score     ${fmtSigned(score)}`,
+        ].join("\n");
+    }
+    const s = cellSummary(cell);
+    const disc = s.discounted > 0 ? `, ${s.discounted} rows discounted` : "";
+    const qualityDetail = s.cold
+        ? `n_eff ${s.nEff} < ${MIN_SAMPLES} (cold)`
+        : `q̂=(qSum ${cell.qSum} + ${PRIOR_K})/(n ${cell.n} + ${2 * PRIOR_K}) − 0.5  n_raw ${s.nRaw}${disc}`;
+    const perfDetail = cell.doneMedianMs === undefined || s.cold
+        ? `cold`
+        : `median ${Math.round(cell.doneMedianMs / 60_000)}m vs ref ${REF_MS / 60_000}m  done=${cell.doneCount}`;
+    const availDetail = `quotaHits ${cell.quotaHits} / dispatches ${cell.dispatches}`;
+    const overrunDetail = `overruns ${cell.overruns ?? 0} / dispatches ${cell.dispatches}`;
+    const explore = cell.dispatches >= EXPLORE_CAP
+        ? `spent  dispatches ${cell.dispatches} ≥ cap ${EXPLORE_CAP}`
+        : `remaining ${s.exploreRemaining}  bonus ${explorationBonus(cell).toFixed(3)}`;
+    return [
+        header,
+        `  quality   ${fmtSigned(terms.quality)}   ${qualityDetail}`,
+        `  perf      ${fmtSigned(terms.perf)}   ${perfDetail}`,
+        `  avail     ${fmtSigned(terms.avail)}   ${availDetail}`,
+        `  overrun   ${fmtSigned(terms.overrun)}   ${overrunDetail}`,
+        `  score     ${fmtSigned(score)}   (deciding only below prefer/cost/tier — ROUTE-08)`,
+        `  explore   ${explore}`,
+    ].join("\n");
+}
 // Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
 // profile even under the default off — same trust ramp as `tickmarkr plan`. The routing path stays inert.
 function show(cwd) {
@@ -51,7 +172,8 @@ function show(cwd) {
         // VIS-04/ROUTE-15 — preview must match routing's tuning, never the bare module default.
         const score = learnedScore(p, shape, chKey, channel, { availWeight: cfg.routing.learnedTuning?.availWeight }).toFixed(3);
         const cold = cell.n < MIN_SAMPLES ? `  cold (n<${MIN_SAMPLES})` : "";
-        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${cold}`;
+        const disc = (cell.discounted ?? 0) > 0 ? `  disc=${cell.discounted}` : "";
+        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${disc}${cold}`;
     });
     return [...header, "", "  shape      channel                      class obs   quality  median    dispatch  score", ...rows].join("\n");
 }

package/dist/compile/collateral.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, relative } from "node:path";
+import picomatch from "picomatch";
 // Advisory plan-time scan only (OBS-12/13/14/21). NEVER expands files[], fails compile, or
 // feeds the scope gate — a warning the author acts on. Plain-text (no AST), capped + sorted.
 /** Max test files walked under tests/ (sorted walk; rest ignored). */
@@ -99,7 +100,8 @@ export function collateralLints(tasks, repoRoot) {
     };
     const lines = [];
     for (const t of tasks) {
-        const scoped = new Set(t.files.map((f) => f.replace(/^\.\//, "")));
+        // OBS-22: scopeGate accepts picomatch globs; advisory collateral warnings must agree.
+        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
         const srcFiles = t.files.map((f) => f.replace(/^\.\//, "")).filter(isSrcPath);
         if (!srcFiles.length)
             continue;
@@ -107,7 +109,7 @@ export function collateralLints(tasks, repoRoot) {
         const needles = [...new Set(srcFiles.flatMap(needlesFor))];
         const hits = [];
         for (const tf of testFiles) {
-            if (scoped.has(tf))
+            if (scoped(tf))
                 continue;
             const text = read(tf);
             if (text === null)

package/dist/drivers/herdr.d.ts

@@ -28,6 +28,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     private glyphFor;
     private joinGroup;
     run(slot: Slot, cmd: string): Promise<void>;
+    private waitOk;
     waitOutput(slot: Slot, pattern: string, timeoutMs: number, opts?: {
         regex?: boolean;
     }): Promise<boolean>;

package/dist/drivers/herdr.js

@@ -275,15 +275,25 @@ export class HerdrDriver {
         if (r.code !== 0)
             throw new Error(`herdr pane run failed: ${r.stderr || r.stdout}`);
     }
+    waitOk(code, stdout) {
+        if (code !== 0 || !stdout.trim())
+            return code === 0; // herdr's successful waits may be silent
+        try {
+            return !Object.hasOwn(JSON.parse(stdout), "error");
+        }
+        catch {
+            return false; // a non-empty herdr wait response must be a parseable envelope
+        }
+    }
     async waitOutput(slot, pattern, timeoutMs, opts) {
         const pane = await this.paneId(slot);
         const r = await this.herdr(`wait output ${shq(pane)} --match ${shq(pattern)}${opts?.regex ? " --regex" : ""} --timeout ${Math.floor(timeoutMs)}`, slot.cwd, timeoutMs + 15_000);
-        return r.code === 0 && !r.stdout.includes('"error"'); // dead pane: exit 0 + error json (herdr bite)
+        return this.waitOk(r.code, r.stdout); // dead pane: exit 0 + top-level error envelope (herdr bite)
     }
     async waitAgentStatus(slot, status, timeoutMs) {
         const pane = await this.paneId(slot);
         const r = await this.herdr(`wait agent-status ${shq(pane)} --status ${shq(status)} --timeout ${Math.floor(timeoutMs)}`, slot.cwd, timeoutMs + 15_000);
-        return r.code === 0 && !r.stdout.includes('"error"');
+        return this.waitOk(r.code, r.stdout);
     }
     async status(slot) {
         return this.statusByName(slot.name);

package/dist/gates/scope.js

@@ -1,5 +1,5 @@
 import picomatch from "picomatch";
-import { shOk } from "../run/git.js";
+import { shGitOk } from "../run/git.js";
 /** Pure offender split — corpus-replay oracle exercises this exact decision logic. */
 export function dispositionOffenders(offenders, allowDeviations) {
     const allowedMatch = allowDeviations.length ? picomatch(allowDeviations, { dot: true }) : () => false;
@@ -16,7 +16,7 @@ export function dispositionOffenders(offenders, allowDeviations) {
 export async function scopeGate(worktree, baseRef, files, result, allowDeviations = []) {
     if (!files.length)
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
-    const changed = (await shOk(`git diff --name-only '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
+    const changed = (await shGitOk(`git diff --name-only '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
     const inScope = picomatch(files, { dot: true }); // byte-identical options to assertWriteScope in src/compile/common.ts
     const offenders = changed.filter((f) => !inScope(f));
     if (!offenders.length)

package/dist/plan/prompt.js

@@ -1,5 +1,5 @@
 export function scopePrompt(intent, repair) {
-    return `TICKMARKR-JUDGE
+    return `TICKMARKR-SCOPE
 You are drafting a tickmarkr native spec from an answered intent. Return only the Markdown spec, with no commentary or code fence.
 
 The draft must:

package/dist/route/profile.d.ts

@@ -11,6 +11,7 @@ export interface ProfileRow {
     consults?: number;
     parkKind?: string;
     runId?: string;
+    taskId?: string;
     quotaFailover?: true;
     overrun?: true;
 }
@@ -23,6 +24,7 @@ export interface ProfileCell {
     doneMedianMs?: number;
     nRaw?: number;
     overruns?: number;
+    discounted?: number;
 }
 export interface RoutingProfile {
     cells: Map<string, ProfileCell>;
@@ -38,10 +40,20 @@ export declare const EXPLORE_CAP = 5;
 export declare const HALF_LIFE_RUNS = 5;
 export declare const DECAY_CAP = 30;
 export declare function decayWeight(age: number, halfLife?: number): number;
+export declare const HYGIENE_WEIGHTS: readonly [0, 0.5, 1];
+export type HygieneWeight = (typeof HYGIENE_WEIGHTS)[number];
+export interface ProfileDiscount {
+    runId: string;
+    taskId?: string;
+    weight: 0 | 0.5;
+    reason: string;
+}
+export declare function resolveHygieneWeight(row: ProfileRow, discounts?: readonly ProfileDiscount[]): HygieneWeight;
 export declare function explorationBonus(cell: ProfileCell | undefined): number;
 export declare function classify(r: ProfileRow): 1 | 0.5 | 0 | null;
 export declare function buildProfile(rows: ProfileRow[], opts?: {
     halfLifeRuns?: number;
+    discounts?: readonly ProfileDiscount[];
 }): RoutingProfile;
 export declare function cellOf(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string): ProfileCell | undefined;
 export declare function cellsOf(profile: RoutingProfile): Generator<{
@@ -58,8 +70,18 @@ export interface CellSummary {
     quotaHits: number;
     cold: boolean;
     exploreRemaining: number;
+    discounted: number;
 }
 export declare function cellSummary(cell: ProfileCell): CellSummary;
+export interface LearnedScoreTerms {
+    quality: number;
+    perf: number;
+    avail: number;
+    overrun: number;
+}
+export declare function learnedScoreTerms(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
+    availWeight?: number;
+}): LearnedScoreTerms;
 export declare function learnedScore(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
 }): number;

package/dist/route/profile.js

@@ -31,6 +31,25 @@ export const DECAY_CAP = 30;
 export function decayWeight(age, halfLife = HALF_LIFE_RUNS) {
     return 2 ** -Math.min(Math.floor(age / halfLife), DECAY_CAP);
 }
+// v1.46 T5 evidence hygiene — operator-filed discounts on poisoned runs/tasks. h ∈ {0, 0.5, 1} is dyadic
+// so h·w (w a power of two) and every partial sum stay exact; magnitude headroom loses one bit (2^-32 floor).
+export const HYGIENE_WEIGHTS = [0, 0.5, 1];
+// Resolve h for one row: run-level marks (no taskId) apply to every row in the run; task-level marks are
+// selective. Multiple marks ⇒ minimum weight (most aggressive discount wins).
+export function resolveHygieneWeight(row, discounts = []) {
+    if (!discounts.length || row.runId === undefined)
+        return 1;
+    let h = 1;
+    for (const d of discounts) {
+        if (d.runId !== row.runId)
+            continue;
+        if (d.taskId !== undefined && d.taskId !== row.taskId)
+            continue;
+        if (d.weight < h)
+            h = d.weight;
+    }
+    return h;
+}
 // Phase 14 exploration bonus: an under-observed channel keeps gathering evidence so early bad luck can't
 // starve it permanently (EXP-01). Total by construction — dispatches is a finite non-negative integer counter,
 // the denominator is a compile-time positive constant; no ln/sqrt/data-dependent divide, so none of the
@@ -107,8 +126,12 @@ export function buildProfile(rows, opts = {}) {
         // in IEEE-754 ⇒ the fold stays order-insensitive (v1.7's invariant EXTENDED, not abandoned). Magnitude
         // headroom: weights are multiples of 2^-31, so exactness holds while row-count ≪ 2^21. nRaw is the
         // integer undecayed observation count (Phase 28) — never enters the score arithmetic.
+        // SINGLE evidence-fold site — hygiene h multiplies quality evidence ONLY (n, qSum), never dispatches/quotaHits/overruns.
         if (q !== null) {
-            const w = decayWeight(ageOf(r.runId), halfLife);
+            const h = resolveHygieneWeight(r, opts.discounts);
+            const w = decayWeight(ageOf(r.runId), halfLife) * h;
+            if (h < 1)
+                c.discounted = (c.discounted ?? 0) + 1;
             c.n += w;
             c.qSum += q * w;
             c.nRaw = (c.nRaw ?? 0) + 1;
@@ -154,18 +177,15 @@ export function cellSummary(cell) {
         quotaHits: cell.quotaHits,
         cold: cell.n < MIN_SAMPLES,
         exploreRemaining: Math.max(0, EXPLORE_CAP - cell.dispatches),
+        discounted: cell.discounted ?? 0,
     };
 }
-// Total by construction: every miss returns the explicit NEUTRAL constant; every denominator is a
-// compile-time-positive constant sum; no Record indexing by row strings (the TIER_RANK[typo] scar).
-// Score 0 defers to the static sort keys, which already encode the benchmark-dated tier seeds — a
-// per-channel numeric prior would give differing n=0 scores and break ROUTE-07's byte-identical cold
-// start. Shrinking toward 0 IS shrinking toward the static prior.
-export function learnedScore(profile, shape, chKey, channel, opts = {}) {
+// Per-term decomposition of learnedScore — the single arithmetic source for profile --explain.
+export function learnedScoreTerms(profile, shape, chKey, channel, opts = {}) {
     const availWeight = opts.availWeight ?? AVAIL_WEIGHT;
     const cell = cellOf(profile, shape, chKey, channel);
     if (!cell)
-        return NEUTRAL; // unknown channel ⇒ exactly neutral (empty-profile / cold-start leg, ROUTE-07)
+        return { quality: NEUTRAL, perf: NEUTRAL, avail: NEUTRAL, overrun: NEUTRAL };
     // Cold-start proof (ROUTE-07): n ≤ nRaw ≤ dispatches and doneCount ≤ dispatches by construction, so a
     // thin-dispatch cell (dispatches < MIN_SAMPLES) gates ALL THREE terms to literal +0 ⇒ exactly NEUTRAL.
     // Each term is gated INDEPENDENTLY (no early-exit) so a dispatch-warm/quality-cold HIGH-throttle cell can
@@ -192,6 +212,18 @@ export function learnedScore(profile, shape, chKey, channel, opts = {}) {
     // fact as a quality signal, ejecting it, or predicting it. overruns=0 ⇒ overrunPen 0 (overrun-free byte-identity).
     // Gated on dispatches (≥ MIN_SAMPLES > 0 ⇒ positive denominator, no divide-by-zero) INDEPENDENTLY of n, mirroring
     // the ROUTE-12 avail term exactly. NOT the symmetric (0.5 − ratio) form (the v1.9 ROUTE-16 penalty-only precedent).
-    const overrunPen = cell.dispatches < MIN_SAMPLES ? 0 : -OVERRUN_WEIGHT * ((cell.overruns ?? 0) / cell.dispatches); // ∈ [−OVERRUN_WEIGHT, 0]
-    return quality + perf + avail + overrunPen; // score ∈ (−0.625, +0.525), finite for every input
+    const overrun = cell.dispatches < MIN_SAMPLES ? 0 : -OVERRUN_WEIGHT * ((cell.overruns ?? 0) / cell.dispatches); // ∈ [−OVERRUN_WEIGHT, 0]
+    return { quality, perf, avail, overrun };
+}
+// Total by construction: every miss returns the explicit NEUTRAL constant; every denominator is a
+// compile-time-positive constant sum; no Record indexing by row strings (the TIER_RANK[typo] scar).
+// Score 0 defers to the static sort keys, which already encode the benchmark-dated tier seeds — a
+// per-channel numeric prior would give differing n=0 scores and break ROUTE-07's byte-identical cold
+// start. Shrinking toward 0 IS shrinking toward the static prior.
+export function learnedScore(profile, shape, chKey, channel, opts = {}) {
+    const cell = cellOf(profile, shape, chKey, channel);
+    if (!cell)
+        return NEUTRAL; // unknown channel ⇒ exactly neutral (empty-profile / cold-start leg, ROUTE-07)
+    const t = learnedScoreTerms(profile, shape, chKey, channel, opts);
+    return t.quality + t.perf + t.avail + t.overrun; // score ∈ (−0.625, +0.525), finite for every input
 }

package/dist/route/router.d.ts

@@ -30,5 +30,5 @@ export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
-export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext): Route;
-export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile): Assignment | null;
+export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>): Route;
+export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;

package/dist/route/router.js

@@ -44,7 +44,14 @@ function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
 }
-export function route(task, cfg, channels, profile, preferCtx) {
+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)));
+}
+export function route(task, cfg, channels, profile, preferCtx, exclude) {
+    channels = withoutExcluded(channels, exclude);
     const lints = [];
     const floor = cfg.routing.floors[task.shape];
     const entry = cfg.routing.map[task.shape];
@@ -201,7 +208,8 @@ export function route(task, cfg, channels, profile, preferCtx) {
         ? preferVia : "cheapest sufficient tier");
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
-export function nextChannel(current, task, cfg, channels, tried, profile) {
+export function nextChannel(current, task, cfg, channels, tried, profile, exclude) {
+    channels = withoutExcluded(channels, exclude);
     // already cheapest-sufficient: TIER_RANK asc is the PRIMARY key so escalation climbs one band at a time.
     // Do NOT "unify" this onto route()'s key order (marginal-cost first) — that reverses climb-one-band on mixed fleets (ROUTE-02, D2).
     // ROUTE-13: learnedScore is the STRICTLY-LAST key — within-band tiebreak only. Precomputed

package/dist/run/consult.d.ts

@@ -10,6 +10,11 @@ export interface ConsultVerdict {
     excludeAdapter?: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
+export declare function augmentRetryBrief(feedback: string, opts: {
+    attempted: string[];
+    carried: string[];
+    present: Set<string>;
+}): string;
 export interface Dossier {
     taskId: string;
     trigger: string;