tickmarkr 1.30.0

package/dist/adapters/model-lints.js

@@ -0,0 +1,130 @@
+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";
+// knowledge past this age gets a "rerun drovr doctor" nudge (BLOCKED_POLL_MS-style named constant).
+export const MODEL_STALE_DAYS = 30;
+const DAY_MS = 86400000;
+// cursor-agent 2026.07.08 reports 193 mostly-parameterized ids (e.g. gpt-5.3-codex-high-fast); filter the `auto`
+// pseudo-model + effort/speed variant suffixes from the unconfigured-lint aggregation ONLY — doctor.json keeps the
+// raw list (verified 2026-07-10). Data stays raw; lints stay signal.
+const LINT_VARIANT_RE = /^auto$|-(fast|minimal|low|medium|high|xhigh)$/;
+const LINT_CAP = 5;
+// 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) {
+    const lints = [];
+    for (const id of Object.keys(cfg.tiers)) {
+        const adapter = adapters.find((a) => a.id === id);
+        if (!adapter)
+            continue; // fake/overlay-only tier entry with no adapter — nothing to diff against
+        if (!adapter.listModels) {
+            lints.push(`${id}: no model-list surface — seeds stamped ${SEED_STAMPED}; verify manually`);
+            continue;
+        }
+        const h = health[id];
+        const detected = h?.models ?? []; // MANDATORY default: pre-v1.5 files lack a populated models array
+        if (detected.length === 0) {
+            if (h?.installed)
+                lints.push(`${id}: no detection data — run drovr doctor`);
+            continue; // no data to diff or age
+        }
+        const configured = Object.keys(cfg.tiers[id].models);
+        for (const model of configured) {
+            if (!detected.includes(model)) {
+                lints.push(`${id}: tiers lists ${model} — CLI no longer reports it; tombstone it (${model}: null overlay) or verify the id`);
+            }
+        }
+        const extra = detected.filter((m) => !configured.includes(m) && !LINT_VARIANT_RE.test(m));
+        if (extra.length) {
+            const shown = extra.slice(0, LINT_CAP).join(", ");
+            const tail = extra.length > LINT_CAP ? `, +${extra.length - LINT_CAP} more` : "";
+            lints.push(`${id}: reports ${extra.length} model(s) not in tiers (${shown}${tail}) — classify before routing (benchmark policy)`);
+        }
+        const at = h?.modelsDetectedAt;
+        if (at) {
+            const days = Math.floor((Date.now() - Date.parse(at)) / DAY_MS); // completed days — never overstate age
+            if (days >= MODEL_STALE_DAYS)
+                lints.push(`${id}: model knowledge is ${days} days old — rerun drovr doctor`);
+        }
+    }
+    return lints;
+}
+// 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.
+// Additions render WHOLE-LINE-COMMENTED with a `???` tier placeholder (a tier is a benchmark claim; the
+// 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) {
+    const blocks = [];
+    for (const id of Object.keys(cfg.tiers)) {
+        const adapter = adapters.find((a) => a.id === id);
+        if (!adapter?.listModels)
+            continue; // no adapter / no list surface → nothing to diff (mirror modelLints)
+        const h = health[id];
+        const detected = h?.models ?? [];
+        if (detected.length === 0)
+            continue; // no detection data → don't guess a delta
+        const configured = Object.keys(cfg.tiers[id].models);
+        const date = h?.modelsDetectedAt?.split("T")[0]; // best-effort day stamp
+        const detNote = date ? ` (detected ${date})` : "";
+        const lines = [];
+        // Tombstones: configured ids the CLI no longer reports. Ids are operator-authored (from cfg) → MODEL_ID_RE only.
+        for (const model of configured) {
+            if (detected.includes(model) || !MODEL_ID_RE.test(model))
+                continue;
+            lines.push(`      ${model}: null   # tombstone: ${id} no longer reports this id${detNote}${referenceWarning(cfg, id, model)}`);
+        }
+        // Additions: detected ids not in cfg. WHOLE line commented, no tier (MODEL-06). Ids come from an external
+        // CLI → MODEL_ID_RE (defense-in-depth, T-21-01) + the variant filter (cursor's ~193 parameterized ids).
+        // RELATIONAL gate (no capability judgment — "looks like an embedding model" is auto-tiering's cousin, the
+        // NaN-routing class the v1.5 decision forbids): a detected id is suggested iff it shares a provider prefix
+        // (clause a) OR a canonical segment (clause b, the RENAME case: opencode/glm-5.2 ⇒ zai-coding-plan/glm-5.2)
+        // with some configured id. Everything else collapses into ONE counted summary — never dropped silently.
+        // NB: the bare "" prefix is a real match key on purpose. codex's whole namespace is unprefixed
+        // (gpt-5.6-sol, gpt-5.5), so "" is how a detected gpt-5.7-nova surfaces as an upgrade of a configured
+        // gpt-5.6-sol — the MODEL-05 worked example. The cost is that an adapter with ONE bare configured id
+        // (cursor's composer-2.5) admits every unprefixed detected id; those collapse into the counted summary,
+        // not silently. ponytail: not worth a per-adapter heuristic to quiet cursor at the price of codex signal.
+        const cfgPrefixes = new Set(configured.map(providerPrefix));
+        const cfgCanon = new Set(configured.map(canonical));
+        let omitted = 0;
+        for (const model of detected) {
+            if (configured.includes(model) || !MODEL_ID_RE.test(model) || LINT_VARIANT_RE.test(model))
+                continue;
+            if (!cfgPrefixes.has(providerPrefix(model)) && !cfgCanon.has(canonical(model))) {
+                omitted++;
+                continue;
+            }
+            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)`);
+        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`;
+}
+// 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.
+// providerPrefix("zai/glm-5.2") === "zai"; providerPrefix("gpt-5.5") === "" (bare ids share the "" prefix).
+const providerPrefix = (id) => { const i = id.lastIndexOf("/"); return i < 0 ? "" : id.slice(0, i); };
+// canonical("zai-coding-plan/glm-5.2") === "glm-5.2" — the rename-detecting segment.
+const canonical = (id) => { const i = id.lastIndexOf("/"); return i < 0 ? id : id.slice(i + 1); };
+// A tombstoned id that a routing.map pin / judge / consult still names (on the same adapter) would leave a
+// dangling reference — surface it inline so the operator remaps before deleting the seed.
+function referenceWarning(cfg, adapterId, model) {
+    const refs = [];
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        if (entry.pin?.via === adapterId && entry.pin.model === model)
+            refs.push(`routing.map.${shape}.pin`);
+    }
+    if (cfg.judge.adapter === adapterId && cfg.judge.model === model)
+        refs.push("judge");
+    if (cfg.consult.adapter === adapterId && cfg.consult.model === model)
+        refs.push("consult");
+    return refs.length ? `  # WARNING: still referenced by ${refs.join(", ")} — remap before removing` : "";
+}

package/dist/adapters/opencode.d.ts

@@ -0,0 +1,3 @@
+import { type WorkerAdapter } from "./types.js";
+export declare function parseOpencodeModels(raw: string): string[];
+export declare const opencode: WorkerAdapter;

package/dist/adapters/opencode.js

@@ -0,0 +1,108 @@
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { probeVersion } from "./claude-code.js";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+// v1.5 MODEL-01: pure parser for `opencode models` (one provider/model id per line, no header).
+// Live-verified 2026-07-10, opencode 1.17.15. Lines are already the seed id format; drop blanks.
+export function parseOpencodeModels(raw) {
+    return raw.trim().split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0)
+        .filter((id) => MODEL_ID_RE.test(id));
+}
+export const opencode = {
+    id: "opencode",
+    vendor: "mixed",
+    probe: async () => probeVersion("opencode"),
+    channels: (cfg) => channelsFromConfig("opencode", cfg),
+    headlessCommand: (promptFile, model) => `opencode run -m ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    interactiveCommand: (promptFile, model) => `opencode -m ${shq(model)} --prompt "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseWorkerResult,
+    // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). Plain `models` (NOT --refresh):
+    // opencode reads its own cache offline; --refresh adds an avoidable network dependency (RESEARCH
+    // anti-pattern). Live-verified 2026-07-10, opencode 1.17.15.
+    listModels: async () => {
+        const r = spawnSync("opencode", ["models"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parseOpencodeModels(r.stdout || "");
+    },
+    // SPEND-09: opencode 1.x writes per-message token deltas to SQLite opencode.db (NOT the dead 0.7.x
+    // storage/message/*.json legacy — those files carry zero'd tokens forever). We read POST-HOC via
+    // spawnSync sqlite3 -json, sum message-row tokens whose path.cwd matches this worktree AND whose
+    // time.created (epoch-ms NUMBER) is at/after sinceMs. NEVER read session.tokens_* (session-cumulative
+    // 3A+2B+C trap) and NEVER read rec.cost (opencode reports cost:0 on sub plans; money is the existing
+    // v1.7 sub-channel subscription bucket). NEVER populate tokens.reasoning — it is ⊂ output and
+    // report total() cross-sums reasoning, so setting it double-counts. FAIL OPEN everywhere.
+    collectUsage(cwd, sinceMs) {
+        try {
+            const real = realpathSync(cwd);
+            const dbPath = join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode", "opencode.db");
+            const r = spawnSync("sqlite3", ["-json", dbPath, "SELECT data FROM message WHERE time_created >= " + Math.floor(sinceMs)], { encoding: "utf8", timeout: 10000 });
+            if (r.error || r.status !== 0)
+                return undefined;
+            const raw = (r.stdout || "").trim();
+            if (!raw)
+                return undefined;
+            let rows;
+            try {
+                rows = JSON.parse(raw);
+            }
+            catch {
+                return undefined;
+            }
+            if (!Array.isArray(rows))
+                return undefined;
+            let input = 0, output = 0, kept = false;
+            let cacheRead, cacheWrite;
+            for (const row of rows) {
+                if (!row || typeof row !== "object")
+                    continue;
+                const dataStr = row.data;
+                if (typeof dataStr !== "string")
+                    continue;
+                let recRaw;
+                try {
+                    recRaw = JSON.parse(dataStr);
+                }
+                catch {
+                    continue;
+                }
+                const rec = recRaw;
+                if (rec.path?.cwd !== real)
+                    continue;
+                const created = rec.time?.created;
+                if (typeof created !== "number" || !Number.isFinite(created) || created < sinceMs)
+                    continue;
+                const t = rec.tokens;
+                if (!t || typeof t !== "object")
+                    continue;
+                const tt = t;
+                const n = (k) => (typeof tt[k] === "number" ? tt[k] : 0);
+                input += n("input");
+                output += n("output");
+                const cache = tt.cache;
+                if (cache && typeof cache === "object") {
+                    const cc = cache;
+                    if ("read" in cc)
+                        cacheRead = (cacheRead ?? 0) + (typeof cc.read === "number" ? cc.read : 0);
+                    if ("write" in cc)
+                        cacheWrite = (cacheWrite ?? 0) + (typeof cc.write === "number" ? cc.write : 0);
+                }
+                kept = true;
+            }
+            if (!kept)
+                return undefined;
+            const out = { input, output, ...(cacheRead !== undefined ? { cacheRead } : {}), ...(cacheWrite !== undefined ? { cacheWrite } : {}) };
+            const p = TokenUsageSchema.safeParse(out);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};

package/dist/adapters/pi.d.ts

@@ -0,0 +1,3 @@
+import { type WorkerAdapter } from "./types.js";
+export declare function parsePiModels(raw: string): string[];
+export declare const pi: WorkerAdapter;

package/dist/adapters/pi.js

@@ -0,0 +1,191 @@
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { probeVersion } from "./claude-code.js";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+// SPEND-10: pi writes per-session JSONL to ~/.pi/agent/sessions/<slug>/ where slug is EMPIRICAL
+// (reverse-engineered: "-" + realpath'd cwd with every "/" replaced by "-" + "--", 29-RESEARCH.md Pitfall 7).
+// Session header (type:"session", version:3) carries cwd; assistant messages carry message.usage with
+// per-record ISO `timestamp`. Read POST-HOC; cursor is per-record timestamp (never file mtime).
+// Header cwd === realpath(cwd) guard makes slug-formula drift fail SAFE (unmetered, never mis-metered).
+// FAIL OPEN everywhere: missing dir / unreadable file / torn line / no match ⇒ undefined.
+// SPEND-10: sum ONLY input/output/cacheRead/cacheWrite. usage.reasoning ⊂ usage.output — omit it
+// (report total() cross-sums reasoning; populating it double-counts). NEVER read usage.cost.
+const MAX_SESSION_FILES = 20;
+const MAX_SESSION_BYTES = 8_000_000;
+// v1.5 MODEL-01: pure parser for `pi --list-models` (table: header row + provider/model/... columns).
+// Live-verified 2026-07-10, pi 0.80.3. Columns 0-1 join to the seed id format.
+// MODEL-05 WR-02: anchor on the header by CONTENT, not position — pi emits non-blocking update banners
+// that can precede the table (see banner note below), so slice(1) would drop a banner and parse the real
+// header row as a bogus provider/model id. Find the "provider model ..." header and parse rows after it;
+// fail-open to [] if no header is found.
+export function parsePiModels(raw) {
+    const lines = raw.trim().split("\n");
+    const headerIdx = lines.findIndex((l) => /^provider\s+model\b/.test(l.trim()));
+    if (headerIdx === -1)
+        return [];
+    return lines.slice(headerIdx + 1)
+        .map((l) => l.trim().split(/\s+/))
+        .filter((c) => c.length >= 2)
+        .map(([provider, model]) => `${provider}/${model}`)
+        .filter((id) => MODEL_ID_RE.test(id));
+}
+export const pi = {
+    id: "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",
+    probe: async () => {
+        const h = probeVersion("pi");
+        if (!h.installed)
+            return h;
+        const r = spawnSync("pi", ["--list-models"], { encoding: "utf8", timeout: 15000 });
+        if (r.error || r.status !== 0)
+            return h;
+        return { ...h, servable: parsePiModels(r.stdout || ""), note: "auth verified via pi --list-models (free; auth-filtered by pi)" };
+    },
+    channels: (cfg) => channelsFromConfig("pi", cfg),
+    // --approve: pi's per-directory trust prompt would stall fresh worktrees (herdr scrapes the dialog
+    // as idle — cursor/claude incident class, milestone PITFALLS #2). Global option, legal in BOTH modes
+    // per pi --help v0.80.3 (2026-07-10) — NOT print-only like cursor's --trust. Chosen over the more
+    // hermetic --no-approve so repo-local pi config behaves normally (research Pitfall 5 decision).
+    // Live-checked 2026-07-10, pi 0.80.3 — headless trailer intact, interactive --approve accepted,
+    // no trust prompt; non-blocking update banners render in output (trailer parse tolerates chrome).
+    headlessCommand: (promptFile, model) => `pi -p --approve --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    interactiveCommand: (promptFile, model) => `pi --approve --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseWorkerResult,
+    // v1.5 MODEL-01: fail OPEN to [] (detection is advisory — unlike gates' fail-closed posture).
+    // spawnSync mirrors probeVersion; 15s timeout. Live-verified 2026-07-10, pi 0.80.3.
+    listModels: async () => {
+        const r = spawnSync("pi", ["--list-models"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parsePiModels(r.stdout || "");
+    },
+    collectUsage(cwd, sinceMs) {
+        try {
+            const real = realpathSync(cwd);
+            const slug = "-" + real.replaceAll("/", "-") + "--";
+            const dir = join(homedir(), ".pi", "agent", "sessions", slug);
+            const files = readdirSync(dir)
+                .filter((f) => f.endsWith(".jsonl"))
+                .map((f) => {
+                try {
+                    return { f, m: statSync(join(dir, f)).mtimeMs };
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .filter((x) => x !== undefined)
+                .sort((a, b) => b.m - a.m)
+                .slice(0, MAX_SESSION_FILES);
+            let input = 0, output = 0, kept = false;
+            let cacheRead, cacheWrite;
+            for (const { f } of files) {
+                let text;
+                try {
+                    text = readFileSync(join(dir, f), "utf8").slice(0, MAX_SESSION_BYTES);
+                }
+                catch {
+                    continue;
+                }
+                let headerCwdOk = false;
+                for (const line of text.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    let recRaw;
+                    try {
+                        recRaw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const rec = recRaw;
+                    if (rec.type === "session") {
+                        headerCwdOk = rec.cwd === real;
+                        continue;
+                    }
+                    if (!headerCwdOk)
+                        continue;
+                    if (rec.type !== "message" || rec.message?.role !== "assistant")
+                        continue;
+                    const u = rec.message?.usage;
+                    if (!u || typeof u !== "object")
+                        continue;
+                    const ts = Date.parse(String(rec.timestamp));
+                    if (!Number.isFinite(ts) || ts < sinceMs)
+                        continue;
+                    const uu = u;
+                    const n = (k) => (typeof uu[k] === "number" ? uu[k] : 0);
+                    input += n("input");
+                    output += n("output");
+                    if ("cacheRead" in uu)
+                        cacheRead = (cacheRead ?? 0) + n("cacheRead");
+                    if ("cacheWrite" in uu)
+                        cacheWrite = (cacheWrite ?? 0) + n("cacheWrite");
+                    kept = true;
+                }
+            }
+            if (!kept)
+                return undefined;
+            const out = { input, output, ...(cacheRead !== undefined ? { cacheRead } : {}), ...(cacheWrite !== undefined ? { cacheWrite } : {}) };
+            const p = TokenUsageSchema.safeParse(out);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    // v1.23 T1: last-turn context fill from ~/.pi/agent/sessions/<slug>/<sessionId>.jsonl ONLY.
+    // tokens = input + cacheWrite + cacheRead of the LAST assistant usage record (not a sum over turns).
+    // Disk read only: no pi spawn, no pane, no network. null = unknown.
+    contextUsage(session) {
+        try {
+            const real = realpathSync(session.cwd);
+            const slug = "-" + real.replaceAll("/", "-") + "--";
+            const sid = session.id.replace(/\.jsonl$/i, "");
+            if (!sid || sid.includes("/") || sid.includes("\\") || sid.includes(".."))
+                return null;
+            const file = join(homedir(), ".pi", "agent", "sessions", slug, `${sid}.jsonl`);
+            let text;
+            try {
+                text = readFileSync(file, "utf8").slice(0, MAX_SESSION_BYTES);
+            }
+            catch {
+                return null;
+            }
+            let last;
+            for (const line of text.split("\n")) {
+                if (!line.trim())
+                    continue;
+                let recRaw;
+                try {
+                    recRaw = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const rec = recRaw;
+                if (rec.type !== "message" || rec.message?.role !== "assistant")
+                    continue;
+                const u = rec.message?.usage;
+                if (!u || typeof u !== "object")
+                    continue;
+                const uu = u;
+                const n = (k) => (typeof uu[k] === "number" ? uu[k] : 0);
+                // last turn wins — overwrite, never accumulate
+                last = n("input") + n("cacheWrite") + n("cacheRead");
+            }
+            if (last === undefined)
+                return null;
+            return { tokens: last };
+        }
+        catch {
+            return null;
+        }
+    },
+};

package/dist/adapters/prompt.d.ts

@@ -0,0 +1,6 @@
+import { type Task } from "../graph/schema.js";
+import type { WorkerResult } from "./types.js";
+export declare function buildTaskPrompt(task: Task, feedback?: string, nonce?: string): string;
+export declare function writePrompt(dir: string, task: Task, attempt: number, feedback?: string, nonce?: string): string;
+export declare function trailerPattern(nonce: string): string;
+export declare function parseWorkerResult(raw: string, nonce: string): WorkerResult;

package/dist/adapters/prompt.js

@@ -0,0 +1,84 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderAcceptanceItem } from "../graph/schema.js";
+export function buildTaskPrompt(task, feedback = "", nonce = "") {
+    const list = (xs) => xs.map((x) => `- ${x}`).join("\n");
+    return `You are an autonomous coding worker dispatched by drovr into an isolated git worktree.
+
+## Task ${task.id}: ${task.title}
+Goal: ${task.goal}
+
+## Acceptance criteria (you will be judged against these, verbatim)
+${list(task.acceptance.map(renderAcceptanceItem))}
+${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(task.files)}\n` : ""}${task.context.length ? `\n## Context (read these first)\n${list(task.context)}\n` : ""}
+## Rules
+- Work only inside the current directory (your isolated worktree). Never push. Never switch branches.
+- Make small atomic git commits as you go (git add + git commit, conventional messages).
+- Touch ONLY paths matching the file scope. Out-of-scope edits FAIL the scope gate unless the operator's config allowlists that path — declaring a deviation never passes the gate. If you cannot complete the task without an out-of-scope edit, stop and report ok:false explaining why in "summary". List any out-of-scope paths you did touch, each with a reason, in "deviations" (journaled for the operator's audit).
+- Do not ask questions; you are unattended. Make the smallest correct change.
+${feedback ? `\n## Previous attempt failed gates — fix these specifically\n${feedback}\n` : ""}
+When finished, end your final message with exactly one line (no code fence):
+DROVR_RESULT_${nonce} {"ok":true|false,"summary":"<one sentence>","deviations":["<path or reason>"]}
+`;
+}
+export function writePrompt(dir, task, attempt, feedback = "", nonce = "") {
+    const p = join(dir, "prompts", `${task.id}-a${attempt}.md`);
+    mkdirSync(join(dir, "prompts"), { recursive: true });
+    writeFileSync(p, buildTaskPrompt(task, feedback, nonce));
+    return p;
+}
+// v1.2 interactive completion anchor: matches a real trailer in any key order — even hard-wrapped
+// across lines by a TUI renderer ([\s\S] bridges newlines between tokens) — but never the template
+// line above, whose literal `true|false` is not a bool followed by , or }. v1.4: the run-tagged nonce
+// anchors it so displayed source/diffs (which can't know the nonce) can never premature-harvest.
+// v1.16 (REN-02): dual-parse — accepts both the new marker spelling and the legacy alternation, so a
+// worker/fixture still emitting the old marker keeps parsing through the rename.
+export function trailerPattern(nonce) {
+    return `(?:DROVR|DROVER)_RESULT_${nonce} \\{[\\s\\S]{0,120}?"ok":\\s*(true|false)\\s*[,}]`;
+}
+// all start positions of either marker spelling, ascending — merged so "last occurrence" and
+// "scan backward for the first parseable one" work identically across both spellings.
+function trailerTokenPositions(raw, nonce) {
+    const positions = [];
+    for (const token of [`DROVR_RESULT_${nonce}`, `DROVER_RESULT_${nonce}`]) {
+        for (let i = raw.indexOf(token); i !== -1; i = raw.indexOf(token, i + 1))
+            positions.push(i);
+    }
+    return positions.sort((a, b) => a - b);
+}
+export function parseWorkerResult(raw, nonce) {
+    const fail = (summary) => ({ ok: false, summary, deviations: [], raw });
+    const positions = trailerTokenPositions(raw, nonce);
+    if (positions.length === 0)
+        return fail("worker produced no DROVR_RESULT trailer");
+    // TUIs echo the prompt template, redraw lines, and HARD-wrap the JSON with per-line margins
+    // (cursor does; recent-unwrapped can't rejoin hard newlines). Scan occurrences backward — last
+    // parseable wins — joining wrapped lines, stripping margin/box chrome, and growing the candidate
+    // one closing brace at a time (summaries may themselves contain `}`).
+    for (let idx = positions.length - 1; idx >= 0; idx--) {
+        const at = positions[idx];
+        const open = raw.indexOf("{", at);
+        if (open !== -1) {
+            const joined = raw
+                .slice(open, open + 2000)
+                .split("\n")
+                .map((l) => l.replace(/^[\s│|]+/, "").replace(/[\s│|]+$/, ""))
+                .join("");
+            for (let end = joined.indexOf("}"); end !== -1; end = joined.indexOf("}", end + 1)) {
+                try {
+                    const j = JSON.parse(joined.slice(0, end + 1));
+                    return {
+                        ok: j.ok === true,
+                        summary: String(j.summary ?? ""),
+                        deviations: Array.isArray(j.deviations) ? j.deviations.map(String) : [],
+                        raw,
+                    };
+                }
+                catch {
+                    /* not yet balanced, or template/garbage — grow the candidate or scan back */
+                }
+            }
+        }
+    }
+    return fail("unparseable DROVR_RESULT trailer");
+}

package/dist/adapters/registry.d.ts

@@ -0,0 +1,31 @@
+import type { DrovrConfig } from "../config/config.js";
+import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
+export declare function allAdapters(opts?: {
+    fakeScriptPath?: string;
+}): WorkerAdapter[];
+export declare function getAdapter(id: string, adapters: WorkerAdapter[]): WorkerAdapter;
+export declare function probeAll(adapters: WorkerAdapter[]): Promise<Record<string, AuthHealth>>;
+export declare function probeModels(cfg: DrovrConfig, repoRoot: string, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): Promise<void>;
+export declare function writeDoctor(repoRoot: string, health: Record<string, AuthHealth>): void;
+export declare function readDoctor(repoRoot: string): Record<string, AuthHealth> | null;
+export declare function discoverChannels(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): BillingChannel[];
+export declare function servableExclusions(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
+    key: string;
+    adapter: string;
+}[];
+export declare function servabilityLine(excluded: {
+    key: string;
+    adapter: string;
+}[]): string;
+export declare function modelAuthExclusions(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
+    key: string;
+    adapter: string;
+    reason: string;
+    probedAt: string;
+}[];
+export declare function modelAuthLine(excluded: {
+    key: string;
+    reason: string;
+    probedAt: string;
+}[]): string;
+export declare function doctorAgeMs(repoRoot: string): number | null;