tickmarkr 1.49.0 → 1.51.0

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/drivers/herdr.js

@@ -1,4 +1,5 @@
 import { shq } from "../adapters/types.js";
+import { PANE_IDENTITY_ENV, paneIdentityLine } from "../brand.js";
 import { createWorktree, sh } from "../run/git.js";
 import { herdrSealShellPrefix } from "./subprocess.js";
 import { canonicalizeLegacyName, formatOwnedName, panesToClose, parseOwnedName } from "./types.js";
@@ -115,6 +116,8 @@ export class HerdrDriver {
         const rootPane = res?.root_pane?.pane_id; // auto-created shell pane (SKILL:343)
         if (typeof tabId !== "string" || !tabId)
             throw new Error(`herdr tab create returned no tab_id (refusing untargeted placement): ${t.stdout}`);
+        // T5: the banner's pane identity line, derived from the T1 owned name (legacy names pass through).
+        const identity = shq(paneIdentityLine(canonicalizeLegacyName(name, "")));
         let r = await this.herdr(`agent start ${shq(name)} --cwd ${shq(cwd)} --tab ${shq(tabId)} --no-focus -- bash`);
         if (r.code !== 0 && /agent_name_taken/.test(r.stderr + r.stdout)) {
             // DEFECT-01: a prior (killed) process's kept pane still holds this durable name — reclaim it.
@@ -149,7 +152,7 @@ export class HerdrDriver {
         // worker GETS, not a rule it must remember (P40-02 probe leak). Fail closed: a failed seed rejects.
         // v1.22 T3 / OBS-17: also strip HERDR_ENV + socket path so the worker cannot open/mutate panes in
         // the operator's session. Daemon-side this.herdr() calls keep process.env (unsealed).
-        const seed = await this.herdr(`pane run ${shq(id)} ${shq(`export HERDR_WORKSPACE_ID=${shq(this.ws)}; ${herdrSealShellPrefix()}`)}`);
+        const seed = await this.herdr(`pane run ${shq(id)} ${shq(`export HERDR_WORKSPACE_ID=${shq(this.ws)}; export ${PANE_IDENTITY_ENV}=${identity}; ${herdrSealShellPrefix()}`)}`);
         if (seed.code !== 0)
             throw new Error(`herdr workspace-id seed failed (refusing untargeted pane): ${seed.stderr || seed.stdout}`);
         return { id, name, cwd, tabId };
@@ -260,7 +263,8 @@ export class HerdrDriver {
         // like a failed cd (return null → caller falls back to a per-slot tab). this.ws is guaranteed set —
         // joinGroup runs only after the first member's tabSlot succeeded, which requires it (VIS-10).
         // v1.22 T3: same env seal as tabSlot — strip control-plane vars after the workspace seed.
-        const seed = await this.herdr(`pane run ${shq(pane)} ${shq(`export HERDR_WORKSPACE_ID=${shq(this.ws)}; ${herdrSealShellPrefix()}`)}`);
+        // T5: same brand identity seed as tabSlot — every group member's banner announces its own name.
+        const seed = await this.herdr(`pane run ${shq(pane)} ${shq(`export HERDR_WORKSPACE_ID=${shq(this.ws)}; export ${PANE_IDENTITY_ENV}=${shq(paneIdentityLine(canonicalizeLegacyName(name, "")))}; ${herdrSealShellPrefix()}`)}`);
         if (seed.code !== 0) {
             await this.herdr(`pane close ${shq(pane)}`);
             return null;

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,11 +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 { loadConfig } from "../config/config.js";
+import { bannerShell } from "../brand.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";
@@ -16,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) {
@@ -53,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).
@@ -71,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")
@@ -130,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:
@@ -388,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);
@@ -489,7 +534,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
-                    await driver.run(slot, `${icmd}; ${exitMarkerCmd}`);
+                    // T5: the pane announces itself first — same brand header (logo + dim identity) as the
+                    // judge/review/consult dispatch scripts; one printf one-liner, dispatch mechanics unchanged.
+                    await driver.run(slot, `${bannerShell()}; ${icmd}; ${exitMarkerCmd}`);
                     let paged = false;
                     // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
                     // Any other blocked/idle dialog still pages the operator (paged latch below).
@@ -576,7 +623,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                 }
                 else {
                     const inv = adapter.invoke(t, wt, assignment, { promptFile });
-                    await driver.run(slot, `${inv.command}; ${exitMarkerCmd}`);
+                    // T5: same brand header as the interactive path and the gate/consult dispatch scripts.
+                    await driver.run(slot, `${bannerShell()}; ${inv.command}; ${exitMarkerCmd}`);
                     // OBS-54: headless workers have the same output-inactivity budget as visible panes.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
                     let lastOutput = await driver.read(slot, 500);

package/package.json

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