tickmarkr 1.59.0 → 1.60.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/prefer/floor precedence, review and consult steering syntax,
+provenance rules, and `--quality` / `--mode` flags are documented in
+**[FLEET.md](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](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](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,19 @@ 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(", ")}` : "";
+};
 const shortGoal = (goal, max) => {
     const clause = goal.split(/[,;.?!]/, 1)[0].trim();
     if (clause.length <= max)
@@ -193,19 +200,22 @@ 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)).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 statusCell = stWord +
             (label ? (label === " starved" ? fail(label) : dim(label)) : "") +
-            " ".repeat(stW - (String(st) + label).length);
+            (f.length ? dim(" · ") + fail(f.join(", ")) : "") +
+            " ".repeat(stW - (String(st) + label + failedSuffix(states)).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/config/config.d.ts

@@ -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,28 @@ export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
 export declare function formatFleetPrint(repoRoot: string, opts?: {
     globalDir?: string;
 }): string;
+/** 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>>): string;
-export declare function serializeFleetOverlay(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
+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;
 export {};

package/dist/config/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parse, stringify } from "yaml";
+import { isMap, isScalar, isSeq, parse, parseDocument, stringify } from "yaml";
 import { z } from "zod";
 import { stateDirName } from "../graph/graph.js";
 import { SHAPES, TIERS } from "../graph/schema.js";
@@ -546,12 +546,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(),
@@ -649,6 +653,47 @@ export function formatFleetPrint(repoRoot, opts = {}) {
 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))
@@ -714,11 +759,11 @@ export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}) {
         out.tiers = tiersOut;
     return out;
 }
-export function repoOverlayYaml(overlay, provenance = {}) {
+export function repoOverlayYaml(overlay, provenance = {}, denyNotes = {}) {
     if (!Object.keys(overlay).length)
         return "";
     const fleet = fleetSubset(overlay);
-    const fleetBody = serializeFleetOverlay(fleet, provenance);
+    const fleetBody = serializeFleetOverlay(fleet, provenance, denyNotes);
     const rest = { ...overlay };
     for (const k of FLEET_OVERLAY_KEYS)
         delete rest[k];
@@ -727,25 +772,39 @@ export function repoOverlayYaml(overlay, provenance = {}) {
     const head = stringify(rest).trimEnd();
     return fleetBody ? `${head}\n${fleetBody}` : `${head}\n`;
 }
-export function serializeFleetOverlay(overlay, provenance = {}) {
+export function serializeFleetOverlay(overlay, provenance = {}, denyNotes = {}) {
     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}`);
+    // 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:");
-            if (deny.adapters !== undefined)
-                lines.push(...block({ adapters: deny.adapters }, "    "));
-            if (deny.models !== undefined)
-                lines.push(...block({ models: deny.models }, "    "));
+            lines.push(...denySeq("adapters", deny.adapters));
+            lines.push(...denySeq("models", deny.models));
         }
         if (routing.map)
             lines.push(...block({ map: routing.map }, "  "));
@@ -767,13 +826,11 @@ export function serializeFleetOverlay(overlay, provenance = {}) {
             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}`);
-                    }
+                    // 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) {
@@ -789,10 +846,20 @@ export function serializeFleetOverlay(overlay, provenance = {}) {
     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 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;
@@ -803,17 +870,15 @@ export function unifiedYamlDiff(before, after, label = "config overlay") {
             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]}`);
+        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`;
 }

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.60.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",