tickmarkr 1.49.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/brand.d.ts

@@ -1,9 +1,71 @@
+import type { OwnedName } from "./drivers/types.js";
 export declare const BANNER: string;
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export declare const PLAIN_BANNER: string;
+export declare const PANE_IDENTITY_ENV = "TICKMARKR_PANE_IDENTITY";
+/** One-line pane identity through the T1 ownership contract: role · task · attempt · run. */
+export declare function paneIdentityLine(o: OwnedName): string;
 export declare function bannerShell(): string;
 export declare const TICKMARKR_EXIT_TRAILER = "printf '\\nTICKMARKR_''EXIT:%s\\n' $?";
 /** OBS-50: visible-pane bootstrap script — banner + agent command + byte-identical exit trailer. */
 export declare function paneDispatchScript(body: string[]): string;
 /** OBS-50: one short herdr pane-run line; bootstrap lives in the script file beside the prompt. */
 export declare function paneDispatchCommand(scriptPath: string): string;
+/** The settled brand green ramp (256-color), bright → deep — the BANNER hues. */
+export declare const BRAND_RAMP: readonly [84, 78, 41, 35];
+/** Brand green (ramp anchor 41) — the tickmark hue; also the ok/pass/authed verdict color. */
+export declare const brand: (s: string) => string;
+/** Ok verdicts (pass/authed/green) render in the brand green ramp — same hue as the tickmark. */
+export declare const ok: (s: string) => string;
+/** Fail verdicts (unauthed/red) — red, always paired with the ✗ shape. */
+export declare const fail: (s: string) => string;
+/** Attention (warn/lint) — amber, always paired with the ! shape. */
+export declare const warn: (s: string) => string;
+/** Chrome (legends, rules, parentheticals, inactive state) — dim. */
+export declare const dim: (s: string) => string;
+/** Emphasis (titles, selection, the product name) — bold. */
+export declare const bold: (s: string) => string;
+/** Every semantic color token, for sweeps: each is TTY-gated and NO_COLOR-aware. */
+export declare const TOKENS: {
+    readonly brand: (s: string) => string;
+    readonly ok: (s: string) => string;
+    readonly fail: (s: string) => string;
+    readonly warn: (s: string) => string;
+    readonly dim: (s: string) => string;
+    readonly bold: (s: string) => string;
+};
+/**
+ * The glyph vocabulary — plain characters only; color layers on via tokens so
+ * shape survives NO_COLOR. Bracket toggles ([x]/[ ]) are forbidden on every surface.
+ */
+export declare const GLYPHS: {
+    /** Cursor row pointer in list pickers. */
+    readonly pointer: "❯";
+    /** Active toggle: THE brand tickmark — always rendered via brand(), never brackets. */
+    readonly toggleActive: "✓";
+    /** Inactive toggle: dim circle — always rendered via dim(). */
+    readonly toggleInactive: "○";
+    /** Pass verdict. */
+    readonly pass: "✓";
+    /** Fail verdict. */
+    readonly fail: "✗";
+    /** Attention/warn verdict. */
+    readonly attention: "!";
+    /** Neutral/skip — the dash. */
+    readonly neutral: "-";
+};
+/** The active toggle as rendered: brand green tickmark on a TTY, plain ✓ otherwise. */
+export declare const toggleActive: () => string;
+/** The inactive toggle as rendered: dim circle on a TTY, plain ○ otherwise. */
+export declare const toggleInactive: () => string;
+/** Dominant title line — one glance answers "what am I looking at". Bold on a TTY. */
+export declare const title: (text: string) => string;
+/** Single dim legend line under a title (key hints) — never scattered, never a paragraph. */
+export declare const legend: (text: string) => string;
+/** Horizontal rule sized to the terminal (capped at 100 cols) — dim chrome. */
+export declare const rule: (width?: number) => string;
+/** Aligned key-value row: dim key, plain value. Padding applied BEFORE styling so columns hold. */
+export declare const kvRow: (key: string, value: string, keyWidth?: number) => string;
+export type Verdict = "pass" | "fail" | "warn" | "neutral";
+/** Status row: verdict glyph FIRST, then the label — glyph-first, distinct shape per verdict. */
+export declare const statusRow: (verdict: Verdict, label: string) => string;

package/dist/brand.js

@@ -12,11 +12,21 @@ export const BANNER = [
 ].join("\n");
 /** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
 export const PLAIN_BANNER = BANNER.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
-// Shell one-liner that prints the banner inside a pane before a gate command runs. ESC bytes are
+// T5: the pane identity every visible pane announces under the logo. HerdrDriver seeds this env var
+// into each pane shell at slot() time (paneIdentityLine of the pane's T1 owned name); the banner's
+// identity line reads it at pane runtime, so every role — worker/judge/review/consult — wears the
+// same header without the dispatch call sites threading identity through the script.
+export const PANE_IDENTITY_ENV = "TICKMARKR_PANE_IDENTITY";
+/** One-line pane identity through the T1 ownership contract: role · task · attempt · run. */
+export function paneIdentityLine(o) {
+    return `${o.role} · ${o.taskId} · attempt ${o.attempt}${o.runId ? ` · ${o.runId}` : ""}`;
+}
+// Shell one-liner that prints the banner inside a pane before a gate command runs, followed by ONE
+// dim identity line (the seeded $TICKMARKR_PANE_IDENTITY, else a bare "tickmarkr"). ESC bytes are
 // carried as printf %b escapes (never raw control bytes in a command string crossing the herdr socket).
 export function bannerShell() {
     const printable = BANNER.replaceAll("\x1b", "\\033").replaceAll("\n", "\\n");
-    return `printf '%b\\n' '${printable}'`;
+    return `printf '%b\\n' '${printable}' "\\033[2m\${${PANE_IDENTITY_ENV}:-tickmarkr}\\033[0m"`;
 }
 // OBS-50: quote-split exit marker — herdr echoes the typed command into the transcript that
 // waitOutput matches, so the literal must not appear unsplit in the dispatch line.
@@ -29,3 +39,65 @@ export function paneDispatchScript(body) {
 export function paneDispatchCommand(scriptPath) {
     return `bash ${shq(scriptPath)}`;
 }
+// ── design system (v1.50) ── contract: docs/codebase/CLI-DESIGN.md ──────────
+// Every cockpit surface styles through these tokens/glyphs/helpers. Styled only
+// on a real TTY with NO_COLOR unset; otherwise output is the plain text itself
+// (non-TTY surfaces stay byte-pinned and machine-consumable).
+/** The settled brand green ramp (256-color), bright → deep — the BANNER hues. */
+export const BRAND_RAMP = [84, 78, 41, 35];
+const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const sgr = (code) => (s) => visual() ? `\x1b[${code}m${s}${R}` : s;
+/** Brand green (ramp anchor 41) — the tickmark hue; also the ok/pass/authed verdict color. */
+export const brand = sgr(`38;5;${BRAND_RAMP[2]}`);
+/** Ok verdicts (pass/authed/green) render in the brand green ramp — same hue as the tickmark. */
+export const ok = brand;
+/** Fail verdicts (unauthed/red) — red, always paired with the ✗ shape. */
+export const fail = sgr("31");
+/** Attention (warn/lint) — amber, always paired with the ! shape. */
+export const warn = sgr("33");
+/** Chrome (legends, rules, parentheticals, inactive state) — dim. */
+export const dim = sgr("2");
+/** Emphasis (titles, selection, the product name) — bold. */
+export const bold = sgr("1");
+/** Every semantic color token, for sweeps: each is TTY-gated and NO_COLOR-aware. */
+export const TOKENS = { brand, ok, fail, warn, dim, bold };
+/**
+ * The glyph vocabulary — plain characters only; color layers on via tokens so
+ * shape survives NO_COLOR. Bracket toggles ([x]/[ ]) are forbidden on every surface.
+ */
+export const GLYPHS = {
+    /** Cursor row pointer in list pickers. */
+    pointer: "❯",
+    /** Active toggle: THE brand tickmark — always rendered via brand(), never brackets. */
+    toggleActive: "✓",
+    /** Inactive toggle: dim circle — always rendered via dim(). */
+    toggleInactive: "○",
+    /** Pass verdict. */
+    pass: "✓",
+    /** Fail verdict. */
+    fail: "✗",
+    /** Attention/warn verdict. */
+    attention: "!",
+    /** Neutral/skip — the dash. */
+    neutral: "-",
+};
+/** The active toggle as rendered: brand green tickmark on a TTY, plain ✓ otherwise. */
+export const toggleActive = () => brand(GLYPHS.toggleActive);
+/** The inactive toggle as rendered: dim circle on a TTY, plain ○ otherwise. */
+export const toggleInactive = () => dim(GLYPHS.toggleInactive);
+/** Dominant title line — one glance answers "what am I looking at". Bold on a TTY. */
+export const title = (text) => bold(text);
+/** Single dim legend line under a title (key hints) — never scattered, never a paragraph. */
+export const legend = (text) => dim(text);
+/** Horizontal rule sized to the terminal (capped at 100 cols) — dim chrome. */
+export const rule = (width = Math.min(process.stdout.columns ?? 80, 100)) => dim("─".repeat(width));
+/** Aligned key-value row: dim key, plain value. Padding applied BEFORE styling so columns hold. */
+export const kvRow = (key, value, keyWidth = 14) => `  ${dim(key.padEnd(keyWidth))} ${value}`;
+const VERDICT = {
+    pass: () => ok(GLYPHS.pass),
+    fail: () => fail(GLYPHS.fail),
+    warn: () => warn(GLYPHS.attention),
+    neutral: () => dim(GLYPHS.neutral),
+};
+/** Status row: verdict glyph FIRST, then the label — glyph-first, distinct shape per verdict. */
+export const statusRow = (verdict, label) => `${VERDICT[verdict]()} ${label}`;

package/dist/cli/commands/doctor.js

@@ -1,36 +1,15 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, detectCandidateClis, formatCandidateCliRow, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
-import { BANNER } from "../../brand.js";
+import { allAdapters, detectCandidateClis, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { BANNER, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
-// same gate + palette as status's audit-ledger frame: styled only on a real TTY, plain otherwise
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
-const color = (text, code) => `\x1b[${code}m${text}\x1b[0m`;
-// TTY-only line pass: color the verdict symbols, dim the chrome (section titles, parentheticals,
-// n/a rows). Padding is untouched — every rewrite swaps equal-width text or wraps it in ANSI.
-function stylize(out) {
-    if (!visual())
-        return out;
-    const rule = color("─".repeat(Math.min(process.stdout.columns ?? 80, 100)), 2);
-    return out.split("\n").map((line) => {
-        if (line.startsWith("tickmarkr doctor"))
-            return ` ${color("✓", 32)} ${color("tickmarkr", 1)} doctor ${color("· capability matrix", 2)}\n${rule}`;
-        if (/^(workspace trust|model status|model drift)/.test(line))
-            return color(line, 2);
-        return line
-            .replace(/^(\s+)✓ /, (_, s) => `${s}${color("✓", 32)} `)
-            .replace(/^(\s+)✗ /, (_, s) => `${s}${color("✗", 31)} `)
-            .replace(/^(\s+)! /, (_, s) => `${s}${color("!", 33)} `)
-            .replace(/^(\s+)= (.*)$/, (_, s, rest) => `${s}${color(`= ${rest}`, 2)}`)
-            .replace(/(\(auth assumed; verified at dispatch \(failover on auth\/quota errors\)\))/, (m) => color(m, 2))
-            .replace(/\bauthed\b(?!:)/, color("authed", 32))
-            .replace(/\bunauthed:/, color("unauthed:", 33));
-    }).join("\n");
-}
+const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
+const attentionRow = (text) => `  ${statusRow("warn", text)}`;
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     const cfg = loadConfig(cwd);
     // banner at START — the logo greets the operator before the ~60s probe wait, never trailing it (operator report 2026-07-17)
@@ -63,48 +42,49 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const rows = adapters.map((a) => {
         const h = health[a.id];
         const state = !h.installed ? "not installed" : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
-        return `  ${h.installed ? "✓" : "✗"} ${a.id.padEnd(14)} ${state}`;
+        return alignedStatusRow(h.installed ? "pass" : "fail", a.id, state);
     });
     // v1.48 T1: advisory sweep for known agent CLIs with no adapter — never written to doctor.json health.
-    rows.push(...detectCandidateClis().map(formatCandidateCliRow));
-    rows.push(`  ${HerdrDriver.available() ? "✓" : "✗"} herdr          ${HerdrDriver.available() ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"}`);
+    rows.push(...detectCandidateClis().map(({ binary, version }) => alignedStatusRow("warn", binary, `detected: ${version ?? "version unknown"} (no tickmarkr adapter — not routable)`)));
+    const herdr = HerdrDriver.available();
+    rows.push(alignedStatusRow(herdr ? "pass" : "fail", "herdr", herdr ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"));
     // v1.22 T5: workspace-trust pre-flight — per installed adapter: trusted | seeded | action-required | n/a.
     // action-required names the exact one-time command (or dialog) the operator must run once.
-    rows.push("workspace trust:");
+    rows.push(legend("workspace trust:"));
     for (const a of adapters) {
         if (!health[a.id]?.installed)
             continue;
         if (!a.trust) {
-            rows.push(`  = ${a.id.padEnd(14)} trust: n/a`);
+            rows.push(`  ${dim("=")} ${kvRow(a.id, "trust: n/a").slice(2)}`);
             continue;
         }
         try {
             const v = a.trust(cwd);
             if (v.status === "trusted")
-                rows.push(`  ✓ ${a.id.padEnd(14)} trust: trusted`);
+                rows.push(alignedStatusRow("pass", a.id, "trust: trusted"));
             else if (v.status === "seeded")
-                rows.push(`  ✓ ${a.id.padEnd(14)} trust: seeded`);
+                rows.push(alignedStatusRow("pass", a.id, "trust: seeded"));
             else
-                rows.push(`  ! ${a.id.padEnd(14)} trust: action-required — run ONCE: ${v.command}`);
+                rows.push(alignedStatusRow("warn", a.id, `trust: action-required — run ONCE: ${v.command}`));
         }
         catch (e) {
             // fail closed on the trust line only — never abort the rest of doctor
-            rows.push(`  ! ${a.id.padEnd(14)} trust: action-required — run ONCE: (trust check failed: ${e instanceof Error ? e.message : String(e)})`);
+            rows.push(alignedStatusRow("warn", a.id, `trust: action-required — run ONCE: (trust check failed: ${e instanceof Error ? e.message : String(e)})`));
         }
     }
     for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
         if (!health[sel.adapter]?.installed) {
-            rows.push(`  ! ${role} runs on ${sel.adapter}:${sel.model} — NOT installed; that gate will fail closed until you install it or remap cfg.${role}`);
+            rows.push(attentionRow(`${role} runs on ${sel.adapter}:${sel.model} — NOT installed; that gate will fail closed until you install it or remap cfg.${role}`));
         }
     }
-    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map((l) => `  ! ${l}`));
+    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map(attentionRow));
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
-        rows.push(`  ! ${exclusionLine(excluded)}`);
+        rows.push(attentionRow(exclusionLine(excluded)));
     // HYG-07(a): doctor just probed fresh (probeAll above), so servability attribution is current by construction.
     const servable = servableExclusions(cfg, adapters, health);
     if (servable.length)
-        rows.push(`  ! ${servabilityLine(servable)}`);
+        rows.push(attentionRow(servabilityLine(servable)));
     // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, tickmarkr NEVER applies it.
     // TTY gets a one-line summary + the fragment as a file (the full dump drowned everything else,
     // v1.33.1 onboarding); machine/CI surface keeps the inline dump — layout is pinned by tests.
@@ -114,7 +94,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         if (visual()) {
             const overlayPath = join(tickmarkrDir(cwd), "doctor-overlay.yaml");
             writeFileSync(overlayPath, frag);
-            drift = `\nmodel drift: unclassified models detected — paste-ready overlay written to ${overlayPath} (advisory; tickmarkr never applies it)`;
+            drift = `\n  ${statusRow("warn", `model drift: unclassified models detected — paste-ready overlay written to ${overlayPath} ${dim("(advisory; tickmarkr never applies it)")}`)}`;
         }
         else {
             drift = `\nmodel drift — paste-ready overlay (advisory; tickmarkr never applies):\n${frag}`;
@@ -137,20 +117,24 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         if (!models.length && !unclassified.length)
             return [];
         const w = Math.max(8, ...models.map((m) => m.length));
-        const rows = [`  ${a.id}`];
+        const rows = [`  ${dim(a.id)}`];
         for (const m of models) {
             const v = h.modelAuth?.[m];
-            const auth = !v ? "unknown" : v.authed ? "authed" : `unauthed: ${trunc(v.reason ?? "probe failed", 40)} (${dateOf(v.probedAt)})`;
+            const auth = !v
+                ? dim("unknown")
+                : v.authed
+                    ? ok("authed")
+                    : `${fail("unauthed:")} ${trunc(v.reason ?? "probe failed", 40)} (${dateOf(v.probedAt)})`;
             const d = disallowedBy({ adapter: a.id, model: m }, cfg.routing);
             const denied = d?.by === "deny" ? d.entry : "—";
             const pref = preferRanks({ adapter: a.id, model: m }, cfg).map((p) => `${p.shape}#${p.rank}`).join(",") || "—";
             const windowCol = showWindows
                 ? ` ${String(declaredModelWindow(cfg, a.id, m) ?? "—").padEnd(8)}`
                 : "";
-            rows.push(`    ${m.padEnd(w)} ${classified[m].padEnd(8)}${windowCol} ${auth}  denied=${denied}  prefer=${pref}`);
+            rows.push(`    ${m.padEnd(w)} ${classified[m].padEnd(8)}${windowCol} ${auth}  ${dim("denied=")}${denied}  ${dim("prefer=")}${pref}`);
         }
         if (unclassified.length)
-            rows.push(`    (${unclassified.length} more listed, unclassified)`);
+            rows.push(`    ${dim(`(${unclassified.length} more listed, unclassified)`)}`);
         return rows;
     });
     const autoPrefer = readAutoPrefer(cwd);
@@ -162,11 +146,14 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             const seed = DEFAULT_CONFIG.routing.map[shape]?.prefer ?? [];
             if (!auto.length && !seed.length)
                 return []; // nothing derived, nothing seeded — an empty line is noise
-            return [`    prefer ${shape} (auto): ${auto.join(" > ")} — seed was [${seed.join(", ")}]`];
+            return [`    ${dim(`prefer ${shape} (auto):`)} ${auto.join(" > ")} ${dim("— seed was")} [${seed.join(", ")}]`];
         })
         : [];
     const modelSummary = modelStatus.length || preferStatus.length
-        ? `\nmodel status:\n${[...modelStatus, ...preferStatus].join("\n")}`
+        ? `\n${legend("model status:")}\n${[...modelStatus, ...preferStatus].join("\n")}`
         : "";
-    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
+    const header = visual()
+        ? `${statusRow("pass", `${title("tickmarkr doctor")} ${legend("· capability matrix")}`)}\n${rule()}`
+        : "tickmarkr doctor — capability matrix:";
+    return `${header}\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`;
 }

package/dist/cli/commands/fleet.js

@@ -5,15 +5,14 @@ import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
 import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
-import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, loadConfig, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, unifiedYamlDiff, } from "../../config/config.js";
+import { GLYPHS, bold, legend as legendText, toggleActive, toggleInactive } from "../../brand.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";
-const BOLD = (s) => `\x1b[1m${s}\x1b[0m`;
-const DIM = (s) => `\x1b[2m${s}\x1b[0m`;
-const POINTER = "❯";
 const isDeniedAdapter = (id, editable) => editable.denyAdapters.includes(id);
 const isDeniedModel = (adapter, model, editable) => editable.denyModels.includes(`${adapter}:${model}`);
 function previewTask(shape) {
@@ -57,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";
@@ -75,8 +85,8 @@ function moveCursor(k, cursor, count) {
 }
 // step title (bold) + one dim key legend + rows; exactly one pointer glyph on the cursor row
 function listFrame(title, legend, rows, cursor) {
-    const lines = [BOLD(title), DIM(legend)];
-    rows.forEach((r, i) => lines.push(i === cursor ? `${POINTER} ${BOLD(r)}` : `  ${r}`));
+    const lines = [bold(title), legendText(legend)];
+    rows.forEach((r, i) => lines.push(i === cursor ? `${GLYPHS.pointer} ${bold(r)}` : `  ${r}`));
     return lines;
 }
 // Keypress terminal over the (injectable) input stream. Keypress events are decoded by
@@ -156,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;
@@ -168,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))
@@ -187,16 +204,16 @@ 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];
             const on = !isDeniedAdapter(a.id, editable);
-            return `[${on ? "x" : " "}] ${a.id}  ${h?.version ?? "installed"}  ${h?.authed ? "authed" : "unauthed"}`;
+            return `${on ? toggleActive() : toggleInactive()} ${a.id}  ${h?.version ?? "installed"}  ${h?.authed ? "authed" : "unauthed"}`;
         });
         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))
@@ -220,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,9 +255,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                 }
                 const tier = editable.tiers[a.id]?.[r.model];
                 const denied = isDeniedModel(a.id, r.model, editable);
-                return `[${denied ? " " : "x"}] ${r.model}  ${tier?.tier ?? "???"}  ${denied ? "denied" : "allowed"}`;
+                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));
@@ -285,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);
@@ -293,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) {
@@ -302,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));
@@ -351,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));
@@ -362,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/init.js

@@ -5,7 +5,7 @@ import { parseArgs } from "node:util";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
-import { BANNER } from "../../brand.js";
+import { BANNER, kvRow, legend, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
 import { Journal } from "../../run/journal.js";
 import { doctor } from "./doctor.js";
@@ -264,5 +264,25 @@ export async function init(argv, cwd = process.cwd()) {
     }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
-    return `${notes.join("\n")}\n${doc}\n${nextSteps(cwd, SCAFFOLD_SPEC)}\n${ENVIRONMENTS_FOOTER}`;
+    const next = nextSteps(cwd, SCAFFOLD_SPEC);
+    if (!visual())
+        return `${notes.join("\n")}\n${doc}\n${next}\n${ENVIRONMENTS_FOOTER}`;
+    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
+    const footerRows = ENVIRONMENTS_FOOTER.split("\n").slice(1).map((line) => {
+        const separator = line.indexOf(" — ");
+        return kvRow(line.slice(2, separator), line.slice(separator + 1), 12);
+    });
+    return [
+        title("tickmarkr init"),
+        legend("· setup notes"),
+        rule(),
+        ...noteRows,
+        doc,
+        title("next steps"),
+        legend("· continue from the repository's current state"),
+        rule(),
+        kvRow("next", next.replace(/^next:\s*/, "")),
+        legend("environments:"),
+        ...footerRows,
+    ].join("\n");
 }

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>;