tickmarkr 1.50.0 → 1.51.0

package/dist/adapters/model-lints.d.ts

@@ -17,6 +17,7 @@ export type RoutedAssignment = {
 /** Advisory only — absent windows config or undeclared model window ⇒ no lint. */
 export declare function contextWindowLints(tasks: ReadonlyArray<Task>, assignments: ReadonlyArray<RoutedAssignment>, cfg: TickmarkrConfig, repoRoot: string): string[];
 export declare function seedPreferLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
+export declare function mapTierLints(cfg: TickmarkrConfig): string[];
 export declare function modelLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;
     stateDir?: string;

package/dist/adapters/model-lints.js

@@ -95,6 +95,14 @@ export function seedPreferLints(cfg, health, adapters, overlayPreferShapes = new
     }
     return lints;
 }
+// v1.51 T3: built-in defaults no longer carry map tiers, so any tier surviving the merge came from an
+// overlay. Deprecated — routing.floors is the single band authority; MapEntrySchema.tier removal itself
+// is deferred to the next version. One lint per shape, identical text on every surface (plan + doctor).
+export function mapTierLints(cfg) {
+    return Object.entries(cfg.routing.map)
+        .filter(([, entry]) => entry.tier !== undefined)
+        .map(([shape, entry]) => `routing.map.${shape}.tier: ${entry.tier} is deprecated — move this value to routing.floors.${shape} (single band authority; tier removal deferred to next version)`);
+}
 // Diffs detected models (doctor.json) against configured tiers, both directions, per adapter id in cfg.tiers.
 // No `  ! ` prefix here — the consumer (doctor rows / plan lints) owns that. Pre-v1.5 doctor.json (models:[], no
 // modelsDetectedAt) is the compat baseline: `?.`/`?? []` everywhere, no zod (would reject old files).
@@ -137,6 +145,7 @@ export function modelLints(cfg, health, adapters, opts) {
         }
     }
     lints.push(...seedPreferLints(cfg, health, adapters, opts?.overlayPreferShapes));
+    lints.push(...mapTierLints(cfg)); // v1.51 T3: shared here so plan and doctor draw the exact same message
     return lints;
 }
 // T2/T6: one lint per exclusion, naming the probe reason and date. TTY truncates reasons to 60 chars and

package/dist/cli/commands/fleet.js

@@ -6,9 +6,10 @@ import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
 import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
 import { GLYPHS, bold, legend as legendText, toggleActive, toggleInactive } from "../../brand.js";
-import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, loadConfig, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, unifiedYamlDiff, } from "../../config/config.js";
+import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
 import { route } from "../../route/router.js";
+import { resolveRunMode } from "../../run/daemon.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
 const QUIT = "fleet: quit without writing";
@@ -55,10 +56,21 @@ function provenanceMap(editable) {
     }
     return out;
 }
-function proposedOverlayText(initial, editable, repoRoot) {
-    const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(repoRoot)));
-    return repoOverlayYaml(merged, provenanceMap(editable));
+// v1.51 T4: serializeFleetOverlay predates routing.mode — splice the mode line under routing:
+// so a repo-declared mode survives fleet writes and a mode selection lands as routing.mode.
+function withModeLine(yaml, mode) {
+    if (!mode)
+        return yaml;
+    if (/^routing:$/m.test(yaml))
+        return yaml.replace(/^routing:$/m, `routing:\n  mode: ${mode}`);
+    return `routing:\n  mode: ${mode}\n${yaml}`;
 }
+// v1.51 T4: one gloss per routing mode on the fleet mode screen — mirrors the preset compiler.
+const MODE_GLOSS = {
+    "partner-led": "every shape frontier · explore off",
+    "risk-based": "risk-tiered default floors",
+    "staff-led": "implement/refactor one band down · integrity shapes hold frontier",
+};
 const isAbort = (k) => k.name === "escape" || k.name === "q" || (k.ctrl === true && k.name === "c");
 const isNext = (k) => k.name === "return" || k.name === "enter";
 const isToggle = (k) => k.name === "space";
@@ -154,8 +166,14 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
     const interactive = input.isTTY === true && output.isTTY === true;
-    if (print)
-        return formatFleetPrint(cwd, { globalDir });
+    if (print) {
+        // v1.51 T4: the print surface names the mode and its source layer right under the header —
+        // comment-prefixed so the YAML body stays machine-parseable and regex-stable.
+        const rm = resolveRunMode(cwd, { globalDir });
+        const body = formatFleetPrint(cwd, { globalDir });
+        const nl = body.indexOf("\n");
+        return `${body.slice(0, nl)}\n# mode: ${rm.mode.mode} (${rm.source})${body.slice(nl)}`;
+    }
     if (!interactive)
         return { out: NON_TTY_MSG, code: 1 };
     const fresh = values.fresh ?? false;
@@ -166,15 +184,16 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             code: 1,
         };
     }
-    const cfg = loadConfig(cwd, { globalDir });
+    const rm = resolveRunMode(cwd, { globalDir });
+    const cfg = rm.cfg;
     const initial = fleetEditableFromConfig(cfg);
     const editable = structuredClone(initial);
     const health = cached;
     const term = openTerm(input, output);
     try {
-        // step 1/4 — probe data
+        // step 1/5 — probe data
         const ageLine = formatAge(doctorAgeMs(cwd));
-        term.frame(listFrame("step 1/4 · probe data", "enter continue · r refresh via doctor · esc/q quit", [`probe data: ${ageLine} (.tickmarkr/doctor.json)`], 0));
+        term.frame(listFrame("step 1/5 · probe data", "enter continue · r refresh via doctor · esc/q quit", [`probe data: ${ageLine} (.tickmarkr/doctor.json)`], 0));
         for (;;) {
             const k = await term.key();
             if (isAbort(k))
@@ -185,7 +204,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             if (isNext(k))
                 break;
         }
-        // step 2/4 — agent CLIs (space toggles adapter deny)
+        // step 2/5 — agent CLIs (space toggles adapter deny)
         const installed = adapters.filter((a) => health[a.id]?.installed);
         const adapterRows = () => installed.map((a) => {
             const h = health[a.id];
@@ -194,7 +213,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         });
         const listLegend = "↑↓/jk move · space toggle · enter next · esc/q quit";
         let aCursor = 0;
-        term.frame(listFrame("step 2/4 · agent CLIs", listLegend, adapterRows(), aCursor));
+        term.frame(listFrame("step 2/5 · agent CLIs", listLegend, adapterRows(), aCursor));
         for (;;) {
             const k = await term.key();
             if (isAbort(k))
@@ -218,9 +237,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                 changed = true;
             }
             if (changed)
-                term.frame(listFrame("step 2/4 · agent CLIs", listLegend, adapterRows(), aCursor));
+                term.frame(listFrame("step 2/5 · agent CLIs", listLegend, adapterRows(), aCursor));
         }
-        // step 3/4 — models per enabled adapter (space toggles deny, t assigns tier from the row)
+        // step 3/5 — models per enabled adapter (space toggles deny, t assigns tier from the row)
         const enabledAdapters = installed.filter((a) => !isDeniedAdapter(a.id, editable));
         for (const a of enabledAdapters) {
             const unclassifiedAll = fleetUnclassifiedModels(cfg, health, adapters).filter((u) => u.adapter === a.id);
@@ -238,7 +257,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                 const denied = isDeniedModel(a.id, r.model, editable);
                 return `${denied ? toggleInactive() : toggleActive()} ${r.model}  ${tier?.tier ?? "???"}  ${denied ? "denied" : "allowed"}`;
             });
-            const title = `step 3/4 · models · ${a.id}`;
+            const title = `step 3/5 · models · ${a.id}`;
             const modelsLegend = "↑↓/jk move · space toggle · t tier · enter next · esc/q quit";
             let mCursor = 0;
             term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
@@ -283,7 +302,44 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                     term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
             }
         }
-        // step 4/4 — shape routing (typed entry for pin/tier/prefer from the highlighted row)
+        // step 4/5 — routing mode (selection is in-memory; the write happens only through the diff confirm).
+        // Candidate floor tables come from the ONE preset compiler via resolveRunMode — no mode math here.
+        const modeCfgs = Object.fromEntries(ROUTING_MODES.map((m) => [m, m === rm.mode.mode ? rm : resolveRunMode(cwd, { flag: m, globalDir })]));
+        const modeRows = () => ROUTING_MODES.map((m) => `${m === rm.mode.mode ? toggleActive() : " "} ${m.padEnd(11)}  ${MODE_GLOSS[m]}`);
+        // preview: the highlighted mode's resolved floor table diffed against the current mode
+        const floorPreview = (cand) => {
+            if (cand === rm.mode.mode)
+                return [];
+            const cur = cfg.routing.floors;
+            const next = modeCfgs[cand].cfg.routing.floors;
+            const changed = SHAPES.filter((s) => cur[s] !== next[s]);
+            return [
+                `  floors vs ${rm.mode.mode}:`,
+                ...(changed.length ? changed.map((s) => `    ${s}: ${cur[s]} → ${next[s]}`) : ["    (no floor changes)"]),
+            ];
+        };
+        const modeTitle = "step 4/5 · routing mode";
+        const modeLegend = "↑↓/jk move · enter select · esc/q quit";
+        let modeCursor = ROUTING_MODES.indexOf(rm.mode.mode);
+        let selectedMode = rm.mode.mode;
+        const modeFrame = () => [...listFrame(modeTitle, modeLegend, modeRows(), modeCursor), ...floorPreview(ROUTING_MODES[modeCursor])];
+        term.frame(modeFrame());
+        for (;;) {
+            const k = await term.key();
+            if (isAbort(k))
+                return QUIT;
+            if (isNext(k)) {
+                selectedMode = ROUTING_MODES[modeCursor];
+                break;
+            }
+            const moved = moveCursor(k, modeCursor, ROUTING_MODES.length);
+            if (moved !== modeCursor) {
+                modeCursor = moved;
+                term.frame(modeFrame());
+            }
+        }
+        // step 5/5 — shape routing (typed entry for pin/tier/prefer from the highlighted row);
+        // previews route under the SELECTED mode's resolved floors, never a floor edit of its own
         const channels = discoverChannels(cfg, adapters, health);
         const profile = loadRoutingProfile(cwd, cfg, { preview: true });
         const autoPrefer = readAutoPrefer(cwd);
@@ -291,7 +347,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const shapeRows = () => SHAPES.map((shape) => {
             let now;
             try {
-                const r = route(previewTask(shape), { ...cfg, routing: { ...cfg.routing, map: editable.map, floors: editable.floors } }, channels, profile);
+                const r = route(previewTask(shape), { ...cfg, routing: { ...cfg.routing, map: editable.map, floors: modeCfgs[selectedMode].cfg.routing.floors } }, channels, profile);
                 now = `${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})`;
             }
             catch (e) {
@@ -300,7 +356,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             const auto = autoPrefer?.[shape] && !overlayShapes.has(shape) ? "  (auto-prefer active)" : "";
             return `${shape}  →  ${now}${auto}`;
         });
-        const shapesTitle = "step 4/4 · shape routing";
+        const shapesTitle = "step 5/5 · shape routing";
         const shapesLegend = "↑↓/jk move · a auto · p pin · t tier · f prefer · enter next · esc/q quit";
         let sCursor = 0;
         term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
@@ -349,10 +405,17 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             if (changed)
                 term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
         }
-        // review — unified diff + typed confirm
+        // review — unified diff + typed confirm (the ONLY write path; the mode screen funnels through here)
         const before = currentRepoOverlayText(cwd);
-        const after = proposedOverlayText(initial, editable, cwd);
-        if (fleetEditableEquals(initial, editable) || before === after) {
+        const existing = readOverlayFile(repoOverlayPath(cwd));
+        const modeChanged = selectedMode !== rm.mode.mode;
+        // preserve a repo-declared mode line verbatim; write a new one only when the selection changed it
+        const writeMode = modeChanged ? selectedMode : existing.routing?.mode;
+        const merged = fleetEditableEquals(initial, editable)
+            ? structuredClone(existing)
+            : fleetRepoOverlayFromDelta(initial, editable, existing);
+        const after = withModeLine(repoOverlayYaml(merged, provenanceMap(editable)), writeMode);
+        if ((!modeChanged && fleetEditableEquals(initial, editable)) || before === after) {
             return "fleet: no overlay changes (empty diff)";
         }
         const diff = unifiedYamlDiff(before, after, repoOverlayPath(cwd));
@@ -360,11 +423,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const confirm = await term.askTyped("write overlay? [y/N] ");
         if (!/^y(?:es)?$/i.test(confirm))
             return "fleet: discarded overlay changes";
-        const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(cwd)));
-        const body = repoOverlayYaml(merged, provenanceMap(editable));
         const path = repoOverlayPath(cwd);
         mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, body);
+        writeFileSync(path, after);
         return `fleet: wrote ${path}`;
     }
     finally {

package/dist/cli/commands/plan.d.ts

@@ -1,2 +1,2 @@
 import type { WorkerAdapter } from "../../adapters/types.js";
-export declare function plan(_argv: string[], cwd?: string, adapters?: WorkerAdapter[]): Promise<string>;
+export declare function plan(argv: string[], cwd?: string, adapters?: WorkerAdapter[]): Promise<string>;

package/dist/cli/commands/plan.js

@@ -1,11 +1,14 @@
 import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, servableExclusions, servabilityLine } from "../../adapters/registry.js";
 import { formatModelAuthLine, contextWindowLints, modelLints, ttyVisual } from "../../adapters/model-lints.js";
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
+import { parseArgs } from "node:util";
 import { collateralLints } from "../../compile/collateral.js";
-import { loadConfig } from "../../config/config.js";
+import { DEFAULT_CONFIG, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
 import { loadGraph } from "../../graph/graph.js";
+import { resolveRunMode } from "../../run/daemon.js";
 import { excludedChannels, exclusionLine } from "../../route/preference.js";
-import { route, RoutingError } from "../../route/router.js";
+import { staffLedEvidence } from "../../route/profile.js";
+import { QUALITY_ENV, route, RoutingError } from "../../route/router.js";
 import { modelId } from "../../gates/review.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 // T4 (v1.50): TTY-only brand pass — the title helper frames the routing table, lint/unroutable
@@ -31,12 +34,19 @@ const fleetCanCrossVendorReview = (channels) => {
                 return true;
     return false;
 };
-export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters()) {
+export async function plan(argv, cwd = process.cwd(), adapters = allAdapters()) {
     // ponytail: hardcoded 24h TTL — promote to config when an operator asks. mtime is the signal because
     // doctor.json has no probe timestamp and a schema field would break the existing-files compat invariant.
     const DOCTOR_STALE_MS = 24 * 60 * 60 * 1000;
-    const cfg = loadConfig(cwd);
+    // v1.51 T2: plan previews any mode without a config edit — same source precedence as run
+    // (flag > spec front-matter > repo > global > default), same preset compiler.
+    const { values } = parseArgs({ args: argv, options: { mode: { type: "string" } }, allowPositionals: true });
+    if (values.mode !== undefined && !ROUTING_MODES.includes(values.mode)) {
+        throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
+    }
+    delete process.env[QUALITY_ENV];
     const g = loadGraph(cwd);
+    const { cfg, mode, source } = resolveRunMode(cwd, { flag: values.mode, spec: g.mode });
     // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).
     const cached = readDoctor(cwd);
     const health = cached ?? (await probeAll(adapters));
@@ -46,7 +56,17 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     // output byte-identical to today.
     const profile = loadRoutingProfile(cwd, cfg, { preview: true });
     let deviations = 0;
-    const lines = [`tickmarkr plan — dry run (${channels.length} channels available)`, ""];
+    // v1.51 T4: the mode is never invisible — the header names the resolved mode, its winning
+    // source, and the explore posture; each task row carries a floor-derivation line below.
+    const lines = [
+        `tickmarkr plan — dry run (${channels.length} channels available)`,
+        `mode: ${mode.mode} (${source}) · explore ${cfg.routing.explore?.mode ?? "on"}`,
+        "",
+    ];
+    const derivation = (shape) => {
+        const floor = cfg.routing.floors[shape];
+        return floor ? `    floor ${floor} ← ${mode.provenance[shape] ?? "config floors"}` : null;
+    };
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         lines.push(exclusionLine(excluded), "");
@@ -78,7 +98,24 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
             return ` — ${m.key} is unauthed (${m.reason}, probed ${m.probedAt.split("T")[0]})`;
         return "";
     };
-    const lints = [];
+    // v1.51 T1: mode-resolution lints (shadowed deltas, below-integrity operator floors) surface here every run.
+    const lints = [...mode.lints];
+    // v1.51 T5: staff-led economics guard — when the MODE (never an explicit operator line) lowered a
+    // shape's floor and warm evidence shows the cheap band materially under the mid incumbent, say so.
+    // Advisory only: no floor is raised here or anywhere on prediction — raises stay evidence-triggered
+    // (task-hint floors, the in-run retry ladder), each journaled with provenance.
+    if (mode.mode === "staff-led") {
+        const fmtScore = (s) => `${s < 0 ? "" : "+"}${s.toFixed(3)}`;
+        for (const [shape, floor] of Object.entries(cfg.routing.floors)) {
+            const dflt = DEFAULT_CONFIG.routing.floors[shape];
+            if (mode.provenance[shape] !== "mode staff-led" || !dflt || TIER_RANK[floor] >= TIER_RANK[dflt])
+                continue;
+            const ev = staffLedEvidence(profile, shape, channels);
+            if (ev) {
+                lints.push(`staff-led may cost more than risk-based on ${shape} (cheap best ${fmtScore(ev.cheapBest)} vs mid ${fmtScore(ev.midBest)}, n=${ev.n}) — advisory only, floor stays ${floor}`);
+            }
+        }
+    }
     for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
         if (!health[sel.adapter]?.installed)
             lints.push(`${role}: ${sel.adapter}:${sel.model} not installed — that gate/consult will fail closed`);
@@ -100,6 +137,9 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
             const est = r.assignment.channel === "sub" ? 0 : cfg.pricing[r.assignment.tier];
             cost += est;
             lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`);
+            const d = derivation(t.shape);
+            if (d)
+                lines.push(d);
             if (r.deviation) {
                 deviations++;
                 const d = r.deviation;
@@ -111,6 +151,9 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
                 throw e;
             const msg = `${e.message}${exclusionReason(e.message)}`;
             lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! ${msg}`);
+            const d = derivation(t.shape);
+            if (d)
+                lines.push(d);
             lints.push(`${t.id}: unroutable — ${msg}`);
         }
     }

package/dist/cli/commands/run.js

@@ -1,10 +1,10 @@
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, probeAll, readDoctor } from "../../adapters/registry.js";
-import { loadConfig } from "../../config/config.js";
+import { ROUTING_MODES } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
-import { formatSummary, runDaemon } from "../../run/daemon.js";
-import { route, QUALITY_ENV, NO_EXPLORE_ENV } from "../../route/router.js";
+import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
+import { route, NO_EXPLORE_ENV, QUALITY_ENV } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
 import { ttyVisual } from "../../adapters/model-lints.js";
 import { statusRow } from "../../brand.js";
@@ -24,6 +24,11 @@ export const narrationLine = (event) => {
 };
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
+// v1.51 T2: --quality is a pure compatibility alias for `--mode partner-led` (this run only). It
+// carries no one-band floor raise of its own: the flag never sets ExploreContext.quality or the
+// TICKMARKR_QUALITY env, so no downstream code raises a floor on its behalf (proven in mode-sources).
+const QUALITY_ALIAS_NOTICE = "tickmarkr: --quality is a compatibility alias for --mode partner-led (this run only) — "
+    + "the v1.47 one-band floor raise is retired (deprecated); use --mode partner-led";
 export async function run(argv, cwd = process.cwd()) {
     const { values } = parseArgs({
         args: argv,
@@ -32,6 +37,7 @@ export async function run(argv, cwd = process.cwd()) {
             driver: { type: "string" },
             "route-strict": { type: "boolean" },
             "no-explore": { type: "boolean" },
+            mode: { type: "string" },
             quality: { type: "boolean" },
         },
     });
@@ -40,14 +46,28 @@ export async function run(argv, cwd = process.cwd()) {
         if (!Number.isInteger(n) || n <= 0)
             throw new Error(`--concurrency must be a positive integer (got ${values.concurrency})`);
     }
-    const cfg = loadConfig(cwd);
-    const quality = !!values.quality;
-    const noExplore = !!values["no-explore"] || quality;
-    const exploreCtx = noExplore || quality ? { noExplore, quality } : undefined;
+    if (values.quality && values.mode !== undefined) {
+        throw new Error("--quality is a compatibility alias for --mode partner-led and cannot be combined with an explicit --mode — pass one or the other");
+    }
+    if (values.mode !== undefined && !ROUTING_MODES.includes(values.mode)) {
+        throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
+    }
+    if (values.quality)
+        console.warn(QUALITY_ALIAS_NOTICE);
+    const flagMode = values.mode ?? (values.quality ? "partner-led" : undefined);
+    delete process.env[QUALITY_ENV];
+    const graph = loadGraph(cwd);
+    const { cfg, conflict } = resolveRunMode(cwd, { flag: flagMode, spec: graph.mode });
+    if (conflict) {
+        // Loud, never silent: live intent (the flag) may override compiled intent (the spec) — strict refuses.
+        if (values["route-strict"])
+            throw new Error(`--route-strict: refusing to dispatch — ${conflict}`);
+        console.warn(`tickmarkr: !! ${conflict}`);
+    }
+    const noExplore = !!values["no-explore"];
+    const exploreCtx = noExplore ? { noExplore } : undefined;
     if (noExplore)
         process.env[NO_EXPLORE_ENV] = "1";
-    if (quality)
-        process.env[QUALITY_ENV] = "1";
     try {
         if (values["route-strict"]) {
             const adapters = allAdapters();
@@ -55,13 +75,14 @@ export async function run(argv, cwd = process.cwd()) {
             const channels = discoverChannels(cfg, adapters, health);
             // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
             const profile = loadRoutingProfile(cwd, cfg);
-            const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile, undefined, undefined, exploreCtx).lints);
+            const lints = graph.tasks.flatMap((t) => route(t, cfg, channels, profile, undefined, undefined, exploreCtx).lints);
             if (lints.length)
                 throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
         }
         const s = await runDaemon(cwd, {
             concurrency: values.concurrency ? Number(values.concurrency) : undefined,
             driver: pickDriver(cfg, values.driver),
+            mode: flagMode,
             narrate: (event) => console.log(narrationLine(event)),
         });
         const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
@@ -70,7 +91,5 @@ export async function run(argv, cwd = process.cwd()) {
     finally {
         if (noExplore)
             delete process.env[NO_EXPLORE_ENV];
-        if (quality)
-            delete process.env[QUALITY_ENV];
     }
 }

package/dist/compile/native.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { GATE_NAMES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
+import { GATE_NAMES, GRAPH_ROUTING_MODES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
 import { CompileError, inferShape, sha256 } from "./common.js";
 export const LEGACY_PREFIX = ["dro", "vr"].join("");
 export const TICKMARKR_NATIVE_MARKER = /^<!--\s*tickmarkr:spec(?:\s+v1)?\s*-->\s*$/m;
@@ -20,6 +20,7 @@ export function compileNative(file) {
     const content = readFileSync(file, "utf8");
     const drafts = [];
     let plainCount = 0; // v1.19: plain-string acceptance items compiled as judge oracles (compat) — warn once
+    let specMode;
     for (const line of content.split("\n")) {
         const heading = line.match(HEAD_RE);
         if (heading) {
@@ -27,8 +28,18 @@ export function compileNative(file) {
             continue;
         }
         const draft = drafts.at(-1);
-        if (!draft)
+        if (!draft) {
+            // v1.51 T2: spec front-matter — a top-level `mode: <name>` line before the first task heading
+            // declares the engagement's routing mode (loses only to an explicit run flag).
+            const fm = line.match(/^mode:\s*(\S+)\s*$/);
+            if (fm) {
+                if (!GRAPH_ROUTING_MODES.includes(fm[1])) {
+                    throw new CompileError(`spec front-matter mode must be one of ${GRAPH_ROUTING_MODES.join(", ")} (got ${JSON.stringify(fm[1])})`);
+                }
+                specMode = fm[1];
+            }
             continue;
+        }
         const field = line.match(FIELD_RE);
         if (field) {
             const name = field[1].toLowerCase();
@@ -151,6 +162,7 @@ export function compileNative(file) {
     });
     const result = validateGraph({
         version: 1,
+        ...(specMode ? { mode: specMode } : {}),
         spec: { source: "native", paths: [file], hash: sha256(content) },
         tasks,
     });
@@ -184,6 +196,10 @@ Each task is a "## Tn: Title" heading with "- field: value" bullets.
 acceptance is required on every task (a nested list of observable outcomes).
 
 <!--
+  Spec front-matter (top-level, before the first task heading):
+    mode: partner-led | risk-based | staff-led — this engagement's routing mode
+          (loses only to an explicit \`run --mode\` flag)
+
   Fields available per task:
     goal:        outcome the task must achieve (defaults to the title if omitted)
     shape:       plan | spec | implement | tests | docs | migration | ui | refactor | chore

package/dist/config/config.d.ts

@@ -7,6 +7,14 @@ declare const TierEnum: z.ZodEnum<{
 export type Tier = z.infer<typeof TierEnum>;
 export declare const TIER_RANK: Record<Tier, number>;
 export declare const DEFAULT_DIFF_CAP = 60000;
+export declare const ROUTING_MODES: readonly ["partner-led", "risk-based", "staff-led"];
+declare const ModeEnum: z.ZodEnum<{
+    "partner-led": "partner-led";
+    "risk-based": "risk-based";
+    "staff-led": "staff-led";
+}>;
+export type RoutingMode = z.infer<typeof ModeEnum>;
+export declare const INTEGRITY_FLOOR_SHAPES: readonly ["plan", "spec", "migration", "ui"];
 export declare const MapEntrySchema: z.ZodObject<{
     pin: z.ZodOptional<z.ZodObject<{
         via: z.ZodString;
@@ -60,6 +68,11 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
     contextWarnTokens: z.ZodNumber;
     setup: z.ZodOptional<z.ZodString>;
     routing: z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            "partner-led": "partner-led";
+            "risk-based": "risk-based";
+            "staff-led": "staff-led";
+        }>>;
         map: z.ZodRecord<z.ZodString, z.ZodObject<{
             pin: z.ZodOptional<z.ZodObject<{
                 via: z.ZodString;
@@ -195,6 +208,21 @@ export declare function globalConfigDir(): string;
 export declare function overlayPreferShapes(repoRoot: string, opts?: {
     globalDir?: string;
 }): ReadonlySet<string>;
+export type ModeResolution = {
+    mode: RoutingMode;
+    /** floor shape → "mode <name>" | "config floors" */
+    provenance: Record<string, string>;
+    /** plan lints: shadowed mode deltas + operator floors below the integrity minimum (standing) */
+    lints: string[];
+};
+/** loadConfig plus the mode-resolution record (floor provenance + plan lints). The resolved floors are
+ *  already applied to cfg.routing.floors — route() consumes floors only and never sees the mode. */
+export declare function loadConfigWithMode(repoRoot: string, opts?: {
+    globalDir?: string;
+}): {
+    cfg: TickmarkrConfig;
+    mode: ModeResolution;
+};
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
 }): TickmarkrConfig;

package/dist/config/config.js

@@ -10,6 +10,16 @@ const TierEnum = z.enum(TIERS, {
 });
 export const TIER_RANK = { cheap: 0, mid: 1, frontier: 2 };
 export const DEFAULT_DIFF_CAP = 60_000;
+// v1.51 T1: routing.mode — a preset COMPILED INTO FLOORS at config load. The router never sees the
+// mode; it receives resolved floors only (the structural defense against the quality-silently-loses
+// class — no fourth runtime authority, no new precedence key).
+export const ROUTING_MODES = ["partner-led", "risk-based", "staff-led"];
+const ModeEnum = z.enum(ROUTING_MODES, {
+    error: (iss) => `Invalid option: expected one of "partner-led"|"risk-based"|"staff-led" (got ${JSON.stringify(iss.input)})`,
+});
+// Integrity set (weak-oracle shapes, OBS-68..70 class): no mode may resolve these below frontier.
+// Only an explicit operator floor line can — and it draws a standing plan lint every load.
+export const INTEGRITY_FLOOR_SHAPES = ["plan", "spec", "migration", "ui"];
 export const MapEntrySchema = z.object({
     pin: z.object({ via: z.string(), model: z.string() }).optional(),
     tier: TierEnum.optional(),
@@ -80,6 +90,8 @@ export const TickmarkrConfigSchema = z.object({
     contextWarnTokens: z.number().int().positive(),
     setup: z.string().optional(),
     routing: z.object({
+        // v1.51 T1: preset expanded into floors by loadConfig — absent ⇒ risk-based ⇒ byte-identical routing.
+        mode: ModeEnum.optional(),
         map: z.record(z.string(), MapEntrySchema),
         floors: z.record(z.string(), TierEnum),
         learned: z.enum(["on", "off"]), // v1.6 ROUTE-09 kill switch; a typo (offf) fails loud via safeParse
@@ -155,12 +167,16 @@ export const DEFAULT_CONFIG = {
     taskTimeoutMinutes: 30,
     contextWarnTokens: 170_000, // v1.23 T2: overseer ctx-watch.sh proven threshold
     routing: {
+        // v1.51 T3 (round-2 consult): map entries carry preferences/pins only — band policy lives in
+        // routing.floors, the single tier authority. The dropped tiers (implement mid, tests cheap,
+        // docs cheap) were byte-equal to the floors below, so routing is unchanged. Overlay map tiers
+        // still parse but draw a move-to-floors lint in plan/doctor; MapEntrySchema.tier removal itself
+        // is deferred to the next version (tombstone grammar: tier: null).
         map: {
             plan: { pin: { via: "claude-code", model: "fable" } },
             spec: { pin: { via: "claude-code", model: "fable" } },
-            implement: { tier: "mid", prefer: ["cursor-agent", "codex"] },
-            tests: { tier: "cheap", prefer: ["opencode"] },
-            docs: { tier: "cheap" },
+            implement: { prefer: ["cursor-agent", "codex"] },
+            tests: { prefer: ["opencode"] },
         },
         floors: {
             plan: "frontier", spec: "frontier", migration: "frontier",
@@ -304,14 +320,88 @@ export function overlayPreferShapes(repoRoot, opts = {}) {
     }
     return shapes;
 }
-export function loadConfig(repoRoot, opts = {}) {
+const lowerTier = (t) => (t === "frontier" ? "mid" : "cheap");
+const maxTier = (a, b) => (TIER_RANK[a] >= TIER_RANK[b] ? a : b);
+const integrityMin = (shape) => INTEGRITY_FLOOR_SHAPES.includes(shape) ? "frontier" : "cheap";
+// partner-led = frontier everywhere; staff-led = one band down, integrity-clamped (net effect on the
+// defaults: implement/refactor → cheap, ui → frontier); risk-based = identity, so an absent mode key
+// resolves byte-identically to pre-v1.51 routing.
+function presetFloor(mode, shape, dflt) {
+    if (mode === "partner-led")
+        return "frontier";
+    if (mode === "staff-led")
+        return maxTier(lowerTier(dflt), integrityMin(shape));
+    return dflt;
+}
+/** Which floor shapes the operator wrote in an overlay layer (explicit beats mode; null tombstones stay removed). */
+function overlayFloorEdits(layers) {
+    const explicit = new Set();
+    const tombstoned = new Set();
+    for (const layer of layers) {
+        const floors = layer?.routing?.floors;
+        if (!floors || typeof floors !== "object" || Array.isArray(floors))
+            continue;
+        for (const [shape, v] of Object.entries(floors)) {
+            if (v === null) {
+                explicit.delete(shape);
+                tombstoned.add(shape);
+            }
+            else {
+                tombstoned.delete(shape);
+                explicit.add(shape);
+            }
+        }
+    }
+    return { explicit, tombstoned };
+}
+// Mutates cfg.routing.floors (and explore under partner-led) to the mode-resolved values.
+function resolveRoutingMode(cfg, layers) {
+    const mode = cfg.routing.mode ?? "risk-based";
+    const { explicit, tombstoned } = overlayFloorEdits(layers);
+    const provenance = {};
+    const lints = [];
+    for (const shape of SHAPES) {
+        if (tombstoned.has(shape))
+            continue; // operator removed the floor — a mode never resurrects it
+        const dflt = DEFAULT_CONFIG.routing.floors[shape];
+        const moded = presetFloor(mode, shape, dflt);
+        if (explicit.has(shape)) {
+            const val = cfg.routing.floors[shape];
+            provenance[shape] = "config floors";
+            if (moded !== val && moded !== dflt) {
+                lints.push(`floors.${shape}: ${val} (config floors) overrides mode ${mode} — shadowed delta: ${shape} ${dflt}→${moded}`);
+            }
+            if (TIER_RANK[val] < TIER_RANK[integrityMin(shape)]) {
+                lints.push(`floors.${shape}: ${val} is below integrity minimum frontier — integrity class ${INTEGRITY_FLOOR_SHAPES.join("/")} holds regardless of mode`);
+            }
+            continue;
+        }
+        cfg.routing.floors[shape] = moded;
+        provenance[shape] = `mode ${mode}`;
+    }
+    for (const shape of Object.keys(cfg.routing.floors)) {
+        if (!(shape in provenance))
+            provenance[shape] = "config floors"; // overlay floors on non-shape keys
+    }
+    // partner-led resolves exploration off (probes are the wrong spend under a premium declaration);
+    // staff-led and risk-based leave explore untouched — the round-2 fence rides through as configured.
+    if (mode === "partner-led")
+        cfg.routing.explore = { ...cfg.routing.explore, mode: "off" };
+    return { mode, provenance, lints };
+}
+/** loadConfig plus the mode-resolution record (floor provenance + plan lints). The resolved floors are
+ *  already applied to cfg.routing.floors — route() consumes floors only and never sees the mode. */
+export function loadConfigWithMode(repoRoot, opts = {}) {
     const globalCfg = readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"));
     const repoCfg = readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"));
     const merged = deepMerge(deepMerge(structuredClone(DEFAULT_CONFIG), globalCfg), repoCfg);
     const r = TickmarkrConfigSchema.safeParse(merged);
     if (!r.success)
         throw new ConfigError(z.prettifyError(r.error));
-    return r.data;
+    return { cfg: r.data, mode: resolveRoutingMode(r.data, [globalCfg, repoCfg]) };
+}
+export function loadConfig(repoRoot, opts = {}) {
+    return loadConfigWithMode(repoRoot, opts).cfg;
 }
 export function configTemplate(overlay) {
     const base = `# tickmarkr config overlay — merges over built-in defaults (repo beats global beats defaults)
@@ -321,10 +411,15 @@ export function configTemplate(overlay) {
 # contextWarnTokens: 170000   # v1.23: journal+notify once per attempt when live worker context crosses this (status shows the sample)
 # setup: npm ci --prefer-offline   # run in each fresh task worktree before dispatch
 # routing:
-#   map:                  # per-shape routing; pin an exact CLI+model, or tier+prefer
-#     implement: { tier: mid, prefer: [cursor-agent, codex] }
+#   mode: risk-based      # v1.51: partner-led | risk-based | staff-led — a preset compiled into floors at
+#                         # load (partner-led: every shape frontier + explore off; staff-led: implement/refactor
+#                         # cheap; integrity set plan/spec/migration/ui never resolves below frontier under any
+#                         # mode). Absent = risk-based = byte-identical routing. Explicit floors below beat mode deltas (linted).
+#   map:                  # per-shape preferences/pins; band policy lives in routing.floors
+#     implement: { prefer: [cursor-agent, codex] }
 #     migration: { pin: { via: claude-code, model: fable } }
-#   floors:               # advisory minimum tiers; 'tickmarkr plan' lints violations
+#     tests: { tier: null }   # tombstone: null removes a legacy map tier (deprecated — move the band to routing.floors.tests; schema removal lands next version)
+#   floors:               # tier authority — advisory minimum bands; 'tickmarkr plan' lints violations
 #     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

package/dist/graph/schema.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const SHAPES: readonly ["plan", "spec", "implement", "tests", "docs", "migration", "ui", "refactor", "chore"];
+export declare const GRAPH_ROUTING_MODES: readonly ["partner-led", "risk-based", "staff-led"];
 export declare const STATUSES: readonly ["pending", "running", "gated", "failed", "done", "human"];
 export declare const GATE_NAMES: readonly ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 export declare const TIERS: readonly ["cheap", "mid", "frontier"];
@@ -94,6 +95,11 @@ export declare const TaskSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const RunGraphSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        "partner-led": "partner-led";
+        "risk-based": "risk-based";
+        "staff-led": "staff-led";
+    }>>;
     spec: z.ZodObject<{
         source: z.ZodEnum<{
             speckit: "speckit";

package/dist/graph/schema.js

@@ -1,5 +1,8 @@
 import { z } from "zod";
 export const SHAPES = ["plan", "spec", "implement", "tests", "docs", "migration", "ui", "refactor", "chore"];
+// v1.51 T2: spec-declared routing mode. Mirrors config ROUTING_MODES literally — config.ts imports this
+// module, so a runtime import back would be circular; parity is pinned by test (tests/cli/mode-sources).
+export const GRAPH_ROUTING_MODES = ["partner-led", "risk-based", "staff-led"];
 export const STATUSES = ["pending", "running", "gated", "failed", "done", "human"];
 export const GATE_NAMES = ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 const MANDATORY_GATES = ["build", "test", "lint", "evidence", "scope"];
@@ -88,6 +91,9 @@ export const TaskSchema = z.object({
 export const RunGraphSchema = z
     .object({
     version: z.literal(1),
+    // v1.51 T2: spec front-matter mode — the spec author's routing-mode declaration. Source
+    // precedence: run flag > this > repo config > global config > default (risk-based).
+    mode: z.enum(GRAPH_ROUTING_MODES).optional(),
     spec: z.object({
         source: z.enum(["speckit", "gsd", "prd", "native", "taskmaster"]),
         paths: z.array(z.string()),

package/dist/route/profile.d.ts

@@ -83,6 +83,18 @@ export declare function learnedScoreTerms(profile: RoutingProfile | undefined, s
     availWeight?: number;
     slaMinutes?: number;
 }): LearnedScoreTerms;
+export declare const STAFF_LED_MARGIN = 0.1;
+export interface StaffLedEvidence {
+    cheapBest: number;
+    midBest: number;
+    n: number;
+}
+export declare function staffLedEvidence(profile: RoutingProfile | undefined, shape: string, channels: readonly {
+    adapter: string;
+    model: string;
+    channel: string;
+    tier: string;
+}[]): StaffLedEvidence | null;
 export declare function learnedScore(profile: RoutingProfile | undefined, shape: string, chKey: string, channel: string, opts?: {
     availWeight?: number;
     slaMinutes?: number;

package/dist/route/profile.js

@@ -217,6 +217,37 @@ export function learnedScoreTerms(profile, shape, chKey, channel, opts = {}) {
     const overrun = cell.dispatches < MIN_SAMPLES ? 0 : -OVERRUN_WEIGHT * ((cell.overruns ?? 0) / cell.dispatches); // ∈ [−OVERRUN_WEIGHT, 0]
     return { quality, perf, avail, overrun };
 }
+// v1.51 T5 staff-led economics guard (round-3 Fable §3.3): ONE comparison over existing warm cells,
+// consumed by plan as an ADVISORY lint only. Evidence display, never a floor input — no routing path
+// reads this (anticipatory raises are refused house law: bands move on declarations, structural
+// signals, or the failure ladder — never on the profile's prediction).
+export const STAFF_LED_MARGIN = 0.1; // "materially below" = two quality quanta (2 × the 0.05 term weights)
+// Best WARM learned score per band (cold cells — n < MIN_SAMPLES — are not evidence; the warm best is
+// the band's incumbent proxy). Null unless BOTH bands are warm AND the mid incumbent leads by at least
+// STAFF_LED_MARGIN: silence is the default, so a cold profile can never fire the lint.
+export function staffLedEvidence(profile, shape, channels) {
+    if (!profile)
+        return null;
+    const best = (tier) => {
+        let top = null;
+        for (const c of channels) {
+            if (c.tier !== tier)
+                continue;
+            const cell = cellOf(profile, shape, channelKey(c), c.channel);
+            if (!cell || cell.n < MIN_SAMPLES)
+                continue;
+            const score = learnedScore(profile, shape, channelKey(c), c.channel);
+            if (!top || score > top.score)
+                top = { score, nRaw: cell.nRaw ?? 0 };
+        }
+        return top;
+    };
+    const cheap = best("cheap");
+    const mid = best("mid");
+    if (!cheap || !mid || mid.score - cheap.score < STAFF_LED_MARGIN)
+        return null;
+    return { cheapBest: cheap.score, midBest: mid.score, n: cheap.nRaw + mid.nRaw };
+}
 // 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

package/dist/run/daemon.d.ts

@@ -1,4 +1,5 @@
 import { type WorkerAdapter } from "../adapters/types.js";
+import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type ExecutorDriver } from "../drivers/types.js";
 import { type JournalEvent } from "./journal.js";
 export interface RunOptions {
@@ -9,8 +10,23 @@ export interface RunOptions {
     driver?: ExecutorDriver;
     adapters?: WorkerAdapter[];
     globalDir?: string;
+    mode?: RoutingMode;
     narrate?: (event: JournalEvent) => void;
 }
+export type ModeSource = "run flag" | "spec" | "repo config" | "global config" | "default";
+export interface ResolvedRunMode {
+    cfg: TickmarkrConfig;
+    /** effective mode + per-floor provenance + standing lints, from the ONE preset compiler in config.ts */
+    mode: ModeResolution;
+    source: ModeSource;
+    /** set when the run flag picked a mode below the spec-declared mode (loud warn; --route-strict refuses) */
+    conflict?: string;
+}
+export declare function resolveRunMode(repoRoot: string, opts?: {
+    flag?: RoutingMode;
+    spec?: RoutingMode;
+    globalDir?: string;
+}): ResolvedRunMode;
 export interface RunSummary {
     runId: string;
     branch: string;

package/dist/run/daemon.js

@@ -1,12 +1,14 @@
 import { randomBytes } from "node:crypto";
 import { shq } from "../adapters/types.js";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { stringify } from "yaml";
 import { trailerPattern, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell } from "../brand.js";
-import { loadConfig } from "../config/config.js";
+import { globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
 import { herdrSealShellPrefix, SubprocessDriver } from "../drivers/subprocess.js";
 import { formatOwnedName } from "../drivers/types.js";
 import { captureBaseline, detectGateCommands } from "../gates/baseline.js";
@@ -17,8 +19,41 @@ import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYO
 import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
-import { nextChannel, route } from "../route/router.js";
+import { nextChannel, QUALITY_ENV, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
+const MODE_RANK = { "staff-led": 0, "risk-based": 1, "partner-led": 2 };
+// An override (flag/spec) re-resolves through loadConfigWithMode itself, via a synthesized repo overlay
+// carrying routing.mode — floors, explore, lints, and provenance all come from config.ts's preset
+// compiler, never duplicated mode math here (the quality-silently-loses defense holds by construction).
+function withOverlayMode(repoRoot, mode, globalDir) {
+    const overlay = readOverlayFile(repoOverlayPath(repoRoot));
+    const tmp = mkdtempSync(join(tmpdir(), "tickmarkr-mode-"));
+    try {
+        mkdirSync(join(tmp, ".tickmarkr"), { recursive: true });
+        writeFileSync(join(tmp, ".tickmarkr", "config.yaml"), stringify({ ...overlay, routing: { ...overlay.routing, mode } }));
+        return loadConfigWithMode(tmp, { globalDir });
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}
+export function resolveRunMode(repoRoot, opts = {}) {
+    const overlayMode = (path) => readOverlayFile(path).routing?.mode;
+    const source = opts.flag !== undefined ? "run flag"
+        : opts.spec !== undefined ? "spec"
+            : overlayMode(repoOverlayPath(repoRoot)) !== undefined ? "repo config"
+                : overlayMode(join(opts.globalDir ?? globalConfigDir(), "config.yaml")) !== undefined ? "global config"
+                    : "default";
+    const override = opts.flag ?? opts.spec;
+    const base = loadConfigWithMode(repoRoot, { globalDir: opts.globalDir });
+    const resolved = override === undefined || override === base.mode.mode
+        ? base
+        : withOverlayMode(repoRoot, override, opts.globalDir);
+    const conflict = opts.flag !== undefined && opts.spec !== undefined && MODE_RANK[opts.flag] < MODE_RANK[opts.spec]
+        ? `mode conflict: run flag ${opts.flag} selects a mode below the spec-declared ${opts.spec} — the run flag wins this run`
+        : undefined;
+    return { cfg: resolved.cfg, mode: resolved.mode, source, ...(conflict ? { conflict } : {}) };
+}
 // VIS-01: one formatter, four readers (run-end journal event, run/resume CLI, run-end notify).
 // Parity by construction — every caller renders the same complete bucket line.
 export function formatSummary(s) {
@@ -54,14 +89,11 @@ async function cherryPickCommits(wt, commits) {
     return carried;
 }
 export async function runDaemon(repoRoot, opts = {}) {
-    const cfg = loadConfig(repoRoot, { globalDir: opts.globalDir });
+    // v1.51 T2: retired --quality env seam. Mode resolution owns premium routing now; an exported
+    // TICKMARKR_QUALITY must not resurrect the old one-band floor raise in daemon dispatches.
+    delete process.env[QUALITY_ENV];
     const adapters = opts.adapters ?? allAdapters();
     const health = readDoctor(repoRoot) ?? (await probeAll(adapters));
-    const channels = discoverChannels(cfg, adapters, health);
-    // v1.6 ROUTE-06: build the learned profile ONCE at startup (never per task, never in the comparator).
-    // No preview — the daemon honors routing.learned:off and gets undefined; this snapshot is immutable
-    // for the run, so this run's own telemetry never feeds back into its own routing.
-    const profile = loadRoutingProfile(repoRoot, cfg);
     const driver = opts.driver ?? new SubprocessDriver();
     // HARD-01/02: hold the run lock across the whole read-modify-write of graph.json. Acquire
     // BEFORE loadGraph; release in the finally below (every exit path, incl. throws).
@@ -72,6 +104,18 @@ export async function runDaemon(repoRoot, opts = {}) {
     const lock = acquireRunLock(repoRoot, runId);
     try {
         let graph = loadGraph(repoRoot);
+        // v1.51 T2: the routing mode resolves BEFORE any routing input is built — run flag > spec front-matter
+        // > repo > global > default. The resolved cfg carries mode-compiled floors; route() never sees the mode.
+        const rm = resolveRunMode(repoRoot, { flag: opts.mode, spec: graph.mode, globalDir: opts.globalDir });
+        const cfg = rm.cfg;
+        // v1.51 T4: every dispatch provenance line begins with the mode and its source; when a pin won
+        // the route (the final "→ " segment is a pin, not a degraded-to-auto tail) it names the mode it bypassed.
+        const dispatchProvenance = (p) => `mode ${rm.mode.mode} (${rm.source})${p.split("→ ").pop().startsWith("pin ") ? ` — pin bypasses mode ${rm.mode.mode}` : ""} · ${p}`;
+        const channels = discoverChannels(cfg, adapters, health);
+        // v1.6 ROUTE-06: build the learned profile ONCE at startup (never per task, never in the comparator).
+        // No preview — the daemon honors routing.learned:off and gets undefined; this snapshot is immutable
+        // for the run, so this run's own telemetry never feeds back into its own routing.
+        const profile = loadRoutingProfile(repoRoot, cfg);
         const journal = opts.resume ? Journal.open(repoRoot, runId, opts.narrate) : Journal.create(repoRoot, runId, opts.narrate);
         const branchEvent = opts.resume
             ? [...journal.read()].reverse().find((e) => (e.event === "run-start" || e.event === "run-end" || e.event === "merge") && typeof e.data.branch === "string")
@@ -131,7 +175,7 @@ export async function runDaemon(repoRoot, opts = {}) {
             baseRef = await gitHead(repoRoot);
             baseline = await captureBaseline(repoRoot, commands);
             writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
-            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness
+            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2
         }
         // T6: open the narrator AFTER run-start/run-resume is journaled so the watch surface has a run to
         // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
@@ -389,7 +433,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 lastContextTokens = undefined;
                 graph = setStatus(graph, t.id, "running");
                 saveGraph(repoRoot, graph);
-                journal.append("task-dispatch", t.id, { assignment, attempt, provenance: r.provenance, retryMode });
+                journal.append("task-dispatch", t.id, { assignment, attempt, provenance: dispatchProvenance(r.provenance), retryMode });
                 const taskBase = await integrationHead(intWt); // deps are merged → visible to this task
                 const taskBranch = `${branch}--${t.id}`; // "--": a ref can't nest under the existing integration branch (locked decision 10)
                 const priorWt = worktreePath(repoRoot, taskBranch);

package/package.json

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