tickmarkr 1.59.0 → 1.61.0

package/README.md

@@ -143,94 +143,34 @@ away from a failing adapter will never retry it in subsequent `tickmarkr resume`
 
 ## Choosing your fleet: `tickmarkr fleet`
 
-`tickmarkr doctor` is a pure sensor; `tickmarkr fleet` is the actuator. It walks six steps —
-probe data, agent CLIs, model tiers, routing mode, shape routing with a candidate picker, and
-steering preferences — and ends in a unified diff of your config overlay that is written **only
-on explicit confirm**. Pressing Enter through every step writes nothing. Assigning a tier to a
-model that has no classification yet requires a typed benchmark-provenance note, stored as a
-config comment beside the assignment.
-
-The shape routing step (step 5/6) features an **arrow-driven candidate picker** that ranks
-available channels by the production router's own logic, showing economics (tier + channel
-cost signals for API and sub channels) and the router's rationale for each rank. This replaces
-typed pin entry with verifiable suggestions. Step 4/6 shows an estimated spend context line
-across all shapes under each routing mode's resolved floors, also derived from the same preview
-routing machinery.
+Configure which agent CLIs and models tickmarkr may route before your first run:
 
 ```bash
-tickmarkr fleet          # interactive editor (requires a TTY)
-tickmarkr fleet --print  # effective fleet state (repo > global > defaults), non-interactive — good for CI drift checks
+tickmarkr doctor          # probe auth + capabilities (run after install or credential changes)
+tickmarkr fleet           # interactive editor (requires a TTY) — six steps, confirm to write
+tickmarkr fleet --print   # effective fleet state (repo > global > defaults), non-interactive
+tickmarkr plan            # lint the resolved routing table against your spec
+tickmarkr run             # dispatch with the fleet you confirmed
 ```
 
-Routing obeys a strict precedence — **pin > prefer > floors > marginal-cost auto**:
+`tickmarkr doctor` is a pure sensor; `tickmarkr fleet` is the actuator. The editor walks **six
+steps** — probe data, agent CLIs, model tiers, routing mode, shape routing with a **candidate
+picker**, and steering preferences — and ends in a unified diff of your repo config overlay.
+Nothing is written until you confirm; pressing Enter through every step leaves config unchanged.
+Step 5/6 uses an arrow-driven candidate picker ranked by the production router; step 3 may ask
+for a benchmark-provenance note when you classify a new model.
 
-- **pin** a shape to an exact channel: `map: { plan: { via: claude-code, model: fable } }`
-- **prefer**-rank adapters per shape: `map: { implement: { prefer: [cursor-agent, codex] } }`
-- **floors** set the minimum capability band per shape (`migration: frontier`, `tests: cheap`);
-  auto-routing then picks the cheapest authed channel at or above the floor
-- **deny/allow** bench models or whole adapters without touching tiers (see `deny.models` below)
-- **tiers** classify models into bands — only classified, doctor-authed models ever route
+Routing-mode semantics, pin/floor/prefer precedence, review and consult steering syntax,
+provenance rules, and `--quality` / `--mode` flags are documented in
+**[FLEET.md](https://github.com/alzahrani-khalid/tickmarkr/blob/main/FLEET.md)** (advanced reference).
 
-More levers, all optional and absent-safe (absent config keeps default behavior):
+## Steering
 
-- `routing.explore` — fence the exploration budget: `mode: off`, `excludeShapes`,
-  `excludeComplexityAtOrAbove`, and a per-channel `cap`; `run --no-explore` disables
-  exploration probes for a single run
-- `tiers.<adapter>.windows` — declare context-window sizes per model; doctor grows a window
-  column and `plan` warns (advisory, never blocking) when a task's payload estimate exceeds
-  the routed model's window
-- `routing.sla` — per-shape latency expectations, surfaced as advisory plan lints against the
-  learned performance profile
-- `run --quality` — compatibility alias for `run --mode partner-led` for that run; it disables
-  exploration and records the selected mode in routing provenance
-
-## Steering: routing modes, reviewer preferences, and reruns
-
-### Routing modes
-
-`routing.mode` is a preset that compiles into floor assignments at config load time. The router never sees the mode itself; it receives resolved floors only.
-
-Three routing modes are available:
-
-- **`risk-based`** (default): byte-identical to pre-v1.51 routing. Absent `mode` key resolves as risk-based.
-- **`partner-led`**: resolves every non-overridden shape to a `frontier` floor and disables exploration — use when quality is paramount and cost is secondary.
-- **`staff-led`**: lowers each mode default by one tier (e.g., `implement` and `refactor` become `cheap` instead of `mid`) while keeping the preset floor for the integrity set (`plan`, `spec`, `migration`, `ui`) at `frontier`.
-
-Explicit `routing.floors` entries beat mode-preset deltas and are linted during plan if they shadow the mode's delta; an explicit integrity floor below `frontier` is also linted. The mode is compiled once at config load and never consulted during routing.
-
-### Review preferences
-
-`review.prefer` is an ordered list of reviewer seats for the cross-vendor code-review gate. Entries are matched by diversity (never the same vendor or model as the original worker), and routing reorders the available channels only — it does not admit unauthed or denied channels.
-
-```yaml
-review:
-  prefer: [codex, kimi]           # bare adapter: inherits model from the routed channel
-  prefer: [codex:gpt-5.6-sol, kimi:kimi-code/k3]  # adapter:model explicit
-  prefer: [codex, kimi:kimi-code/k3]  # mixed: bare and explicit
-```
-
-**Grammar**: review prefer entries may name a bare adapter (inheriting the model from the current channel) or an explicit `adapter:model` pair. Bare adapters rank every diversity-eligible channel for that adapter; explicit pairs rank one diversity-eligible channel.
-
-### Consult preferences
-
-`consult.prefer` is a ranked failover list of seats for escalations on deadlock or gate stalls. Unlike review, a consult seat has no channel to inherit a model from, so entries **must be explicit `adapter:model` pairs**.
-
-```yaml
-consult:
-  adapter: claude-code
-  model: fable
-  prefer: [codex:gpt-5.6-sol, kimi:kimi-code/k3]   # adapter:model ONLY
-```
-
-The daemon walks the preference list to the first live adapter, then the pinned `consult.adapter:model` pair as the final fallback. Failed or unparseable verdicts fall to the next entry.
-
-**Grammar**: consult prefer entries require `adapter:model` form — a bare adapter name is invalid and fails config load. Every entry must declare both the adapter and the model because a consult seat runs independently with no channel context.
-
-### Rerun control: --supersedes
-
-`tickmarkr run --supersedes <prior-runId>` marks the current run as a rerun of a prior engagement. The current task graph is used for the rerun; compile it fresh first if the spec changed. The prior runId is recorded in the new journal, and the prior journal records the successor, for audit trails and change attribution.
-
-Use this when you modify the spec or worker logic and want to mark an intentional rerun while preserving the relationship in both run journals.
+Fleet step 6/6 sets `review.prefer` and `consult.prefer`; routing modes (`risk-based`,
+`partner-led`, `staff-led`) are chosen in step 4/6. Full grammar — including when review
+prefer may name a **bare adapter** versus `adapter:model`, and why consult prefer entries
+require **`adapter:model`** form — plus `tickmarkr run --supersedes` rerun control, is in
+**[FLEET.md](https://github.com/alzahrani-khalid/tickmarkr/blob/main/FLEET.md)**.
 
 ## Model scoping and auth detection
 
@@ -426,6 +366,7 @@ accepted contributions are credited via `Co-authored-by:` on the release commit.
 
 ## Documentation
 
+- **[FLEET.md](https://github.com/alzahrani-khalid/tickmarkr/blob/main/FLEET.md)** — routing modes, steering syntax, tier provenance, and run flags (advanced reference)
 - **[LICENSE](LICENSE)** — MIT license
 - **[CONTRIBUTING.md](CONTRIBUTING.md)** — development setup and contribution guidelines
 - **[SECURITY.md](SECURITY.md)** — security policy and private vulnerability reporting

package/dist/cli/commands/fleet.js

@@ -6,7 +6,7 @@ import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
 import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
 import { GLYPHS, bold, legend as legendText, toggleActive, toggleInactive } from "../../brand.js";
-import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, overlayBytesLoadError, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
+import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, harvestFleetProvenance, overlayBytesLoadError, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
 import { candidateRow, costSignal, shapeCandidates } from "./fleet-picker.js";
 import { route } from "../../route/router.js";
@@ -16,6 +16,10 @@ const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY
 const QUIT = "fleet: quit without writing";
 const isDeniedAdapter = (id, editable) => editable.denyAdapters.includes(id);
 const isDeniedModel = (adapter, model, editable) => editable.denyModels.includes(`${adapter}:${model}`);
+// v1.60 T3: every preview surface ranks with the SAME exploration setting as the candidate picker
+// (rankCandidates routes noExplore so repeated calls agree) — a due probe must never make a
+// step-4/5 row disagree with the picker's rank-1 for the same shape and channel set.
+const PREVIEW_EXPLORE = { noExplore: true };
 function previewTask(shape) {
     return {
         id: "fleet-preview",
@@ -190,7 +194,10 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     const rm = resolveRunMode(cwd, { globalDir });
     const cfg = rm.cfg;
-    const initial = fleetEditableFromConfig(cfg);
+    // OBS-88: harvest existing `# note` comments from the overlay bytes at session load — the
+    // session must know about every prior note, not only its own edits, or the next write strips them
+    const harvested = harvestFleetProvenance(currentRepoOverlayText(cwd));
+    const initial = fleetEditableFromConfig(cfg, harvested.tiers);
     const editable = structuredClone(initial);
     const health = cached;
     const term = openTerm(input, output);
@@ -290,16 +297,29 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                 }
                 else if (k.name === "t" && rows[mCursor]) {
                     if (rows[mCursor].kind === "classified") {
-                        return { out: "fleet: tier reassignment on classified models is not supported in v1 — edit config directly", code: 1 };
+                        // v1.60 T2: t on a classified row is a step-3 input mistake like any other — the
+                        // notice renders inline and the session (with every in-session edit) stays alive
+                        term.frame([
+                            ...listFrame(title, modelsLegend, renderRows(rows), mCursor),
+                            "fleet: tier reassignment on classified models is not supported in v1 — edit config directly",
+                        ]);
+                        continue;
+                    }
+                    // v1.60 T2: an input mistake re-prompts the same field — a typo must never unwind
+                    // the whole editor and discard every in-session edit before the review screen
+                    let tier = (await term.askTyped(`tier (${TIERS.join("|")})> `));
+                    while (!TIERS.includes(tier)) {
+                        tier = (await term.askTyped(`fleet: invalid tier ${tier || "(empty)"} — tier (${TIERS.join("|")})> `));
+                    }
+                    let note = await term.askTyped("benchmark provenance note (required): ");
+                    while (!note) {
+                        note = await term.askTyped("fleet: a typed benchmark-provenance note is required — benchmark provenance note (required): ");
                     }
-                    const tier = (await term.askTyped(`tier (${TIERS.join("|")})> `));
-                    if (!TIERS.includes(tier))
-                        return { out: `fleet: invalid tier ${tier}`, code: 1 };
-                    const note = await term.askTyped("benchmark provenance note (required): ");
-                    if (!note)
-                        return { out: "fleet: assigning a tier to an unclassified model requires a typed benchmark-provenance note", code: 1 };
                     editable.tiers[a.id] ??= {};
-                    editable.tiers[a.id][rows[mCursor].model] = { tier, provenance: note };
+                    // stamp at typing time — the serializer writes provenance verbatim, so harvested notes
+                    // round-trip byte-for-byte instead of accreting a fresh date suffix every write (OBS-88)
+                    const today = new Date().toISOString().slice(0, 10);
+                    editable.tiers[a.id][rows[mCursor].model] = { tier, provenance: `${note} — fleet ${today}` };
                     changed = true;
                 }
                 if (changed)
@@ -325,7 +345,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             let apiUsd = 0;
             for (const shape of SHAPES) {
                 try {
-                    const a = route(previewTask(shape), previewCfg(cand), channels, profile).assignment;
+                    const a = route(previewTask(shape), previewCfg(cand), channels, profile, undefined, undefined, PREVIEW_EXPLORE).assignment;
                     tierCount[a.tier] = (tierCount[a.tier] ?? 0) + 1;
                     if (a.channel === "sub")
                         subs += 1;
@@ -393,7 +413,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const shapeRows = () => SHAPES.map((shape) => {
             let now;
             try {
-                const r = route(previewTask(shape), previewCfg(selectedMode), channels, profile);
+                const r = route(previewTask(shape), previewCfg(selectedMode), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
                 now = `${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})  ${costSignal(r.assignment, cfg.pricing)}`;
             }
             catch (e) {
@@ -527,7 +547,14 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             else
                 delete merged[key];
         }
-        const after = withModeLine(repoOverlayYaml(merged, provenanceMap(editable)), writeMode);
+        // OBS-88: session notes (which include the harvested ones attached at load) win per model;
+        // harvested notes alone cover entries with no editable seat — e.g. a null tombstone's comment
+        const tierNotes = structuredClone(harvested.tiers);
+        for (const [ad, ms] of Object.entries(provenanceMap(editable))) {
+            for (const [m, n] of Object.entries(ms))
+                (tierNotes[ad] ??= {})[m] = n;
+        }
+        const after = withModeLine(repoOverlayYaml(merged, tierNotes, { adapters: harvested.denyAdapters, models: harvested.denyModels }), writeMode);
         if ((!modeChanged && !steeringChanged && fleetEditableEquals(initial, editable)) || before === after) {
             return "fleet: no overlay changes (empty diff)";
         }

package/dist/cli/commands/plan.js

@@ -8,7 +8,7 @@ import { loadGraph } from "../../graph/graph.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { excludedChannels, exclusionLine } from "../../route/preference.js";
 import { staffLedEvidence } from "../../route/profile.js";
-import { QUALITY_ENV, route, RoutingError } from "../../route/router.js";
+import { route, RoutingError } from "../../route/router.js";
 import { modelId } from "../../gates/review.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 // T4 (v1.50): TTY-only brand pass — the title helper frames the routing table, lint/unroutable
@@ -44,7 +44,6 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters())
     if (values.mode !== undefined && !ROUTING_MODES.includes(values.mode)) {
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
-    delete process.env[QUALITY_ENV];
     const g = loadGraph(cwd);
     const { cfg, mode, source } = resolveRunMode(cwd, { flag: values.mode, spec: g.mode });
     // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).

package/dist/cli/commands/run.js

@@ -4,7 +4,7 @@ import { ROUTING_MODES } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
-import { route, NO_EXPLORE_ENV, QUALITY_ENV } from "../../route/router.js";
+import { route, NO_EXPLORE_ENV } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
 import { ttyVisual } from "../../adapters/model-lints.js";
 import { statusRow } from "../../brand.js";
@@ -25,8 +25,9 @@ export const narrationLine = (event) => {
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 // v1.51 T2: --quality is a pure compatibility alias for `--mode partner-led` (this run only). It
-// carries no one-band floor raise of its own: the flag never sets ExploreContext.quality or the
-// TICKMARKR_QUALITY env, so no downstream code raises a floor on its behalf (proven in mode-sources).
+// carries no one-band floor raise of its own — and since the OBS-89 rip (v1.60) route() no longer
+// reads the retired TICKMARKR_QUALITY env at all, so no downstream code can raise a floor on its
+// behalf (proven in mode-sources).
 const QUALITY_ALIAS_NOTICE = "tickmarkr: --quality is a compatibility alias for --mode partner-led (this run only) — "
     + "the v1.47 one-band floor raise is retired (deprecated); use --mode partner-led";
 export async function run(argv, cwd = process.cwd()) {
@@ -56,7 +57,6 @@ export async function run(argv, cwd = process.cwd()) {
     if (values.quality)
         console.warn(QUALITY_ALIAS_NOTICE);
     const flagMode = values.mode ?? (values.quality ? "partner-led" : undefined);
-    delete process.env[QUALITY_ENV];
     const graph = loadGraph(cwd);
     const { cfg, conflict } = resolveRunMode(cwd, { flag: flagMode, spec: graph.mode });
     if (conflict) {

package/dist/cli/commands/status.js

@@ -54,12 +54,24 @@ const gateStates = (task, events) => {
 };
 // verdict semantics only: pass brand green, fail red, skip/open dim chrome — everything else stays quiet
 const GATE_STATE_TOKEN = { pass: ok, fail, skip: dim, open: dim };
-const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => {
-    const chip = `${GATE_KEYS[gate]}${gateBox(states[i], unicode)}`;
-    return unicode ? GATE_STATE_TOKEN[states[i]](chip) : chip;
-}).join(" ");
-// plain (uncolored) chip width for column math — ANSI codes have zero display width
-const gateChainWidth = (unicode) => GATE_NAMES.reduce((w, gate) => w + GATE_KEYS[gate].length + (unicode ? 1 : 3) + 1, -1);
+// TTY cells are bare glyphs in fixed GATE_NAMES order — gate identity lives once in the frame
+// legend, and in words on a failing row; non-TTY keeps the letter+box chips (byte-pinned surface)
+const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
+    ? GATE_STATE_TOKEN[states[i]](gateBox(states[i], true))
+    : `${GATE_KEYS[gate]}${gateBox(states[i], false)}`).join(" ");
+// plain (uncolored) cell width for column math — ANSI codes have zero display width
+const gateChainWidth = (unicode) => GATE_NAMES.reduce((w, gate) => w + (unicode ? 1 : GATE_KEYS[gate].length + 3) + 1, -1);
+const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
+// plain-text form of the failed-gate words for column math; rendered with a dim dot + red names
+const failedSuffix = (states) => {
+    const f = failedGates(states);
+    return f.length ? ` · ${f.join(", ")}` : "";
+};
+// a designed human gate parks the task BEFORE any gate result exists (daemon.ts execTask), so the
+// awaited approval is named from task state alone — never from gate results. Failed gates win the
+// cell when present: a post-approval park is not awaiting the designed gate. Plain text for column
+// math; rendered with a dim dot + warn words. TTY-only — the non-TTY surface stays byte-pinned.
+const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
 const shortGoal = (goal, max) => {
     const clause = goal.split(/[,;.?!]/, 1)[0].trim();
     if (clause.length <= max)
@@ -193,19 +205,24 @@ const renderFrame = (cwd) => {
             : `no runs yet${dot}`) +
         `${gauge} ${done === g.tasks.length && g.tasks.length > 0 ? ok(tally) : tally}`;
     const hr = rule(Math.min(width, 100));
-    const gatesLegend = legend(`   gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(" · ")}`);
+    const gatesLegend = legend(`   gates: ${GATE_NAMES.join(" · ")}`);
     const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
-    const stW = Math.max(...cells.map((c) => (String(c.st) + c.label).length));
+    const stW = Math.max(...cells.map((c) => (String(c.st) + c.label + failedSuffix(c.states) + humanGateSuffix(c.t, c.st, c.states)).length));
     const chainW = gateChainWidth(true);
     const assignW = Math.max(...cells.map((c) => c.assignCol.length));
     const goalW = Math.max(8, width - (5 + idW) - 2 - chainW - 2 - stW - 2 - assignW);
     const rows = cells.map(({ t, st, label, assignCol, states }) => {
         const goal = shortGoal(t.goal, goalW).padEnd(goalW);
         const stWord = st === "done" ? ok(String(st)) : st === "failed" ? fail(String(st)) : st === "human" ? warn(String(st)) : String(st);
+        // a fail names its gate in words right here — the one moment gate identity is needed on a row
+        const f = failedGates(states);
+        const human = humanGateSuffix(t, st, states);
         const statusCell = stWord +
             (label ? (label === " starved" ? fail(label) : dim(label)) : "") +
-            " ".repeat(stW - (String(st) + label).length);
+            (f.length ? dim(" · ") + fail(f.join(", ")) : "") +
+            (human ? dim(" · ") + warn("awaiting approval") : "") +
+            " ".repeat(stW - (String(st) + label + failedSuffix(states) + human).length);
         return `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`)}`;
     });
     return [header, hr, gatesLegend, ...rows].join("\n");

package/dist/compile/native.d.ts

@@ -1,4 +1,5 @@
 import { type RunGraph } from "../graph/schema.js";
+export declare const COLLECTABLE_TESTS = "tests/**/*.test.ts";
 export declare const LEGACY_PREFIX: string;
 export declare const TICKMARKR_NATIVE_MARKER: RegExp;
 export declare const NATIVE_MARKER: RegExp;

package/dist/compile/native.js

@@ -1,6 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
+import picomatch from "picomatch";
 import { GATE_NAMES, GRAPH_ROUTING_MODES, ORACLES, SHAPES, TIERS, validateGraph } from "../graph/schema.js";
 import { CompileError, inferShape, sha256 } from "./common.js";
+// OBS-97: mirror of the vitest.config.ts suite include — the only path class vitest collects.
+export const COLLECTABLE_TESTS = "tests/**/*.test.ts";
 export const LEGACY_PREFIX = ["dro", "vr"].join("");
 export const TICKMARKR_NATIVE_MARKER = /^<!--\s*tickmarkr:spec(?:\s+v1)?\s*-->\s*$/m;
 export const NATIVE_MARKER = new RegExp(`^<!--\\s*(?:tickmarkr|${LEGACY_PREFIX}):spec(?:\\s+v1)?\\s*-->\\s*$`, "m");
@@ -116,6 +119,35 @@ export function compileNative(file) {
             `Add to each section in ${file}:\n- acceptance:\n  - <observable outcome>`);
     }
     const csv = (value) => (value && value.toLowerCase() !== "none" ? value.split(",").map((item) => item.trim()).filter(Boolean) : []);
+    // OBS-97: a typed test: oracle needs a collectable home. vitest only collects COLLECTABLE_TESTS
+    // paths, so a task whose non-empty files[] cannot host one makes scope-green and acceptance-green
+    // mutually exclusive by construction — run-20260719-210434 burned two dispatch attempts before a
+    // consult diagnosed exactly this. Empty files[] stays exempt: no file scope means unrestricted
+    // (src/gates/scope.ts). An entry hosts a collectable path iff its glob can produce one — probed by
+    // substituting each wildcard run with a test-shaped segment (also covers literal test-file paths).
+    const collectable = picomatch(COLLECTABLE_TESTS, { dot: true });
+    // Single-token substitution is not a true glob-overlap test (tests/**/*.ts needs "probe.test",
+    // a bare ** needs the whole collectable path) — probe with several test-shaped tokens and accept
+    // if ANY candidate satisfies both globs. Scopes that truly cannot host one still fail every probe.
+    const PROBE_TOKENS = ["probe.test.ts", "probe.test", "tests/probe.test.ts"];
+    const canHostTest = (entry) => {
+        const self = picomatch(entry, { dot: true });
+        return PROBE_TOKENS.some((token) => {
+            const probe = entry.replace(/\*+/g, token);
+            return self(probe) && collectable(probe);
+        });
+    };
+    const homeless = drafts
+        .filter((draft) => {
+        const files = csv(draft.fields.files);
+        return files.length > 0 && !files.some(canHostTest)
+            && draft.acceptance.some((item) => typeof item !== "string" && item.oracle === "test");
+    })
+        .map((draft) => draft.id);
+    if (homeless.length) {
+        throw new CompileError(`OBS-97: task${homeless.length === 1 ? "" : "s"} ${homeless.join(", ")} carr${homeless.length === 1 ? "ies" : "y"} a test: acceptance oracle but files[] cannot host a vitest-collectable test path (${COLLECTABLE_TESTS}).\n` +
+            `Add a ${COLLECTABLE_TESTS} entry to files[] in ${file}, or replace the test: oracle with command:/judge:.`);
+    }
     const tasks = drafts.map((draft) => {
         const { fields } = draft;
         const shape = fields.shape ?? inferShape(draft.title);

package/dist/config/config.d.ts

@@ -235,8 +235,8 @@ export type InitConfigOverlay = {
     };
 };
 export declare function configTemplate(overlay?: InitConfigOverlay): string;
-/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
-export declare const FLEET_OVERLAY_KEYS: readonly ["routing", "tiers"];
+export { FLEET_OVERLAY_KEYS, fleetEditableEquals, fleetRepoOverlayFromDelta, harvestFleetProvenance, repoOverlayYaml, serializeFleetOverlay, unifiedYamlDiff, } from "./fleet-overlay.js";
+export type { FleetDenyNotes, HarvestedProvenance } from "./fleet-overlay.js";
 export type FleetTierAssignment = {
     tier: Tier;
     provenance?: string;
@@ -250,7 +250,7 @@ export type FleetEditable = {
 };
 export declare function repoOverlayPath(repoRoot: string): string;
 export declare function readOverlayFile(path: string): Record<string, unknown>;
-export declare function fleetEditableFromConfig(cfg: TickmarkrConfig): FleetEditable;
+export declare function fleetEditableFromConfig(cfg: TickmarkrConfig, provenance?: Record<string, Record<string, string>>): FleetEditable;
 /** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
 export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
     globalDir?: string;
@@ -259,10 +259,3 @@ export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
 export declare function formatFleetPrint(repoRoot: string, opts?: {
     globalDir?: string;
 }): string;
-/** Build the repo overlay fragment fleet would write for edits since session start. */
-export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>): Record<string, unknown>;
-export declare function repoOverlayYaml(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
-export declare function serializeFleetOverlay(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
-export declare function unifiedYamlDiff(before: string, after: string, label?: string): string;
-export declare function fleetEditableEquals(a: FleetEditable, b: FleetEditable): boolean;
-export {};

package/dist/config/config.js

@@ -533,8 +533,9 @@ export function configTemplate(overlay) {
     const nl = base.indexOf("\n");
     return `${base.slice(0, nl + 1)}${lines.join("\n")}\n${base.slice(nl + 1)}`;
 }
-/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
-export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
+// v1.61 seed 8: the fleet-overlay provenance cluster (harvesting, serialization, diff rendering)
+// moved to fleet-overlay.ts as a pure move — re-exported here so prior import paths keep working.
+export { FLEET_OVERLAY_KEYS, fleetEditableEquals, fleetRepoOverlayFromDelta, harvestFleetProvenance, repoOverlayYaml, serializeFleetOverlay, unifiedYamlDiff, } from "./fleet-overlay.js";
 export function repoOverlayPath(repoRoot) {
     return join(repoRoot, stateDirName(repoRoot), "config.yaml");
 }
@@ -546,12 +547,16 @@ export function readOverlayFile(path) {
         throw new ConfigError(`invalid overlay at ${path}`);
     return raw;
 }
-export function fleetEditableFromConfig(cfg) {
+export function fleetEditableFromConfig(cfg, provenance = {}) {
     const tiers = {};
     for (const [adapter, entry] of Object.entries(cfg.tiers)) {
         tiers[adapter] = {};
-        for (const [model, tier] of Object.entries(entry.models))
-            tiers[adapter][model] = { tier };
+        for (const [model, tier] of Object.entries(entry.models)) {
+            // OBS-88: notes harvested from the overlay ride the session state from load, so a later
+            // write knows about every existing note — not only the ones this session typed itself
+            const note = provenance[adapter]?.[model];
+            tiers[adapter][model] = note ? { tier, provenance: note } : { tier };
+        }
     }
     return {
         denyAdapters: [...(cfg.routing.deny?.adapters ?? [])].sort(),
@@ -561,14 +566,6 @@ export function fleetEditableFromConfig(cfg) {
         floors: { ...cfg.routing.floors },
     };
 }
-function fleetSubset(obj) {
-    const out = {};
-    for (const k of FLEET_OVERLAY_KEYS) {
-        if (obj[k] !== undefined)
-            out[k] = obj[k];
-    }
-    return out;
-}
 /** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
 export function fleetKeyLayer(repoRoot, dotted, opts = {}) {
     const gdir = opts.globalDir ?? globalConfigDir();
@@ -646,177 +643,3 @@ export function formatFleetPrint(repoRoot, opts = {}) {
     }
     return `${lines.join("\n")}\n`;
 }
-function sortedUnique(xs) {
-    return [...new Set(xs)].sort();
-}
-/** Build the repo overlay fragment fleet would write for edits since session start. */
-export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}) {
-    if (fleetEditableEquals(initial, edited))
-        return {};
-    const out = structuredClone(existingRepo);
-    const routing = { ...out.routing };
-    let routingTouched = false;
-    const denyChanged = sortedUnique(initial.denyAdapters).join() !== sortedUnique(edited.denyAdapters).join()
-        || sortedUnique(initial.denyModels).join() !== sortedUnique(edited.denyModels).join();
-    if (denyChanged) {
-        routing.deny = {
-            adapters: edited.denyAdapters.length ? edited.denyAdapters : null,
-            models: edited.denyModels.length ? edited.denyModels : null,
-        };
-        routingTouched = true;
-    }
-    const mapDelta = {};
-    for (const shape of new Set([...Object.keys(initial.map), ...Object.keys(edited.map)])) {
-        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape]))
-            mapDelta[shape] = edited.map[shape];
-    }
-    if (Object.keys(mapDelta).length) {
-        routing.map = { ...routing.map, ...mapDelta };
-        routingTouched = true;
-    }
-    const floorDelta = {};
-    for (const shape of new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)])) {
-        if (initial.floors[shape] !== edited.floors[shape])
-            floorDelta[shape] = edited.floors[shape];
-    }
-    if (Object.keys(floorDelta).length) {
-        routing.floors = { ...routing.floors, ...floorDelta };
-        routingTouched = true;
-    }
-    if (routingTouched)
-        out.routing = routing;
-    const tiersOut = {
-        ...out.tiers,
-    };
-    let tiersTouched = false;
-    const adapters = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
-    for (const adapter of adapters) {
-        const models = new Set([
-            ...Object.keys(initial.tiers[adapter] ?? {}),
-            ...Object.keys(edited.tiers[adapter] ?? {}),
-        ]);
-        const modelDelta = {};
-        for (const model of models) {
-            const a = initial.tiers[adapter]?.[model];
-            const b = edited.tiers[adapter]?.[model];
-            if (JSON.stringify(a) !== JSON.stringify(b)) {
-                modelDelta[model] = b === null || b === undefined ? null : b.tier;
-            }
-        }
-        if (Object.keys(modelDelta).length) {
-            // spread the existing entry so vendor/channel/windows survive the rewrite — dropping them
-            // makes the overlay unloadable for any adapter without a default seed (reload-guard class)
-            tiersOut[adapter] = { ...tiersOut[adapter], models: { ...tiersOut[adapter]?.models, ...modelDelta } };
-            tiersTouched = true;
-        }
-    }
-    if (tiersTouched)
-        out.tiers = tiersOut;
-    return out;
-}
-export function repoOverlayYaml(overlay, provenance = {}) {
-    if (!Object.keys(overlay).length)
-        return "";
-    const fleet = fleetSubset(overlay);
-    const fleetBody = serializeFleetOverlay(fleet, provenance);
-    const rest = { ...overlay };
-    for (const k of FLEET_OVERLAY_KEYS)
-        delete rest[k];
-    if (!Object.keys(rest).length)
-        return fleetBody;
-    const head = stringify(rest).trimEnd();
-    return fleetBody ? `${head}\n${fleetBody}` : `${head}\n`;
-}
-export function serializeFleetOverlay(overlay, provenance = {}) {
-    if (!Object.keys(overlay).length)
-        return "";
-    const lines = [];
-    const today = new Date().toISOString().slice(0, 10);
-    // OBS-75: never glue stringify() output onto a key line — wrap the key into the object and
-    // re-indent the whole emitted block, so sequences/nested maps nest correctly and null
-    // tombstones/empty collections survive the serialize→parse round-trip.
-    const block = (obj, pad) => stringify(obj).trimEnd().split("\n").map((l) => `${pad}${l}`);
-    const routing = overlay.routing;
-    if (routing) {
-        lines.push("routing:");
-        const deny = routing.deny;
-        if (deny && (deny.adapters !== undefined || deny.models !== undefined)) {
-            lines.push("  deny:");
-            if (deny.adapters !== undefined)
-                lines.push(...block({ adapters: deny.adapters }, "    "));
-            if (deny.models !== undefined)
-                lines.push(...block({ models: deny.models }, "    "));
-        }
-        if (routing.map)
-            lines.push(...block({ map: routing.map }, "  "));
-        if (routing.floors)
-            lines.push(...block({ floors: routing.floors }, "  "));
-    }
-    const tiers = overlay.tiers;
-    if (tiers && Object.keys(tiers).length) {
-        lines.push("tiers:");
-        for (const [adapter, entry] of Object.entries(tiers)) {
-            const body = [];
-            if (entry.vendor)
-                body.push(`    vendor: ${entry.vendor}`);
-            if (entry.channel)
-                body.push(`    channel: ${entry.channel}`);
-            if (entry.windows)
-                body.push(...block({ windows: entry.windows }, "    "));
-            const models = Object.entries(entry.models ?? {});
-            if (models.length) {
-                body.push("    models:");
-                for (const [model, tier] of models) {
-                    if (tier === null)
-                        body.push(`      ${model}: null`);
-                    else {
-                        const note = provenance[adapter]?.[model];
-                        const suffix = note ? `  # ${note} — fleet ${today}` : "";
-                        body.push(`      ${model}: ${tier}${suffix}`);
-                    }
-                }
-            }
-            else if (entry.models) {
-                body.push("    models: {}"); // present-but-empty: explicit {} — a childless header parses as null and the loader rejects it
-            }
-            // a bare `adapter:` line parses as a null tombstone and would DELETE the adapter's default seeds on merge
-            if (body.length)
-                lines.push(`  ${adapter}:`, ...body);
-            else
-                lines.push(`  ${adapter}: {}`);
-        }
-    }
-    return `${lines.join("\n")}\n`;
-}
-export function unifiedYamlDiff(before, after, label = "config overlay") {
-    const a = before.split("\n");
-    const b = after.split("\n");
-    if (before === after)
-        return "";
-    const header = [`--- ${label} (current)`, `+++ ${label} (proposed)`];
-    const hunks = [];
-    let i = 0;
-    let j = 0;
-    while (i < a.length || j < b.length) {
-        if (i < a.length && j < b.length && a[i] === b[j]) {
-            i++;
-            j++;
-            continue;
-        }
-        const startI = i;
-        const startJ = j;
-        while (i < a.length && (j >= b.length || a[i] !== b[j]))
-            i++;
-        while (j < b.length && (i >= a.length || a[i] !== b[j]))
-            j++;
-        hunks.push("@@");
-        for (let k = startI; k < i; k++)
-            hunks.push(`-${a[k]}`);
-        for (let k = startJ; k < j; k++)
-            hunks.push(`+${b[k]}`);
-    }
-    return `${header.join("\n")}\n${hunks.join("\n")}\n`;
-}
-export function fleetEditableEquals(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}

package/dist/config/fleet-overlay.d.ts

@@ -0,0 +1,27 @@
+import type { FleetEditable } from "./config.js";
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export declare const FLEET_OVERLAY_KEYS: readonly ["routing", "tiers"];
+/** Trailing `# note` comments on per-entry lines an operator may have hand-written or a prior
+ *  fleet write stamped: model tier lines (including null tombstones) and deny list items. */
+export type HarvestedProvenance = {
+    tiers: Record<string, Record<string, string>>;
+    denyAdapters: Record<string, string>;
+    denyModels: Record<string, string>;
+};
+/** OBS-88: harvest existing provenance comments from raw repo-overlay bytes at fleet-session
+ *  load. yaml.parse discards comments, so before this every fleet write re-serialized the file
+ *  knowing only the current session's own notes and silently stripped all prior ones — a typed
+ *  benchmark-provenance note survived exactly one write. Fail-open to empty: an unreadable
+ *  overlay is the loader's problem to reject, never the harvester's. */
+export declare function harvestFleetProvenance(overlayText: string): HarvestedProvenance;
+/** Harvested deny-entry notes keyed by the exact entry string, re-attached at serialize time. */
+export type FleetDenyNotes = {
+    adapters?: Record<string, string>;
+    models?: Record<string, string>;
+};
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>): Record<string, unknown>;
+export declare function repoOverlayYaml(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>, denyNotes?: FleetDenyNotes): string;
+export declare function serializeFleetOverlay(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>, denyNotes?: FleetDenyNotes): string;
+export declare function unifiedYamlDiff(before: string, after: string, label?: string): string;
+export declare function fleetEditableEquals(a: FleetEditable, b: FleetEditable): boolean;

package/dist/config/fleet-overlay.js

@@ -0,0 +1,249 @@
+// Fleet-overlay provenance cluster (v1.61 seed 8): harvesting, serialization, and diff rendering
+// for the `tickmarkr fleet` write path. Pure move out of config.ts — prior import paths preserved
+// via re-exports there.
+import { isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
+function fleetSubset(obj) {
+    const out = {};
+    for (const k of FLEET_OVERLAY_KEYS) {
+        if (obj[k] !== undefined)
+            out[k] = obj[k];
+    }
+    return out;
+}
+function sortedUnique(xs) {
+    return [...new Set(xs)].sort();
+}
+/** OBS-88: harvest existing provenance comments from raw repo-overlay bytes at fleet-session
+ *  load. yaml.parse discards comments, so before this every fleet write re-serialized the file
+ *  knowing only the current session's own notes and silently stripped all prior ones — a typed
+ *  benchmark-provenance note survived exactly one write. Fail-open to empty: an unreadable
+ *  overlay is the loader's problem to reject, never the harvester's. */
+export function harvestFleetProvenance(overlayText) {
+    const out = { tiers: {}, denyAdapters: {}, denyModels: {} };
+    if (!overlayText.trim())
+        return out;
+    const doc = parseDocument(overlayText);
+    const note = (n) => {
+        const c = isScalar(n) ? n.comment : undefined;
+        return typeof c === "string" && c.trim() ? c.trim() : undefined;
+    };
+    const tiers = doc.getIn(["tiers"]);
+    if (isMap(tiers)) {
+        for (const ap of tiers.items) {
+            if (!isScalar(ap.key))
+                continue;
+            const models = isMap(ap.value) ? ap.value.get("models") : undefined;
+            if (!isMap(models))
+                continue;
+            for (const mp of models.items) {
+                const n = note(mp.value);
+                if (isScalar(mp.key) && n)
+                    (out.tiers[String(ap.key.value)] ??= {})[String(mp.key.value)] = n;
+            }
+        }
+    }
+    for (const [key, dest] of [["adapters", out.denyAdapters], ["models", out.denyModels]]) {
+        const seq = doc.getIn(["routing", "deny", key]);
+        if (!isSeq(seq))
+            continue;
+        for (const item of seq.items) {
+            const n = note(item);
+            if (isScalar(item) && n)
+                dest[String(item.value)] = n;
+        }
+    }
+    return out;
+}
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}) {
+    if (fleetEditableEquals(initial, edited))
+        return {};
+    const out = structuredClone(existingRepo);
+    const routing = { ...out.routing };
+    let routingTouched = false;
+    const denyChanged = sortedUnique(initial.denyAdapters).join() !== sortedUnique(edited.denyAdapters).join()
+        || sortedUnique(initial.denyModels).join() !== sortedUnique(edited.denyModels).join();
+    if (denyChanged) {
+        routing.deny = {
+            adapters: edited.denyAdapters.length ? edited.denyAdapters : null,
+            models: edited.denyModels.length ? edited.denyModels : null,
+        };
+        routingTouched = true;
+    }
+    const mapDelta = {};
+    for (const shape of new Set([...Object.keys(initial.map), ...Object.keys(edited.map)])) {
+        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape]))
+            mapDelta[shape] = edited.map[shape];
+    }
+    if (Object.keys(mapDelta).length) {
+        routing.map = { ...routing.map, ...mapDelta };
+        routingTouched = true;
+    }
+    const floorDelta = {};
+    for (const shape of new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)])) {
+        if (initial.floors[shape] !== edited.floors[shape])
+            floorDelta[shape] = edited.floors[shape];
+    }
+    if (Object.keys(floorDelta).length) {
+        routing.floors = { ...routing.floors, ...floorDelta };
+        routingTouched = true;
+    }
+    if (routingTouched)
+        out.routing = routing;
+    const tiersOut = {
+        ...out.tiers,
+    };
+    let tiersTouched = false;
+    const adapters = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
+    for (const adapter of adapters) {
+        const models = new Set([
+            ...Object.keys(initial.tiers[adapter] ?? {}),
+            ...Object.keys(edited.tiers[adapter] ?? {}),
+        ]);
+        const modelDelta = {};
+        for (const model of models) {
+            const a = initial.tiers[adapter]?.[model];
+            const b = edited.tiers[adapter]?.[model];
+            if (JSON.stringify(a) !== JSON.stringify(b)) {
+                modelDelta[model] = b === null || b === undefined ? null : b.tier;
+            }
+        }
+        if (Object.keys(modelDelta).length) {
+            // spread the existing entry so vendor/channel/windows survive the rewrite — dropping them
+            // makes the overlay unloadable for any adapter without a default seed (reload-guard class)
+            tiersOut[adapter] = { ...tiersOut[adapter], models: { ...tiersOut[adapter]?.models, ...modelDelta } };
+            tiersTouched = true;
+        }
+    }
+    if (tiersTouched)
+        out.tiers = tiersOut;
+    return out;
+}
+export function repoOverlayYaml(overlay, provenance = {}, denyNotes = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const fleet = fleetSubset(overlay);
+    const fleetBody = serializeFleetOverlay(fleet, provenance, denyNotes);
+    const rest = { ...overlay };
+    for (const k of FLEET_OVERLAY_KEYS)
+        delete rest[k];
+    if (!Object.keys(rest).length)
+        return fleetBody;
+    const head = stringify(rest).trimEnd();
+    return fleetBody ? `${head}\n${fleetBody}` : `${head}\n`;
+}
+export function serializeFleetOverlay(overlay, provenance = {}, denyNotes = {}) {
+    if (!Object.keys(overlay).length)
+        return "";
+    const lines = [];
+    // OBS-75: never glue stringify() output onto a key line — wrap the key into the object and
+    // re-indent the whole emitted block, so sequences/nested maps nest correctly and null
+    // tombstones/empty collections survive the serialize→parse round-trip.
+    const block = (obj, pad) => stringify(obj).trimEnd().split("\n").map((l) => `${pad}${l}`);
+    // deny lists emit item-by-item through the same stringify quoting rules as block(), so a
+    // harvested `# reason` can re-attach to its exact entry (multi-line emissions never take one)
+    const denySeq = (key, v) => {
+        if (v === undefined)
+            return [];
+        if (v === null || !v.length)
+            return block({ [key]: v }, "    ");
+        const out = [`    ${key}:`];
+        for (const item of v) {
+            const emitted = stringify([item]).trimEnd().split("\n");
+            const n = denyNotes[key]?.[item];
+            if (n && emitted.length === 1)
+                emitted[0] += `  # ${n}`;
+            out.push(...emitted.map((l) => `      ${l}`));
+        }
+        return out;
+    };
+    const routing = overlay.routing;
+    if (routing) {
+        lines.push("routing:");
+        const deny = routing.deny;
+        if (deny && (deny.adapters !== undefined || deny.models !== undefined)) {
+            lines.push("  deny:");
+            lines.push(...denySeq("adapters", deny.adapters));
+            lines.push(...denySeq("models", deny.models));
+        }
+        if (routing.map)
+            lines.push(...block({ map: routing.map }, "  "));
+        if (routing.floors)
+            lines.push(...block({ floors: routing.floors }, "  "));
+    }
+    const tiers = overlay.tiers;
+    if (tiers && Object.keys(tiers).length) {
+        lines.push("tiers:");
+        for (const [adapter, entry] of Object.entries(tiers)) {
+            const body = [];
+            if (entry.vendor)
+                body.push(`    vendor: ${entry.vendor}`);
+            if (entry.channel)
+                body.push(`    channel: ${entry.channel}`);
+            if (entry.windows)
+                body.push(...block({ windows: entry.windows }, "    "));
+            const models = Object.entries(entry.models ?? {});
+            if (models.length) {
+                body.push("    models:");
+                for (const [model, tier] of models) {
+                    // OBS-88: notes serialize verbatim (fresh session notes arrive pre-stamped with their
+                    // "— fleet <date>" suffix), so a harvested note round-trips byte-for-byte every write
+                    const note = provenance[adapter]?.[model];
+                    const suffix = note ? `  # ${note}` : "";
+                    body.push(`      ${model}: ${tier === null ? "null" : tier}${suffix}`);
+                }
+            }
+            else if (entry.models) {
+                body.push("    models: {}"); // present-but-empty: explicit {} — a childless header parses as null and the loader rejects it
+            }
+            // a bare `adapter:` line parses as a null tombstone and would DELETE the adapter's default seeds on merge
+            if (body.length)
+                lines.push(`  ${adapter}:`, ...body);
+            else
+                lines.push(`  ${adapter}: {}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function unifiedYamlDiff(before, after, label = "config overlay") {
+    if (before === after)
+        return "";
+    const a = before.split("\n");
+    const b = after.split("\n");
+    // v1.60 T3: shortest-edit (LCS) matching. The old scan resynced greedily on the first mismatched
+    // line, so one inserted line could cascade into a whole-file remove/re-add hunk on the one
+    // confirmation surface an operator reviews before a write.
+    // ponytail: O(n·m) table — overlays are tens of lines; Myers O(nd) if files ever grow.
+    const lcs = Array.from({ length: a.length + 1 }, () => Array.from({ length: b.length + 1 }, () => 0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const header = [`--- ${label} (current)`, `+++ ${label} (proposed)`];
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        const del = [];
+        const add = [];
+        while ((i < a.length || j < b.length) && !(i < a.length && j < b.length && a[i] === b[j])) {
+            if (j >= b.length || (i < a.length && lcs[i + 1][j] >= lcs[i][j + 1]))
+                del.push(`-${a[i++]}`);
+            else
+                add.push(`+${b[j++]}`);
+        }
+        hunks.push("@@", ...del, ...add);
+    }
+    return `${header.join("\n")}\n${hunks.join("\n")}\n`;
+}
+export function fleetEditableEquals(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/dist/route/router.d.ts

@@ -1,5 +1,5 @@
 import { type Assignment, type BillingChannel } from "../adapters/types.js";
-import { type TickmarkrConfig, type Tier } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 import type { Task } from "../graph/schema.js";
 import { type RoutingProfile } from "./profile.js";
 export type LadderStep = "retry" | "escalate" | "consult" | "human";
@@ -28,12 +28,10 @@ export interface RoutingPreferContext {
 }
 export interface ExploreContext {
     noExplore?: boolean;
-    quality?: boolean;
 }
 export declare const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
 export declare const QUALITY_ENV = "TICKMARKR_QUALITY";
 export declare const ROUTING_ENV_SEAMS: readonly ["TICKMARKR_QUALITY", "TICKMARKR_NO_EXPLORE"];
-export declare const raiseTier: (tier: Tier) => Tier;
 export declare class RoutingError extends Error {
     constructor(msg: string);
 }

package/dist/route/router.js

@@ -3,15 +3,18 @@ import { TIER_RANK } from "../config/config.js";
 import { disallowedBy } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
 export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
+// OBS-89 (v1.60): the TICKMARKR_QUALITY variable is RETIRED — nothing in src reads it anymore and
+// route() ignores it entirely (the v1.47 one-band floor raise, its exploration suppression, and the
+// env fallback were deleted, not moved). The name survives solely as a scrub target: the spawn seam
+// keeps erasing a stale operator shell's legacy export from child environments, and the retired-seam
+// tests (tests/run/git.test.ts, tests/setup.ts, tests/gates/baseline.test.ts) pin that contract.
 export const QUALITY_ENV = "TICKMARKR_QUALITY";
 // OBS-74: every routing env seam, in one list — the spawn seam (src/run/git.ts) scrubs exactly
 // these from child env so gate/baseline/tip-verify children are hermetic by construction.
 export const ROUTING_ENV_SEAMS = [QUALITY_ENV, NO_EXPLORE_ENV];
 const exploreCap = (cfg) => cfg.routing.explore?.cap ?? EXPLORE_CAP;
-const qualityOn = (exploreCtx) => !!exploreCtx?.quality || process.env[QUALITY_ENV] === "1";
-export const raiseTier = (tier) => tier === "cheap" ? "mid" : tier === "mid" ? "frontier" : "frontier";
 const exploreOff = (task, cfg, exploreCtx) => {
-    if (qualityOn(exploreCtx) || exploreCtx?.noExplore || process.env[NO_EXPLORE_ENV] === "1")
+    if (exploreCtx?.noExplore || process.env[NO_EXPLORE_ENV] === "1")
         return true;
     const e = cfg.routing.explore;
     if (!e)
@@ -110,15 +113,6 @@ function withoutExcluded(channels, exclude) {
     // OBS-57: in-run demotion after consecutive no-trailer windows — route around poisoned channels for the rest of the run.
     return channels.filter((c) => !exclude.has(channelKey(c)));
 }
-const qualityBound = (quality, configFloor, taskFloor) => {
-    if (!quality)
-        return undefined;
-    if (configFloor)
-        return `floor ${configFloor}→${raiseTier(configFloor)} (--quality)`;
-    if (taskFloor)
-        return `floor ${taskFloor}→${raiseTier(taskFloor)} (--quality)`;
-    return undefined;
-};
 const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
     if (slaMinutes === undefined || !profile)
         return;
@@ -135,7 +129,6 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     channels = withoutExcluded(channels, exclude);
     const lints = [];
     const advisoryFloor = cfg.routing.floors[task.shape];
-    const quality = qualityOn(exploreCtx);
     const floor = advisoryFloor;
     const slaMinutes = cfg.routing.sla?.[task.shape];
     // ponytail: sla is plan-time advisory only — never thread into learnedScore (would reroute warm rivals).
@@ -173,8 +166,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
             lints.push(`${task.id} (${task.shape}): ${what} routes ${tier}, below advisory floor ${advisoryFloor}`);
         }
     };
-    const taskFloorRaw = task.routingHints?.floor;
-    const taskFloor = taskFloorRaw && quality ? raiseTier(taskFloorRaw) : taskFloorRaw;
+    const taskFloor = task.routingHints?.floor;
     const source = task.routingHints?.source;
     const src = source ? `, ${source}` : ""; // never interpolate a possibly-undefined source
     // task pin: planner-authored, try-first — degrades on miss or below-floor (D-05, research A3), never throws
@@ -201,12 +193,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         return { assignment: toAssignment(c), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pin ${entry.pin.via}:${entry.pin.model} (config routing.map)` };
     }
     const baseTier = floor ?? "cheap";
-    let minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier; // task floor is a hard >= constraint in all paths (D-04)
-    if (quality && advisoryFloor) {
-        const raised = raiseTier(advisoryFloor);
-        if (TIER_RANK[raised] > TIER_RANK[minTier])
-            minTier = raised;
-    }
+    const minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier; // task floor is a hard >= constraint in all paths (D-04)
     if (prefActive)
         for (const p of prefer ?? [])
             preflightPrefer(p);
@@ -301,10 +288,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         eligible = spreadStatic(sortedStatic);
         spreadDecided = channelKey(eligible[0]) !== channelKey(sortedStatic[0]);
     }
-    const bound = qualityBound(quality, advisoryFloor, taskFloorRaw) ??
-        (taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
-            floor ? `floor ${floor} (config floors)` :
-                "tier cheap (default)");
+    const bound = taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
+        floor ? `floor ${floor} (config floors)` :
+            "tier cheap (default)";
     // name the key that actually broke the tie: prefer outranks the marginal-cost/tier keys, so if the
     // winner matched a prefer entry, prefer decided it — not "cheapest sufficient tier" (ROUTE-03, WR-01)
     const preferVia = preferFromAuto(task.shape, preferCtx)

package/dist/run/daemon.js

@@ -19,7 +19,7 @@ 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, QUALITY_ENV, route } from "../route/router.js";
+import { nextChannel, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
 import { normalizeStallSnapshot } from "./stall.js";
 const MODE_RANK = { "staff-led": 0, "risk-based": 1, "partner-led": 2 };
@@ -90,9 +90,8 @@ async function cherryPickCommits(wt, commits) {
     return carried;
 }
 export async function runDaemon(repoRoot, opts = {}) {
-    // 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];
+    // v1.51 T2 / OBS-89 (v1.60): retired --quality env seam. Mode resolution owns premium routing;
+    // route() no longer reads the retired env at all, so the old entrypoint scrub is gone with it.
     const adapters = opts.adapters ?? allAdapters();
     const health = readDoctor(repoRoot) ?? (await probeAll(adapters));
     const driver = opts.driver ?? new SubprocessDriver();

package/package.json

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