tickmarkr 2.5.3 → 2.5.4

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

@@ -128,6 +128,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
         }>;
         floors: Record<string, "cheap" | "mid" | "frontier">;
         learned: "on" | "off";
+        escalateTier: "on" | "off";
         allowUnverifiedModels: boolean;
         mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
         learnedTuning?: {
@@ -185,6 +186,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
         complexityThreshold: number;
         timeoutMs: number;
         required: boolean;
+        floor: "cheap" | "mid" | "frontier" | "worker";
         prefer?: string[] | undefined;
         policy?: "full" | "judge-only" | undefined;
         criticalPaths?: string[] | undefined;
@@ -245,6 +247,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
         }>;
         floors: Record<string, "cheap" | "mid" | "frontier">;
         learned: "on" | "off";
+        escalateTier: "on" | "off";
         allowUnverifiedModels: boolean;
         mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
         learnedTuning?: {
@@ -302,6 +305,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
         complexityThreshold: number;
         timeoutMs: number;
         required: boolean;
+        floor: "cheap" | "mid" | "frontier" | "worker";
         prefer?: string[] | undefined;
         policy?: "full" | "judge-only" | undefined;
         criticalPaths?: string[] | undefined;

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -11,11 +11,11 @@ import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
-import { staffLedEvidence } from "../../route/profile.js";
+import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, readProfileCursor, recordedGraphDefinitionHash, RUNS_WINDOW } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -292,6 +292,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             }
         }
     }
+    lints.push(...tierEscalationAdvisories(cwd, cfg, g.tasks));
     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`);
@@ -437,3 +438,143 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
     return stylizePlan(lines.join("\n"));
 }
+function extractClimb(event, taskShapeMap) {
+    if (event.event !== "tier-escalated")
+        return undefined;
+    const d = (event.data && typeof event.data === "object") ? event.data : {};
+    const shape = (typeof d.shape === "string" && d.shape)
+        || (typeof event.shape === "string" && event.shape)
+        || (typeof event.taskId === "string" ? taskShapeMap.get(event.taskId) : undefined)
+        || (typeof d.taskId === "string" ? taskShapeMap.get(d.taskId) : undefined);
+    if (!shape)
+        return undefined;
+    const beforeAssignment = (d.beforeAssignment && typeof d.beforeAssignment === "object") ? d.beforeAssignment : undefined;
+    const afterAssignment = (d.afterAssignment && typeof d.afterAssignment === "object") ? d.afterAssignment : undefined;
+    let fromTier = (typeof d.fromTier === "string" && d.fromTier)
+        || (typeof d.from === "string" && d.from)
+        || (typeof d.tierBefore === "string" && d.tierBefore)
+        || (typeof d.before === "string" && d.before)
+        || (typeof d.previousTier === "string" && d.previousTier)
+        || (typeof event.fromTier === "string" && event.fromTier)
+        || (typeof event.from === "string" && event.from)
+        || (typeof beforeAssignment?.tier === "string" && beforeAssignment.tier);
+    let toTier = (typeof d.toTier === "string" && d.toTier)
+        || (typeof d.to === "string" && d.to)
+        || (typeof d.tierAfter === "string" && d.tierAfter)
+        || (typeof d.after === "string" && d.after)
+        || (typeof d.nextTier === "string" && d.nextTier)
+        || (typeof d.tier === "string" && d.tier)
+        || (typeof event.toTier === "string" && event.toTier)
+        || (typeof event.to === "string" && event.to)
+        || (typeof afterAssignment?.tier === "string" && afterAssignment.tier);
+    if (!fromTier || !toTier) {
+        const text = [d.details, d.message, d.reason, d.summary, d.provenance].filter((s) => typeof s === "string").join(" ");
+        const m = /\b(cheap|mid|frontier)\s+to\s+(cheap|mid|frontier)\b/i.exec(text);
+        if (m) {
+            fromTier = fromTier || m[1].toLowerCase();
+            toTier = toTier || m[2].toLowerCase();
+        }
+    }
+    if (!fromTier || !toTier)
+        return undefined;
+    return { shape, fromTier, toTier };
+}
+function tierEscalationAdvisories(cwd, cfg, graphTasks) {
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runsRoot))
+        return [];
+    let candidateRunIds;
+    try {
+        candidateRunIds = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+    const cursor = readProfileCursor(cwd);
+    if (cursor)
+        candidateRunIds = candidateRunIds.filter((id) => id > cursor);
+    const windowRunIds = candidateRunIds.slice(-RUNS_WINDOW);
+    if (!windowRunIds.length)
+        return [];
+    // Leg-2 T5 (OBS-971): task ids restart at T1 every spec, so a shape lookup is only valid against the
+    // graph the run actually executed. Fallback to the current graph only when the run left no snapshot.
+    const currentShapeMap = new Map(graphTasks.map((t) => [t.id, t.shape]));
+    const numDistinct = windowRunIds.length;
+    const ascIndex = new Map(windowRunIds.map((id, i) => [id, i]));
+    const halfLife = cfg.routing.learnedTuning?.halfLifeRuns ?? HALF_LIFE_RUNS;
+    const shapeClimbs = new Map();
+    for (const runId of windowRunIds) {
+        const journalPath = join(runsRoot, runId, "journal.jsonl");
+        let lines;
+        try {
+            lines = readFileSync(journalPath, "utf8").split("\n");
+        }
+        catch {
+            continue;
+        }
+        let taskShapeMap = currentShapeMap;
+        const runGraphPath = join(runsRoot, runId, "graph.json");
+        if (existsSync(runGraphPath)) {
+            try {
+                const runGraph = JSON.parse(readFileSync(runGraphPath, "utf8"));
+                if (Array.isArray(runGraph.tasks)) {
+                    taskShapeMap = new Map();
+                    for (const rt of runGraph.tasks) {
+                        if (typeof rt?.id === "string" && typeof rt?.shape === "string")
+                            taskShapeMap.set(rt.id, rt.shape);
+                    }
+                }
+            }
+            catch {
+                // unreadable snapshot: fall back to the current graph
+            }
+        }
+        const runClimbedShapes = new Map();
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const event = parsed;
+            if (event.event !== "tier-escalated")
+                continue;
+            const climb = extractClimb(event, taskShapeMap);
+            if (climb) {
+                runClimbedShapes.set(climb.shape, { fromTier: climb.fromTier, toTier: climb.toTier });
+            }
+        }
+        const age = numDistinct - 1 - ascIndex.get(runId);
+        const w = decayWeight(age, halfLife);
+        for (const [shape, { fromTier, toTier }] of runClimbedShapes) {
+            let entry = shapeClimbs.get(shape);
+            if (!entry) {
+                entry = { fromTier, toTier, runs: new Set(), weighted: 0 };
+                shapeClimbs.set(shape, entry);
+            }
+            const tierRank = (t) => (t in TIER_RANK ? TIER_RANK[t] : 0);
+            if (tierRank(toTier) > tierRank(entry.toTier)) {
+                entry.toTier = toTier;
+            }
+            entry.runs.add(runId);
+            entry.weighted += w;
+        }
+    }
+    const advisories = [];
+    for (const shape of [...shapeClimbs.keys()].sort()) {
+        const info = shapeClimbs.get(shape);
+        const climbedRuns = info.runs.size;
+        const totalRuns = numDistinct;
+        const weightVal = Number.isInteger(info.weighted) ? info.weighted : Number(info.weighted.toFixed(2));
+        advisories.push(`${shape}: climbed from ${info.fromTier} to ${info.toTier} in ${climbedRuns} of ${totalRuns} runs (weighted ${weightVal}) — consider routing.floors.${shape}: ${info.toTier}`);
+    }
+    return advisories;
+}

package/dist/cli/commands/resume.js

@@ -5,6 +5,7 @@ import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
 import { narrationSink, bindNarration } from "./run.js";
+import { assertRefsWritable } from "../../run/git.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
@@ -36,6 +37,7 @@ export async function resume(argv, cwd = process.cwd()) {
     if (collisions.length) {
         throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
     }
+    await assertRefsWritable(cwd, "resume");
     const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,

package/dist/cli/commands/run.js

@@ -10,6 +10,7 @@ import { formatJournalNarration, loadRoutingProfile, newRunId } from "../../run/
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
+import { assertRefsWritable } from "../../run/git.js";
 // ── the operator event rail (v1.99 T2) ──────────────────────────────────────────────────────────
 // A run's TTY narration is an operator EVENT RAIL, not the journal dump it used to echo. The
 // repetitive worker-contact / worker-status polls and the ungated phase-start rows are the bulk of
@@ -61,10 +62,16 @@ export const RAIL_ROWS = {
     // run lifecycle
     "run-start": { label: "started", tone: "active" },
     "run-resume": { label: "resumed", tone: "active" },
+    "restore-rerouted": { label: "restore rerouted", tone: "attention" },
+    "tier-escalated": { label: "tier climbed", tone: "attention" },
     "resume-restore": { label: "restored", tone: "neutral" },
     // the operator's audited --graph-changed release: the resumed run journals it through this sink
     "graph-rehash": { label: "graph rehashed", tone: "attention" },
     "lock-reclaimed": { label: "lock reclaimed", tone: "neutral" },
+    // WB-1 (OBS-988): the daemon noticed its own cockpit die and what it did about it
+    "watch-board-lost": { label: "board lost", tone: "attention" },
+    "watch-board-reopened": { label: "board reopened", tone: "pass" },
+    "watch-board-reopen-failed": { label: "board reopen failed", tone: "fail" },
     "run-end": { label: "finished", tone: "neutral" },
     "tip-verify": { label: "tip verify", tone: "pass" },
     "tip-verify-failed": { label: "tip verify", tone: "fail" },
@@ -215,6 +222,8 @@ const RAIL_SALIENT = [
     // both journal `gates: string[]` and neither states a scalar the ladder can pick up
     { key: "gates", render: (v) => (Array.isArray(v) && v.length > 0 ? `gates ${v.join(", ")}` : undefined) },
     { key: "channel", render: (v) => (typeof v === "string" ? `channel ${v}` : undefined) },
+    // the pane a board was lost on or reopened in — nothing on the ladder names it
+    { key: "pane", render: (v) => (typeof v === "string" ? `pane ${v}` : undefined) },
     { key: "status", render: (v) => (typeof v === "string" ? `status ${v}` : undefined) },
     { key: "cause", render: (v) => (typeof v === "string" ? `cause ${v}` : undefined) },
     { key: "silentMs", render: (v) => (typeof v === "number" ? `silent ${Math.round(v / 1000)}s` : undefined) },
@@ -493,6 +502,7 @@ export async function run(argv, cwd = process.cwd()) {
             if (lints.length)
                 throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
         }
+        await assertRefsWritable(cwd, "run");
         // The run id is minted HERE rather than inside the daemon, because the narration sink has to know
         // which run it is narrating before the first event arrives (the daemon's `narrate` callback is
         // handed an event and nothing else, and `run-start` carries no run id). `runDaemon` uses the id

package/dist/compile/collateral.d.ts

@@ -28,6 +28,8 @@ export declare function classifyScopeOffenders(taskId: string, hard: ReadonlyArr
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.
+ * OBS-971: uncapped — every predicted path is listed, with direct importers of an owned source
+ * sorted first, followed by the total count. The runtime map (collateralHits) remains unchanged.
  */
 export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
 /**

package/dist/compile/collateral.js

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join, relative } from "node:path";
+import { extname, join, posix, relative } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { criticalPathHits, DEFAULT_CONFIG, DEFAULT_REVIEW_CRITICAL_PATHS, effectiveReviewPolicy, loadConfig, } from "../config/config.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
@@ -156,20 +156,61 @@ export function classifyScopeOffenders(taskId, hard, predicted) {
     const missed = hard.filter((f) => !named.has(f));
     return { authoring: hard.length > 0 && missed.length === 0, predicted: hit, missed, repair: filesRepair(taskId, hit) };
 }
+const moduleKey = (path) => path.replace(/\\/g, "/").replace(/\.(?:[cm]?[jt]sx?)$/, "");
+function directImportSpecifiers(text) {
+    // Comments cannot create an edge. Keep strings intact because they are the import target.
+    const source = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+    const specifiers = new Set();
+    for (const match of source.matchAll(/\bimport\s+(?:type\s+)?(?:[\w$*{},\s]+?\s+from\s+)?["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    for (const match of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+        specifiers.add(match[1]);
+    }
+    return [...specifiers];
+}
+function directlyImports(testPath, testText, sourcePath) {
+    const target = moduleKey(sourcePath);
+    const testDir = posix.dirname(testPath.replace(/\\/g, "/"));
+    return directImportSpecifiers(testText).some((specifier) => {
+        const imported = specifier.startsWith(".")
+            ? posix.normalize(posix.join(testDir, specifier))
+            : specifier.startsWith("src/") ? specifier : "";
+        return imported !== "" && moduleKey(imported) === target;
+    });
+}
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.
+ * OBS-971: uncapped — every predicted path is listed, with direct importers of an owned source
+ * sorted first, followed by the total count. The runtime map (collateralHits) remains unchanged.
  */
 export function collateralLints(tasks, repoRoot) {
     const lines = [];
-    for (const [id, hits] of collateralHits(tasks, repoRoot)) {
-        const listed = hits.slice(0, MAX_HITS_PER_TASK).join(", ");
-        // OBS-547: the cap hides names, never predictions. Say so, and say where the hidden ones surface —
-        // a count with no route is exactly what left one run's victim unreadable.
-        const tail = hits.length > MAX_HITS_PER_TASK
-            ? ` (${hits.length} total; ${MAX_HITS_PER_TASK} shown, ${hits.length - MAX_HITS_PER_TASK} capped out of view`
-                + ` but RETAINED for the scope gate — a matching scope red prints the hidden path with its files[] repair)`
-            : "";
+    const hitsMap = collateralHits(tasks, repoRoot);
+    const read = makeReader(repoRoot);
+    const tasksById = new Map(tasks.map((t) => [t.id, t]));
+    for (const [id, hits] of hitsMap) {
+        const t = tasksById.get(id);
+        const files = (t?.files ?? []).map((f) => f.replace(/^\.\//, ""));
+        const ownedSources = files.filter(isSrcPath);
+        const direct = [];
+        const indirect = [];
+        for (const h of hits) {
+            const text = read(h) ?? "";
+            const isDirect = ownedSources.some((src) => directlyImports(h, text, src));
+            if (isDirect) {
+                direct.push(h);
+            }
+            else {
+                indirect.push(h);
+            }
+        }
+        direct.sort((a, b) => a.localeCompare(b));
+        indirect.sort((a, b) => a.localeCompare(b));
+        const ordered = [...direct, ...indirect];
+        const listed = ordered.join(", ");
+        const tail = hits.length > MAX_HITS_PER_TASK ? ` (${hits.length} total)` : "";
         lines.push(`${id}: likely collateral tests not in files[]: ${listed}${tail}`);
     }
     return lines;

package/dist/compile/ownership.d.ts

@@ -31,6 +31,13 @@ export type OwnershipFinding = {
     ownerTaskId: string;
     path: string;
     detail: string;
+} | {
+    code: "unowned-source-of-owned-test";
+    taskId: string;
+    test: string;
+    source: string;
+    corroboration?: OwnershipCorroboration;
+    detail: string;
 };
 export declare const SHAPE_ORACLES: readonly ["tests/run/narration.test.ts", "tests/cli/brand-surfaces.test.ts", "tests/run/notify-identity.test.ts", "tests/run/outcome-projections.test.ts", "tests/cockpit/setup.test.ts"];
 export declare const SHAPE_ORACLE_SOURCES: readonly ["src/run/daemon.ts", "src/cli/commands/run.ts"];

package/dist/compile/ownership.js

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, extname, join, posix } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { collateralHits } from "./collateral.js";
@@ -17,21 +17,24 @@ export const SHAPE_ORACLE_MAP = {
     "src/run/daemon.ts": SHAPE_ORACLES,
     "src/cli/commands/run.ts": SHAPE_ORACLES,
 };
-// Anchored-glob only: a files[] entry touches a mapped source when it names the source (or its
-// extensionless stem) exactly, or when its glob's literal head — everything before the first
-// wildcard — is the stem plus a literal dot, i.e. the wildcard only ever spans the extension
-// ("src/run/daemon.*"). A broad multi-file glob like "src/**" that merely happens to cover the
-// source is an unrelated task casting a wide net, not one touching daemon narration — that
-// distinction is what broke every fixture using tests/fixtures/sample.prd.md's files: src/** task.
-function touchesSource(files, source) {
+// A files[] entry touches a mapped shape-oracle source when it names it literally or by stem, or when
+// the entry's glob — anchored or broad — matches the source AND the source exists in the repository
+// being compiled: "src/run/**" owning this repository's daemon owns the five oracles, while the
+// shipped sample PRD's "src/**" task in a repository holding no mapped source compiles clean.
+// Anchored globs like "src/run/daemon.*" target the source specifically and touch it regardless.
+function touchesSource(files, source, repoRoot) {
     const stem = source.replace(/\.(?:[cm]?[jt]sx?)$/, "");
     return files.some((entry) => {
         if (entry === source || entry === stem)
             return true;
         const special = entry.search(/[*?{[]/);
-        // Leg-2 v2.5.3: the anchored head is necessary, not sufficient — the pattern must also MATCH the
-        // source under the shared matcher, or "src/run/daemon.{js,jsx}" (never daemon.ts) would count as a touch.
-        return special !== -1 && entry.slice(0, special) === `${stem}.` && filesGlob([entry])(source);
+        if (special === -1)
+            return false;
+        if (!filesGlob([entry])(source))
+            return false;
+        if (entry.slice(0, special) === `${stem}.`)
+            return true;
+        return repoRoot !== undefined && existsSync(join(repoRoot, source));
     });
 }
 const normalize = (path) => path.replace(/^\.\//, "").split("\\").join("/");
@@ -133,20 +136,24 @@ function mentionsCommandEntry(text) {
     return /(?:^|\/)src\/cli\/index\.(?:ts|js)\b/.test(text)
         || /["'`]src["'`]\s*,\s*["'`]cli["'`]\s*,\s*["'`]index\.(?:ts|js)["'`]/.test(text);
 }
-function corroboration(test, matches) {
-    // A .test.ts-shaped collateral fixture is not by itself a dedicated test. Requiring a runner leaf
-    // keeps import-only scan fixtures advisory while every executable subject in the measured union stays.
+function corroborateSource(test, sourcePath) {
     const executable = test.text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
     if (!/\b(?:test|it)(?:\.(?:concurrent|each|fails|only|skip|todo))*\s*\(/.test(executable))
         return undefined;
-    for (const match of matches) {
-        if (directlyImports(test, match.source))
-            return { kind: "direct-import", source: match.source };
-    }
+    if (directlyImports(test, sourcePath))
+        return { kind: "direct-import", source: sourcePath };
     if (invokesChildProcessSpawn(test.text) && mentionsCommandEntry(test.text)) {
-        const command = matches.find(({ source }) => /^src\/cli\/commands\/[^/]+\.(?:[cm]?[jt]sx?)$/.test(source));
-        if (command)
-            return { kind: "command-entry-spawn", source: command.source, entry: "src/cli/index.ts" };
+        if (/^src\/cli\/commands\/[^/]+\.(?:[cm]?[jt]sx?)$/.test(sourcePath)) {
+            return { kind: "command-entry-spawn", source: sourcePath, entry: "src/cli/index.ts" };
+        }
+    }
+    return undefined;
+}
+function corroboration(test, matches) {
+    for (const match of matches) {
+        const evidence = corroborateSource(test, match.source);
+        if (evidence)
+            return evidence;
     }
     return undefined;
 }
@@ -239,7 +246,7 @@ export function ownershipFindings(tasks, repoRoot) {
     }
     for (const entry of indexed) {
         for (const [source, oracles] of Object.entries(SHAPE_ORACLE_MAP)) {
-            if (!touchesSource(entry.files, source))
+            if (!touchesSource(entry.files, source, repoRoot))
                 continue;
             for (const oracle of oracles) {
                 if (!entry.owns(oracle)) {
@@ -254,6 +261,35 @@ export function ownershipFindings(tasks, repoRoot) {
             }
         }
     }
+    for (const test of sources) {
+        const testOwners = owners(test.path);
+        if (testOwners.length === 0)
+            continue;
+        const testStem = basename(test.path).replace(/\.test\.ts$/, "");
+        for (const sourcePath of allSources) {
+            if (owners(sourcePath).length > 0)
+                continue;
+            const sourceStem = basename(sourcePath, extname(sourcePath));
+            if (testStem !== sourceStem && !testStem.startsWith(`${sourceStem}-`))
+                continue;
+            const evidence = corroborateSource(test, sourcePath);
+            if (!evidence)
+                continue;
+            for (const owner of testOwners) {
+                findings.push({
+                    code: "unowned-source-of-owned-test",
+                    taskId: owner.task.id,
+                    test: test.path,
+                    source: sourcePath,
+                    corroboration: evidence,
+                    detail: `${test.path} owned by ${owner.task.id} is a dedicated test of ${sourcePath} but no task owns ${sourcePath}`
+                        + (evidence.kind === "direct-import" ? `; it imports ${evidence.source} directly`
+                            : evidence.kind === "command-entry-spawn"
+                                ? `; it spawns ${evidence.entry} to exercise ${evidence.source}` : ""),
+                });
+            }
+        }
+    }
     for (const source of sources) {
         for (const owner of owners(source.path)) {
             for (const path of repositoryPaths(source.text)) {
@@ -290,6 +326,7 @@ export function ownershipFindings(tasks, repoRoot) {
             case "unowned-shape-oracle": return f.oracle;
             case "test-path-outside-allowlist": return f.test;
             case "unordered-context-write": return f.path;
+            case "unowned-source-of-owned-test": return f.test;
         }
     };
     return findings.sort((a, b) => {

package/dist/config/config.d.ts

@@ -175,6 +175,10 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             on: "on";
             off: "off";
         }>;
+        escalateTier: z.ZodDefault<z.ZodEnum<{
+            on: "on";
+            off: "off";
+        }>>;
         learnedTuning: z.ZodOptional<z.ZodObject<{
             halfLifeRuns: z.ZodOptional<z.ZodNumber>;
             availWeight: z.ZodOptional<z.ZodNumber>;
@@ -275,6 +279,11 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             "judge-only": "judge-only";
         }>>;
         criticalPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        floor: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"worker">, z.ZodEnum<{
+            cheap: "cheap";
+            mid: "mid";
+            frontier: "frontier";
+        }>]>>;
     }, z.core.$strip>;
     consult: z.ZodObject<{
         adapter: z.ZodString;

package/dist/config/config.js

@@ -302,6 +302,8 @@ export const TickmarkrConfigSchema = z.object({
         }),
         floors: z.record(z.string(), TierEnum),
         learned: z.enum(["on", "off"]), // v1.6 ROUTE-09 kill switch; a typo (offf) fails loud via safeParse
+        // OBS-986 (ES-1): climb one tier on request when untried channels exist in higher tiers.
+        escalateTier: z.enum(["on", "off"]).default("on"),
         // v1.9 ROUTE-15 — optional overrides for profile.ts HALF_LIFE_RUNS/AVAIL_WEIGHT; absent ⇒ byte-identical defaults.
         // SIBLING of learned (not nested): routing.learned is the on/off enum switch.
         learnedTuning: z.object({
@@ -366,6 +368,11 @@ export const TickmarkrConfigSchema = z.object({
         // R3: globs no task may skip review on (input/demux/lifecycle, gates/run/drivers/adapters, anything
         // reaching a shell). A judge-only task intersecting one of these fails COMPILE, never silently skips.
         criticalPaths: z.array(z.string()).optional(),
+        // RF-1 (OBS-922 add.2/3): review.floor — `worker` (default) names no tier and leaves the seat
+        // ranking to the author's routed seat; a tier is folded in as max(task floor, this) by reviewGate
+        // and its retry — it can raise a seat and never lower one. Not in the template: the cockpit
+        // fixture pins the fresh-install bytes (see d0e89a9a).
+        floor: z.union([z.literal("worker"), TierEnum]).default("worker"),
     }),
     // v1.54 T1: prefer — ranked consult seat failover. Entries MUST be adapter:model (unlike
     // review.prefer's adapter|adapter:model grammar): a consult seat has no channel to inherit a
@@ -445,6 +452,7 @@ export const DEFAULT_CONFIG = {
         // a workspace that has accumulated ≥MIN_SAMPLES warm telemetry per cell. Preview any workspace's effect
         // first with `tickmarkr plan` / `tickmarkr report`; flip to "off" to pin exact static routing (the kill switch stands).
         learned: "on",
+        escalateTier: "on",
         allowUnverifiedModels: false,
     },
     // Seed table (spec §13). New models = edit this (or your config.yaml), never code.
@@ -590,7 +598,7 @@ export const DEFAULT_CONFIG = {
     judge: { adapter: "claude-code", model: "fable" },
     // R3: no `policy` floor — the neutral floor leaves the compiler's per-task assignment standing, so
     // the path-keyed rule is reachable out of the box rather than raised to full by construction.
-    review: { complexityThreshold: 7, timeoutMs: 900_000, required: true, criticalPaths: [...DEFAULT_REVIEW_CRITICAL_PATHS] },
+    review: { complexityThreshold: 7, timeoutMs: 900_000, required: true, floor: "worker", criticalPaths: [...DEFAULT_REVIEW_CRITICAL_PATHS] },
     consult: { adapter: "claude-code", model: "fable", stallMinutes: 15 },
     // v1.4: gate LLM calls (judge/review/consult) run headless by default; pane opts back into visible agents.
     // v1.2: workers are the real agent TUI in the pane; "print" restores the -p-rendered-in-pane path.
@@ -784,6 +792,7 @@ export function configTemplate(overlay) {
 #   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'
+#   escalateTier: on       # on | off (default on): climb one tier on request when untried channels exist in higher tiers
 #   learnedTuning: { halfLifeRuns: 5, availWeight: 0.05 }  # optional; defaults byte-identical
 #   explore: { mode: on, excludeShapes: [], excludeComplexityAtOrAbove: null, cap: 5 }  # optional; absent ⇒ byte-identical
 #   sla: { implement: 15 }  # optional per-shape minutes — advisory plan lint only; absent ⇒ no lint
@@ -817,7 +826,9 @@ export function configTemplate(overlay) {
 #   test: npm test
 #   byShape:
 #     docs: { acceptance: false, review: false }  # baseline, evidence, and scope are mandatory
-# review: { complexityThreshold: 7, timeoutMs: 900000, required: true, prefer: [codex:gpt-5.6-sol, kimi] }
+# review: { complexityThreshold: 7, timeoutMs: 900000, required: true, floor: worker, prefer: [codex:gpt-5.6-sol, kimi] }
+#                         # floor: worker (default) | cheap | mid | frontier — the reviewer seats at or above
+#                         # max(author tier, task floor, this tier, prior reviewer); a tier here only raises it
 #                         # prefer: ordered reviewer seat preference (adapter | adapter:model); ranks
 #                         # diversity-eligible channels only — never admits a same-vendor/same-model reviewer
 # consult: { adapter: claude-code, model: fable, stallMinutes: 15, prefer: [codex:gpt-5.6-sol, kimi:kimi-code/k3] }

package/dist/drivers/herdr.d.ts

@@ -128,6 +128,11 @@ export declare class HerdrDriver implements ExecutorDriver {
     close(slot: Slot): Promise<void>;
     private closeGrouped;
     private watchPanes;
+    /** WB-1 (OBS-988): the daemon proved this run's own board lost. Forget the cached slot FIRST — even a
+     *  retire that fails must never let the narrator answer with the ghost again — then take the pane
+     *  back on ownership alone: the dead UI can never acknowledge, so the stop request is left for a
+     *  merely stuck one to find. Serialized with the narrator so no split races the close. */
+    retireLostWatch(slot: Slot): Promise<void>;
     /** Name collisions never confer repository ownership. Unknown boards stay protected. */
     private retireWatch;
     focus(target: FocusTarget): Promise<FocusResult>;

package/dist/drivers/herdr.js

@@ -6,7 +6,7 @@ import { declaredInputBoxForWorkerName, matchesEmptyInputBox, matchesInputBox, m
 import { consumePaneLaunchIntent, PANE_IDENTITY_ENV, paneIdentityLine } from "../brand.js";
 import { createWorktree, sh } from "../run/git.js";
 import { Journal } from "../run/journal.js";
-import { readSupervision, readWatchBoard, reserveWatchBoard, stopWatchBoard, WATCH_OWNER_ENV } from "../run/supervision.js";
+import { readSupervision, readWatchBoard, requestWatchBoardStop, reserveWatchBoard, stopWatchBoard, WATCH_OWNER_ENV } from "../run/supervision.js";
 import { herdrSealShellPrefix } from "./subprocess.js";
 import { canonicalizeLegacyName, formatOwnedName, panesToClose, parseOwnedName } from "./types.js";
 // VIS-09 P43-03: adopted safety floor from 43-MEASUREMENT.md (narrowest safe 53 → floor 108).
@@ -1169,8 +1169,16 @@ export class HerdrDriver {
             throw new Error("herdr pane list returned no panes");
         return panes.filter(p => p.workspace_id === this.ws && p.label === name);
     }
+    /** WB-1 (OBS-988): the daemon proved this run's own board lost. Forget the cached slot FIRST — even a
+     *  retire that fails must never let the narrator answer with the ghost again — then take the pane
+     *  back on ownership alone: the dead UI can never acknowledge, so the stop request is left for a
+     *  merely stuck one to find. Serialized with the narrator so no split races the close. */
+    async retireLostWatch(slot) {
+        this.watches.delete(slot.name);
+        await this.serial(() => this.retireWatch(slot, true));
+    }
     /** Name collisions never confer repository ownership. Unknown boards stay protected. */
-    async retireWatch(slot) {
+    async retireWatch(slot, lost = false) {
         const runId = parseOwnedName(slot.name)?.runId;
         const owner = runId ? readWatchBoard(slot.cwd, runId) : undefined;
         const matches = await this.watchPanes(slot.name);
@@ -1181,7 +1189,10 @@ export class HerdrDriver {
             owner.pane !== slot.id || matches.length !== 1 || matches[0]?.pane_id !== owner.pane) {
             throw new Error(`watch ownership unknown or foreign for ${slot.name}; existing board protected`);
         }
-        await stopWatchBoard(owner, this.time);
+        if (lost)
+            requestWatchBoardStop(owner); // a lost owner never answers; only a live one still gets the ack window
+        else
+            await stopWatchBoard(owner, this.time);
         const verified = await this.watchPanes(slot.name);
         if (verified.length !== 1 || verified[0]?.pane_id !== owner.pane)
             throw new Error("watch target changed after acknowledgement; pane protected");

package/dist/drivers/types.d.ts

@@ -106,6 +106,7 @@ export interface ExecutorDriver {
     narrateWith?(narrate: (event: JournalEvent) => void): void;
     worktree(repo: string, branch: string, baseRef: string): Promise<string>;
     narrator?: (cwd: string, command: string, runId?: string) => Promise<Slot>;
+    retireLostWatch?: (slot: Slot) => Promise<void>;
     /** Best-effort projection of a task's lifecycle onto the execution host. */
     project?: (taskId: string, state: "in-progress" | "in-review" | "completed") => Promise<void>;
     reconcile?: (desired: Set<string>, runId: string, opts?: PanesToCloseOpts) => Promise<void>;