tickmarkr 1.46.0 → 1.47.0

package/dist/config/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parse } from "yaml";
+import { parse, stringify } from "yaml";
 import { z } from "zod";
 import { stateDirName } from "../graph/graph.js";
 import { SHAPES, TIERS } from "../graph/schema.js";
@@ -20,6 +20,8 @@ export const TierEntrySchema = z.object({
     vendor: z.string(),
     channel: z.enum(["sub", "api"]),
     models: z.record(z.string(), TierEnum),
+    // v1.47 T3: optional per-model context-window sizes (tokens). Absent block ⇒ no doctor column, no plan lint.
+    windows: z.record(z.string(), z.number().int().positive()).optional(),
 });
 // v1.10 FLEET-06: optional routing.allow/deny fleet preference; absent blocks ⇒ byte-identical routing/discovery.
 // deny wins on conflict; presence of allow (even {} / empty arrays) activates allowlist (fail-closed).
@@ -87,6 +89,15 @@ export const TickmarkrConfigSchema = z.object({
             halfLifeRuns: z.number().positive().optional(),
             availWeight: z.number().nonnegative().optional(),
         }).optional(),
+        // E3 (v1.45-T3): optional exploration fence — absent block ⇒ byte-identical to pre-v1.45 routing.
+        explore: z.object({
+            mode: z.enum(["on", "off"]).optional(),
+            excludeShapes: z.array(z.string()).optional(),
+            excludeComplexityAtOrAbove: z.number().int().min(1).max(10).nullable().optional(),
+            cap: z.number().int().positive().optional(),
+        }).optional(),
+        // v1.47 T4: per-shape time SLA in minutes — advisory plan lint only; absent ⇒ byte-identical routing.
+        sla: z.record(z.string(), z.number().positive()).optional(),
         // Pre-v1.21 doctor.json lacks per-model verdicts. Keep legacy unknown-is-routable behavior opt-in.
         allowUnverifiedModels: z.boolean(),
         allow: PrefBlockSchema.optional(),
@@ -305,6 +316,8 @@ export function configTemplate(overlay) {
 #     migration: frontier
 #   learned: on            # default ON (ROUTE-14); cold profile = exact v1.5 static routing, warms per workspace. Set 'off' to pin static routing; preview with 'tickmarkr plan'
 #   learnedTuning: { halfLifeRuns: 5, availWeight: 0.05 }  # optional; defaults byte-identical
+#   explore: { mode: on, excludeShapes: [], excludeComplexityAtOrAbove: null, cap: 5 }  # optional; absent ⇒ byte-identical
+#   sla: { implement: 15 }  # optional per-shape minutes — advisory plan lint only; absent ⇒ no lint
 #   allow: { adapters: [claude-code, codex] }   # optional fleet allowlist; presence activates even if empty (fail-closed)
 #   deny: { models: [codex:gpt-5.5] }           # optional fleet denylist; deny beats allow on conflict
 #   # entry grammar: adapter id | model id | adapter:model (entries in either list accept all three forms)
@@ -365,3 +378,277 @@ export function configTemplate(overlay) {
     const nl = base.indexOf("\n");
     return `${base.slice(0, nl + 1)}${lines.join("\n")}\n${base.slice(nl + 1)}`;
 }
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
+export function repoOverlayPath(repoRoot) {
+    return join(repoRoot, stateDirName(repoRoot), "config.yaml");
+}
+export function readOverlayFile(path) {
+    const raw = readYaml(path);
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== "object" || Array.isArray(raw))
+        throw new ConfigError(`invalid overlay at ${path}`);
+    return raw;
+}
+export function fleetEditableFromConfig(cfg) {
+    const tiers = {};
+    for (const [adapter, entry] of Object.entries(cfg.tiers)) {
+        tiers[adapter] = {};
+        for (const [model, tier] of Object.entries(entry.models))
+            tiers[adapter][model] = { tier };
+    }
+    return {
+        denyAdapters: [...(cfg.routing.deny?.adapters ?? [])].sort(),
+        denyModels: [...(cfg.routing.deny?.models ?? [])].sort(),
+        tiers,
+        map: structuredClone(cfg.routing.map),
+        floors: { ...cfg.routing.floors },
+    };
+}
+function fleetSubset(obj) {
+    const out = {};
+    for (const k of FLEET_OVERLAY_KEYS) {
+        if (obj[k] !== undefined)
+            out[k] = obj[k];
+    }
+    return out;
+}
+/** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
+export function fleetKeyLayer(repoRoot, dotted, opts = {}) {
+    const gdir = opts.globalDir ?? globalConfigDir();
+    const globalRaw = readOverlayFile(join(gdir, "config.yaml"));
+    const repoRaw = readOverlayFile(repoOverlayPath(repoRoot));
+    const parts = dotted.split(".");
+    const at = (layer) => {
+        let cur = layer;
+        for (const p of parts) {
+            if (cur === undefined || cur === null || typeof cur !== "object" || Array.isArray(cur))
+                return undefined;
+            cur = cur[p];
+        }
+        return cur;
+    };
+    if (at(repoRaw) !== undefined)
+        return "repo";
+    if (at(globalRaw) !== undefined)
+        return "global";
+    return "defaults";
+}
+/** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
+export function formatFleetPrint(repoRoot, opts = {}) {
+    const gdir = opts.globalDir ?? globalConfigDir();
+    const effective = loadConfig(repoRoot, { globalDir: gdir });
+    const editable = fleetEditableFromConfig(effective);
+    const lines = ["# tickmarkr fleet — effective state (repo > global > defaults)"];
+    const annotate = (dotted, yaml) => `${yaml}  # ${fleetKeyLayer(repoRoot, dotted, opts)}`;
+    const denyAdapters = editable.denyAdapters;
+    const denyModels = editable.denyModels;
+    if (denyAdapters.length || denyModels.length) {
+        lines.push("routing:");
+        lines.push("  deny:");
+        if (denyAdapters.length)
+            lines.push(annotate("routing.deny.adapters", `    adapters: ${stringify(denyAdapters).trim()}`));
+        if (denyModels.length)
+            lines.push(annotate("routing.deny.models", `    models: ${stringify(denyModels).trim()}`));
+    }
+    const mapKeys = Object.keys(editable.map).sort();
+    if (mapKeys.length) {
+        if (!lines.some((l) => l === "routing:"))
+            lines.push("routing:");
+        lines.push("  map:");
+        for (const shape of mapKeys) {
+            const entry = editable.map[shape];
+            const body = stringify(entry, { indent: 4 }).trim().split("\n").map((l) => `    ${l}`).join("\n");
+            lines.push(annotate(`routing.map.${shape}`, `    ${shape}:`));
+            lines.push(body.split("\n").slice(1).join("\n"));
+        }
+    }
+    const floorKeys = Object.keys(editable.floors).sort();
+    if (floorKeys.length) {
+        if (!lines.some((l) => l === "routing:"))
+            lines.push("routing:");
+        lines.push(annotate("routing.floors", `  floors: ${stringify(Object.fromEntries(floorKeys.map((k) => [k, editable.floors[k]]))).trim().replace(/^/gm, "  ")}`));
+    }
+    const tierAdapters = Object.keys(editable.tiers).sort();
+    if (tierAdapters.length) {
+        lines.push("tiers:");
+        for (const adapter of tierAdapters) {
+            const models = editable.tiers[adapter];
+            const modelIds = Object.keys(models).sort();
+            if (!modelIds.length)
+                continue;
+            lines.push(`  ${adapter}:`);
+            lines.push("    models:");
+            for (const model of modelIds) {
+                const v = models[model];
+                if (v === null)
+                    lines.push(`      ${model}: null`);
+                else
+                    lines.push(annotate(`tiers.${adapter}.models.${model}`, `      ${model}: ${v.tier}`));
+            }
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function sortedUnique(xs) {
+    return [...new Set(xs)].sort();
+}
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}) {
+    if (fleetEditableEquals(initial, edited))
+        return {};
+    const out = structuredClone(existingRepo);
+    const routing = { ...out.routing };
+    let routingTouched = false;
+    const denyChanged = sortedUnique(initial.denyAdapters).join() !== sortedUnique(edited.denyAdapters).join()
+        || sortedUnique(initial.denyModels).join() !== sortedUnique(edited.denyModels).join();
+    if (denyChanged) {
+        routing.deny = {
+            adapters: edited.denyAdapters.length ? edited.denyAdapters : null,
+            models: edited.denyModels.length ? edited.denyModels : null,
+        };
+        routingTouched = true;
+    }
+    const mapDelta = {};
+    for (const shape of new Set([...Object.keys(initial.map), ...Object.keys(edited.map)])) {
+        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape]))
+            mapDelta[shape] = edited.map[shape];
+    }
+    if (Object.keys(mapDelta).length) {
+        routing.map = { ...routing.map, ...mapDelta };
+        routingTouched = true;
+    }
+    const floorDelta = {};
+    for (const shape of new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)])) {
+        if (initial.floors[shape] !== edited.floors[shape])
+            floorDelta[shape] = edited.floors[shape];
+    }
+    if (Object.keys(floorDelta).length) {
+        routing.floors = { ...routing.floors, ...floorDelta };
+        routingTouched = true;
+    }
+    if (routingTouched)
+        out.routing = routing;
+    const tiersOut = {
+        ...out.tiers,
+    };
+    let tiersTouched = false;
+    const adapters = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
+    for (const adapter of adapters) {
+        const models = new Set([
+            ...Object.keys(initial.tiers[adapter] ?? {}),
+            ...Object.keys(edited.tiers[adapter] ?? {}),
+        ]);
+        const modelDelta = {};
+        for (const model of models) {
+            const a = initial.tiers[adapter]?.[model];
+            const b = edited.tiers[adapter]?.[model];
+            if (JSON.stringify(a) !== JSON.stringify(b)) {
+                modelDelta[model] = b === null || b === undefined ? null : b.tier;
+            }
+        }
+        if (Object.keys(modelDelta).length) {
+            tiersOut[adapter] = { models: { ...tiersOut[adapter]?.models, ...modelDelta } };
+            tiersTouched = true;
+        }
+    }
+    if (tiersTouched)
+        out.tiers = tiersOut;
+    return out;
+}
+export function repoOverlayYaml(overlay, provenance = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const fleet = fleetSubset(overlay);
+    const fleetBody = serializeFleetOverlay(fleet, provenance);
+    const rest = { ...overlay };
+    for (const k of FLEET_OVERLAY_KEYS)
+        delete rest[k];
+    if (!Object.keys(rest).length)
+        return fleetBody;
+    const head = stringify(rest).trimEnd();
+    return fleetBody ? `${head}\n${fleetBody}` : `${head}\n`;
+}
+export function serializeFleetOverlay(overlay, provenance = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const lines = [];
+    const today = new Date().toISOString().slice(0, 10);
+    const routing = overlay.routing;
+    if (routing) {
+        lines.push("routing:");
+        const deny = routing.deny;
+        if (deny) {
+            lines.push("  deny:");
+            if (deny.adapters)
+                lines.push(`    adapters: ${stringify(deny.adapters).trim()}`);
+            if (deny.models)
+                lines.push(`    models: ${stringify(deny.models).trim()}`);
+        }
+        if (routing.map) {
+            lines.push("  map:");
+            for (const [shape, entry] of Object.entries(routing.map)) {
+                lines.push(`    ${shape}:`);
+                const body = stringify(entry, { indent: 2 }).trim().split("\n");
+                lines.push(...body.map((l) => `      ${l}`));
+            }
+        }
+        if (routing.floors)
+            lines.push(`  floors: ${stringify(routing.floors).trim().replace(/^/gm, "  ")}`);
+    }
+    const tiers = overlay.tiers;
+    if (tiers) {
+        lines.push("tiers:");
+        for (const [adapter, entry] of Object.entries(tiers)) {
+            lines.push(`  ${adapter}:`);
+            if (entry.vendor)
+                lines.push(`    vendor: ${entry.vendor}`);
+            if (entry.channel)
+                lines.push(`    channel: ${entry.channel}`);
+            lines.push("    models:");
+            for (const [model, tier] of Object.entries(entry.models ?? {})) {
+                if (tier === null)
+                    lines.push(`      ${model}: null`);
+                else {
+                    const note = provenance[adapter]?.[model];
+                    const suffix = note ? `  # ${note} — fleet ${today}` : "";
+                    lines.push(`      ${model}: ${tier}${suffix}`);
+                }
+            }
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function unifiedYamlDiff(before, after, label = "config overlay") {
+    const a = before.split("\n");
+    const b = after.split("\n");
+    if (before === after)
+        return "";
+    const header = [`--- ${label} (current)`, `+++ ${label} (proposed)`];
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        const startI = i;
+        const startJ = j;
+        while (i < a.length && (j >= b.length || a[i] !== b[j]))
+            i++;
+        while (j < b.length && (i >= a.length || a[i] !== b[j]))
+            j++;
+        hunks.push("@@");
+        for (let k = startI; k < i; k++)
+            hunks.push(`-${a[k]}`);
+        for (let k = startJ; k < j; k++)
+            hunks.push(`+${b[k]}`);
+    }
+    return `${header.join("\n")}\n${hunks.join("\n")}\n`;
+}
+export function fleetEditableEquals(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/dist/gates/acceptance.js

@@ -61,14 +61,19 @@ const isTest = (a) => typeof a === "object" && a.oracle === "test";
 const isJudge = (a) => typeof a === "string" || (typeof a === "object" && a.oracle === "judge");
 // npm/yarn/pnpm/npx script wrappers need `--` to forward -t to the underlying vitest/jest runner; a bare
 // runner (vitest/jest) takes -t directly. -t is the shared testNamePattern shorthand both honor.
+// OBS-62: vitest -t treats the name as a regex — escape metachars so a verbatim-titled test matches.
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 // OBS-55: when the base command already contains `--`, append -t after forwarded args — a second `--`
 // makes vitest treat -t as a positional file filter and the name filter is dropped.
 export function testFiltered(testCmd, name) {
+    const pattern = escapeRegExp(name);
     const wrapped = /^\s*(npm|yarn|pnpm|npx)\b/.test(testCmd);
     if (wrapped && /\s--\s/.test(testCmd))
-        return `${testCmd} -t ${shq(name)}`;
+        return `${testCmd} -t ${shq(pattern)}`;
     const fwd = wrapped ? "-- " : "";
-    return `${testCmd} ${fwd}-t ${shq(name)}`;
+    return `${testCmd} ${fwd}-t ${shq(pattern)}`;
 }
 // vitest/jest summary: "Tests  N passed | M skipped (T)" — count passed+failed as actually ran.
 function testsRan(output) {

package/dist/gates/scope.d.ts

@@ -1,8 +1,9 @@
 import type { WorkerResult } from "../adapters/types.js";
 import type { GateResult } from "./types.js";
+export declare function scopeDiffBase(worktree: string, integrationTip: string): Promise<string>;
 /** Pure offender split — corpus-replay oracle exercises this exact decision logic. */
 export declare function dispositionOffenders(offenders: string[], allowDeviations: string[]): {
     hard: string[];
     allowed: string[];
 };
-export declare function scopeGate(worktree: string, baseRef: string, files: string[], result: WorkerResult, allowDeviations?: string[]): Promise<GateResult>;
+export declare function scopeGate(worktree: string, integrationTip: string, files: string[], result: WorkerResult, allowDeviations?: string[]): Promise<GateResult>;

package/dist/gates/scope.js

@@ -1,5 +1,14 @@
 import picomatch from "picomatch";
 import { shGitOk } from "../run/git.js";
+// OBS-61: the live integration tip can advance between attempts (sibling merge) while a resumed
+// worktree stays parented on the old base — merge-base(tip, HEAD) pins the diff to the worktree's
+// creation ancestor so sibling edits cannot leak into scope as false out-of-scope offenders.
+export async function scopeDiffBase(worktree, integrationTip) {
+    const head = (await shGitOk("git rev-parse HEAD", worktree)).trim();
+    if (head === integrationTip)
+        return integrationTip;
+    return (await shGitOk(`git merge-base '${integrationTip}' '${head}'`, worktree)).trim();
+}
 /** 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;
@@ -13,9 +22,10 @@ export function dispositionOffenders(offenders, allowDeviations) {
     }
     return { hard, allowed };
 }
-export async function scopeGate(worktree, baseRef, files, result, allowDeviations = []) {
+export async function scopeGate(worktree, integrationTip, files, result, allowDeviations = []) {
     if (!files.length)
         return { gate: "scope", pass: true, details: "no file scope declared — unrestricted" };
+    const baseRef = await scopeDiffBase(worktree, integrationTip);
     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));

package/dist/route/profile.d.ts

@@ -49,7 +49,7 @@ export interface ProfileDiscount {
     reason: string;
 }
 export declare function resolveHygieneWeight(row: ProfileRow, discounts?: readonly ProfileDiscount[]): HygieneWeight;
-export declare function explorationBonus(cell: ProfileCell | undefined): number;
+export declare function explorationBonus(cell: ProfileCell | undefined, cap?: number): number;
 export declare function classify(r: ProfileRow): 1 | 0.5 | 0 | null;
 export declare function buildProfile(rows: ProfileRow[], opts?: {
     halfLifeRuns?: number;
@@ -81,7 +81,9 @@ export interface LearnedScoreTerms {
 }
 export declare function learnedScoreTerms(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
+    slaMinutes?: number;
 }): LearnedScoreTerms;
 export declare function learnedScore(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
+    slaMinutes?: number;
 }): number;

package/dist/route/profile.js

@@ -59,10 +59,11 @@ export function resolveHygieneWeight(row, discounts = []) {
 // yielded no quality obs (quota parks) has spent its budget — stop probing it, don't probe it forever.
 // ponytail: rank-decay ships in v1.8 (buildProfile below); remaining ceiling = doneMedianMs staleness
 // (perf term is undecayed) and per-cell EWMA as the finer upgrade path.
-export function explorationBonus(cell) {
+// ROUTE-15 PARAM-SHAPE: optional cap threads from routing.explore.cap; undefined ⇒ module default (byte-identical).
+export function explorationBonus(cell, cap = EXPLORE_CAP) {
     if (!cell)
         return 0;
-    return Math.max(0, 1 - cell.dispatches / EXPLORE_CAP); // ∈ [0,1]; exactly 0 once dispatches ≥ cap
+    return Math.max(0, 1 - cell.dispatches / cap); // ∈ [0,1]; exactly 0 once dispatches ≥ cap
 }
 const QUALITY_FAIL_PARKS = new Set(["ladder-exhausted", "attempt-cap", "gate-fail"]);
 // Quality observation per row: 1 clean, 0.5 degraded, 0 verified failure, null excluded/unobserved.
@@ -183,6 +184,7 @@ export function cellSummary(cell) {
 // 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 refMs = opts.slaMinutes !== undefined ? opts.slaMinutes * 60_000 : REF_MS;
     const cell = cellOf(profile, shape, chKey, channel);
     if (!cell)
         return { quality: NEUTRAL, perf: NEUTRAL, avail: NEUTRAL, overrun: NEUTRAL };
@@ -198,7 +200,7 @@ export function learnedScoreTerms(profile, shape, chKey, channel, opts = {}) {
     // 0 — a silent ROUTE-07 break. With it, every quotaHits=0 cell is byte-identical to pre-ROUTE-12.
     const perf = cell.n < MIN_SAMPLES || cell.doneMedianMs === undefined || cell.doneCount < MIN_SAMPLES
         ? 0
-        : PERF_WEIGHT * (REF_MS / (REF_MS + cell.doneMedianMs) - 0.5);
+        : PERF_WEIGHT * (refMs / (refMs + cell.doneMedianMs) - 0.5);
     // PENALTY-ONLY availability (ROUTE-12): a throttling channel is less available — deprioritize it without ever
     // treating quota as a quality signal, ejecting it, or predicting quota. quotaHits=0 ⇒ avail 0 (no-throttle
     // byte-identity). Gated on dispatches (≥ MIN_SAMPLES > 0 ⇒ positive denominator, no divide-by-zero) INDEPENDENTLY

package/dist/route/router.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel } from "../adapters/types.js";
-import { type TickmarkrConfig } from "../config/config.js";
+import { type TickmarkrConfig, type Tier } from "../config/config.js";
 import type { Task } from "../graph/schema.js";
 import { type RoutingProfile } from "./profile.js";
 export type LadderStep = "retry" | "escalate" | "consult" | "human";
@@ -26,9 +26,16 @@ export interface RoutingPreferContext {
     doctorFresh: boolean;
     overlayPreferShapes: ReadonlySet<string>;
 }
+export interface ExploreContext {
+    noExplore?: boolean;
+    quality?: boolean;
+}
+export declare const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
+export declare const QUALITY_ENV = "TICKMARKR_QUALITY";
+export declare const raiseTier: (tier: Tier) => Tier;
 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, exclude?: ReadonlySet<string>): Route;
+export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>, exploreCtx?: ExploreContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;

package/dist/route/router.js

@@ -1,7 +1,27 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { disallowedBy } from "./preference.js";
-import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore } from "./profile.js";
+import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
+export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
+export const QUALITY_ENV = "TICKMARKR_QUALITY";
+const exploreCap = (cfg) => cfg.routing.explore?.cap ?? EXPLORE_CAP;
+const qualityOn = (exploreCtx) => !!exploreCtx?.quality || process.env[QUALITY_ENV] === "1";
+export const raiseTier = (tier) => tier === "cheap" ? "mid" : tier === "mid" ? "frontier" : "frontier";
+const exploreOff = (task, cfg, exploreCtx) => {
+    if (qualityOn(exploreCtx) || exploreCtx?.noExplore || process.env[NO_EXPLORE_ENV] === "1")
+        return true;
+    const e = cfg.routing.explore;
+    if (!e)
+        return false;
+    if (e.mode === "off")
+        return true;
+    if (e.excludeShapes?.includes(task.shape))
+        return true;
+    const thr = e.excludeComplexityAtOrAbove;
+    if (thr != null && task.complexity >= thr)
+        return true;
+    return false;
+};
 const autoPreferList = (doc, shape) => {
     const v = doc?.[shape];
     return Array.isArray(v) ? v : undefined;
@@ -50,10 +70,36 @@ function withoutExcluded(channels, exclude) {
     // 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) {
+const qualityBound = (quality, configFloor, taskFloor) => {
+    if (!quality)
+        return undefined;
+    if (configFloor)
+        return `floor ${configFloor}→${raiseTier(configFloor)} (--quality)`;
+    if (taskFloor)
+        return `floor ${taskFloor}→${raiseTier(taskFloor)} (--quality)`;
+    return undefined;
+};
+const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
+    if (slaMinutes === undefined || !profile)
+        return;
+    const cell = cellOf(profile, task.shape, channelKey(c), c.channel);
+    if (!cell?.doneMedianMs || cell.doneCount < MIN_SAMPLES)
+        return;
+    const slaMs = slaMinutes * 60_000;
+    if (cell.doneMedianMs <= slaMs)
+        return;
+    const medianMin = Math.round(cell.doneMedianMs / 60_000);
+    lints.push(`${task.id} (${task.shape}): median ${medianMin}m exceeds sla ${slaMinutes}m — learned perf term references sla ${slaMinutes}m ref`);
+};
+export function route(task, cfg, channels, profile, preferCtx, exclude, exploreCtx) {
     channels = withoutExcluded(channels, exclude);
     const lints = [];
-    const floor = cfg.routing.floors[task.shape];
+    const advisoryFloor = cfg.routing.floors[task.shape];
+    const quality = qualityOn(exploreCtx);
+    const floor = advisoryFloor;
+    const slaMinutes = cfg.routing.sla?.[task.shape];
+    // 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 prefActive = !!(cfg.routing.allow || cfg.routing.deny);
@@ -83,11 +129,12 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         }
     };
     const lintFloor = (tier, what) => {
-        if (floor && TIER_RANK[tier] < TIER_RANK[floor]) {
-            lints.push(`${task.id} (${task.shape}): ${what} routes ${tier}, below advisory floor ${floor}`);
+        if (advisoryFloor && TIER_RANK[tier] < TIER_RANK[advisoryFloor]) {
+            lints.push(`${task.id} (${task.shape}): ${what} routes ${tier}, below advisory floor ${advisoryFloor}`);
         }
     };
-    const taskFloor = task.routingHints?.floor;
+    const taskFloorRaw = task.routingHints?.floor;
+    const taskFloor = taskFloorRaw && quality ? raiseTier(taskFloorRaw) : taskFloorRaw;
     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
@@ -98,6 +145,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         const c = channels.find((c) => c.adapter === taskPin.via && c.model === taskPin.model);
         if (c && (!taskFloor || TIER_RANK[c.tier] >= TIER_RANK[taskFloor])) {
             lintFloor(c.tier, "task pin");
+            maybeSlaLint(lints, task, profile, slaMinutes, c);
             return { assignment: toAssignment(c), ladder: ladderFor(task, entry), lints, provenance: `pin ${taskPin.via}:${taskPin.model} (task hint${src})` };
         }
         const why = c ? `below task floor ${taskFloor}` : "unavailable";
@@ -109,10 +157,16 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         disallowedPin(entry.pin.via, entry.pin.model, "map pin (config routing.map)");
         const c = resolvePin(entry.pin, channels);
         lintFloor(c.tier, "map pin");
+        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 = entry?.tier ?? floor ?? "cheap";
-    const minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier; // task floor is a hard >= constraint in all paths (D-04)
+    let minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier; // task floor is a hard >= constraint in all paths (D-04)
+    if (quality && advisoryFloor) {
+        const raised = raiseTier(advisoryFloor);
+        if (TIER_RANK[raised] > TIER_RANK[minTier])
+            minTier = raised;
+    }
     if (entry?.tier)
         lintFloor(entry.tier, "map tier");
     if (prefActive)
@@ -145,13 +199,15 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         // is keyed by channelKey alone, which would collide only if a fleet exposed the same adapter:model on
         // both classes at once — impossible under today's scalar TierEntrySchema.channel.
         // ROUTE-15: availWeight threads from config as a pure param; undefined ⇒ module default (byte-identical).
-        const scores = new Map(eligibleRaw.map((c) => [channelKey(c), learnedScore(profile, task.shape, channelKey(c), c.channel, { availWeight: cfg.routing.learnedTuning?.availWeight })]));
+        const scores = new Map(eligibleRaw.map((c) => [channelKey(c), learnedScore(profile, task.shape, channelKey(c), c.channel, scoreOpts)]));
         const scoreOf = (c) => scores.get(channelKey(c));
         // v1.6 Phase 14: exploration bonus precomputed ONCE (Pitfall 5), a new key ABOVE the score. EXP-01 needs
         // it above the score (a warm-good incumbent can't permanently outrank an under-cap rival in a static tie);
         // magnitude-free as its own lexicographic key. EXP-02 holds structurally: pins returned at :67/:78 and the
         // floor filtered eligibleRaw at :89, all upstream of this block, so the bonus decides only within a static tie.
-        const bonuses = new Map(eligibleRaw.map((c) => [channelKey(c), explorationBonus(cellOf(profile, task.shape, channelKey(c), c.channel))]));
+        const cap = exploreCap(cfg);
+        const off = exploreOff(task, cfg, exploreCtx);
+        const bonuses = new Map(eligibleRaw.map((c) => [channelKey(c), off ? 0 : explorationBonus(cellOf(profile, task.shape, channelKey(c), c.channel), cap)]));
         const bonusOf = (c) => bonuses.get(channelKey(c));
         const staticWinner = [...eligibleRaw].sort(staticCmp)[0];
         // Phase 34 ROUTE-17: prefer becomes a BAND + group-rep keys so exploration fires ACROSS prefer
@@ -182,7 +238,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         const diffKey = ru ? firstDiff(w, ru) : -1;
         const probe = diffKey === 1 || diffKey === 6;
         if (probe) {
-            learnedChosen = `via exploration probe (dispatches=${cellOf(profile, task.shape, channelKey(w), w.channel)?.dispatches ?? 0} < ${EXPLORE_CAP})`;
+            learnedChosen = `via exploration probe (dispatches=${cellOf(profile, task.shape, channelKey(w), w.channel)?.dispatches ?? 0} < ${cap})`;
         }
         else if (diffKey === 2 || diffKey === 7) {
             const n = cellOf(profile, task.shape, channelKey(w), w.channel)?.n ?? 0;
@@ -195,10 +251,11 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
     else {
         eligible = eligibleRaw.sort(staticCmp); // ROUTE-07/09: literally the v1.5 code path — dead code cannot deviate
     }
-    const bound = taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
-        entry?.tier ? `tier ${entry.tier} (config routing.map)` :
-            floor ? `floor ${floor} (config floors)` :
-                "tier cheap (default)";
+    const bound = qualityBound(quality, advisoryFloor, taskFloorRaw) ??
+        (taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
+            entry?.tier ? `tier ${entry.tier} (config routing.map)` :
+                floor ? `floor ${floor} (config floors)` :
+                    "tier cheap (default)");
     // name the key that actually broke the tie: prefer outranks the marginal-cost/tier keys, so if the
     // winner matched a prefer entry, prefer decided it — not "cheapest sufficient tier" (ROUTE-03, WR-01)
     const preferVia = preferFromAuto(task.shape, preferCtx)
@@ -206,6 +263,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude) {
         : "via prefer";
     const chosenBy = learnedChosen || (prefer && preferIndex(eligible[0], prefer) < prefer.length
         ? preferVia : "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 } : {}) };
 }
 export function nextChannel(current, task, cfg, channels, tried, profile, exclude) {

package/dist/run/daemon.js

@@ -427,7 +427,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 const promptFile = writePrompt(journal.dir, t, attempt, feedback, nonce);
                 // OBS-56: state the non-interactive, one-pass finish contract and the OBS-54 stall budget in every
                 // worker prompt, not only consult retry guidance. Prepended so prompt.ts's completion trailer stays last.
-                const workerContract = `## Harness contract\n- This harness is non-interactive: make one continuous pass; do not stop for questions or follow-up input.\n- You have a ${taskTimeoutMinutes} minute stall window. Budget the full suite once, then commit and emit the completion trailer before it expires.`;
+                const workerContract = `## Harness contract\n- This harness is non-interactive: make one continuous pass; do not stop for questions or follow-up input.\n- You have a ${taskTimeoutMinutes} minute stall window. Budget the full suite once, then commit and emit the completion trailer before it expires.\n- Each test: acceptance criterion must exist as a vitest test whose title matches the criterion string verbatim.`; // OBS-64
                 // OBS-47: state the worktree layout contract in the worker prompt (cheap-tier workers were
                 // committing/deleting node_modules and tripping the scope gate). The harness re-asserts the link
                 // itself before gates regardless of what the worker does with it.

package/package.json

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