tickmarkr 1.30.0

package/dist/adapters/codex.js

@@ -0,0 +1,257 @@
+import { mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, 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-07: codex writes per-session JSONL to ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl — date-partitioned,
+// NOT cwd-keyed. session_meta.payload.cwd is FILE-SCOPED (one codex exec per cwd). token_count events carry
+// per-turn DELTAS in payload.info.last_token_usage; we read POST-HOC (never the pane, never the trailer).
+// last_token_usage is the per-turn DELTA; total_token_usage is the session cumulative — reading it is the
+// 3A+2B+C trap (arithmetic-verified 29-RESEARCH.md). Filter PER RECORD by top-level ISO timestamp >= sinceMs
+// (this attempt's dispatch wall-clock). reasoning_output_tokens ⊂ output_tokens — omit reasoning entirely;
+// report.ts total() cross-sums reasoning and populating it double-counts (claude reference impl also omits it).
+// FAIL OPEN everywhere: missing dir / torn line / info:null / bad timestamp / cwd mismatch ⇒ undefined.
+const MAX_SESSION_FILES = 20;
+const MAX_SESSION_BYTES = 8_000_000;
+const DAY_MS = 86_400_000;
+function codexSessionDayDirs(sessions, sinceMs) {
+    const out = [];
+    let years;
+    try {
+        years = readdirSync(sessions);
+    }
+    catch {
+        return [];
+    }
+    for (const y of years) {
+        if (!/^\d{4}$/.test(y))
+            continue;
+        const yPath = join(sessions, y);
+        let months;
+        try {
+            months = readdirSync(yPath);
+        }
+        catch {
+            continue;
+        }
+        for (const m of months) {
+            if (!/^\d{2}$/.test(m))
+                continue;
+            const mPath = join(yPath, m);
+            let days;
+            try {
+                days = readdirSync(mPath);
+            }
+            catch {
+                continue;
+            }
+            for (const d of days) {
+                if (!/^\d{2}$/.test(d))
+                    continue;
+                if (Date.UTC(Number(y), Number(m) - 1, Number(d)) + 2 * DAY_MS > sinceMs)
+                    out.push(join(y, m, d));
+            }
+        }
+    }
+    return out;
+}
+// v1.5 MODEL-01: codex has NO list subcommand (verified 2026-07-10 — `codex models` errors); its
+// own ~/.codex/models_cache.json is a timestamped JSON cache. File read, zero subprocess/network.
+// Fails OPEN to { models: [] } on missing/corrupt cache. Version drift observed (installed CLI
+// 0.143.0 vs cache client_version 0.144.0, 2026-07-10) — hence the defensive try/catch and no shape
+// assumptions. CODEX_HOME is codex's own relocation env. fetchedAt is the honest codex knowledge age.
+export function readCodexModelsCache(path) {
+    const p = path ?? join(process.env.CODEX_HOME || join(homedir(), ".codex"), "models_cache.json");
+    try {
+        const d = JSON.parse(readFileSync(p, "utf8"));
+        const models = (d.models ?? [])
+            .filter((m) => m?.visibility === "list" && typeof m.slug === "string" && m.slug.length > 0)
+            .map((m) => m.slug)
+            .filter((id) => MODEL_ID_RE.test(id));
+        return { models, fetchedAt: typeof d.fetched_at === "string" ? d.fetched_at : undefined };
+    }
+    catch {
+        return { models: [] };
+    }
+}
+// drovr worktrees keep their gitdir under the MAIN repo's .git/worktrees/<name> — outside the
+// workspace-write sandbox root — so git commit dies on index.lock (incident run-20260709-104447
+// P87-08: "Unable to create …/.git/worktrees/…/index.lock"). Expanded by the pane shell at the
+// worktree cwd; in a plain repo it resolves to ./.git (already writable, harmless).
+const GITDIR_WRITABLE = `-c "sandbox_workspace_write.writable_roots=[\\"$(git rev-parse --path-format=absolute --git-common-dir)\\"]"`;
+// v1.22 T5 / OBS-16: codex keys trust on absolute path under [projects."<root>"] trust_level="trusted"
+// in ~/.codex/config.toml (CODEX_HOME relocates the dir). Worktrees inherit parent-project trust when
+// the REPO ROOT is trusted — seed the root once, cover every future worktree. Idempotent: a second
+// call that finds the entry returns trusted without rewriting. configPath is the test seam.
+export function seedCodexTrust(repoRoot, configPath) {
+    let root;
+    try {
+        root = realpathSync(repoRoot);
+    }
+    catch {
+        root = repoRoot;
+    }
+    const cfgPath = configPath ?? join(process.env.CODEX_HOME || join(homedir(), ".codex"), "config.toml");
+    // TOML quoted-key form matches codex's own writer: [projects."/abs/path"]
+    const header = `[projects.${JSON.stringify(root)}]`;
+    const entry = `${header}\ntrust_level = "trusted"\n`;
+    let text = "";
+    try {
+        text = readFileSync(cfgPath, "utf8");
+    }
+    catch {
+        /* missing file — seed creates it */
+    }
+    if (hasCodexTrustedProject(text, root))
+        return { status: "trusted" };
+    // exact one-time operator command if the write fails (readonly home, sandbox, etc.)
+    const once = `mkdir -p ${shq(dirname(cfgPath))} && printf '\\n[projects.%s]\\ntrust_level = "trusted"\\n' ${shq(JSON.stringify(root))} >> ${shq(cfgPath)}`;
+    try {
+        mkdirSync(dirname(cfgPath), { recursive: true });
+        const base = text === "" || text.endsWith("\n") ? text : `${text}\n`;
+        writeFileSync(cfgPath, `${base}\n${entry}`, { mode: 0o600 });
+        return { status: "seeded" };
+    }
+    catch {
+        return { status: "action-required", command: once };
+    }
+}
+// Match [projects."/path"] or [projects.'/path'] then trust_level = "trusted" before the next section.
+export function hasCodexTrustedProject(text, root) {
+    const esc = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(String.raw `\[projects\.(?:"${esc}"|'${esc}')\][^\[]*?trust_level\s*=\s*"trusted"`, "s");
+    return re.test(text);
+}
+export const codex = {
+    id: "codex",
+    vendor: "openai",
+    probe: async () => probeVersion("codex"),
+    channels: (cfg) => channelsFromConfig("codex", cfg),
+    // --sandbox workspace-write is the autonomous sandbox mode (codex v0.144.1+)
+    headlessCommand: (promptFile, model) => `codex exec --sandbox workspace-write ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    // TUI uses expanded -a never -s workspace-write (exec-only flags do not apply)
+    // (--help 2026-07-09: valid approval policies are untrusted|on-request|never; the previously
+    // used `on-failure` is invalid and made codex exit 2 pre-inference)
+    interactiveCommand: (promptFile, model) => `codex -a never -s workspace-write ${GITDIR_WRITABLE} --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseWorkerResult,
+    // v1.22 T5: seed [projects."<repoRoot>"] trust_level="trusted" so fresh worktrees never stall on
+    // "Do you trust this directory?" (OBS-16). doctor-only side effect.
+    trust: (repoRoot) => seedCodexTrust(repoRoot),
+    // v1.5 MODEL-01: file read only (no `codex models` subcommand exists, verified 2026-07-10).
+    // Already fails OPEN to [] internally — advisory detection, unlike gates' fail-closed.
+    listModels: async () => readCodexModelsCache().models,
+    // v1.5 MODEL-05: codex reads an offline cache, so "now" would re-stamp an ancient cache fresh and the
+    // 30-day staleness lint could never fire. Surface the cache's own fetched_at so doctor stamps the real age.
+    listModelsFetchedAt: () => readCodexModelsCache().fetchedAt,
+    collectUsage(cwd, sinceMs) {
+        try {
+            const real = realpathSync(cwd);
+            const sessions = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "sessions");
+            const dayDirs = codexSessionDayDirs(sessions, sinceMs);
+            const files = [];
+            for (const dayDir of dayDirs) {
+                const fullDay = join(sessions, dayDir);
+                let names;
+                try {
+                    names = readdirSync(fullDay);
+                }
+                catch {
+                    continue;
+                }
+                for (const f of names) {
+                    if (!f.endsWith(".jsonl"))
+                        continue;
+                    const p = join(fullDay, f);
+                    try {
+                        files.push({ path: p, m: statSync(p).mtimeMs });
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            files.sort((a, b) => b.m - a.m);
+            const bounded = files.slice(0, MAX_SESSION_FILES);
+            let input = 0, output = 0, kept = false;
+            let cacheRead;
+            for (const { path: fp } of bounded) {
+                let text;
+                try {
+                    text = readFileSync(fp, "utf8").slice(0, MAX_SESSION_BYTES);
+                }
+                catch {
+                    continue;
+                }
+                const lines = text.split("\n");
+                let fileCwd;
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    let recRaw;
+                    try {
+                        recRaw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const rec = recRaw;
+                    if (rec.type === "session_meta") {
+                        const pcwd = rec.payload?.cwd;
+                        fileCwd = typeof pcwd === "string" ? pcwd : undefined;
+                        break;
+                    }
+                }
+                if (fileCwd !== real)
+                    continue;
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    let recRaw;
+                    try {
+                        recRaw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const rec = recRaw;
+                    if (rec.type === "session_meta")
+                        continue;
+                    if (rec.type !== "event_msg")
+                        continue;
+                    const payload = rec.payload;
+                    if (!payload || payload.type !== "token_count")
+                        continue;
+                    const info = payload.info;
+                    if (!info || typeof info !== "object")
+                        continue;
+                    const ts = Date.parse(String(rec.timestamp));
+                    if (!Number.isFinite(ts) || ts < sinceMs)
+                        continue;
+                    const last = info.last_token_usage;
+                    if (!last || typeof last !== "object")
+                        continue;
+                    const u = last;
+                    const n = (k) => (typeof u[k] === "number" ? u[k] : 0);
+                    const inTok = n("input_tokens"), cached = n("cached_input_tokens");
+                    input += Math.max(0, inTok - cached);
+                    output += n("output_tokens");
+                    if (cached > 0)
+                        cacheRead = (cacheRead ?? 0) + cached;
+                    kept = true;
+                }
+            }
+            if (!kept)
+                return undefined;
+            const out = { input, output, ...(cacheRead !== undefined ? { cacheRead } : {}) };
+            const p = TokenUsageSchema.safeParse(out);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};

package/dist/adapters/cursor-agent.d.ts

@@ -0,0 +1,4 @@
+import { type TrustDialog, type WorkerAdapter } from "./types.js";
+export declare const CURSOR_TRUST_DIALOG: TrustDialog;
+export declare function parseCursorModels(raw: string): string[];
+export declare const cursorAgent: WorkerAdapter;

package/dist/adapters/cursor-agent.js

@@ -0,0 +1,62 @@
+import { spawnSync } from "node:child_process";
+import { probeVersion } from "./claude-code.js";
+import { parseWorkerResult } from "./prompt.js";
+import { channelsFromConfig, MODEL_ID_RE, shq } from "./types.js";
+// v1.22 T5 / OBS-19: cursor's interactive TUI parks on this exact dialog for every fresh worktree
+// (--trust is print-only). No durable trusted-folders store is seedable from doctor; the daemon
+// auto-answers Enter once per slot when the pane matches this fingerprint.
+export const CURSOR_TRUST_DIALOG = {
+    fingerprint: "Workspace Trust Required",
+    key: "Enter",
+};
+// v1.5 MODEL-01: pure parser for `cursor-agent --list-models` (header "Available models", blank,
+// then "id - Display Name" per line). Live-verified 2026-07-10, cursor-agent 2026.07.08.
+// Token before " - "; `auto` is KEPT (raw persistence — lint-side filtering is Plan 08-02).
+export function parseCursorModels(raw) {
+    return raw.trim().split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && l !== "Available models")
+        .map((l) => l.split(" - ")[0].trim())
+        .filter((id) => MODEL_ID_RE.test(id));
+}
+// SPEND-08: collectUsage is DELIBERATELY ABSENT — won't-implement-with-documented-reason,
+// consistent with `.planning/REQUIREMENTS.md` SPEND-08 and `.planning/ROADMAP.md` Phase 29 Success
+// Criterion #2 (operator disposition logged `.overseer/DECISIONS.md` 2026-07-11). Evidence:
+// `.planning/phases/29-fleet-metering/29-RESEARCH.md` (cursor-agent 2026.07.09 exhaustive on-disk probe).
+// NO billing usage in any store — `chats/<md5(cwd)>/store.db` = schema-less protobuf whose token-shaped
+// varints decode to context-window occupancy, not billing tokens; `agent-transcripts/*.jsonl` = text-only
+// (no usage, no per-record timestamp, no cwd); `ai-tracking` = code attribution only. The known
+// `result.usage.*` is stdout-only behind `--print --trust`: a stdout tee is NOT "the adapter's own
+// on-disk session store" (metering honesty invariant, REQUIREMENTS.md) AND is unavailable in the
+// default interactive worker mode; a guessed protobuf parser is banned (SPEND-10 discipline). Consequence:
+// cursor channels report honestly `unmetered`. Revisit if a future cursor-agent version persists usage
+// on disk (re-probe is one ls + one sqlite3 .tables away).
+export const cursorAgent = {
+    id: "cursor-agent",
+    vendor: "cursor",
+    probe: async () => probeVersion("cursor-agent"),
+    channels: (cfg) => channelsFromConfig("cursor-agent", cfg),
+    headlessCommand: (promptFile, model) => `cursor-agent -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --force --output-format text`,
+    // NO --trust here: cursor rejects it outside --print ("--trust can only be used with --print/headless
+    // mode", exit 1 — v1.4 phase-1 incident). Fresh worktrees therefore show the trust dialog; v1.22 T5
+    // auto-answers it once per slot via trustDialog (OBS-19 burned 4×35m attempts without this).
+    interactiveCommand: (promptFile, model) => `cursor-agent --model ${shq(model)} --force "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseWorkerResult,
+    // v1.22 T5: no writable durable store for interactive trust (headless --trust is non-persistent and
+    // print-only). Doctor names the dialog; the daemon auto-answers it via trustDialog once per slot.
+    trust: () => ({
+        status: "action-required",
+        command: 'accept the cursor-agent "Workspace Trust Required" dialog (Enter) — drovr auto-answers once per slot',
+    }),
+    trustDialog: CURSOR_TRUST_DIALOG,
+    // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). --list-models may touch the
+    // network (1.35s wall vs 0.34s CPU, RESEARCH A1); 15s timeout + fail-open covers offline.
+    // Live-verified 2026-07-10, cursor-agent 2026.07.08.
+    listModels: async () => {
+        const r = spawnSync("cursor-agent", ["--list-models"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parseCursorModels(r.stdout || "");
+    },
+};

package/dist/adapters/fake.d.ts

@@ -0,0 +1,45 @@
+import type { DrovrConfig } from "../config/config.js";
+import type { Task } from "../graph/schema.js";
+import { type Assignment, type AuthHealth, type BillingChannel, type ContextUsage, type Invocation, type SessionRef, type TokenUsage, type WorkerAdapter, type WorkerResult } from "./types.js";
+export interface FakeScript {
+    tasks: Record<string, Array<{
+        shell: string;
+        result?: {
+            ok: boolean;
+            summary: string;
+            deviations?: string[];
+        };
+        usage?: {
+            input: number;
+            output: number;
+            cacheRead?: number;
+            cacheWrite?: number;
+            reasoning?: number;
+        };
+    }>>;
+    judge?: unknown;
+    review?: unknown;
+    consult?: unknown;
+}
+export declare class FakeAdapter implements WorkerAdapter {
+    private scriptPath;
+    id: string;
+    vendor: string;
+    private script;
+    private attempts;
+    constructor(scriptPath: string);
+    probe(): Promise<AuthHealth>;
+    channels(_cfg: DrovrConfig): BillingChannel[];
+    private judgeIdx;
+    headlessCommand(promptFile: string, _model: string): string;
+    resumeCommand(_sessionId: string, promptFile: string, model: string): string;
+    private stepCommand;
+    collectUsage(cwd: string, sinceMs: number): TokenUsage | undefined;
+    contextUsage(_session: SessionRef): ContextUsage | null;
+    private nonceFor;
+    invoke(task: Task, _cwd: string, _a: Assignment, ctx: {
+        promptFile: string;
+    }): Invocation;
+    interactiveCommand(promptFile: string, _model: string): string | null;
+    parse(output: string, nonce: string): WorkerResult;
+}

package/dist/adapters/fake.js

@@ -0,0 +1,115 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseWorkerResult } from "./prompt.js";
+import { shq, TokenUsageSchema } from "./types.js";
+// ponytail: deterministic scripted adapter — the whole integration suite runs on it, zero tokens.
+export class FakeAdapter {
+    scriptPath;
+    id = "fake";
+    vendor = "fake-a";
+    script;
+    attempts = new Map();
+    constructor(scriptPath) {
+        this.scriptPath = scriptPath;
+        this.script = JSON.parse(readFileSync(scriptPath, "utf8"));
+    }
+    async probe() {
+        return { installed: true, authed: true, version: "fake", models: ["fake-1", "fake-2"] };
+    }
+    channels(_cfg) {
+        return [
+            { adapter: "fake", vendor: "fake-a", model: "fake-1", channel: "sub", tier: "frontier" },
+            { adapter: "fake", vendor: "fake-b", model: "fake-2", channel: "api", tier: "frontier" },
+        ];
+    }
+    judgeIdx = 0; // Phase 47: per-instance judge verdict cursor — advances only on DROVR-JUDGE prompts
+    headlessCommand(promptFile, _model) {
+        // Phase 47 (GATE-09): detect role at COMMAND-BUILD time. runHeadless/runViaDriver write the prompt
+        // file BEFORE calling headlessCommand, so it exists here. The counter advances ONLY when the prompt
+        // contains DROVR-JUDGE — a review/consult prompt never touches it (research Pitfall 3).
+        let isJudge = false;
+        try {
+            isJudge = /DROVR-JUDGE/.test(readFileSync(promptFile, "utf8"));
+        }
+        catch {
+            // unreadable promptFile: can't detect role; serve static values (legacy headless-call behavior)
+        }
+        const serve = (key) => {
+            let val = this.script[key];
+            if (key === "judge" && isJudge && Array.isArray(val)) {
+                // array served sequentially per judge prompt, clamped to last (steps[min(n,len-1)] idiom)
+                val = val[Math.min(this.judgeIdx, val.length - 1)];
+                this.judgeIdx++;
+            }
+            const p = join(dirname(this.scriptPath), `${key}.json`);
+            writeFileSync(p, JSON.stringify(val ?? {}, null, 1));
+            return p;
+        };
+        return `bash -c 'grep -q DROVR-JUDGE ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q DROVR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q DROVR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
+    }
+    resumeCommand(_sessionId, promptFile, model) {
+        return this.interactiveCommand(promptFile, model) ?? this.headlessCommand(promptFile, model);
+    }
+    stepCommand(taskId, n, nonce) {
+        const steps = this.script.tasks[taskId] ?? [];
+        const step = steps[Math.min(n, steps.length - 1)] ?? {
+            shell: "true",
+            result: { ok: false, summary: `fake script has no entry for ${taskId}` },
+        };
+        // SPEND-01: synthetic usage as a TIMESTAMPED disk record the fake's own reader picks up post-hoc —
+        // never a trailer, never pane text. node stamps a real ms-precision ISO time (bash 3.2 on darwin has
+        // no ms clock) so the record lands at/after this attempt's dispatch and clears the sinceMs cursor.
+        // Written AFTER the step's `git add`/commit ⇒ stays untracked ⇒ invisible to the scope/evidence gates.
+        const usageWrite = step.usage
+            ? `; node -e ${shq(`require("fs").writeFileSync(".drovr-usage.json", JSON.stringify({timestamp:new Date().toISOString(), usage:${JSON.stringify(step.usage)}}))`)}`
+            : "";
+        const base = !step.result
+            ? `bash -c ${shq(step.shell)}` // no trailer: scripted stall/quota
+            : `bash -c ${shq(step.shell)}; echo ${shq(`DROVR_RESULT_${nonce} ` + JSON.stringify({ deviations: [], ...step.result }))}`;
+        return base + usageWrite;
+    }
+    // SPEND-01: read the cwd-keyed usage record from DISK (never a pane), honoring the attempt cursor.
+    // A record stamped before sinceMs, an unparseable stamp, or a bad usage shape all fail OPEN to
+    // undefined ⇒ unmetered — never 0, never a thrown error that could fail a healthy task.
+    collectUsage(cwd, sinceMs) {
+        try {
+            const rec = JSON.parse(readFileSync(join(cwd, ".drovr-usage.json"), "utf8"));
+            const ts = Date.parse(rec?.timestamp);
+            if (!Number.isFinite(ts) || ts < sinceMs)
+                return undefined; // cursor honored, fail-open
+            const p = TokenUsageSchema.safeParse(rec?.usage);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined; // no record / unreadable ⇒ unmetered
+        }
+    }
+    // v1.23 T1: fake has no knowable session store — always null (unknown). Callers must NOT coerce
+    // null to 0 or treat it as over-threshold (telemetry fail-open).
+    contextUsage(_session) {
+        return null;
+    }
+    // the run nonce lives in the prompt writePrompt handed us; echo a matching trailer so
+    // parseWorkerResult(output, nonce) succeeds exactly as before the nonce existed
+    nonceFor(promptFile) {
+        try {
+            return /DROVR_RESULT_([0-9a-z]+)/.exec(readFileSync(promptFile, "utf8"))?.[1] ?? "";
+        }
+        catch {
+            return "";
+        }
+    }
+    invoke(task, _cwd, _a, ctx) {
+        const n = this.attempts.get(task.id) ?? 0;
+        this.attempts.set(task.id, n + 1);
+        return { command: this.stepCommand(task.id, n, this.nonceFor(ctx.promptFile)) };
+    }
+    // task + attempt come from writePrompt's `<taskId>-a<n>.md` contract — interactiveCommand has no task arg
+    interactiveCommand(promptFile, _model) {
+        const m = /([A-Za-z0-9_-]+)-a(\d+)\.md$/.exec(promptFile);
+        return m ? this.stepCommand(m[1], Number(m[2]), this.nonceFor(promptFile)) : null;
+    }
+    parse(output, nonce) {
+        return parseWorkerResult(output, nonce);
+    }
+}

package/dist/adapters/grok.d.ts

@@ -0,0 +1,4 @@
+import { type WorkerAdapter } from "./types.js";
+export declare function grokAuthed(authJsonText: string, nowMs: number): boolean;
+export declare function parseGrokModels(raw: string): string[];
+export declare const grok: WorkerAdapter;

package/dist/adapters/grok.js

@@ -0,0 +1,122 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } 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 } from "./types.js";
+// GROK-03: collectUsage is DELIBERATELY ABSENT — documented won't-implement, consistent with the
+// metering-honesty invariant (adapters/types.ts:65-67: "harness-emitted structured usage ONLY, read
+// POST-HOC from the CLI's own cwd-keyed store"). Five-way diagnosis (all [LIVE-RES] 2026-07-11,
+// grok 0.2.93, evidence in .planning/phases/40-native-grok-adapter/40-RESEARCH.md F-4):
+// (1) Session store ~/.grok/sessions/<percent-encoded-realpath>/<uuid>/ (chat_history.jsonl,
+//     events.jsonl, summary.json, …) — zero matches for input_tokens|output_tokens|total_tokens|
+//     "usage"|"cost" across every file, re-verified on a fresh session.
+// (2) No `grok usage` subcommand (full subcommand list captured: agent, completions, dashboard,
+//     export, help, import, inspect, leader, login, logout, mcp, memory, models, plugin, sessions,
+//     setup, trace, update, version, worktree, wrap).
+// (3) No newer CLI — `grok update --check --json` → {"updateAvailable":false,…}.
+// (4) `grok trace <id> --local` export and ~/.grok/logs/unified.jsonl (1,447 lines) — zero counters.
+// (5) --debug-file traces DO carry real per-turn input_tokens=… output_tokens=… cache_read_tokens=…
+//     — a REAL source, REJECTED for stated reasons:
+//     (a) it exists ONLY because drovr would inject --debug-file into every dispatch — a side-channel
+//         drovr creates, not a record the CLI keeps (same class as cursor's rejected --print --trust
+//         stdout tee, cursor-agent.ts:25-28);
+//     (b) DECISIVE: at DEBUG level the log verbatim-dumps the full OIDC bearer JWT and every MCP server
+//         env secret — an actual plaintext SUPABASE_ACCESS_TOKEN was observed — drovr forcing a
+//         per-attempt secret-spilling file onto disk to meter a sub channel fails its own security
+//         posture;
+//     (c) it is tracing diagnostics text with no format contract (xAI can reshape it in any patch).
+// Consequence: grok channels report honestly `unmetered` — daemon.ts's optional-chaining on the
+// absent method and report.ts's "unmetered (adapter reports no usage)" line render it by construction
+// with ZERO changes to daemon/journal/report (they already handle absence; SPEND-11 proved a silent
+// zero is worse than an honest nothing). Revisit if grok ships a usage block in the
+// `-p --output-format json` envelope or a counter in the session store — re-probe is one
+// `grok -p` + one grep away. This comment is the defense against a future maintainer "helpfully"
+// wiring up the secret-spilling trace path and writing the operator's credentials to disk.
+// ponytail: grok loads the operator's global Claude-Code-compat config — a 165-char prompt measured
+// input_tokens=82874 (orchestrator research, 2026-07-11); no --strict-mcp-config analog in 0.2.93.
+// 40-02 checks grok --help / ~/.grok/config.toml for a documented compat toggle; re-MEASUREMENT is
+// deferred to an operator-run step (the only token counter is the rejected DEBUG trace — see above).
+// GROK-01. Auth verdict from ~/.grok/auth.json ONLY. NEVER consult `grok models`: its banner is
+// live-proven WRONG in both directions ("You are not authenticated." while authed 2026-07-11 AM
+// [40-CONTEXT D-03]; "You are logged in with grok.com." hours later same token [40-RESEARCH F-1];
+// suspected leader-process staleness via ~/.grok/leader.sock). An entry is authed iff it has a
+// non-empty refresh_token OR an unexpired expires_at — refresh_token alone suffices because the CLI
+// auto-refreshes an expired access key (observed in the DEBUG trace: authenticate method=cached_token
+// → set api_key). Gating on expires_at alone reintroduces the false-negative class GROK-01 exists to
+// kill. Missing/unreadable/empty file ⇒ authed:false (truthful — `grok logout` clears the file).
+// Nested shape { "<issuer>::<client_id>": { refresh_token?, expires_at?, … } } [40-RESEARCH F-2].
+export function grokAuthed(authJsonText, nowMs) {
+    try {
+        const j = JSON.parse(authJsonText);
+        return Object.values(j).some((e) => {
+            if (!e || typeof e !== "object")
+                return false;
+            const { refresh_token, expires_at } = e;
+            // refresh_token presence DOMINATES an expired expires_at — the CLI auto-refreshes (GROK-01 trap).
+            if (typeof refresh_token === "string" && refresh_token.length > 0)
+                return true;
+            const exp = Date.parse(String(expires_at));
+            return Number.isFinite(exp) && exp > nowMs;
+        });
+    }
+    catch {
+        return false; // missing/unreadable/empty/garbage ⇒ truthfully unauthed (HYG-05 polarity)
+    }
+}
+// GROK-04 listModels parse (MODEL-05 WR-02): anchor by CONTENT on the exact "Available models:" header
+// — banner lines above it (whatever they claim about auth) never reach the parser BY CONSTRUCTION
+// (40-RESEARCH F-1 verbatim fixture). Strip a leading "* "/"- " prefix and a trailing " (default)"
+// suffix; drop empties; filter through MODEL_ID_RE. No header ⇒ [] (fail-open — listing is advisory).
+export function parseGrokModels(raw) {
+    const lines = raw.split("\n");
+    const headerIdx = lines.findIndex((l) => l.trim() === "Available models:");
+    if (headerIdx === -1)
+        return [];
+    return lines.slice(headerIdx + 1)
+        .map((l) => l.trim().replace(/^[*-]\s+/, "").replace(/\s+\(default\)$/, ""))
+        .filter((id) => id.length > 0 && MODEL_ID_RE.test(id));
+}
+export const grok = {
+    id: "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",
+    probe: async () => {
+        const h = probeVersion("grok");
+        if (!h.installed)
+            return h;
+        let authed = false;
+        try {
+            authed = grokAuthed(readFileSync(join(homedir(), ".grok", "auth.json"), "utf8"), Date.now());
+        }
+        catch { /* missing/unreadable ⇒ truthfully unauthed */ }
+        return authed
+            ? { ...h, note: "auth verified via ~/.grok/auth.json (free, no network; `grok models` banner is state-flappy — never parsed for auth)" }
+            : { ...h, authed: false, note: "no valid ~/.grok/auth.json entry (grok login to fix)" };
+    },
+    channels: (cfg) => channelsFromConfig("grok", cfg),
+    // GROK-02 headless. --output-format plain is the default but pin it explicitly; live-verified
+    // 2026-07-11 (40-RESEARCH F-3): trailer intact + unwrapped, exit 0. "$(cat file)" matches every
+    // other adapter and is already quoting-proven. --permission-mode bypassPermissions is the
+    // autonomous-worker analog of claude's --dangerously-skip-permissions. NEVER pass grok's
+    // -w/--worktree flag — grok manages its OWN worktrees; a nested worktree inside drovr's worktree
+    // is scope-gate chaos (src/run/git.ts owns worktrees).
+    headlessCommand: (promptFile, model) => `grok -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --permission-mode bypassPermissions --output-format plain`,
+    // GROK-02 interactive. Positional prompt seeds the TUI (40-CONTEXT D-01). Same permission flag;
+    // NEVER the -w/--worktree flag (see headless comment above — drovr owns worktrees).
+    interactiveCommand: (promptFile, model) => `grok --model ${shq(model)} --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseWorkerResult, // prompt.ts — last-valid-trailer, hard-wrap tolerant. No grok fork.
+    // v1.5 MODEL-01: fail OPEN to [] (advisory detection, unlike gates). Parses the model LIST only —
+    // the auth banner on line 1 is ignored BY CONSTRUCTION (parseGrokModels anchors on the header).
+    // Advisory/doctor-only — never in the dispatch or auth path (types.ts:56-60).
+    // Live-verified 2026-07-11 format, grok 0.2.93, 40-RESEARCH F-1.
+    listModels: async () => {
+        const r = spawnSync("grok", ["models"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parseGrokModels(r.stdout || "");
+    },
+};

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

@@ -0,0 +1,6 @@
+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 function modelLints(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): string[];
+export declare function suggestOverlay(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[]): string;