tickmarkr 1.58.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
 
@@ -415,11 +355,18 @@ These are optional — the CLI works standalone. Skills are repo-scoped and ship
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, the green bar (build/test/lint), and 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, the green bar (build/test/lint), and
 design invariants. Pull requests welcome; non-trivial changes should include test coverage.
 
+**Boundaries:** this repo is a squashed export of private development — each release is a verified
+snapshot, not a live mirror of every commit. Before tickmarkr 2.0, minor versions may break with every
+break noted in [CHANGELOG.md](CHANGELOG.md). Support is best effort for the latest version only;
+accepted contributions are credited via `Co-authored-by:` on the release commit. Details in
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## 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/init.js

@@ -1,5 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
@@ -61,7 +62,7 @@ function nextSteps(cwd, scaffoldedSpec) {
     return `next: edit ${scaffoldedSpec}, then tickmarkr compile ${scaffoldedSpec} && tickmarkr plan && tickmarkr run`;
 }
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
-const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
+const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto", "tickmarkr-overseer"];
 const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
 const DOCS_END = "<!-- tickmarkr:agent-docs end -->";
 const AGENT_DOCS = `${DOCS_BEGIN}
@@ -110,9 +111,16 @@ A run is green only when the run-end event exists in the journal AND tip verify
 When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the target pane afterward; never report "relayed" without read-back.
 ${DOCS_END}
 `;
-const skillsRoot = (cwd) => existsSync(join(cwd, ".claude", "skills")) ? join(cwd, ".claude", "skills") : join(cwd, ".agents", "skills");
-const skillPath = (cwd, skill) => join(skillsRoot(cwd), skill, "SKILL.md");
-const skillsInstalled = (cwd) => AGENT_SKILLS.every((s) => existsSync(skillPath(cwd, s)));
+// Every applicable host location gets the skills, each paired with its own repository guidance
+// file: codex discovers .agents/skills + AGENTS.md (always applicable); claude discovers
+// .claude/skills + CLAUDE.md (applicable when the repo already shows claude usage).
+const hostTargets = (cwd) => {
+    const targets = [{ skillsDir: join(cwd, ".agents", "skills"), docPath: join(cwd, "AGENTS.md") }];
+    if (existsSync(join(cwd, ".claude")) || existsSync(join(cwd, "CLAUDE.md")))
+        targets.push({ skillsDir: join(cwd, ".claude", "skills"), docPath: join(cwd, "CLAUDE.md") });
+    return targets;
+};
+const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
 const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : "auto";
 async function installAgentFiles(cwd, force, docs, notes) {
     const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -124,31 +132,30 @@ async function installAgentFiles(cwd, force, docs, notes) {
         return /^(?:y|yes)$/i.test((await prompt.question(`${question} [y/N] `)).trim());
     };
     try {
-        for (const skill of AGENT_SKILLS) {
-            const dest = skillPath(cwd, skill);
-            const exists = existsSync(dest);
-            if (exists && !force && !(await confirm(`Overwrite ${dest}?`))) {
-                notes.push(`skipped existing ${dest}; pass --force to overwrite it`);
-                continue;
+        for (const { skillsDir, docPath } of hostTargets(cwd)) {
+            for (const skill of AGENT_SKILLS) {
+                const dest = join(skillsDir, skill, "SKILL.md");
+                const exists = existsSync(dest);
+                if (exists && !force && !(await confirm(`Overwrite ${dest}?`))) {
+                    notes.push(`skipped existing ${dest}; pass --force to overwrite it`);
+                    continue;
+                }
+                // whole skill dir, not just SKILL.md — the overseer ships its pane-watcher script
+                cpSync(fileURLToPath(new URL(`../../../skills/${skill}`, import.meta.url)), join(skillsDir, skill), { recursive: true });
+                notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
+            }
+            const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
+            if (current.includes(DOCS_BEGIN) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs begin -->`)
+                || current.includes(DOCS_END) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs end -->`)) {
+                notes.push(`kept existing tickmarkr agent docs in ${docPath}`);
+            }
+            else if (docs || await confirm(`Append tickmarkr agent docs to ${docPath}?`)) {
+                appendFileSync(docPath, `${current ? current.endsWith("\n") ? "\n" : "\n\n" : ""}${AGENT_DOCS}`);
+                notes.push(`appended tickmarkr agent docs to ${docPath}`);
+            }
+            else {
+                notes.push(`skipped agent docs for ${docPath}; pass --docs to append them`);
             }
-            mkdirSync(join(skillsRoot(cwd), skill), { recursive: true });
-            writeFileSync(dest, readFileSync(new URL(`../../../skills/${skill}/SKILL.md`, import.meta.url)), exists ? undefined : { flag: "wx" });
-            notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
-        }
-        const claude = join(cwd, "CLAUDE.md");
-        const agents = join(cwd, "AGENTS.md");
-        const docPath = existsSync(claude) || !existsSync(agents) ? claude : agents;
-        const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
-        if (current.includes(DOCS_BEGIN) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs begin -->`)
-            || current.includes(DOCS_END) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs end -->`)) {
-            notes.push(`kept existing tickmarkr agent docs in ${docPath}`);
-        }
-        else if (docs || await confirm(`Append tickmarkr agent docs to ${docPath}?`)) {
-            appendFileSync(docPath, `${current ? current.endsWith("\n") ? "\n" : "\n\n" : ""}${AGENT_DOCS}`);
-            notes.push(`appended tickmarkr agent docs to ${docPath}`);
-        }
-        else {
-            notes.push(`skipped agent docs for ${docPath}; pass --docs to append them`);
         }
     }
     finally {
@@ -183,7 +190,7 @@ async function runInitWizard(cwd) {
         let installSkills = false;
         if (!skillsInstalled(cwd)) {
             const skillsDef = existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd);
-            installSkills = await askYesNo(rl, "Install agent skills (tickmarkr-loop/tickmarkr-auto)?", skillsDef);
+            installSkills = await askYesNo(rl, "Install agent skills (tickmarkr-loop/tickmarkr-auto/tickmarkr-overseer)?", skillsDef);
         }
         return { overlay: { driver, concurrency, visibility: { llm } }, installSkills };
     }

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.58.0",
+  "version": "1.60.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
@@ -31,6 +31,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "lint": "oxlint src tests scripts",
+    "pretest": "npm run build",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "schema": "tsx scripts/emit-schema.ts",

package/skills/tickmarkr-auto/SKILL.md

@@ -14,7 +14,9 @@ When working in a multi-agent terminal environment, decide your role before star
 
 - **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
 - **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
-- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty — dim ghost-text suggestions are UI, not queued input; ANSI-verify before alarming) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with your host's launch form, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty — dim ghost-text suggestions are UI, not queued input; ANSI-verify before alarming) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
+  - **Claude Code:** `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions`
+  - **Codex:** `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --ask-for-approval never --sandbox workspace-write`
 
 Outside a multi-agent terminal environment, run the loop directly.
 

package/skills/tickmarkr-loop/SKILL.md

@@ -13,7 +13,9 @@ When working in a multi-agent terminal environment, decide your role before star
 
 - **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
 - **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
-- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has [stood down](#stand-down-mission-end-and-retirement) and close its tab.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with your host's launch form, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has [stood down](#stand-down-mission-end-and-retirement) and close its tab.
+  - **Claude Code:** `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions`
+  - **Codex:** `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --ask-for-approval never --sandbox workspace-write`
 
 Outside a multi-agent terminal environment, run the loop directly.
 

package/skills/tickmarkr-overseer/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: tickmarkr-overseer
+description: "Use when the user asks to oversee/supervise/babysit an autonomous tickmarkr run in a Herdr workspace (e.g. '/tickmarkr-overseer run the milestone', 'supervise this tickmarkr run', 'babysit this pipeline'). Requires HERDR_ENV=1. The skill argument is the mission (what to run end-to-end)."
+---
+
+# Overseer (tickmarkr)
+
+Become the OVERSEER for this workspace. Do no heavy work directly — build and supervise a two-tier
+hierarchy of VISIBLE agents (you → orchestrator → tickmarkr's own worker fleet), and route human decisions
+to the user with evidence.
+
+The mission is the skill argument. If empty, ask the user what to run end-to-end before doing anything else.
+Requires `HERDR_ENV=1`; if unset, say so and stop.
+
+## Setup
+
+0. **Adopt before you build.** If this workspace already has a supervision hierarchy — an
+   OVERSEER/ORCHESTRATOR tab, a live agent named `*orch*`, or a `<repo>/<state-dir>/overseer/` dir
+   (state dir = `.tickmarkr/`; legacy standalone `<repo>/.overseer/` counts
+   too) — do NOT spawn a duplicate (two orchestrators risk two concurrent tickmarkr runs in one repo,
+   which tickmarkr forbids). Read that dir's `DECISIONS.md` + `ORCH-BRIEF.md`, check the existing agents'
+   status, and either ADOPT the
+   existing orchestrator (updated brief, re-armed watchers) or, if the old hierarchy is dead, archive the
+   stale brief and build fresh.
+1. Load the `herdr` skill. `herdr pane list` to map the workspace — the focused pane is yours. Rename your
+   tab OVERSEER; create ONE tab ORCHESTRATOR.
+   **Live tab labels (standing operator rule, 2026-07-12):** on every decision or state change (role
+   handoff, task done/merged, run end) rename the affected tabs — and keep labels SHORT: the role as the
+   main name plus at most ONE hot-state token. Vocabulary: ORCH carries the milestone and progress
+   fraction (`ORCH · v1.19 4/5`, updated on every task-done); WORKERS carries the task token (tickmarkr
+   updates it). Never long context strings or ✓-chains.
+2. **Orchestrator**: Launch the orchestrator with your agent host. For Claude Code, use `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions` (pin a strong model with `--model <m>` if the operator has a policy). For Codex, use `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --ask-for-approval never --sandbox workspace-write` (add `--model <m>` to specify the model). Workers you never spawn — tickmarkr spawns its own visible worker panes.
+3. **Standing instructions travel as a brief FILE, never as pane text** — PTY input truncates at ~1024B and a
+   truncated brief silently drops policy. Write the full brief to `<repo>/.tickmarkr/overseer/ORCH-BRIEF.md`
+   (inside the tickmarkr state dir — already self-gitignored, no exclude step needed), then send one line:
+   `herdr pane run <orch> "Read .tickmarkr/overseer/ORCH-BRIEF.md and follow it exactly."` The brief MUST contain: the
+   mission, the pane mechanics below, rules 1–2, and require a verbatim one-sentence acknowledgment of the
+   human-checkpoint rule before anything is dispatched. Delete the dir at mission end.
+4. Arm the watcher (Supervision). Report the hierarchy map (pane ids + names) to the user.
+
+## Supervising tickmarkr as the executor
+
+When the mission runs `/tickmarkr-auto` (tickmarkr dispatches the workers), supervision changes shape:
+
+- **Give the run a live surface.** `tickmarkr run` is stdout-silent until run-end by design — split a pane in the
+  ORCHESTRATOR tab running `tickmarkr status --watch`. Narration also arrives as herdr notifications.
+- **Watch the journal, not the panes.** The append-only journal
+  (`.tickmarkr/runs/<runId>/journal.jsonl`) is the
+  source of truth. Arm a background watcher on `run-end` / `task-human` / `task-failed` / `consult-verdict`
+  events; never sleep-poll inside an agent turn.
+- **Daemon liveness ≠ journal activity.** A dead daemon emits no events, so journal watchers sleep through
+  its death. `tickmarkr status` prints last-event age + daemon pid liveness; check it before diagnosing a stall.
+  Recovery is `tickmarkr resume <runId>` — crash-safe by design (journal replay restores attempt counts and
+  consult channel bans).
+- **Gate quiet ≠ idle.** Between `worker-result` and the batched `gate-result`s tickmarkr runs shell gates plus a
+  headless LLM judge/review with little visible signal — check the journal timestamps before intervening.
+- **Classify gate failures before reacting.** The same fingerprint failing across DIFFERENT workers, or a
+  scope/test catch-22 (attempt N edits a file → scope gate fails; attempt N+1 leaves it → test gate fails),
+  is a PLAN defect: widen `files_modified` in the phase PLAN, recompile the phase dir after the run ends or
+  the task parks, release (`human → pending`), resume. A cross-vendor review rejection with concrete findings
+  is a REAL defect — let the escalation ladder work.
+- **Dialog watchers go stale per attempt.** Every retry/escalation may spawn a new pane; re-arm dialog
+  watchers on each `task-dispatch` journal event.
+
+## Pane mechanics that bite
+
+- **Verified send protocol**: `herdr agent send` writes WITHOUT Enter, and `pane run`'s Enter can be swallowed
+  by bracketed-paste on long payloads. Robust sequence: read the pane (bare prompt required) → send-text →
+  sleep 2–3s → send-keys Enter → read back (input empty / agent `working`). Never report "briefed" without
+  the read-back. Long content goes in a brief file, never pane text.
+- **Guard-before-Enter** (race-safe prompt answering): chain with `&&` — pane get shows `blocked` && pane
+  read shows the expected option under the cursor && only then send-keys. If no longer `blocked`, someone
+  already answered; do nothing.
+- `herdr wait agent-status` exits 1 on timeout, 0 on match — but ALSO 0 (with an error JSON) when the pane is
+  GONE. Never chain `wait && act` without confirming the pane exists.
+- Stale typed input is unclearable via CLI — supersede it:
+  `pane run "<-- disregard everything before this arrow (stale draft). ACTUAL: <message>"`.
+
+## Supervision watcher
+
+Arm the bundled watcher as its OWN Bash call with `run_in_background` — chaining it after other commands
+with `&` orphans it from the wake chain. It prints one wake reason and exits; re-arm after every wake.
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-panes.sh WORKER_PANE ORCH_PANE [--fast-blocked]
+```
+
+Default mode wakes only when both panes are quiet (dropped handoff) or the orchestrator blocks; the
+orchestrator gets a 90s grace window to handle worker blocks first. For long parked stretches a targeted
+`herdr wait agent-status <pane> --status <s> --timeout <ms>` beats the watcher. When parking a human
+checkpoint, also fire `herdr notification show "HUMAN CHECKPOINT: <gate>" --sound request`.
+
+## Specialist pipeline rules
+
+- **Dedicated consultant tab**: Consultants (agents spawned to gather synthesis input for decisions like SCOPER analysis or architectural reviews) must run in a DEDICATED tab separate from the ORCHESTRATOR tab. When the orchestrator stands down, the consultant panes should persist so their assessments remain available for review and reference.
+- **Scoper worktree rule**: The SCOPER (or any worktree-based specialist synthesizing into the spec pipeline) must do ALL git operations in a dedicated worktree (e.g., `git worktree add /private/tmp/tkr-scoper-v155 -b spec/...`), never switching the main checkout's branch. This prevents race conditions between the specialist's branch operations and the orchestrator's shipping logic.
+
+## Non-negotiable rules
+
+1. **Takeover rule**: only act on a worker if it needs input AND the orchestrator is not `working`.
+2. **Human checkpoints (absolute)**: any gate marked `autonomous: false` or asking for product/visual
+   sign-off is NEVER auto-answered — regardless of how obviously correct the highlighted option looks. Leave
+   it blocked and bring the user the decision WITH evidence. If the mission explicitly delegates authority,
+   routine-class gates may be overseer-decided after polling the operator first — but spend and ship gates
+   NEVER self-decide.
+3. **Trust disk over transcripts**: verify artifacts on disk before building on them; a subagent killed
+   mid-flight still renders "Done" without writing its artifact.
+4. **Report concisely on every state change**: what happened, who handled it, what's next. Lead with the
+   outcome. Surface product decisions; never make them.
+5. **Log every abnormality** to `.planning/OBSERVATIONS.md` (or the project's ledger), even mid-run.

package/skills/tickmarkr-overseer/scripts/watch-panes.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# watch-panes.sh — Herdr overseer watcher.
+# Polls worker + orchestrator agent_status via `herdr pane get`, prints ONE wake
+# reason to stdout, then exits. Run it via the Bash tool with run_in_background
+# so the overseer is re-invoked when it fires. Re-run (re-arm) after every wake.
+#
+# Usage:
+#   watch-panes.sh WORKER_PANE ORCH_PANE [--fast-blocked] [--cap-seconds N] [--settle-seconds N]
+#
+# Options:
+#   --fast-blocked     Wake fast (20s debounce) whenever the WORKER blocks, even
+#                      if the orchestrator is working. Use during stretches with
+#                      human checkpoints. Without it, a blocked worker gets a 90s
+#                      grace window for the orchestrator to handle it first
+#                      (takeover rule), and only wakes if BOTH panes are quiet.
+#   --cap-seconds N    Max watch duration (default 14400 = 4h).
+#   --settle-seconds N Initial sleep before polling (default 60) so a
+#                      just-dispatched turn can start without an instant refire.
+#
+# Wake reasons printed:
+#   WORKER_PANE_GONE / ORCH_PANE_GONE   — a pane disappeared
+#   ORCH:blocked WORKER:<s>             — orchestrator itself needs input
+#   WORKER:blocked ORCH:<s>             — worker blocked (fast-blocked mode)
+#   WORKER:<s> ORCH:<s>                 — both quiet: dropped handoff / done
+#   WATCH_CAP_REACHED ...               — cap hit, everything still working
+set -u
+WORKER="${1:?worker pane id required}"
+ORCH="${2:?orchestrator pane id required}"
+shift 2
+FAST_BLOCKED=false
+CAP=14400
+SETTLE=60
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --fast-blocked) FAST_BLOCKED=true ;;
+    --cap-seconds) CAP="$2"; shift ;;
+    --settle-seconds) SETTLE="$2"; shift ;;
+  esac
+  shift
+done
+
+get_status() {
+  herdr pane get "$1" 2>/dev/null | python3 -c '
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    p = d.get("result", {}).get("pane", d.get("result", {}))
+    print(p.get("agent_status", "unknown"))
+except Exception:
+    print("gone")
+' 2>/dev/null || echo gone
+}
+
+# Transient CLI/server failures also read as "gone" — recheck before declaring.
+confirmed_gone() {
+  sleep 5
+  [ "$(get_status "$1")" = "gone" ]
+}
+
+END=$((SECONDS + CAP))
+sleep "$SETTLE"
+while [ $SECONDS -lt $END ]; do
+  WS=$(get_status "$WORKER")
+  OS=$(get_status "$ORCH")
+  if [ "$WS" = "gone" ]; then
+    confirmed_gone "$WORKER" && { echo "WORKER_PANE_GONE ORCH:$(get_status "$ORCH")"; exit 0; }
+    continue
+  fi
+  if [ "$OS" = "gone" ]; then
+    confirmed_gone "$ORCH" && { echo "ORCH_PANE_GONE WORKER:$(get_status "$WORKER")"; exit 0; }
+    continue
+  fi
+  # orchestrator itself stuck on a prompt (debounced)
+  if [ "$OS" = "blocked" ]; then
+    sleep 15
+    [ "$(get_status "$ORCH")" = "blocked" ] && { echo "ORCH:blocked WORKER:$WS"; exit 0; }
+  fi
+  # human-checkpoint mode: wake fast on any persisting worker block
+  if $FAST_BLOCKED && [ "$WS" = "blocked" ]; then
+    sleep 20
+    [ "$(get_status "$WORKER")" = "blocked" ] && { echo "WORKER:blocked ORCH:$(get_status "$ORCH")"; exit 0; }
+  fi
+  # standard mode: worker needs attention AND orchestrator is not driving
+  if [ "$WS" != "working" ]; then
+    sleep 90
+    WS2=$(get_status "$WORKER"); OS2=$(get_status "$ORCH")
+    if [ "$WS2" != "working" ] && [ "$OS2" != "working" ]; then
+      echo "WORKER:$WS2 ORCH:$OS2"; exit 0
+    fi
+  fi
+  sleep 20
+done
+echo "WATCH_CAP_REACHED WORKER:$(get_status "$WORKER") ORCH:$(get_status "$ORCH")"