tickmarkr 1.49.0 → 1.51.0

package/dist/cli/commands/plan.js

@@ -1,12 +1,32 @@
 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
+// markers carry the attention glyph, section labels dim to chrome (the doctor/status system).
+// Gated on ttyVisual(): the non-TTY surface returns untouched (byte-pinned, machine-consumable).
+const stylizePlan = (out) => {
+    if (!ttyVisual())
+        return out;
+    return out.split("\n").map((line, i) => {
+        if (i === 0)
+            return `${title(line)}\n${rule()}`;
+        if (/^(routing|context window|scope) lints:$/.test(line))
+            return dim(line);
+        return line
+            .replace(/^(\s+)! /, (_, s) => `${s}${warn(GLYPHS.attention)} `)
+            .replace(/^(  \S+\s+\S+\s+)!! /, (_, p) => `${p}${warn("!!")} `);
+    }).join("\n");
+};
 const fleetCanCrossVendorReview = (channels) => {
     for (let i = 0; i < channels.length; i++)
         for (let j = 0; j < channels.length; j++)
@@ -14,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));
@@ -29,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), "");
@@ -61,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`);
@@ -83,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;
@@ -94,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}`);
         }
     }
@@ -114,5 +174,5 @@ export async function plan(_argv, cwd = process.cwd(), adapters = allAdapters())
     const scopeLints = collateralLints(g.tasks, cwd);
     if (scopeLints.length)
         lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
-    return lines.join("\n");
+    return stylizePlan(lines.join("\n"));
 }

package/dist/cli/commands/report.js

@@ -1,5 +1,7 @@
 import { parseArgs } from "node:util";
+import { ttyVisual } from "../../adapters/model-lints.js";
 import { addUsage } from "../../adapters/types.js";
+import { dim, rule, title } from "../../brand.js";
 import { loadConfig } from "../../config/config.js";
 import { estimateCosts } from "../../report/cost.js";
 import { cellsOf, cellSummary } from "../../route/profile.js";
@@ -287,6 +289,16 @@ function textReport(runId, events, rows, cwd) {
         `  probes this run (route-deviation explore): ${probes}`,
     ].join("\n");
 }
+// T4 (v1.50): TTY-only brand pass over the text report — title frame + dim section chrome; row
+// text and alignment untouched (the doctor/status system). Gated on ttyVisual(): the non-TTY
+// surface returns untouched, and --md never styles (the record is a document surface).
+const stylizeReport = (out) => {
+    if (!ttyVisual())
+        return out;
+    return out
+        .replace(/^.*$/m, (first) => `${title(first)}\n${rule()}`) // non-global /m ⇒ first line only
+        .replace(/^(engagement summary — audit trail:|spend — tokens[^\n]*|spend — money:|learning \([^\n]*)$/gm, (l) => dim(l));
+};
 export async function report(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
         args: argv,
@@ -302,5 +314,5 @@ export async function report(argv, cwd = process.cwd()) {
         const rows = j.readTelemetry();
         return renderMarkdownRecord(runId, events, estimateCosts(rows, loadConfig(cwd).cost), rows);
     }
-    return textReport(runId, events, j.readTelemetry(), cwd);
+    return stylizeReport(textReport(runId, events, j.readTelemetry(), cwd));
 }

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

@@ -1,3 +1,5 @@
+import { type JournalEvent } from "../../run/journal.js";
+export declare const narrationLine: (event: JournalEvent) => string;
 export declare function run(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;

package/dist/cli/commands/run.js

@@ -1,13 +1,34 @@
 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";
+// T4 (v1.50): lifecycle verdict glyphs on the live narration stream — glyph-first, message text
+// unchanged (the doctor/status visual system). TTY-gated: the piped narration surface stays
+// byte-identical to formatJournalNarration.
+const NARRATION_VERDICTS = {
+    "task-dispatch": "neutral",
+    "task-done": "pass",
+    "task-failed": "fail",
+    "task-human": "warn",
+};
+export const narrationLine = (event) => {
+    const line = formatJournalNarration(event);
+    const verdict = NARRATION_VERDICTS[event.event];
+    return verdict !== undefined && ttyVisual() ? statusRow(verdict, line) : line;
+};
 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,
@@ -16,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" },
         },
     });
@@ -24,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();
@@ -39,14 +75,15 @@ 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),
-            narrate: (event) => console.log(formatJournalNarration(event)),
+            mode: flagMode,
+            narrate: (event) => console.log(narrationLine(event)),
         });
         const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
         return { out, code: summaryGreen(s) ? 0 : 2 };
@@ -54,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/cli/commands/status.js

@@ -1,4 +1,4 @@
-import { BANNER } from "../../brand.js";
+import { BANNER, GLYPHS, dim, fail, legend, ok, rule, statusRow, title, warn } from "../../brand.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, pendingTasks } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { Journal, engagementComparable } from "../../run/journal.js";
@@ -19,17 +19,8 @@ const attemptStartIdx = (events, taskId) => {
     return idx;
 };
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
-const color = (text, code, enabled) => enabled ? `\x1b[${code}m${text}\x1b[0m` : text;
-const taskBox = (status, unicode) => {
-    if (unicode) {
-        if (status === "done")
-            return "✓";
-        if (status === "failed")
-            return "✗";
-        if (status === "human")
-            return "⏸";
-        return "☐";
-    }
+// non-TTY machine surface only — the TTY frame draws task verdicts via statusRow
+const taskBox = (status) => {
     if (status === "done")
         return "[x]";
     if (status === "failed" || status === "human")
@@ -37,8 +28,10 @@ const taskBox = (status, unicode) => {
     return "[ ]";
 };
 const gateBox = (state, unicode) => {
-    if (unicode)
-        return state === "pass" ? "✓" : state === "fail" ? "✗" : state === "skip" ? "·" : "☐";
+    if (unicode) {
+        // shared glyph vocabulary: pass/fail verdicts, dash for skip, dim circle for not-yet-run
+        return state === "pass" ? GLYPHS.pass : state === "fail" ? GLYPHS.fail : state === "skip" ? GLYPHS.neutral : GLYPHS.toggleInactive;
+    }
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
 const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
@@ -59,9 +52,12 @@ const gateStates = (task, events) => {
     }
     return GATE_NAMES.map((gate) => task.gates.includes(gate) ? outcomes.get(gate) ?? "open" : "skip");
 };
-// verdict semantics only: pass green, fail red, skip/open dim chrome — everything else stays quiet
-const GATE_STATE_COLOR = { pass: 32, fail: 31, skip: 2, open: 2 };
-const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => color(`${GATE_KEYS[gate]}${gateBox(states[i], unicode)}`, GATE_STATE_COLOR[states[i]], unicode)).join(" ");
+// verdict semantics only: pass brand green, fail red, skip/open dim chrome — everything else stays quiet
+const GATE_STATE_TOKEN = { pass: ok, fail, skip: dim, open: dim };
+const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => {
+    const chip = `${GATE_KEYS[gate]}${gateBox(states[i], unicode)}`;
+    return unicode ? GATE_STATE_TOKEN[states[i]](chip) : chip;
+}).join(" ");
 // plain (uncolored) chip width for column math — ANSI codes have zero display width
 const gateChainWidth = (unicode) => GATE_NAMES.reduce((w, gate) => w + GATE_KEYS[gate].length + (unicode ? 1 : 3) + 1, -1);
 const shortGoal = (goal, max) => {
@@ -159,61 +155,62 @@ const renderFrame = (cwd) => {
         const assignCol = contexts.has(t.id) ? `${channel}${divider}ctx ${contexts.get(t.id)}` : channel;
         return { t, st, label, assignCol, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
     });
-    const statusColor = (st) => st === "done" ? 32 : st === "failed" ? 31 : st === "human" ? 33 : 36;
     if (!unicode) {
         // machine/CI surface — layout unchanged (pipes, greps, and the golden pins depend on it)
         const rows = cells.map(({ t, st, label, assignCol, states }) => {
             const chain = gateChain(states, false);
-            const prefix = `  ${taskBox(st, false)} ${t.id} `;
+            const prefix = `  ${taskBox(st)} ${t.id} `;
             const suffix = `  ${chain}  ${String(st)}${label}  ${assignCol}`;
             return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
         });
         const header = runId
             ? `tickmarkr status${divider}run ${runId}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events).replaceAll(" · ", divider)}${divider}${done}/${g.tasks.length} done`
             : `tickmarkr status${divider}no runs yet${divider}${done}/${g.tasks.length} done`;
-        const legend = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
-        return [header, legend, ...rows].join("\n");
+        const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
+        return [header, legendLine, ...rows].join("\n");
     }
-    // TTY: audit-ledger frame — bold brand mark, dim chrome, semantic color only on verdicts,
-    // completion gauge, and column-aligned rows (pad plain text FIRST, colorize after: ANSI has
-    // zero display width and would corrupt padEnd math)
-    const dim = (s) => color(s, 2, true);
+    // TTY: cockpit frame composed through src/brand.ts (CLI-DESIGN.md) — dominant run title,
+    // dim chrome, semantic color only on verdicts, completion gauge, and column-aligned status
+    // rows (pad plain text FIRST, colorize after: ANSI has zero display width and would corrupt
+    // padEnd math)
     const dot = dim(" · ");
     const anyFailed = cells.some((c) => c.st === "failed");
     const gaugeCells = 10;
     const fill = g.tasks.length ? Math.round((done / g.tasks.length) * gaugeCells) : 0;
-    const gauge = (fill ? color("█".repeat(fill), anyFailed ? 31 : 32, true) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
+    const gauge = (fill ? (anyFailed ? fail : ok)("█".repeat(fill)) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
     const live = liveness(events)
-        .replace(/\bdead\b/, color("dead", 31, true))
-        .replace(/\bfinished\b/, color("finished", 2, true))
-        .replace(/\balive\b/, color("alive", 32, true))
+        .replace(/\bdead\b/, fail("dead"))
+        .replace(/\bfinished\b/, dim("finished"))
+        .replace(/\balive\b/, ok("alive"))
         .replaceAll(" · ", dot);
     const tally = `${done}/${g.tasks.length} done`;
-    const header = ` ${color("✓", 32, true)} ${color("tickmarkr", 1, true)}${dot}` +
+    const header = ` ${title(runId ? `run ${runId}` : "tickmarkr")}${dot}` +
         (runId
-            ? `run ${runId}${dot}${!comparable ? `${NOT_COMPARABLE_NOTICE}${dot}` : ""}${live}${dot}`
+            ? `${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}`
             : `no runs yet${dot}`) +
-        `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? color(tally, 32, true) : tally}`;
-    const rule = dim("─".repeat(Math.min(width, 100)));
-    const legend = dim(`   gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(" · ")}`);
+        `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
+    const hr = rule(Math.min(width, 100));
+    const gatesLegend = legend(`   gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(" · ")}`);
+    const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
     const stW = Math.max(...cells.map((c) => (String(c.st) + c.label).length));
     const chainW = gateChainWidth(true);
     const assignW = Math.max(...cells.map((c) => c.assignCol.length));
     const goalW = Math.max(8, width - (5 + idW) - 2 - chainW - 2 - stW - 2 - assignW);
     const rows = cells.map(({ t, st, label, assignCol, states }) => {
-        const box = color(taskBox(st, true), st === "done" ? 32 : st === "failed" ? 31 : st === "human" ? 33 : 2, true);
         const goal = shortGoal(t.goal, goalW).padEnd(goalW);
-        const statusCell = color(String(st), statusColor(st), true) +
-            (label ? (label === " starved" ? color(label, 31, true) : dim(label)) : "") +
+        const stWord = st === "done" ? ok(String(st)) : st === "failed" ? fail(String(st)) : st === "human" ? warn(String(st)) : String(st);
+        const statusCell = stWord +
+            (label ? (label === " starved" ? fail(label) : dim(label)) : "") +
             " ".repeat(stW - (String(st) + label).length);
-        return `  ${box} ${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`;
+        return `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`)}`;
     });
-    return [header, rule, legend, ...rows].join("\n");
+    return [header, hr, gatesLegend, ...rows].join("\n");
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
+    // cockpit surface: banner + frame on a TTY (doctor's pattern); pipes get the bare frame
     if (!argv.includes("--watch"))
-        return renderFrame(cwd);
+        return visual() ? BANNER + renderFrame(cwd) : renderFrame(cwd);
     const iterations = opts.iterations ?? Infinity;
     const sleep = opts.sleep ?? defaultSleep;
     const bounded = Number.isFinite(iterations);
@@ -223,7 +220,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     for (let i = 0; i < iterations; i++) {
         const frame = renderFrame(cwd);
         if (tty)
-            process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame}\n\x1b[2m watching · refresh ${REFRESH_MS / 1000}s · ^C to quit\x1b[0m`);
+            process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame}\n${legend(` watching · refresh ${REFRESH_MS / 1000}s · ^C to quit`)}`);
         else
             process.stdout.write(frame + sep);
         if (bounded)

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;