tickmarkr 1.84.0 → 1.86.0

package/dist/gates/run-gates.js

@@ -1,4 +1,6 @@
-import { channelKey } from "../adapters/types.js";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { channelKey, shq } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { getAdapter } from "../adapters/registry.js";
 import { GATE_NAMES } from "../graph/schema.js";
@@ -9,13 +11,118 @@ import { captureLlmOutput } from "./llm.js";
 import { marginalCostRank } from "../route/router.js";
 import { reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
+import { shGit } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
+const TEST_FILE_RE = /(?:^|\/)[^/]*\.(?:test|spec)\.[cm]?[jt]sx?$/;
+// relative specifiers only — `from "./x.js"`, `import("./x.js")`, `require("./x.js")`
+const IMPORT_RE = /(?:\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*)["'](\.[^"']*)["']/g;
+const SELECTION_FILE_CAP = 3000;
+/**
+ * T4: the tests covering this round's diff, or undefined when the diff cannot be attributed with
+ * certainty — a rename or delete (the old path's coverage is gone), or a changed file no test
+ * reaches. Coverage: a test file covers itself; a test covers every file reachable from it through
+ * relative imports, directly or transitively.
+ *
+ * ponytail: ceiling — relative specifiers only (no tsconfig paths, no bare aliases, no computed
+ * specifiers), and an import cycle contributes only what it had resolved when re-entered. So this
+ * CAN miss. The miss is bounded by construction, not by care: the merge-candidate round re-runs the
+ * full suite on the same commit, so a miss costs one round and can never merge. Teach it a resolver
+ * (tsconfig paths, package exports) if selection ever misses often enough to be worth a round.
+ */
+async function coveringTests(worktree, baseRef) {
+    const diff = await shGit(`git diff --name-status ${shq(baseRef)} HEAD`, worktree);
+    if (diff.code !== 0)
+        return undefined;
+    const changed = [];
+    for (const line of diff.stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const status = parts[0] ?? "";
+        // R (rename) and D (delete): whatever used to cover the old path is unattributable now — full suite.
+        if (!status || status[0] === "R" || status[0] === "D" || parts.length < 2)
+            return undefined;
+        changed.push(parts[parts.length - 1]);
+    }
+    if (!changed.length)
+        return undefined;
+    const listed = await shGit("git ls-files", worktree);
+    if (listed.code !== 0)
+        return undefined;
+    const tracked = listed.stdout.split("\n").filter(Boolean);
+    if (tracked.length > SELECTION_FILE_CAP)
+        return undefined; // ponytail: a huge repo pays the full suite rather than a long scan
+    const trackedSet = new Set(tracked);
+    const tests = tracked.filter((p) => TEST_FILE_RE.test(p));
+    if (!tests.length)
+        return undefined;
+    const resolveSpec = (from, spec) => {
+        const base = posix.join(posix.dirname(from), spec);
+        // ESM-TS writes ".js" for a ".ts" source; a directory specifier means its index.
+        const candidates = [base, base.replace(/\.js$/, ".ts"), base.replace(/\.jsx$/, ".tsx"),
+            `${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`];
+        return candidates.find((c) => trackedSet.has(c));
+    };
+    const reachCache = new Map();
+    const reachOf = (file) => {
+        const cached = reachCache.get(file);
+        if (cached)
+            return cached;
+        const out = new Set();
+        reachCache.set(file, out); // cycle guard: a re-entered file contributes what it has so far
+        let src;
+        try {
+            src = readFileSync(posix.join(worktree, file), "utf8");
+        }
+        catch {
+            return out;
+        }
+        for (const m of src.matchAll(IMPORT_RE)) {
+            const dep = m[1] ? resolveSpec(file, m[1]) : undefined;
+            if (!dep || out.has(dep))
+                continue;
+            out.add(dep);
+            for (const t of reachOf(dep))
+                out.add(t);
+        }
+        return out;
+    };
+    const selected = new Set();
+    for (const file of changed) {
+        if (TEST_FILE_RE.test(file)) {
+            selected.add(file);
+            continue;
+        }
+        const covering = tests.filter((t) => reachOf(t).has(file));
+        if (!covering.length)
+            return undefined; // nothing covers this file — only the full suite can speak for it
+        for (const t of covering)
+            selected.add(t);
+    }
+    return [...selected].sort();
+}
+/**
+ * The configured test command narrowed to these files. Mirrors testFiltered's `--` rule (acceptance.ts:104):
+ * npm/yarn/pnpm/npx script wrappers need one `--` to forward positional filters to the underlying runner;
+ * a command that already has `--` takes them directly. Every path is quoted — config flows into a shell.
+ */
+export function testCommandForFiles(testCmd, files) {
+    const wrapped = /^\s*(?:npm|yarn|pnpm|npx)\b/.test(testCmd);
+    const fwd = wrapped && !/\s--\s/.test(testCmd) ? " --" : "";
+    return `${testCmd}${fwd} ${files.map(shq).join(" ")}`;
+}
 export async function runGates(task, ctx) {
     const results = [];
     let commits = [];
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
+    const v185 = ctx.pipeline === "v185";
+    // T4 (OBS-265): a GREEN selected-test run is a screen, not the round's verdict — the merge-candidate
+    // round re-runs the full suite on the same commit and THAT is what the round reports. Held here so
+    // exactly one `test` gate-result ever leaves a round, always carrying which suite spoke for it.
+    // (A RED screen IS the verdict: the round ends there, so it is recorded immediately.)
+    let heldTest;
     const sequence = GATE_NAMES.filter((g) => enabled(g));
     const total = sequence.length;
     const indexOf = (gate) => sequence.indexOf(gate) + 1;
@@ -23,42 +130,109 @@ export async function runGates(task, ctx) {
         results.push(result);
         await ctx.onGate?.({ phase: "end", gate: result.gate, result });
     };
-    const emitStart = async (gate) => {
-        await ctx.onGate?.({ phase: "start", gate, index: indexOf(gate), total });
+    const emitStart = async (gate, parentAt) => {
+        await ctx.onGate?.({ phase: "start", gate, index: indexOf(gate), total, ...(parentAt === undefined ? {} : { parentAt }) });
+    };
+    // The returned array stays in GATE_NAMES order however few gates a short-circuiting round reached.
+    // A round that ends before its merge-candidate stage flushes the held screen on the way out, so a
+    // green subset run is still journaled exactly once — as a selected run, which is what it was.
+    const done = async () => {
+        if (heldTest) {
+            const held = heldTest;
+            heldTest = undefined;
+            await ctx.onGate?.({ phase: "end", gate: "test", result: held });
+        }
+        return {
+            results: [...results].sort((a, b) => GATE_NAMES.indexOf(a.gate) - GATE_NAMES.indexOf(b.gate)),
+            commits,
+        };
     };
-    // 1. build/test/lint vs shared baseline — deterministic and cheap, first
     const toolGates = ["build", "test", "lint"].filter(enabled);
-    if (toolGates.length) {
-        // ponytail: compareToBaseline batches build/test/lint — their starts are emitted at iteration,
-        // not at true execution start. They are collectively sub-second (measured), so the debounce
-        // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
-        const toolResults = await compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, toolGates);
-        for (const r of toolResults) {
-            await emitStart(r.gate);
-            await record(r);
+    // build/test/lint vs the shared baseline
+    const runBattery = async (commands, selected) => {
+        if (!toolGates.length)
+            return;
+        if (!v185) {
+            // ponytail: compareToBaseline batches build/test/lint — their starts are emitted at iteration,
+            // not at true execution start. They are collectively sub-second (measured), so the debounce
+            // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
+            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, toolGates);
+            for (const r of toolResults) {
+                await emitStart(r.gate);
+                await record(r);
+            }
+            return;
         }
-        if (failed())
-            return { results, commits };
-    }
-    // 2. evidence — did the worker actually commit anything?
-    if (enabled("evidence")) {
-        await emitStart("evidence");
+        // T4 (OBS-265): one command at a time, stopping at the first red — a failed build no longer buys
+        // the full vitest suite before anyone reads its verdict.
+        for (const g of toolGates) {
+            await emitStart(g);
+            const [r] = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [g]);
+            if (g === "test" && selected) {
+                const screened = { ...r, meta: { ...r.meta, selectedTests: selected } };
+                // green: held (see heldTest) so the full suite below can supersede it with ONE verdict.
+                if (!screened.pass)
+                    await record(screened);
+                else {
+                    heldTest = screened;
+                    results.push(screened);
+                }
+            }
+            else {
+                await record(r);
+            }
+            if (failed())
+                return;
+        }
+    };
+    // The two sub-second git checks, as pure verdicts: no journal, no results push. Both read committed
+    // state only (commits ahead of base, `git diff --name-only base..HEAD`), so neither can be moved by
+    // anything the battery does to the worktree — which is what lets the screen below trust them early.
+    const evidenceResult = async () => {
         const e = await evidenceGate(ctx.worktree, ctx.baseRef);
         commits = e.commits;
-        await record({ gate: e.gate, pass: e.pass, details: e.details });
-        if (!e.pass)
-            return { results, commits };
-    }
-    // 3. scope
-    if (enabled("scope")) {
-        await emitStart("scope");
-        await record(await scopeGate(ctx.worktree, ctx.baseRef, task.files, ctx.result, ctx.cfg.scope?.allowDeviations ?? []));
-        if (failed())
-            return { results, commits };
-    }
-    // 4. acceptance judge (first LLM spend — everything cheaper already passed)
-    if (enabled("acceptance")) {
-        await emitStart("acceptance");
+        return { gate: e.gate, pass: e.pass, details: e.details };
+    };
+    const scopeResult = () => scopeGate(ctx.worktree, ctx.baseRef, task.files, ctx.result, ctx.cfg.scope?.allowDeviations ?? []);
+    const runGate = async (gate, compute) => {
+        await emitStart(gate);
+        await record(await compute());
+    };
+    /**
+     * T4 (OBS-265): the deterministic git checks run BEFORE the battery, as a screen — they answer
+     * "is this diff worth starting a ~3.7m tool battery for?" before the first command runs. A red
+     * screen IS the round's verdict: what it produced is journaled (in the order it ran) and the round
+     * ends there, so a drive-by out-of-scope edit costs <1s instead of the whole battery.
+     *
+     * A green screen changes nothing downstream. The recorded sequence stays GATE_NAMES order, so the
+     * journal, `tickmarkr report`, the surfaces, and resume's GATE_NAMES walk over already-satisfied
+     * gates all keep reading exactly one order.
+     *
+     * ponytail: the price of that is re-reading two git checks (~40ms) in their canonical positions
+     * rather than teaching every consumer of the gate stream a second order. Both reads see the same
+     * commits — the battery never moves HEAD — so the screen cannot disagree with the gate it screens
+     * for. Charge it only when there IS a battery command to protect.
+     */
+    const screenBlocks = async () => {
+        if (!toolGates.some((g) => ctx.commands[g]))
+            return false;
+        const screened = [];
+        for (const [gate, compute] of [["evidence", evidenceResult], ["scope", scopeResult]]) {
+            if (!enabled(gate))
+                continue;
+            screened.push(await compute());
+            if (screened[screened.length - 1].pass)
+                continue;
+            for (const r of screened) {
+                await emitStart(r.gate);
+                await record(r);
+            }
+            return true;
+        }
+        return false;
+    };
+    // acceptance judge — LLM spend, so everything deterministic has already passed when this runs
+    const runAcceptance = async () => {
         const judgeAdapter = getAdapter(ctx.cfg.judge.adapter, ctx.adapters);
         const jvia = ctx.via
             ? { driver: ctx.via.driver, keep: ctx.via.keep, onSlot: ctx.via.onSlot, name: ctx.via.nameFor("judge", judgeAdapter.id), label: ctx.via.labelFor("judge") }
@@ -121,13 +295,10 @@ export async function runGates(task, ctx) {
             a = await invokeJudge(retryAdapter, retry.model, retryJvia);
             a = { ...a, meta: { ...a.meta, judgeRetry: { flaked: flakedKey, retried: channelKey({ adapter: retry.adapter, model: retry.model }) } } };
         }
-        await withJudgeInvocationEvidence(invocations, () => record(a));
-        if (failed())
-            return { results, commits };
-    }
-    // 5. cross-vendor review
-    if (enabled("review")) {
-        await emitStart("review");
+        return { result: a, invocations };
+    };
+    // cross-vendor review
+    const runReview = async () => {
         let rv = await reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, ctx.adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir);
         // OBS-193: an unparseable review verdict retries the REVIEW exactly once on a different reviewer —
         // never the worker (GATE-09's judge-retry shape: straight-line single `if`, meta-only detection,
@@ -145,7 +316,80 @@ export async function runGates(task, ctx) {
                 rv = { ...second, meta: { ...second.meta, reviewRetry: { flaked, retried } } };
             }
         }
-        await record(rv);
+        return rv;
+    };
+    if (v185 && await screenBlocks())
+        return done();
+    // A non-final round may run only the tests covering its own diff; the merge-candidate round below
+    // pays the full suite anyway, so a selection that misses costs a round and can never merge.
+    const selected = v185 && ctx.selectTests && enabled("test") && ctx.commands.test
+        ? await coveringTests(ctx.worktree, ctx.baseRef)
+        : undefined;
+    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected);
+    if (failed())
+        return done();
+    if (enabled("evidence")) {
+        await runGate("evidence", evidenceResult);
+        if (failed())
+            return done();
+    }
+    if (enabled("scope")) {
+        await runGate("scope", scopeResult);
+        if (failed())
+            return done();
+    }
+    if (v185 && (enabled("acceptance") || enabled("review"))) {
+        // Judge and review are launched TOGETHER (96m of serialization over 5 runs). Enforcement is
+        // unchanged — it is still the AND of both, both still fail closed, and neither reads the other's
+        // verdict: each gets the same commit and the same brief it always got, and neither promise is
+        // reachable from inside the other. Only the waiting is gone.
+        const parentAt = Date.now();
+        // Both starts are emitted before either gate is launched, so the stream's order is the round's
+        // order and not a race between two dispatches. BOTH ARE IN FLIGHT BEFORE EITHER IS AWAITED:
+        // whichever adapter is slower no longer decides when the other one runs.
+        if (enabled("acceptance"))
+            await emitStart("acceptance", parentAt);
+        if (enabled("review"))
+            await emitStart("review", parentAt);
+        const judging = enabled("acceptance") ? runAcceptance() : undefined;
+        const reviewing = enabled("review") ? runReview() : undefined;
+        // Attach BOTH publication handlers before awaiting either. Dispatch concurrency alone is not
+        // enough: an acceptance-first await withholds a completed review behind a slow/hung judge and a
+        // process death can lose that already-earned verdict. The returned result is still sorted into
+        // GATE_NAMES order by done(); the event stream truthfully records each independent completion.
+        const judged = judging?.then((outcome) => withJudgeInvocationEvidence(outcome.invocations, () => record(outcome.result)));
+        const reviewed = reviewing?.then((outcome) => record(outcome));
+        await Promise.all([judged, reviewed]);
+        if (failed())
+            return done();
+    }
+    else if (!v185) {
+        // Legacy serial walk — frozen, and reachable only from the fixtures that pin it.
+        if (enabled("acceptance")) {
+            await emitStart("acceptance");
+            const judged = await runAcceptance();
+            await withJudgeInvocationEvidence(judged.invocations, () => record(judged.result));
+            if (failed())
+                return done();
+        }
+        if (enabled("review")) {
+            await emitStart("review");
+            await record(await runReview());
+        }
+        return done();
+    }
+    // The merge-candidate round: every other gate is green, so THIS round is the one that can merge —
+    // the full suite runs on the exact gated commit before the pipeline reports green. Nothing merges
+    // on a subset (spec: "nothing merges without a complete green suite"). Its verdict SUPERSEDES the
+    // held screen rather than joining it: one `test` entry in the record, one `test` end event in the
+    // stream, and `fullSuite` says which suite spoke while `selectedTests` keeps what the screen ran.
+    if (selected) {
+        await emitStart("test");
+        const [full] = await compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"]);
+        const merged = { ...full, meta: { ...full.meta, fullSuite: true, selectedTests: selected } };
+        results[results.findIndex((r) => r.gate === "test")] = merged;
+        heldTest = undefined;
+        await ctx.onGate?.({ phase: "end", gate: "test", result: merged });
     }
-    return { results, commits };
+    return done();
 }

package/dist/gates/verdict-cause.d.ts

@@ -0,0 +1,4 @@
+export type VerdictDiscriminator = "approve" | "pass" | "ok" | "action";
+export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict";
+export declare function hasVerdictParticipationWitness(raw: string, nonce: string, discriminator: VerdictDiscriminator): boolean;
+export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator): VerdictUnparseableCause;

package/dist/gates/verdict-cause.js

@@ -0,0 +1,63 @@
+const MAX_WITNESS_BYTES = 4096;
+const JSON_STRING_VALUE = String.raw `"(?:\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4})|[^"\\\u0000-\u001F])*"`;
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Pane renderers hard-wrap at physical columns and prefix continuation lines with whitespace or box
+// chrome. Joining those renderer lines is deliberately narrower than parsing: it restores split keys,
+// values and delimiters, but it does not require the response to be complete or valid JSON.
+function joinRendererLines(raw) {
+    return raw.replace(/\r\n?/g, "\n").split("\n")
+        .map((line) => line.replace(/^[\t │|]+/, "").replace(/[\t │|]+$/, ""))
+        .join("");
+}
+// Yield only the first structural prefix of each object candidate. Stopping at the next unquoted
+// opening brace prevents a nonce from one object binding a discriminator from another; the prompts
+// put their discriminator before any nested object, so no valid boundary shape is lost.
+function objectPrefixes(raw) {
+    const joined = joinRendererLines(raw);
+    const prefixes = [];
+    for (let open = joined.indexOf("{"); open !== -1; open = joined.indexOf("{", open + 1)) {
+        const ceiling = Math.min(joined.length, open + MAX_WITNESS_BYTES);
+        let end = ceiling;
+        let quoted = false;
+        let escaped = false;
+        for (let i = open + 1; i < ceiling; i++) {
+            const char = joined[i];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (char === "\\")
+                    escaped = true;
+                else if (char === '"')
+                    quoted = false;
+                continue;
+            }
+            if (char === '"')
+                quoted = true;
+            else if (char === "{") {
+                end = i;
+                break;
+            }
+            else if (char === "}") {
+                end = i + 1;
+                break;
+            }
+        }
+        prefixes.push(joined.slice(open, end));
+    }
+    return prefixes;
+}
+export function hasVerdictParticipationWitness(raw, nonce, discriminator) {
+    const noncePattern = new RegExp(String.raw `"nonce"\s*:\s*${escapeRegex(JSON.stringify(nonce))}\s*[,]`);
+    const valuePattern = discriminator === "action" ? JSON_STRING_VALUE : "(?:true|false)";
+    const discriminatorPattern = new RegExp(String.raw `"${discriminator}"\s*:\s*${valuePattern}\s*[,}]`);
+    return objectPrefixes(raw).some((prefix) => noncePattern.test(prefix) && discriminatorPattern.test(prefix));
+}
+export function classifyVerdictCause(raw, nonce, discriminator) {
+    if (raw.trim().length === 0)
+        return "empty-output";
+    return hasVerdictParticipationWitness(raw, nonce, discriminator)
+        ? "malformed-verdict"
+        : "no-verdict";
+}

package/dist/graph/schema.d.ts

@@ -12,9 +12,11 @@ export type Oracle = (typeof ORACLES)[number];
 export declare const AcceptanceItemSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     oracle: z.ZodLiteral<"command">;
     command: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     oracle: z.ZodLiteral<"test">;
     test: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     oracle: z.ZodLiteral<"judge">;
     text: z.ZodString;
@@ -43,9 +45,11 @@ export declare const TaskSchema: z.ZodObject<{
     acceptance: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         oracle: z.ZodLiteral<"command">;
         command: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         oracle: z.ZodLiteral<"test">;
         test: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         oracle: z.ZodLiteral<"judge">;
         text: z.ZodString;
@@ -133,9 +137,11 @@ export declare const RunGraphSchema: z.ZodObject<{
         acceptance: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             oracle: z.ZodLiteral<"command">;
             command: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             oracle: z.ZodLiteral<"test">;
             test: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             oracle: z.ZodLiteral<"judge">;
             text: z.ZodString;

package/dist/graph/schema.js

@@ -11,11 +11,14 @@ export const TIERS = ["cheap", "mid", "frontier"];
 // A plain string is the read-old/write-new compat form — semantically a judge oracle (spec §2).
 export const ORACLES = ["command", "test", "judge"];
 // Typed acceptance oracle: command carries the thing to run, test the test name, judge free text.
-// Anything else (a typed object naming an unknown oracle) fails validation loudly here.
+// text is OPTIONAL non-empty on command/test (declared prose beside the oracle; judge requires it).
+// Declaring it matters: z.object strips unknown keys, and loadGraph revalidates on every read —
+// an undeclared text would be silently discarded at the next load. Anything else (a typed object
+// naming an unknown oracle, or a text that is not a non-empty string) fails validation loudly here.
 export const AcceptanceItemSchema = z.union([
     z.string().min(1),
-    z.object({ oracle: z.literal("command"), command: z.string().min(1) }),
-    z.object({ oracle: z.literal("test"), test: z.string().min(1) }),
+    z.object({ oracle: z.literal("command"), command: z.string().min(1), text: z.string().min(1).optional() }),
+    z.object({ oracle: z.literal("test"), test: z.string().min(1), text: z.string().min(1).optional() }),
     z.object({ oracle: z.literal("judge"), text: z.string().min(1) }),
 ]);
 // Shared text rendering of one acceptance item — every consumer (worker prompt, acceptance gate,
@@ -24,9 +27,9 @@ export function renderAcceptanceItem(item) {
     if (typeof item === "string")
         return item;
     if (item.oracle === "command")
-        return `$ ${item.command}`;
+        return item.text ?? `$ ${item.command}`;
     if (item.oracle === "test")
-        return `test: ${item.test}`;
+        return item.text ?? `test: ${item.test}`;
     return item.text; // judge — bare text, byte-identical to a plain-string judge criterion
 }
 export const TaskSchema = z.object({

package/dist/route/router.d.ts

@@ -19,11 +19,6 @@ export interface Route {
     deviation?: RouteDeviation;
 }
 export interface RoutingPreferContext {
-    autoPrefer?: {
-        derivedAt: string;
-        [shape: string]: string[] | string;
-    };
-    doctorFresh: boolean;
     overlayPreferShapes: ReadonlySet<string>;
 }
 export interface ExploreContext {

package/dist/route/router.js

@@ -28,19 +28,9 @@ const exploreOff = (task, cfg, exploreCtx) => {
         return true;
     return false;
 };
-const autoPreferList = (doc, shape) => {
-    const v = doc?.[shape];
-    return Array.isArray(v) ? v : undefined;
-};
-const preferFromAuto = (shape, preferCtx) => !!preferCtx?.doctorFresh && !!preferCtx.autoPrefer && !preferCtx.overlayPreferShapes.has(shape) &&
-    autoPreferList(preferCtx.autoPrefer, shape) !== undefined;
-const effectivePrefer = (shape, entry, preferCtx) => {
-    if (preferCtx?.overlayPreferShapes.has(shape))
-        return entry?.prefer;
-    if (preferCtx?.doctorFresh && preferCtx.autoPrefer)
-        return autoPreferList(preferCtx.autoPrefer, shape) ?? entry?.prefer;
-    return entry?.prefer;
-};
+// v1.86 T3: autoPrefer is deleted — prefer is operator-declared only. Nothing is ever derived
+// from probe health, tier data, or a machine-built shape table.
+const effectivePrefer = (entry) => entry?.prefer;
 export class RoutingError extends Error {
     constructor(msg) {
         super(msg);
@@ -134,7 +124,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     // ponytail: sla is plan-time advisory only — never thread into learnedScore (would reroute warm rivals).
     const scoreOpts = { availWeight: cfg.routing.learnedTuning?.availWeight };
     const entry = cfg.routing.map[task.shape];
-    const prefer = effectivePrefer(task.shape, entry, preferCtx);
+    const prefer = effectivePrefer(entry);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
         const d = disallowedBy({ adapter: via, model }, cfg.routing);
@@ -167,6 +157,14 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
     };
     const taskFloor = task.routingHints?.floor;
+    const mapPinFloor = taskFloor && (!advisoryFloor || TIER_RANK[taskFloor] >= TIER_RANK[advisoryFloor])
+        ? { tier: taskFloor, source: "task" }
+        : advisoryFloor ? { tier: advisoryFloor, source: "config" } : undefined;
+    const lintMapPinFloor = (tier) => {
+        if (mapPinFloor && TIER_RANK[tier] < TIER_RANK[mapPinFloor.tier]) {
+            lints.push(`${task.id} (${task.shape}): map pin routes ${tier}, below ${mapPinFloor.source} floor ${mapPinFloor.tier} — map pins are supreme`);
+        }
+    };
     const source = task.routingHints?.source;
     const src = source ? `, ${source}` : ""; // never interpolate a possibly-undefined source
     // task pin: planner-authored, try-first — degrades on miss or below-floor (D-05, research A3), never throws
@@ -188,12 +186,13 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     if (entry?.pin) {
         disallowedPin(entry.pin.via, entry.pin.model, "map pin (config routing.map)");
         const c = resolvePin(entry.pin, channels);
-        lintFloor(c.tier, "map pin");
+        lintMapPinFloor(c.tier);
         maybeSlaLint(lints, task, profile, slaMinutes, c);
         return { assignment: toAssignment(c), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pin ${entry.pin.via}:${entry.pin.model} (config routing.map)` };
     }
     const baseTier = floor ?? "cheap";
-    const minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier; // task floor is a hard >= constraint in all paths (D-04)
+    // D-04: a task floor is hard only on floor/auto paths; the map-pin branch above stays supreme.
+    const minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier;
     if (prefActive)
         for (const p of prefer ?? [])
             preflightPrefer(p);
@@ -293,13 +292,10 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
             "tier cheap (default)";
     // name the key that actually broke the tie: prefer outranks the marginal-cost/tier keys, so if the
     // winner matched a prefer entry, prefer decided it — not "cheapest sufficient tier" (ROUTE-03, WR-01)
-    const preferVia = preferFromAuto(task.shape, preferCtx)
-        ? `via prefer (auto-modernized ${preferCtx.autoPrefer.derivedAt.slice(0, 10)})`
-        : "via prefer";
     // a spread-decided winner is never inside a prefer band (the spread skips those runs), so the
     // three arms below are mutually exclusive by construction
     const chosenBy = learnedChosen || (spreadDecided ? "via frontier spread"
-        : prefer && preferIndex(eligible[0], prefer) < prefer.length ? preferVia : "cheapest sufficient tier");
+        : prefer && preferIndex(eligible[0], prefer) < prefer.length ? "via prefer" : "cheapest sufficient tier");
     maybeSlaLint(lints, task, profile, slaMinutes, eligible[0]);
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }

package/dist/run/consult.d.ts

@@ -2,6 +2,7 @@ import type { WorkerAdapter } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 import type { GateResult } from "../gates/types.js";
+import { type VerdictUnparseableCause } from "../gates/verdict-cause.js";
 export interface ConsultVerdict {
     action: "retry" | "reroute" | "decompose" | "human";
     notes: string;
@@ -23,6 +24,11 @@ export interface Dossier {
     diff: string;
     gates: GateResult[];
 }
+export interface ConsultParseResult {
+    verdict: ConsultVerdict | null;
+    cause?: VerdictUnparseableCause;
+}
+export declare function parseConsultVerdict(out: string, nonce: string): ConsultParseResult;
 export declare function buildDossierPrompt(d: Dossier, nonce: string): string;
 export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
     keep?: boolean;