tickmarkr 1.34.0 → 1.36.0

package/README.md

@@ -8,11 +8,15 @@ gates) only after independent verification. An **engagement** (`tickmarkr run`)
 into a task graph, routes work to the best installed agent CLI (claude-code, codex, cursor-agent,
 opencode, grok, pi) by cost within capability floors, dispatches **field teams** in isolated git
 worktrees — as real visible TUIs when running under [herdr](https://herdr.dev), headless
-subprocesses otherwise — and records every event in the **audit trail** (`.drovr/runs/<runId>/journal.jsonl`).
+subprocesses otherwise — and records every event in the **audit trail** (engagement state directory).
 Green tasks consolidate onto a `tickmarkr/<runId>` **consolidation** branch; **sign-off** (merge to
 your mainline) is always the Partner's call, never the engine's. A fully green engagement is an
 **unqualified opinion** — every assertion independently ticked.
 
+<!-- tickmarkr:compat-legacy BEGIN: sanctioned naming residue, unchanged pending shim spec -->
+**Legacy naming (unchanged):** tickmarkr reads existing state from `.drovr/` directories and resumes runs with legacy `drovr/<runId>` branch names recorded in their journals; new engagements write to `tickmarkr/<runId>`. Environment variables `DROVR_*` remain unchanged (e.g., `DROVR_FAKE_SCRIPT`, `DROVR_E2E`). Spec markers use the historical `<!-- drovr:spec -->` comment. These names are pending formalization in a future shim spec; no action required — existing runs and configurations remain fully compatible.
+<!-- tickmarkr:compat-legacy END -->
+
 > The package ships `tickmarkr` and `tkr` only; `tkr` is the short alias.
 
 ## Vocabulary
@@ -30,7 +34,7 @@ Audit voice in docs and reports maps to engine concepts exactly once:
 | assertion | Acceptance criterion (`acceptance[]` entry) |
 | tickmark | Passed gate |
 | audit evidence | Evidence gate (commits/diff exist) |
-| audit trail | Journal (`.drovr/runs/<runId>/journal.jsonl`) |
+| audit trail | Journal (engagement event ledger) |
 | the consolidation | Integration branch (`tickmarkr/<runId>`) |
 | sign-off / issuance | Merge consolidation branch to main |
 | unqualified opinion | Green engagement (all tasks merged) |
@@ -46,11 +50,11 @@ These are law; the codebase fails closed around them:
 
 - `acceptance[]` required on every task; compile fails without it
 - new engagements consolidate to a `tickmarkr/<runId>` branch — never main (resume of older
-  engagements keeps the branch names recorded in their journal, including legacy `drovr/<runId>`)
+  engagements keeps the branch names recorded in their journal)
 - gates never trust worker claims; tickmarkr verifies everything itself
-- state is files + git only (`.drovr/`); no DB, no services
+- state is files + git only; no DB, no services
 - worker/judge/review/consult prompts end with machine-parseable trailers
-  (`DROVR_RESULT` / JSON verdicts); parse defensively, fail closed
+  (structured JSON verdicts); parse defensively, fail closed
 
 Any agent (or human) operating this repo must respect the same five rules above — they are not
 merely internal implementation details, they are the contract the gates enforce.
@@ -86,9 +90,9 @@ at 30s.
 ## Quickstart (5 minutes)
 
 ```bash
-tickmarkr init                 # guided setup + doctor; scaffolds .drovr/config.yaml and tickmarkr.spec.md
-# edit tickmarkr.spec.md        # the native spec template, marked <!-- drovr:spec -->
-tickmarkr compile tickmarkr.spec.md # spec → .drovr/graph.json (fails without acceptance criteria)
+tickmarkr init                 # guided setup + doctor; scaffolds config and spec template
+# edit tickmarkr.spec.md        # the native spec template
+tickmarkr compile tickmarkr.spec.md # spec → engagement graph (fails without acceptance criteria)
 tickmarkr plan                 # dry-run routing table + cost estimate + floor lints
 tickmarkr run                  # execute the graph (--concurrency N --driver herdr|subprocess --route-strict)
 tickmarkr report <runId> --md  # engagement record in Markdown
@@ -170,7 +174,7 @@ cursor-agent and claude-code entirely.
 
 ## Model scoping and auth detection
 
-Each agent CLI exposes a list of available models. tickmarkr's routing works only with **classified** models — those you explicitly enter into `.drovr/config.yaml` under `tiers`. The `tickmarkr doctor` command probes these models to detect auth status and records the results in `.drovr/doctor.json`, which routing consumes to avoid 401/403 dispatch failures.
+Each agent CLI exposes a list of available models. tickmarkr's routing works only with **classified** models — those you explicitly enter into the config under `tiers`. The `tickmarkr doctor` command probes these models to detect auth status and records the results, which routing consumes to avoid 401/403 dispatch failures.
 
 **Model terminology**:
 
@@ -180,7 +184,7 @@ Each agent CLI exposes a list of available models. tickmarkr's routing works onl
 
 When you run `tickmarkr doctor`, it:
 1. Probes each classified model exactly once (one minimal headless API call per model per adapter)
-2. Records results in `.drovr/doctor.json`: `authed: true` or `authed: false` with the failure reason and probe timestamp
+2. Records results locally: `authed: true` or `authed: false` with the failure reason and probe timestamp
 3. Prints a model-status table for classified models only, showing tier, auth verdict, denial status, and prefer rank
 
 **Routing and auth**:
@@ -206,9 +210,9 @@ routing:
 ## Run output and narration
 
 When you execute `tickmarkr run`, the daemon streams live narration of each audit-trail event to stdout — task status changes,
-gate results (tickmarks), worker dispatch, and merge commits. This narration is derived from the append-only `.drovr/runs/<runId>/journal.jsonl`
-ledger, which remains the authoritative source of truth for resumability. If an engagement is interrupted, `tickmarkr resume <runId>`
-replays the journal and picks up where it left off. You can also tail the journal directly for raw event inspection or
+gate results (tickmarks), worker dispatch, and merge commits. This narration is derived from the append-only event ledger,
+which remains the authoritative source of truth for resumability. If an engagement is interrupted, `tickmarkr resume <runId>`
+replays the ledger and picks up where it left off. You can also tail the ledger directly for raw event inspection or
 feed it to external tools; the narration is a convenience layer on top.
 
 ## Usage and cost
@@ -235,7 +239,7 @@ and first-attempt success rate. Cost reporting follows strict honesty rules and
 - **Ranges, never single numbers**: quota multipliers and monthly-window variation make subscription costs a range, not a point estimate
 - **"Not measurable" never becomes $0**: if a channel lacks pricing or metering data, the report explicitly states "not measurable"
 - **Basis always shown**: every cost figure prints the token count, rate used, and date so estimates can be audited
-- **No network calls**: pricing config is operator-maintained in `.drovr/config.yaml` (or `~/.config/tickmarkr/config.yaml`; legacy `~/.config/drovr` still read), seeded with dated
+- **No network calls**: pricing config is operator-maintained locally, seeded with dated
   comments and LiteLLM's JSON file named as the copy-from source; tickmarkr never calls home to fetch rates
 - **Attribution from journal**: token counts come from tickmarkr's own telemetry spans in the audit trail, never from provider invoices or dashboards
 
@@ -323,11 +327,11 @@ produced the graph. Upstream, these front-ends exist:
 
 | Spec source | Support | How |
 |---|---|---|
-| **tickmarkr spec** (native format) | Native/default | `tickmarkr init` template with the `<!-- drovr:spec -->` marker |
+| **tickmarkr spec** (native format) | Native/default | `tickmarkr init` template with native spec marker |
 | **Spec Kit** feature dir | Native | dir containing `tasks.md` |
 | **GSD** phase dir | Native | dir containing `*-PLAN.md` |
 | **Markdown PRD** | Native (universal adapter) | any `.md` with tasks + acceptance criteria |
-| OpenSpec, BMAD, Superpowers, others | Not yet | render to a tickmarkr spec (the `<!-- drovr:spec -->` marker plus the full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
+| OpenSpec, BMAD, Superpowers, others | Not yet | render to a tickmarkr spec (with full Task surface), or contribute a front-end: one parser module behind `src/compile/index.ts`, same pattern as `gsd.ts` |
 
 Compile fails loudly on anything it can't recognize (`--type native|speckit|prd|gsd` to force).
 
@@ -393,10 +397,9 @@ npm run test:coverage  # same suite, coverage floors enforced (see below)
 npm run e2e            # opt-in real-CLI end-to-end — DOES spend tokens, needs ≥1 agent CLI installed
 ```
 
-`npm test` and `npm run test:coverage` must never call a real agent CLI or spend tokens — that's
-what `DROVR_FAKE_SCRIPT` and the `FakeAdapter` (`src/adapters/fake.ts`) exist for. If a change
-needs a real CLI to verify, that test belongs under `npm run e2e` (`tests/e2e/`), gated behind
-`DROVR_E2E=1`, never in the default suite.
+`npm test` and `npm run test:coverage` must never call a real agent CLI or spend tokens —
+test isolation uses deterministic fixtures. If a change needs a real CLI to verify, that test
+belongs under `npm run e2e` (`tests/e2e/`), an opt-in test suite not run in CI.
 
 Coverage floor: `src/{graph,route,gates,run}/**` must stay at lines 80% / functions 80% /
 branches 70% — this is the CLAUDE.md invariant, enforced verbatim in `vitest.config.ts`.
@@ -432,7 +435,7 @@ behavior) are logged as a numbered entry (`OBS-NN`) in `.planning/OBSERVATIONS.m
 That file is the standing abnormality ledger for this repo — read it before assuming a rough edge
 is new.
 
-Design spec: `docs/superpowers/specs/2026-07-07-drover-design.md`.
+See the design spec in docs/superpowers/specs/.
 
 ## License
 

package/dist/adapters/claude-code.js

@@ -38,6 +38,7 @@ export function probeVersion(bin) {
 export const claudeCode = {
     id: "claude-code",
     vendor: "anthropic",
+    probeCwd: "neutral",
     probe: async () => probeVersion("claude"),
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree
@@ -49,15 +50,15 @@ export const claudeCode = {
     // Gotchas (both bit the 2026-07-10 live check): bare '{}' is REJECTED ("mcpServers: expected record"),
     // and --mcp-config is VARIADIC — a positional after it is eaten as a config-file path, so another
     // flag must always follow the value, never the prompt.
-    headlessCommand: (promptFile, model) => `claude -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --permission-mode acceptEdits --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text`,
+    headlessCommand: (promptFile, model) => `claude -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --permission-mode bypassPermissions --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text`,
     // HYG-03: the residual first-entry dialog on an interactive TUI is the workspace TRUST dialog (not MCP
     // config loading) — CLI-imposed, no flag to pre-accept, only store is claude's global last-writer-wins
     // ~/.claude.json keyed on the exact path. Closed WON'T-FIX (decision B, 2026-07-10): drovr writes nothing
     // to that file (a seed races claude's own writes, nondeterministically). Amortizes to one operator dismissal
     // per stable worktree path; blocked-pane paging surfaces it. Do NOT change this command to "fix" the dialog —
     // see .planning/REQUIREMENTS.md HYG-03 and 21-02-LIVE-CHECK.md. Revisit if upstream ships a --trust flag.
-    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode acceptEdits "$(cat ${shq(promptFile)})"`,
-    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode acceptEdits "$(cat ${shq(promptFile)})"`,
+    interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

package/dist/adapters/grok.js

@@ -83,6 +83,7 @@ export const grok = {
     // FLEET-04 cross-vendor honesty: xai is diversity-distinct from anthropic/openai/cursor/zhipu.
     // MUST equal tiers.grok.vendor (a test pins the equality).
     vendor: "xai",
+    probeCwd: "neutral",
     probe: async () => {
         const h = probeVersion("grok");
         if (!h.installed)

package/dist/adapters/model-lints.d.ts

@@ -1,14 +1,17 @@
-import type { DrovrConfig } from "../config/config.js";
+import { type DrovrConfig } from "../config/config.js";
 import { type AuthHealth, type WorkerAdapter } from "./types.js";
 export declare const SEED_STAMPED = "2026-07-09";
 export declare const MODEL_STALE_DAYS = 30;
 export declare const ttyVisual: () => boolean;
+export declare function seedPreferLints(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
 export declare function modelLints(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;
+    stateDir?: string;
+    overlayPreferShapes?: ReadonlySet<string>;
 }): string[];
 export declare function formatModelAuthLine(excluded: {
     key: string;
     reason: string;
     probedAt: string;
-}[], tty?: boolean): string;
-export declare function suggestOverlay(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): string;
+}[], tty?: boolean, stateDir?: string): string;
+export declare function suggestOverlay(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], stateDir?: string): string;

package/dist/adapters/model-lints.js

@@ -1,3 +1,4 @@
+import { DEFAULT_CONFIG, TIER_RANK } from "../config/config.js";
 import { MODEL_ID_RE } from "./types.js";
 // date the tiers seeds were last live-verified (Phase 6/7 reseed) — surfaced when an adapter has no list surface.
 export const SEED_STAMPED = "2026-07-09";
@@ -10,14 +11,43 @@ const DAY_MS = 86400000;
 const LINT_VARIANT_RE = /^auto$|-(fast|minimal|low|medium|high|xhigh)$/;
 const LINT_CAP = 5;
 const TTY_LINT_CAP = 3;
-const DOCTOR_JSON_REF = " — see .drovr/doctor.json";
+const DEFAULT_STATE_DIR = ".drovr";
+const doctorJsonRef = (stateDir) => ` — see ${stateDir}/doctor.json`;
 export const ttyVisual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const adapterHasAuthedChannel = (adapterId, shape, cfg, health, adapters) => {
+    const entry = cfg.routing.map[shape];
+    const minTier = entry?.tier ?? cfg.routing.floors[shape] ?? "cheap";
+    const a = adapters.find((x) => x.id === adapterId);
+    const h = health[adapterId];
+    if (!a || !h?.installed || typeof a.channels !== "function")
+        return false;
+    if (!h.modelAuth || !Object.keys(h.modelAuth).length)
+        return true; // no per-model probe data — compat, not dead
+    return a.channels(cfg).some((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier] && h.modelAuth?.[c.model]?.authed === true);
+};
+// OBS-30 T2: warn when a built-in seed prefer names an adapter with zero authed channels this probe pass.
+export function seedPreferLints(cfg, health, adapters, overlayPreferShapes = new Set()) {
+    const lints = [];
+    for (const shape of Object.keys(cfg.routing.map)) {
+        if (overlayPreferShapes.has(shape))
+            continue;
+        for (const p of DEFAULT_CONFIG.routing.map[shape]?.prefer ?? []) {
+            const adapterId = p.includes(":") ? p.slice(0, p.indexOf(":")) : p;
+            if (!cfg.tiers[adapterId])
+                continue;
+            if (!adapterHasAuthedChannel(adapterId, shape, cfg, health, adapters)) {
+                lints.push(`routing seed names dead adapter '${adapterId}' for shape '${shape}' — auto-prefer is routing around it`);
+            }
+        }
+    }
+    return lints;
+}
 // Diffs detected models (doctor.json) against configured tiers, both directions, per adapter id in cfg.tiers.
 // No `  ! ` prefix here — the consumer (doctor rows / plan lints) owns that. Pre-v1.5 doctor.json (models:[], no
 // modelsDetectedAt) is the compat baseline: `?.`/`?? []` everywhere, no zod (would reject old files).
 export function modelLints(cfg, health, adapters, opts) {
     const cap = opts?.tty ? TTY_LINT_CAP : LINT_CAP;
-    const doctorRef = opts?.tty ? DOCTOR_JSON_REF : "";
+    const doctorRef = opts?.tty ? doctorJsonRef(opts.stateDir ?? DEFAULT_STATE_DIR) : "";
     const lints = [];
     for (const id of Object.keys(cfg.tiers)) {
         const adapter = adapters.find((a) => a.id === id);
@@ -53,18 +83,19 @@ export function modelLints(cfg, health, adapters, opts) {
                 lints.push(`${id}: model knowledge is ${days} days old — rerun tickmarkr doctor`);
         }
     }
+    lints.push(...seedPreferLints(cfg, health, adapters, opts?.overlayPreferShapes));
     return lints;
 }
 // T2/T6: one lint per exclusion, naming the probe reason and date. TTY truncates reasons to 60 chars and
 // points at doctor.json for the full text; non-TTY is byte-identical to the pre-T6 registry helper.
-export function formatModelAuthLine(excluded, tty) {
+export function formatModelAuthLine(excluded, tty, stateDir = DEFAULT_STATE_DIR) {
     const trunc = (s, n) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
     const parts = excluded.map(({ key, reason, probedAt }) => {
         const r = tty ? trunc(reason, 60) : reason;
         return `${key} (${r} — probed ${probedAt.split("T")[0]})`;
     });
     const base = `model auth: ${excluded.length} channel(s) unauthed — ${parts.join(", ")}`;
-    return tty ? `${base}${DOCTOR_JSON_REF}` : base;
+    return tty ? `${base}${doctorJsonRef(stateDir)}` : base;
 }
 // MODEL-05/06: render detected-vs-configured drift as a paste-ready config.yaml fragment. Locked v1.5
 // decision: detection is strictly advisory — doctor prints, a human pastes; NO --write/--apply exists.
@@ -72,7 +103,7 @@ export function formatModelAuthLine(excluded, tty) {
 // machine never fabricates one — auto-tiering reopens the NaN-routing class). Removals render as LIVE
 // `<id>: null` tombstones (deepMerge deletes the key). Pure function: no fs, no routing contact.
 // Returns "" when no adapter has a delta. Mirrors modelLints' per-adapter guards exactly.
-export function suggestOverlay(cfg, health, adapters) {
+export function suggestOverlay(cfg, health, adapters, stateDir = DEFAULT_STATE_DIR) {
     const blocks = [];
     for (const id of Object.keys(cfg.tiers)) {
         const adapter = adapters.find((a) => a.id === id);
@@ -116,13 +147,13 @@ export function suggestOverlay(cfg, health, adapters) {
             lines.push(`      # ${model}: ???   #${date ? ` detected ${date} —` : ""} classify per benchmark policy (AA Index + SWE-bench Pro, dated), then uncomment`);
         }
         if (omitted)
-            lines.push(`      # (+${omitted} other detected id${omitted === 1 ? "" : "s"} not related to your configured models — see .drovr/doctor.json)`);
+            lines.push(`      # (+${omitted} other detected id${omitted === 1 ? "" : "s"} not related to your configured models — see ${stateDir}/doctor.json)`);
         if (lines.length)
             blocks.push(`  ${id}:\n    models:\n${lines.join("\n")}`);
     }
     if (blocks.length === 0)
         return "";
-    return `# paste into .drovr/config.yaml — drovr prints this, it never applies it\ntiers:\n${blocks.join("\n")}\n`;
+    return `# paste into ${stateDir}/config.yaml — tickmarkr prints this, it never applies it\ntiers:\n${blocks.join("\n")}\n`;
 }
 // Purely relational id split for the addition gate (see suggestOverlay). Local, not exported: this is NOT a
 // global identity concept — src/gates/review.ts has its own local modelId(), deliberately not shared.

package/dist/adapters/opencode.js

@@ -16,6 +16,7 @@ export function parseOpencodeModels(raw) {
 export const opencode = {
     id: "opencode",
     vendor: "mixed",
+    probeCwd: "neutral",
     probe: async () => probeVersion("opencode"),
     channels: (cfg) => channelsFromConfig("opencode", cfg),
     headlessCommand: (promptFile, model) => `opencode run -m ${shq(model)} "$(cat ${shq(promptFile)})"`,

package/dist/adapters/pi.js

@@ -37,6 +37,7 @@ export const pi = {
     // FLEET-04: cross-vendor review honesty — GLM's provider (pi's own label is "zai"; either is
     // diversity-distinct from anthropic/openai/cursor/mixed). Must equal tiers.pi.vendor.
     vendor: "zhipu",
+    probeCwd: "neutral",
     probe: async () => {
         const h = probeVersion("pi");
         if (!h.installed)

package/dist/adapters/registry.d.ts

@@ -1,4 +1,5 @@
-import type { DrovrConfig } from "../config/config.js";
+import { type DrovrConfig } from "../config/config.js";
+import { type RoutingProfile } from "../route/profile.js";
 import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
 export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
@@ -7,6 +8,21 @@ export declare function getAdapter(id: string, adapters: WorkerAdapter[]): Worke
 export declare function probeAll(adapters: WorkerAdapter[]): Promise<Record<string, AuthHealth>>;
 export type ProbeModelStatus = "ok" | "timeout" | "failed";
 export type ProbeModelProgress = (adapter: string, model: string, status: ProbeModelStatus, durationMs: number) => void;
+export interface AutoPreferDoc {
+    derivedAt: string;
+    [shape: string]: string[] | string;
+}
+export declare const pendingAutoPreferKey: unique symbol;
+export declare const DOCTOR_ROUTING_STALE_MS: number;
+export declare function deriveAutoPrefer(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, profile?: RoutingProfile): AutoPreferDoc;
+export declare function readAutoPrefer(repoRoot: string): AutoPreferDoc | null;
+export declare function routingPreferContext(repoRoot: string, cfg: DrovrConfig, opts?: {
+    globalDir?: string;
+}): {
+    autoPrefer?: AutoPreferDoc;
+    doctorFresh: boolean;
+    overlayPreferShapes: ReadonlySet<string>;
+};
 export declare function probeModels(cfg: DrovrConfig, repoRoot: string, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, onProgress?: ProbeModelProgress): Promise<void>;
 export declare function writeDoctor(repoRoot: string, health: Record<string, AuthHealth>): void;
 export declare function readDoctor(repoRoot: string): Record<string, AuthHealth> | null;

package/dist/adapters/registry.js

@@ -1,10 +1,13 @@
 import { existsSync, mkdtempSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { overlayPreferShapes, TIER_RANK } from "../config/config.js";
 import { modelLints, suggestOverlay } from "./model-lints.js";
 import { HerdrDriver } from "../drivers/herdr.js";
 import { drovrDir, stateDirName } from "../graph/graph.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../route/preference.js";
+import { learnedScore } from "../route/profile.js";
+import { marginalCostRank } from "../route/router.js";
 import { sh } from "../run/git.js";
 import { claudeCode } from "./claude-code.js";
 import { codex } from "./codex.js";
@@ -47,6 +50,57 @@ function probeFailure(code, stdout, stderr, timedOut, timeoutMs = MODEL_PROBE_TI
         ? output.slice(0, 240) || `probe exited ${code}`
         : undefined;
 }
+export const pendingAutoPreferKey = Symbol.for("tickmarkr.pendingAutoPrefer");
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+// ponytail: 24h TTL matches plan.ts staleness — promote to config when an operator asks.
+export const DOCTOR_ROUTING_STALE_MS = 24 * 60 * 60 * 1000;
+export function deriveAutoPrefer(cfg, adapters, health, profile) {
+    const derivedAt = new Date().toISOString();
+    const out = { derivedAt };
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        const minTier = entry?.tier ?? cfg.routing.floors[shape] ?? "cheap";
+        const ranked = [];
+        for (const a of adapters) {
+            const h = health[a.id];
+            if (!h?.installed || !h?.authed || typeof a.channels !== "function")
+                continue;
+            const qualifying = a.channels(cfg).filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier] && h.modelAuth?.[c.model]?.authed === true);
+            if (!qualifying.length)
+                continue;
+            const durations = qualifying
+                .map((c) => h.modelAuth?.[c.model]?.durationMs)
+                .filter((d) => typeof d === "number");
+            ranked.push({
+                adapter: a.id,
+                mc: Math.min(...qualifying.map(marginalCostRank)),
+                dur: durations.length ? median(durations) : Number.POSITIVE_INFINITY,
+                learned: profile ? Math.max(...qualifying.map((c) => learnedScore(profile, shape, channelKey(c), c.channel))) : 0,
+            });
+        }
+        ranked.sort((a, b) => a.mc - b.mc || a.dur - b.dur || b.learned - a.learned);
+        out[shape] = ranked.map((r) => r.adapter);
+    }
+    return out;
+}
+export function readAutoPrefer(repoRoot) {
+    const raw = readDoctorFile(repoRoot);
+    if (!raw || typeof raw.autoPrefer !== "object" || raw.autoPrefer === null)
+        return null;
+    return raw.autoPrefer;
+}
+export function routingPreferContext(repoRoot, cfg, opts = {}) {
+    const age = doctorAgeMs(repoRoot);
+    const doctorFresh = age !== null && age <= DOCTOR_ROUTING_STALE_MS;
+    return {
+        autoPrefer: doctorFresh ? readAutoPrefer(repoRoot) ?? undefined : undefined,
+        doctorFresh,
+        overlayPreferShapes: overlayPreferShapes(repoRoot, opts),
+    };
+}
 const probeModelStatus = (v) => v.authed ? "ok" : v.reason?.includes("timed out") ? "timeout" : "failed";
 // v1.21: one bounded, headless call per configured model; detected-but-unclassified models never enter this loop.
 export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
@@ -62,6 +116,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
             return;
         const verdicts = {};
         const priorModelAuth = priorHealth?.[a.id]?.modelAuth;
+        const probeRoot = a.probeCwd === "neutral" ? mkdtempSync(join(tmpdir(), "tickmarkr-probe-")) : repoRoot;
         // models probe concurrently too (v1.33.5) — sequential chains made init wall time Σ(models×60s)
         // on the slowest adapter (measured 96s); each probe is one tiny prompt, safe to overlap.
         // Capped at MODEL_PROBE_CONCURRENCY per adapter (v1.33.5 regression: 4 concurrent codex exec
@@ -78,12 +133,12 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                 else {
                     const promptFile = join(mkdtempSync(join(tmpdir(), "drovr-auth-")), "probe.md");
                     writeFileSync(promptFile, MODEL_PROBE_PROMPT);
-                    const r = await sh(a.headlessCommand(promptFile, model), repoRoot, MODEL_PROBE_TIMEOUT_MS);
+                    const r = await sh(a.headlessCommand(promptFile, model), probeRoot, MODEL_PROBE_TIMEOUT_MS);
                     if (r.timedOut && priorTimedOut) {
                         verdict = { authed: false, reason: `probe timed out (repeat — retry skipped) (${MODEL_PROBE_TIMEOUT_MS}ms)`, probedAt, durationMs: Date.now() - t0 };
                     }
                     else if (r.timedOut) {
-                        const r2 = await sh(a.headlessCommand(promptFile, model), repoRoot, MODEL_PROBE_TIMEOUT_MS);
+                        const r2 = await sh(a.headlessCommand(promptFile, model), probeRoot, MODEL_PROBE_TIMEOUT_MS);
                         if (r2.timedOut) {
                             verdict = { authed: false, reason: `probe timed out twice (${MODEL_PROBE_TIMEOUT_MS}ms)`, probedAt, durationMs: Date.now() - t0 };
                         }
@@ -106,6 +161,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
         });
         h.modelAuth = verdicts;
     }));
+    health[pendingAutoPreferKey] = deriveAutoPrefer(cfg, adapters, health);
 }
 // T2: caps concurrent probes per adapter at 2 — v1.33.5 regression, 4 concurrent codex exec in one
 // repo made ALL 4 time out where sequential passed 2/4 (suspected CLI self-contention).
@@ -121,12 +177,24 @@ async function mapLimit(items, limit, fn) {
     await Promise.all(workers);
 }
 const doctorPath = (repoRoot) => join(repoRoot, stateDirName(repoRoot), "doctor.json");
+function readDoctorFile(repoRoot) {
+    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+}
 export function writeDoctor(repoRoot, health) {
     drovrDir(repoRoot);
-    writeFileSync(doctorPath(repoRoot), JSON.stringify(health, null, 2) + "\n");
+    const pending = health[pendingAutoPreferKey];
+    const payload = { ...health };
+    delete payload[pendingAutoPreferKey];
+    if (pending)
+        payload.autoPrefer = pending;
+    writeFileSync(doctorPath(repoRoot), JSON.stringify(payload, null, 2) + "\n");
 }
 export function readDoctor(repoRoot) {
-    return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
+    const raw = readDoctorFile(repoRoot);
+    if (!raw)
+        return null;
+    const { autoPrefer: _, ...health } = raw;
+    return health;
 }
 export function discoverChannels(cfg, adapters, health) {
     const base = adapters
@@ -247,7 +315,7 @@ export function formatDoctorReport(cwd, cfg, health, adapters, opts = {}) {
             rows.push(`  ! ${role} runs on ${sel.adapter}:${sel.model} — NOT installed; that gate will fail closed until you install it or remap cfg.${role}`);
         }
     }
-    rows.push(...modelLints(cfg, health, adapters).map((l) => `  ! ${l}`));
+    rows.push(...modelLints(cfg, health, adapters, { stateDir: stateDirName(cwd) }).map((l) => `  ! ${l}`));
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         rows.push(`  ! ${exclusionLine(excluded)}`);
@@ -255,7 +323,7 @@ export function formatDoctorReport(cwd, cfg, health, adapters, opts = {}) {
     if (servable.length)
         rows.push(`  ! ${servabilityLine(servable)}`);
     const visual = process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
-    const frag = suggestOverlay(cfg, health, adapters);
+    const frag = suggestOverlay(cfg, health, adapters, stateDirName(cwd));
     let drift = "";
     if (frag) {
         if (visual) {
@@ -293,6 +361,6 @@ export function formatDoctorReport(cwd, cfg, health, adapters, opts = {}) {
         return statusRows;
     });
     const modelSummary = modelStatus.length ? `\nmodel status:\n${modelStatus.join("\n")}` : "";
-    const wrote = opts.wrote === false ? "" : `\nwrote .drovr/doctor.json`;
+    const wrote = opts.wrote === false ? "" : `\nwrote ${stateDirName(cwd)}/doctor.json`;
     return `tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}${wrote}`;
 }

package/dist/adapters/types.d.ts

@@ -72,6 +72,7 @@ export declare function matchesTrustDialog(paneText: string, dialog: TrustDialog
 export interface WorkerAdapter {
     id: string;
     vendor: string;
+    probeCwd?: "repo" | "neutral";
     probe(): Promise<AuthHealth>;
     channels(cfg: DrovrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;

package/dist/cli/commands/compile.js

@@ -1,7 +1,7 @@
 import { isAbsolute, join } from "node:path";
 import { parseArgs } from "node:util";
 import { compileSource } from "../../compile/index.js";
-import { saveGraph } from "../../graph/graph.js";
+import { saveGraph, stateDirName } from "../../graph/graph.js";
 import { isRunLockLive } from "../../run/lock.js";
 export async function compile(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
@@ -16,8 +16,9 @@ export async function compile(argv, cwd = process.cwd()) {
     const g = compileSource(isAbsolute(src) ? src : join(cwd, src), values.type, cwd);
     // HARD-01: a compile clobbering a running daemon's graph.json is the same last-write-wins race
     // as a second daemon. Read-only check — compile never acquires/holds (it's instantaneous).
+    const stateDir = stateDirName(cwd);
     if (isRunLockLive(cwd))
-        throw new Error(".drovr/graph.lock is held by another drovr run, or is a stale/garbage lock — refusing to overwrite graph.json. If no run is active, run `drovr unlock`.");
+        throw new Error(`${stateDir}/graph.lock is held by another drovr run, or is a stale/garbage lock — refusing to overwrite graph.json. If no run is active, run \`drovr unlock\`.`);
     saveGraph(cwd, g);
-    return `compiled ${src} → .drovr/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
+    return `compiled ${src} → ${stateDir}/graph.json (${g.tasks.length} tasks, source ${g.spec.source}, hash ${g.spec.hash.slice(0, 12)})`;
 }

package/dist/cli/commands/doctor.js

@@ -1,9 +1,9 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
-import { drovrDir } from "../../graph/graph.js";
+import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { drovrDir, stateDirName } from "../../graph/graph.js";
 import { modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
-import { loadConfig } from "../../config/config.js";
+import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 // same gate + palette as status's audit-ledger frame: styled only on a real TTY, plain otherwise
@@ -91,7 +91,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(`  ! ${role} runs on ${sel.adapter}:${sel.model} — NOT installed; that gate will fail closed until you install it or remap cfg.${role}`);
         }
     }
-    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual() }).map((l) => `  ! ${l}`));
+    rows.push(...modelLints(cfg, health, adapters, { tty: ttyVisual(), stateDir: stateDirName(cwd), overlayPreferShapes: overlayPreferShapes(cwd) }).map((l) => `  ! ${l}`));
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
         rows.push(`  ! ${exclusionLine(excluded)}`);
@@ -102,7 +102,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // MODEL-05/06: print-only drift fragment; advisory, whole-line-commented additions, drovr NEVER applies it.
     // TTY gets a one-line summary + the fragment as a file (the full dump drowned everything else,
     // v1.33.1 onboarding); machine/CI surface keeps the inline dump — layout is pinned by tests.
-    const frag = suggestOverlay(cfg, health, adapters);
+    const frag = suggestOverlay(cfg, health, adapters, stateDirName(cwd));
     let drift = "";
     if (frag) {
         if (visual()) {
@@ -143,6 +143,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             rows.push(`    (${unclassified.length} more listed, unclassified)`);
         return rows;
     });
-    const modelSummary = modelStatus.length ? `\nmodel status:\n${modelStatus.join("\n")}` : "";
-    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote .drovr/doctor.json`);
+    const autoPrefer = readAutoPrefer(cwd);
+    const preferStatus = autoPrefer
+        ? Object.keys(cfg.routing.map).flatMap((shape) => {
+            const auto = autoPrefer[shape];
+            if (!Array.isArray(auto))
+                return [];
+            const seed = DEFAULT_CONFIG.routing.map[shape]?.prefer ?? [];
+            if (!auto.length && !seed.length)
+                return []; // nothing derived, nothing seeded — an empty line is noise
+            return [`    prefer ${shape} (auto): ${auto.join(" > ")} — seed was [${seed.join(", ")}]`];
+        })
+        : [];
+    const modelSummary = modelStatus.length || preferStatus.length
+        ? `\nmodel status:\n${[...modelStatus, ...preferStatus].join("\n")}`
+        : "";
+    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
 }

package/dist/cli/commands/profile.js

@@ -1,7 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../../config/config.js";
-import { drovrDir } from "../../graph/graph.js";
+import { drovrDir, stateDirName } from "../../graph/graph.js";
 import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
 import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
 // drovr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
@@ -15,14 +15,15 @@ export async function profile(argv, cwd = process.cwd()) {
 // blanket-gitignores it, so the cursor is never git-addable. Opaque string: used only in a runId > compare.
 function reset(cwd) {
     const cursor = Journal.latestRunId(cwd) ?? ""; // empty repo ⇒ empty cursor ⇒ readProfileCursor === undefined
+    const stateDir = stateDirName(cwd);
     const path = join(drovrDir(cwd), "profile-since");
     writeFileSync(path, cursor + "\n");
     return [
         cursor
             ? `profile reset — learned routing now forgets runs at or before ${cursor}.`
             : `profile reset — no runs yet; wrote an empty cursor.`,
-        `  wrote .drovr/profile-since (telemetry is UNTOUCHED — report/resume still see every run).`,
-        `  to un-reset: delete .drovr/profile-since.`,
+        `  wrote ${stateDir}/profile-since (telemetry is UNTOUCHED — report/resume still see every run).`,
+        `  to un-reset: delete ${stateDir}/profile-since.`,
     ].join("\n");
 }
 // Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
@@ -40,7 +41,7 @@ function show(cwd) {
     if (!p || p.cells.size === 0) {
         // preview bypasses the switch ⇒ undefined here means data, not policy: no telemetry, or all behind the cursor.
         header.push("", cursor
-            ? `  empty profile — no telemetry after the reset cursor (delete .drovr/profile-since to see earlier runs).`
+            ? `  empty profile — no telemetry after the reset cursor (delete ${stateDirName(cwd)}/profile-since to see earlier runs).`
             : `  empty profile — no telemetry yet.`);
         return header.join("\n");
     }

package/dist/config/config.d.ts

@@ -177,6 +177,9 @@ export declare class ConfigError extends Error {
 }
 export declare const DEFAULT_CONFIG: DrovrConfig;
 export declare function globalConfigDir(): string;
+export declare function overlayPreferShapes(repoRoot: string, opts?: {
+    globalDir?: string;
+}): ReadonlySet<string>;
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
 }): DrovrConfig;

package/dist/config/config.js

@@ -262,6 +262,19 @@ export function globalConfigDir() {
     const legacy = join(base, "drovr");
     return existsSync(join(next, "config.yaml")) || !existsSync(join(legacy, "config.yaml")) ? next : legacy;
 }
+export function overlayPreferShapes(repoRoot, opts = {}) {
+    const shapes = new Set();
+    for (const layer of [readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml")), readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"))]) {
+        const map = layer?.routing?.map;
+        if (!map)
+            continue;
+        for (const [shape, entry] of Object.entries(map)) {
+            if (entry && Object.prototype.hasOwnProperty.call(entry, "prefer") && entry.prefer !== null)
+                shapes.add(shape);
+        }
+    }
+    return shapes;
+}
 export function loadConfig(repoRoot, opts = {}) {
     const globalCfg = readYaml(join(opts.globalDir ?? globalConfigDir(), "config.yaml"));
     const repoCfg = readYaml(join(repoRoot, stateDirName(repoRoot), "config.yaml"));

package/dist/gates/review.js

@@ -30,7 +30,7 @@ export function pickReviewer(author, channels, exclude = []) {
 const DIFF_CAP = 60_000;
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers) {
     if (task.complexity < cfg.review.complexityThreshold) {
-        return { gate: "review", pass: true, details: `skipped — complexity ${task.complexity} < threshold ${cfg.review.complexityThreshold}` };
+        return { gate: "review", pass: true, details: `skipped — complexity ${task.complexity} < threshold ${cfg.review.complexityThreshold}`, meta: { skipped: true } };
     }
     const reviewer = pickReviewer(author, channels, excludeReviewers ?? []);
     if (!reviewer) {

package/dist/graph/graph.js

@@ -6,7 +6,13 @@ export function stateDirName(repoRoot) {
     const cached = stateDirs.get(repoRoot);
     if (cached)
         return cached;
-    const name = existsSync(join(repoRoot, ".drovr")) ? ".drovr" : existsSync(join(repoRoot, ".drover")) ? ".drover" : ".drovr";
+    const name = existsSync(join(repoRoot, ".tickmarkr"))
+        ? ".tickmarkr"
+        : existsSync(join(repoRoot, ".drovr"))
+            ? ".drovr"
+            : existsSync(join(repoRoot, ".drover"))
+                ? ".drover"
+                : ".tickmarkr";
     stateDirs.set(repoRoot, name);
     return name;
 }

package/dist/route/router.d.ts

@@ -18,9 +18,17 @@ export interface Route {
     provenance: string;
     deviation?: RouteDeviation;
 }
+export interface RoutingPreferContext {
+    autoPrefer?: {
+        derivedAt: string;
+        [shape: string]: string[] | string;
+    };
+    doctorFresh: boolean;
+    overlayPreferShapes: ReadonlySet<string>;
+}
 export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
-export declare function route(task: Task, cfg: DrovrConfig, channels: BillingChannel[], profile?: RoutingProfile): Route;
+export declare function route(task: Task, cfg: DrovrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: DrovrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile): Assignment | null;

package/dist/route/router.js

@@ -2,6 +2,19 @@ import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { disallowedBy } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore } from "./profile.js";
+const autoPreferList = (doc, shape) => {
+    const v = doc?.[shape];
+    return Array.isArray(v) ? v : undefined;
+};
+const preferFromAuto = (shape, preferCtx) => !!preferCtx?.doctorFresh && !!preferCtx.autoPrefer && !preferCtx.overlayPreferShapes.has(shape) &&
+    autoPreferList(preferCtx.autoPrefer, shape) !== undefined;
+const effectivePrefer = (shape, entry, preferCtx) => {
+    if (preferCtx?.overlayPreferShapes.has(shape))
+        return entry?.prefer;
+    if (preferCtx?.doctorFresh && preferCtx.autoPrefer)
+        return autoPreferList(preferCtx.autoPrefer, shape) ?? entry?.prefer;
+    return entry?.prefer;
+};
 export class RoutingError extends Error {
     constructor(msg) {
         super(msg);
@@ -31,10 +44,11 @@ function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
 }
-export function route(task, cfg, channels, profile) {
+export function route(task, cfg, channels, profile, preferCtx) {
     const lints = [];
     const floor = cfg.routing.floors[task.shape];
     const entry = cfg.routing.map[task.shape];
+    const prefer = effectivePrefer(task.shape, entry, preferCtx);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
         const d = disallowedBy({ adapter: via, model }, cfg.routing);
@@ -95,12 +109,12 @@ export function route(task, cfg, channels, profile) {
     if (entry?.tier)
         lintFloor(entry.tier, "map tier");
     if (prefActive)
-        for (const p of entry?.prefer ?? [])
+        for (const p of prefer ?? [])
             preflightPrefer(p);
     // key order is a contract: prefer > marginal cost > tier (cheapest sufficient) > learned score (v1.6 ROUTE-06)
     // > discovery order (same-tier fairness, D2). The learned score is the LAST key — it decides only the
     // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08).
-    const staticCmp = (a, b) => preferIndex(a, entry?.prefer) - preferIndex(b, entry?.prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
+    const staticCmp = (a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
     const eligibleRaw = channels.filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier]);
     if (!eligibleRaw.length) {
         let msg = `${task.id}: no channel at tier>=${minTier}; available: ${channels.map(channelKey).join(", ") || "(none)"}`;
@@ -137,19 +151,19 @@ export function route(task, cfg, channels, profile) {
         // entries, while intra-entry order (cost > tier > bonus > score) and every cold path stay byte-identical.
         // Cold reduces to preferIndex || cost || tier ≡ staticCmp (proof P1); rep keys use the group HEAD so
         // the probed group's budget self-extinguishes at EXPLORE_CAP (P4); flat lexicographic K is total (P5).
-        const prefer = entry?.prefer ?? [];
+        const preferBands = prefer ?? [];
         const groupCmp = (a, b) => marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier] ||
             bonusOf(b) - bonusOf(a) || scoreOf(b) - scoreOf(a);
         const heads = new Map();
         for (const c of [...eligibleRaw].sort(groupCmp)) {
-            const g = preferIndex(c, prefer);
+            const g = preferIndex(c, preferBands);
             if (!heads.has(g))
                 heads.set(g, c);
         }
         const keyOf = new Map(eligibleRaw.map((c) => {
-            const g = preferIndex(c, prefer);
+            const g = preferIndex(c, preferBands);
             const rep = heads.get(g);
-            return [channelKey(c), [g < prefer.length ? 0 : 1, -bonusOf(rep), -scoreOf(rep), g,
+            return [channelKey(c), [g < preferBands.length ? 0 : 1, -bonusOf(rep), -scoreOf(rep), g,
                     marginalCostRank(c), TIER_RANK[c.tier], -bonusOf(c), -scoreOf(c)]];
         }));
         const kOf = (c) => keyOf.get(channelKey(c));
@@ -180,8 +194,11 @@ export function route(task, cfg, channels, profile) {
                 "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 chosenBy = learnedChosen || (entry?.prefer && preferIndex(eligible[0], entry.prefer) < entry.prefer.length
-        ? "via prefer" : "cheapest sufficient tier");
+    const preferVia = preferFromAuto(task.shape, preferCtx)
+        ? `via prefer (auto-modernized ${preferCtx.autoPrefer.derivedAt.slice(0, 10)})`
+        : "via prefer";
+    const chosenBy = learnedChosen || (prefer && preferIndex(eligible[0], prefer) < prefer.length
+        ? preferVia : "cheapest sufficient tier");
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
 export function nextChannel(current, task, cfg, channels, tried, profile) {

package/dist/run/daemon.js

@@ -11,7 +11,7 @@ import { captureBaseline, detectGateCommands } from "../gates/baseline.js";
 import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
 import { consult } from "./consult.js";
-import { gitHead, sh } from "./git.js";
+import { cleanupRunWorktrees, gitHead, sh } from "./git.js";
 import { Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask } from "./merge.js";
@@ -706,6 +706,12 @@ export async function runDaemon(repoRoot, opts = {}) {
         };
         journal.append("run-end", undefined, { ...summary });
         await reconcile(); // run-end boundary: nothing in flight — full sweep (empty desired set)
+        // OBS-28: lingering worktrees starve CLI probes; keepPanes:forever is the debug override.
+        if (!keepForever) {
+            const green = summary.failed.length === 0 && summary.human.length === 0
+                && summary.blocked.length === 0 && summary.pending.length === 0;
+            await cleanupRunWorktrees(repoRoot, branch, { removeIntegration: green, removeTaskIds: summary.done });
+        }
         // VIS-02: name each blocked subtree by its nearest parked/failed root, e.g. "3 blocked behind P40-02".
         const attribution = [...attributeBlocked(graph).entries()]
             .sort(([a], [b]) => a.localeCompare(b))

package/dist/run/git.d.ts

@@ -7,6 +7,13 @@ export interface ShResult {
 export declare function sh(cmd: string, cwd: string, timeoutMs?: number): Promise<ShResult>;
 export declare function shOk(cmd: string, cwd: string): Promise<string>;
 export declare function gitHead(cwd: string): Promise<string>;
+export declare const sanitizeBranch: (branch: string) => string;
+export declare const worktreePath: (repo: string, branch: string) => string;
+/** OBS-28: remove this run's recorded worktrees; tolerates already-gone paths. */
+export declare function cleanupRunWorktrees(repo: string, branch: string, opts: {
+    removeIntegration: boolean;
+    removeTaskIds: string[];
+}): Promise<void>;
 export declare function resolveIntegrationBranch(repo: string, branch: string): Promise<string>;
 export declare function createWorktree(repo: string, branch: string, baseRef: string): Promise<string>;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;

package/dist/run/git.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { drovrDir } from "../graph/graph.js";
@@ -47,7 +47,16 @@ export async function shOk(cmd, cwd) {
 export async function gitHead(cwd) {
     return (await shOk("git rev-parse HEAD", cwd)).trim();
 }
-const sanitize = (branch) => branch.replace(/[^\w.-]+/g, "-");
+export const sanitizeBranch = (branch) => branch.replace(/[^\w.-]+/g, "-");
+const sanitize = sanitizeBranch;
+export const worktreePath = (repo, branch) => join(drovrDir(repo), "worktrees", sanitize(branch));
+/** OBS-28: remove this run's recorded worktrees; tolerates already-gone paths. */
+export async function cleanupRunWorktrees(repo, branch, opts) {
+    if (opts.removeIntegration)
+        await removeWorktree(repo, worktreePath(repo, branch));
+    for (const id of opts.removeTaskIds)
+        await removeWorktree(repo, worktreePath(repo, `${branch}--${id}`));
+}
 const branchExists = async (repo, branch) => (await sh(`git rev-parse --verify ${shq(`refs/heads/${branch}`)}`, repo)).code === 0;
 export async function resolveIntegrationBranch(repo, branch) {
     if (!branch.startsWith("drovr/"))
@@ -68,8 +77,21 @@ export async function createWorktree(repo, branch, baseRef) {
     if (existsSync(dir))
         await removeWorktree(repo, dir);
     await shOk(`git worktree add -B ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+    linkNodeModules(repo, dir);
     return dir;
 }
+// best-effort: devDep-based gates (tsx, vitest) shell out root-anchored and ENOENT in a bare
+// fresh worktree (OBS-27); failure here must never fail worktree creation
+function linkNodeModules(repo, dir) {
+    const src = join(repo, "node_modules");
+    const dest = join(dir, "node_modules");
+    if (!existsSync(src) || existsSync(dest))
+        return;
+    try {
+        symlinkSync(src, dest, "dir");
+    }
+    catch { /* best-effort */ }
+}
 export async function removeWorktree(repo, dir) {
     await sh(`git worktree remove --force ${shq(dir)}`, repo); // best-effort; stale dirs are re-added with -B
     await sh(`rm -rf ${shq(dir)}`, repo);

package/dist/run/lock.js

@@ -1,7 +1,7 @@
 import { linkSync, readFileSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { drovrDir } from "../graph/graph.js";
+import { drovrDir, stateDirName } from "../graph/graph.js";
 // HARD-01/02: coarse per-run advisory lock over .drovr/graph.json. LOCK-02: the lock is created by
 // the link(2) idiom — write the full payload to graph.lock.<pid>.tmp, then linkSync(tmp, lockPath),
 // which is atomic and throws EEXIST if the lock already exists (the mutual-exclusion primitive).
@@ -125,11 +125,12 @@ export function acquireRunLock(repoRoot, runId) {
             const again = acquireRunLock(repoRoot, runId); // re-serializes two stealers through linkSync
             return { reclaimed: { pid: pid ?? -1, mtimeMs }, ...again };
         }
+        const stateDir = stateDirName(repoRoot);
         if (garbage)
-            throw new Error(".drovr/graph.lock holds an unreadable/garbage payload — refusing to reclaim it; run `drovr unlock` to remove it");
+            throw new Error(`${stateDir}/graph.lock holds an unreadable/garbage payload — refusing to reclaim it; run \`drovr unlock\` to remove it`);
         // LOCK-02: shouldRefuse is false whenever dead, so this throw is reached only for a LIVE holder
         // (incl. EPERM = alive-but-not-ours). The dead-but-fresh case self-clears via the reclaim branch.
-        throw new Error(`.drovr/graph.lock held by pid ${pid ?? "?"}${heldRun ? ` (run ${heldRun})` : ""} — another drovr run? (operator escape: \`drovr unlock\`)`);
+        throw new Error(`${stateDir}/graph.lock held by pid ${pid ?? "?"}${heldRun ? ` (run ${heldRun})` : ""} — another drovr run? (operator escape: \`drovr unlock\`)`);
     }
 }
 export function releaseRunLock(repoRoot) {
@@ -169,7 +170,7 @@ export function unlockRun(repoRoot) {
         return { held: false };
     } // statSync ENOENT ⇒ no lock
     if (!insp.dead && !insp.garbage) {
-        throw new Error(`.drovr/graph.lock held by LIVE pid ${insp.pid}${insp.runId ? ` (run ${insp.runId})` : ""} — refusing to unlock; stop that run first`);
+        throw new Error(`${stateDirName(repoRoot)}/graph.lock held by LIVE pid ${insp.pid}${insp.runId ? ` (run ${insp.runId})` : ""} — refusing to unlock; stop that run first`);
     }
     try {
         unlinkSync(p);

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -12,9 +12,9 @@ Use this to execute a requested sequence of repository specs. It is SDD-agnostic
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. 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 send, then supervise it.
-- **Primary session without an orchestrator:** create one child orchestration session, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR 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 send, then supervise it as OVERSEER.
+- **Primary session without an orchestrator:** rename your own tab OVERSEER, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
 
 Outside a multi-agent terminal environment, run the loop directly.
 

package/skills/tickmarkr-loop/SKILL.md

@@ -11,9 +11,9 @@ Use this for any spec that `tickmarkr compile` accepts. It is SDD-agnostic: use
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. 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 send, then supervise it.
-- **Primary session without an orchestrator:** create one child orchestration session, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR 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 send, then supervise it as OVERSEER.
+- **Primary session without an orchestrator:** rename your own tab OVERSEER, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
 
 Outside a multi-agent terminal environment, run the loop directly.