tickmarkr 1.37.0 → 1.40.0

package/README.md

@@ -6,25 +6,25 @@
 
 tickmarkr is a spec-driven orchestration harness for AI coding agent CLIs. You write a spec with
 acceptance criteria; the engine routes tasks to the best installed agent CLI (claude-code, codex,
-cursor-agent, opencode, grok, pi) by cost and capability, dispatches work in isolated git worktrees
-— as interactive TUIs when running under [herdr](https://herdr.dev), headless subprocesses otherwise
-— and independently verifies every result before merge. Green tasks consolidate onto a
+cursor-agent, opencode, grok, pi) by cost and capability, dispatches work in git worktrees for
+change isolation — as interactive TUIs when running under [herdr](https://herdr.dev), headless
+subprocesses otherwise — and independently verifies each committed result by checking for no new
+baseline failures per task, then strictly verifying the integration tip. Green tasks consolidate onto a
 `tickmarkr/<runId>` branch; merging to your mainline is always your call, never automated. Engage
 with full visibility into routing decisions, worker progress, and gate verdicts — or run headless
-and review the audit trail afterward.
+and review the local execution log afterward.
 
-<!-- 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`). New specs use the `<!-- tickmarkr:spec -->` marker; the historical `<!-- drovr:spec -->` marker is still accepted. These names are pending formalization in a future shim spec; no action required — existing runs and configurations remain fully compatible.
-<!-- tickmarkr:compat-legacy END -->
+Here, **isolated git worktrees** means change isolation: each task gets its own worktree and branch
+so its diff is separated from sibling tasks. It is not a process sandbox or host-containment boundary.
 
 ## Invariants
 
 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)
-- gates never trust worker claims; tickmarkr verifies everything itself
+- new engagements consolidate to a `tickmarkr/<runId>` branch — never main
+- gates never trust worker claims; each task is checked for no new baseline failures and the merged
+  integration tip is strictly re-verified
 - state is files + git only; no DB, no services
 - worker/judge/review/consult prompts end with machine-parseable trailers
   (structured JSON verdicts); parse defensively, fail closed
@@ -73,7 +73,8 @@ tickmarkr report <runId> --md  # engagement record in Markdown
 
 That's the flow: `init` scaffolds config, you write tasks with `acceptance[]` criteria, `compile`
 validates and builds the graph, `plan` shows routing decisions and cost, `run` dispatches work to
-installed CLIs and independently verifies every result, and `report` documents the outcome. All
+installed CLIs and checks each task for no new baseline failures before strictly verifying the
+integration tip, and `report` documents the outcome. All
 green tasks land on `tickmarkr/<runId>` — merge to your mainline is your decision.
 
 ## Agent-ready repos: `tickmarkr init --agent`
@@ -103,7 +104,7 @@ Consent rules — every write is additive, never destructive:
 
 ```bash
 tickmarkr status               # engagement state (--watch to follow live)
-tickmarkr resume <runId>       # continue an engagement from the audit trail
+tickmarkr resume <runId>       # continue an engagement from the local execution log
 tickmarkr approve <runId> <taskId>   # approve a parked task (--reason to document)
 tickmarkr report <runId>       # cost/quality report
 tickmarkr profile              # show the learned routing profile
@@ -165,11 +166,11 @@ routing:
 ```
 `tickmarkr plan` lints denied models identically to unauthed ones. Re-enable by deleting one line.
 
-## Run output and audit trail
+## Run output and local execution log
 
-When you execute `tickmarkr run`, the daemon records every event in an append-only ledger (the audit trail):
+When you execute `tickmarkr run`, the daemon records every event in an append-only local journal:
 task dispatch, gate verdicts, worker status, and merges. Narration streams to stdout; you can also
-`--watch` or tail the ledger directly. If interrupted, `tickmarkr resume <runId>` replays the ledger
+`--watch` or tail the journal directly. If interrupted, `tickmarkr resume <runId>` replays the journal
 and continues from the last stable state — deterministic, not ephemeral.
 
 ## Usage and cost
@@ -198,7 +199,7 @@ and first-attempt success rate. Cost reporting follows strict honesty rules and
 - **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 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
+- **Attribution from journal**: token counts come from tickmarkr's own telemetry spans in the local journal, never from provider invoices or dashboards
 
 ## Visibility: optional supervised workspace
 
@@ -253,7 +254,7 @@ Every pane and tab tickmarkr creates receives a **parseable ownership name** enc
 
 tickmarkr creates all owned panes only within the run's workspace; any tickmarkr-owned panes discovered outside the run's workspace (from prior runs or placement bugs) are reconciled and closed. Any pane not matching the ownership contract is **foreign** — created by you or another tool — and is never closed automatically.
 
-**Desired-state reconciliation**: A pure function computes the exact set of panes that should exist from the audit trail at any moment:
+**Desired-state reconciliation**: A pure function computes the exact set of panes that should exist from the local journal at any moment:
 - Worker panes for all in-flight task attempts
 - Gate panes for unread judge/review/consult verdicts
 - The watch pane (if running)
@@ -269,11 +270,11 @@ Reconciliation failures (herdr unavailable, a pane vanished mid-sweep) never fai
 
 ### Workspace trust
 
-tickmarkr runs work in fresh git worktrees cloned from your repo. Before dispatch, workers check
-whether the repo is trusted by their CLI:
+tickmarkr creates fresh git worktrees for change isolation. That is separate from each CLI's own
+workspace-trust behavior:
 
-- `tickmarkr doctor` probes each CLI's trust status and auto-seeds trust where possible
-- Some CLIs show a "Workspace Trust" dialog; tickmarkr detects and auto-answers it once per task
+- `tickmarkr doctor` invokes each installed adapter's trust hook where supported and seeds trust where possible
+- Some CLIs show a "Workspace Trust" dialog; tickmarkr auto-answers only a recognized fingerprint once per slot
 - Other blocked dialogs page you for manual approval
 
 ## Spec formats
@@ -298,8 +299,9 @@ Every task requires explicit `acceptance[]` criteria; compile fails without them
 - **`test <name>`** — run a named test from your suite (must exist)
 - **`judge <rubric>`** — LLM verdict against your rubric; fail-closed, never overrides failed command/test
 
-At runtime, the **scope gate** verifies that workers only touched files declared in the spec. If a
-worker must change out-of-scope paths, the task pauses as a human gate — your approval is required.
+At runtime, the **scope gate** derives `git diff --name-only` from the task base and compares it with
+the spec-declared files. Out-of-scope edits fail unless the operator config explicitly allowlists
+them; worker-declared deviations are recorded as notes, not authority.
 
 ## Claude Code integration
 

package/dist/adapters/claude-code.js

@@ -6,7 +6,7 @@ import { parseWorkerResult } from "./prompt.js";
 import { channelsFromConfig, shq, TokenUsageSchema } from "./types.js";
 // SPEND-01/SPEND-11: claude writes a per-session JSONL to ~/.claude/projects/<slug>/ where slug is the
 // realpath'd cwd with every non-alphanumeric char replaced by "-" (verified 114/114 — 36-DIAGNOSIS.md).
-// The old `/`-only formula missed the "." in `.drovr/worktrees/…` — ENOENT on every worktree dispatch.
+// The old `/`-only formula missed the "." in `.tickmarkr/worktrees/…` — ENOENT on every worktree dispatch.
 // Each assistant message carries a per-record ISO `timestamp` and message.usage. We read it POST-HOC
 // (never the pane, never the trailer) and sum
 // tokens for records whose top-level cwd matches this task's worktree AND whose timestamp is at/after
@@ -43,9 +43,9 @@ export const claudeCode = {
     channels: (cfg) => channelsFromConfig("claude-code", cfg),
     // --strict-mcp-config --mcp-config '{"mcpServers":{}}': pin the MCP surface to empty so fresh-worktree
     // workers/gates don't load project .mcp.json servers (herdr scrapes dialogs as idle — v1.4 incident,
-    // memory drovr-worker-mcp-dialog-stall). Live-verified 2026-07-10 on claude 2.1.205 (operator check):
+    // memory tickmarkr-worker-mcp-dialog-stall). Live-verified 2026-07-10 on claude 2.1.205 (operator check):
     // headless (-p) fully suppressed — exit 0, no dialog. Interactive TUI STILL shows the project
-    // MCP-enable dialog (project trust/enablement, not config loading); Esc dismisses it, and drovr's
+    // MCP-enable dialog (project trust/enablement, not config loading); Esc dismisses it, and tickmarkr's
     // blocked/idle paging surfaces the pane to the operator (same path as cursor's trust dialog).
     // 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
@@ -53,7 +53,7 @@ export const claudeCode = {
     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
+    // ~/.claude.json keyed on the exact path. Closed WON'T-FIX (decision B, 2026-07-10): tickmarkr 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.

package/dist/adapters/codex.js

@@ -75,7 +75,7 @@ export function readCodexModelsCache(path) {
         return { models: [] };
     }
 }
-// drovr worktrees keep their gitdir under the MAIN repo's .git/worktrees/<name> — outside the
+// tickmarkr 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).

package/dist/adapters/fake.d.ts

@@ -1,4 +1,4 @@
-import type { DrovrConfig } from "../config/config.js";
+import type { TickmarkrConfig } 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 {
@@ -29,7 +29,7 @@ export declare class FakeAdapter implements WorkerAdapter {
     private attempts;
     constructor(scriptPath: string);
     probe(): Promise<AuthHealth>;
-    channels(_cfg: DrovrConfig): BillingChannel[];
+    channels(_cfg: TickmarkrConfig): BillingChannel[];
     private judgeIdx;
     headlessCommand(promptFile: string, _model: string): string;
     resumeCommand(_sessionId: string, promptFile: string, model: string): string;

package/dist/adapters/fake.js

@@ -14,7 +14,13 @@ export class FakeAdapter {
         this.script = JSON.parse(readFileSync(scriptPath, "utf8"));
     }
     async probe() {
-        return { installed: true, authed: true, version: "fake", models: ["fake-1", "fake-2"] };
+        return {
+            installed: true, authed: true, version: "fake", models: ["fake-1", "fake-2"],
+            modelAuth: {
+                "fake-1": { authed: true, probedAt: "1970-01-01T00:00:00.000Z" },
+                "fake-2": { authed: true, probedAt: "1970-01-01T00:00:00.000Z" },
+            },
+        };
     }
     channels(_cfg) {
         return [
@@ -22,14 +28,16 @@ export class FakeAdapter {
             { 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
+    judgeIdx = 0; // Phase 47: per-instance judge verdict cursor — advances only on TICKMARKR-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).
+        // contains TICKMARKR-JUDGE — a review/consult prompt never touches it (research Pitfall 3).
+        let prompt = "";
         let isJudge = false;
         try {
-            isJudge = /DROVR-JUDGE/.test(readFileSync(promptFile, "utf8"));
+            prompt = readFileSync(promptFile, "utf8");
+            isJudge = /TICKMARKR-JUDGE/.test(prompt);
         }
         catch {
             // unreadable promptFile: can't detect role; serve static values (legacy headless-call behavior)
@@ -41,11 +49,19 @@ export class FakeAdapter {
                 val = val[Math.min(this.judgeIdx, val.length - 1)];
                 this.judgeIdx++;
             }
+            if (key === "judge" && isJudge && val && typeof val === "object" && !Array.isArray(val)) {
+                const verdict = val;
+                if (verdict.pass === true && Array.isArray(verdict.criteria) && verdict.criteria.length === 0) {
+                    const items = prompt.match(/## Acceptance criteria \(judge\)\n([\s\S]*?)\n\n## Diff/)?.[1]
+                        .split("\n").filter((line) => line.startsWith("- ")).map((line) => line.slice(2)) ?? [];
+                    val = { ...verdict, criteria: items.map((criterion) => ({ criterion, met: true, reason: "scripted fake pass" })) };
+                }
+            }
             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'`;
+        return `bash -c 'grep -q TICKMARKR-JUDGE ${shq(promptFile)} && cat ${shq(serve("judge"))}; grep -q TICKMARKR-REVIEW ${shq(promptFile)} && cat ${shq(serve("review"))}; grep -q TICKMARKR-CONSULT ${shq(promptFile)} && cat ${shq(serve("consult"))}; true'`;
     }
     resumeCommand(_sessionId, promptFile, model) {
         return this.interactiveCommand(promptFile, model) ?? this.headlessCommand(promptFile, model);
@@ -59,21 +75,23 @@ export class FakeAdapter {
         // 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.
+        // Written BEFORE the trailer echo (same order real CLIs use: session-store rows land during work,
+        // completion marker last) so an interactive harvest on the trailer never races the usage writer.
+        // Still after the step's `git add`/commit ⇒ stays untracked ⇒ invisible to 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)}}))`)}`
+            ? `; node -e ${shq(`require("fs").writeFileSync(".tickmarkr-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;
+            : `bash -c ${shq(step.shell)}${usageWrite}; echo ${shq(`TICKMARKR_RESULT_${nonce} ` + JSON.stringify({ deviations: [], ...step.result }))}`;
+        return base;
     }
     // 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 rec = JSON.parse(readFileSync(join(cwd, ".tickmarkr-usage.json"), "utf8"));
             const ts = Date.parse(rec?.timestamp);
             if (!Number.isFinite(ts) || ts < sinceMs)
                 return undefined; // cursor honored, fail-open
@@ -93,7 +111,7 @@ export class FakeAdapter {
     // parseWorkerResult(output, nonce) succeeds exactly as before the nonce existed
     nonceFor(promptFile) {
         try {
-            return /DROVR_RESULT_([0-9a-z]+)/.exec(readFileSync(promptFile, "utf8"))?.[1] ?? "";
+            return /TICKMARKR_RESULT_([0-9a-z]+)/.exec(readFileSync(promptFile, "utf8"))?.[1] ?? "";
         }
         catch {
             return "";

package/dist/adapters/grok.js

@@ -19,11 +19,11 @@ import { channelsFromConfig, MODEL_ID_RE, shq } from "./types.js";
 // (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
+//     (a) it exists ONLY because tickmarkr would inject --debug-file into every dispatch — a side-channel
+//         tickmarkr 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
+//         env secret — an actual plaintext SUPABASE_ACCESS_TOKEN was observed — tickmarkr 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).
@@ -102,11 +102,11 @@ export const grok = {
     // 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
+    // -w/--worktree flag — grok manages its OWN worktrees; a nested worktree inside tickmarkr'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).
+    // NEVER the -w/--worktree flag (see headless comment above — tickmarkr 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) };

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

@@ -1,10 +1,10 @@
-import { type DrovrConfig } from "../config/config.js";
+import { type TickmarkrConfig } 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?: {
+export declare function seedPreferLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], overlayPreferShapes?: ReadonlySet<string>): string[];
+export declare function modelLints(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     tty?: boolean;
     stateDir?: string;
     overlayPreferShapes?: ReadonlySet<string>;
@@ -14,4 +14,4 @@ export declare function formatModelAuthLine(excluded: {
     reason: string;
     probedAt: string;
 }[], tty?: boolean, stateDir?: string): string;
-export declare function suggestOverlay(cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], stateDir?: string): string;
+export declare function suggestOverlay(cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], stateDir?: string): string;

package/dist/adapters/model-lints.js

@@ -11,7 +11,7 @@ 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 DEFAULT_STATE_DIR = ".drovr";
+const DEFAULT_STATE_DIR = ".tickmarkr";
 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) => {

package/dist/adapters/prompt.js

@@ -18,7 +18,7 @@ ${task.files.length ? `\n## File scope — touch ONLY paths matching:\n${list(ta
 - 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>"]}
+TICKMARKR_RESULT_${nonce} {"ok":true|false,"summary":"<one sentence>","deviations":["<path or reason>"]}
 `;
 }
 export function writePrompt(dir, task, attempt, feedback = "", nonce = "") {
@@ -31,26 +31,21 @@ export function writePrompt(dir, task, attempt, feedback = "", nonce = "") {
 // 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*[,}]`;
+    return `TICKMARKR_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 token = `TICKMARKR_RESULT_${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);
+    for (let i = raw.indexOf(token); i !== -1; i = raw.indexOf(token, i + 1))
+        positions.push(i);
+    return positions;
 }
 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");
+        return fail("worker produced no TICKMARKR_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
@@ -80,5 +75,5 @@ export function parseWorkerResult(raw, nonce) {
             }
         }
     }
-    return fail("unparseable DROVR_RESULT trailer");
+    return fail("unparseable TICKMARKR_RESULT trailer");
 }

package/dist/adapters/registry.d.ts

@@ -1,4 +1,4 @@
-import { type DrovrConfig } from "../config/config.js";
+import { type TickmarkrConfig } 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?: {
@@ -14,20 +14,20 @@ export interface AutoPreferDoc {
 }
 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 deriveAutoPrefer(cfg: TickmarkrConfig, 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?: {
+export declare function routingPreferContext(repoRoot: string, cfg: TickmarkrConfig, 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 probeModels(cfg: TickmarkrConfig, 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;
-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>): {
+export declare function discoverChannels(cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): BillingChannel[];
+export declare function servableExclusions(cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
     key: string;
     adapter: string;
 }[];
@@ -35,7 +35,7 @@ export declare function servabilityLine(excluded: {
     key: string;
     adapter: string;
 }[]): string;
-export declare function modelAuthExclusions(cfg: DrovrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
+export declare function modelAuthExclusions(cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>): {
     key: string;
     adapter: string;
     reason: string;
@@ -54,6 +54,6 @@ export declare function initDoctorReuse(repoRoot: string, fresh: boolean): {
     ageMs: number | null;
     health: Record<string, AuthHealth> | null;
 };
-export declare function formatDoctorReport(cwd: string, cfg: DrovrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
+export declare function formatDoctorReport(cwd: string, cfg: TickmarkrConfig, health: Record<string, AuthHealth>, adapters: WorkerAdapter[], opts?: {
     wrote?: boolean;
 }): string;

package/dist/adapters/registry.js

@@ -4,7 +4,7 @@ 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 { tickmarkrDir, 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";
@@ -22,7 +22,7 @@ export function allAdapters(opts = {}) {
     // keeps the Phase 6 shape→channel matrix byte-identical; inserting anywhere else silently
     // reassigns shapes on same-tier ties. grok is appended AFTER pi for the same reason.
     const real = [claudeCode, codex, cursorAgent, opencode, pi, grok];
-    const fakePath = opts.fakeScriptPath ?? process.env.DROVR_FAKE_SCRIPT ?? process.env.DROVER_FAKE_SCRIPT;
+    const fakePath = opts.fakeScriptPath ?? process.env.TICKMARKR_FAKE_SCRIPT;
     return fakePath ? [new FakeAdapter(fakePath), ...real] : real;
 }
 export function getAdapter(id, adapters) {
@@ -131,7 +131,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
                     verdict = { authed: false, reason: "headless probe unavailable", probedAt, durationMs: Date.now() - t0 };
                 }
                 else {
-                    const promptFile = join(mkdtempSync(join(tmpdir(), "drovr-auth-")), "probe.md");
+                    const promptFile = join(mkdtempSync(join(tmpdir(), "tickmarkr-auth-")), "probe.md");
                     writeFileSync(promptFile, MODEL_PROBE_PROMPT);
                     const r = await sh(a.headlessCommand(promptFile, model), probeRoot, MODEL_PROBE_TIMEOUT_MS);
                     if (r.timedOut && priorTimedOut) {
@@ -181,7 +181,7 @@ function readDoctorFile(repoRoot) {
     return existsSync(doctorPath(repoRoot)) ? JSON.parse(readFileSync(doctorPath(repoRoot), "utf8")) : null;
 }
 export function writeDoctor(repoRoot, health) {
-    drovrDir(repoRoot);
+    tickmarkrDir(repoRoot);
     const pending = health[pendingAutoPreferKey];
     const payload = { ...health };
     delete payload[pendingAutoPreferKey];
@@ -202,10 +202,10 @@ export function discoverChannels(cfg, adapters, health) {
         .flatMap((a) => {
         const h = health[a.id];
         const s = h?.servable;
-        // T2 (2026-07-13): a model doctor marked unauthed (modelAuth[model].authed===false) advertises NO
-        // channel — routing a 403 into dispatch was the v1.10 regression. modelAuthed is true when no verdict
-        // is recorded (absent modelAuth ⇒ unknown ⇒ routable), so an all-authed/pre-v1.5 fleet is byte-identical.
-        return a.channels(cfg).filter((c) => modelAuthed(h, c.model) && (!s || s.includes(c.model)));
+        // T2 (2026-07-13): only a model doctor marked authed (modelAuth[model].authed===true) advertises a
+        // channel — routing an unknown or 403 into dispatch is fail-closed. Operators with pre-v1.21 doctor.json
+        // can opt into the prior unknown-is-routable behavior with routing.allowUnverifiedModels.
+        return a.channels(cfg).filter((c) => modelAuthed(h, c.model, cfg.routing.allowUnverifiedModels) && (!s || s.includes(c.model)));
     });
     if (!cfg.routing.allow && !cfg.routing.deny)
         return base;
@@ -233,23 +233,23 @@ export function servabilityLine(excluded) {
     const parts = excluded.map(({ key, adapter }) => `${key} (not in ${adapter}'s served model list)`);
     return `servability: ${excluded.length} channel(s) unservable — ${parts.join(", ")}`;
 }
-// T2 (2026-07-13): channels discoverChannels dropped because doctor marked their model unauthed
-// (modelAuth[model].authed===false). Computed from the SAME inputs as the drop (a.channels(cfg)) so
-// attribution can never drift from behavior. installed+authed mirrors the discoverChannels adapter gate;
-// a missing modelAuth record ⇒ unknown ⇒ NOT excluded (compat with pre-v1.5 doctor.json + probeAll fallback).
+// T2 (2026-07-13): channels discoverChannels dropped because doctor marked their model unauthed or left it
+// unverified. Computed from the SAME inputs as the drop (a.channels(cfg)) so attribution can never drift from
+// behavior. installed+authed mirrors the discoverChannels adapter gate.
 export function modelAuthExclusions(cfg, adapters, health) {
     const out = [];
     for (const a of adapters) {
         const h = health[a.id];
         if (!h?.installed || !h?.authed)
             continue;
-        const verdicts = h.modelAuth;
-        if (!verdicts)
-            continue;
         for (const c of a.channels(cfg)) {
-            const v = verdicts[c.model];
+            const v = h.modelAuth?.[c.model];
+            if (modelAuthed(h, c.model, cfg.routing.allowUnverifiedModels))
+                continue;
             if (v?.authed === false)
                 out.push({ key: channelKey(c), adapter: a.id, reason: v.reason ?? "probe failed", probedAt: v.probedAt });
+            else
+                out.push({ key: channelKey(c), adapter: a.id, reason: "no model auth verdict — run tickmarkr doctor", probedAt: "not recorded" });
         }
     }
     return out;
@@ -327,7 +327,7 @@ export function formatDoctorReport(cwd, cfg, health, adapters, opts = {}) {
     let drift = "";
     if (frag) {
         if (visual) {
-            const overlayPath = join(drovrDir(cwd), "doctor-overlay.yaml");
+            const overlayPath = join(tickmarkrDir(cwd), "doctor-overlay.yaml");
             writeFileSync(overlayPath, frag);
             drift = `\nmodel drift: unclassified models detected — paste-ready overlay written to ${overlayPath} (advisory; tickmarkr never applies it)`;
         }

package/dist/adapters/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { DrovrConfig, Tier } from "../config/config.js";
+import type { TickmarkrConfig, Tier } from "../config/config.js";
 import type { Task } from "../graph/schema.js";
 export declare const TokenUsageSchema: z.ZodObject<{
     input: z.ZodNumber;
@@ -38,7 +38,7 @@ export interface AuthHealth {
     servable?: string[];
     modelAuth?: Record<string, ModelAuth>;
 }
-export declare function modelAuthed(health: AuthHealth | undefined, model: string): boolean;
+export declare function modelAuthed(health: AuthHealth | undefined, model: string, allowUnverifiedModels?: boolean): boolean;
 export interface Invocation {
     command: string;
 }
@@ -74,7 +74,7 @@ export interface WorkerAdapter {
     vendor: string;
     probeCwd?: "repo" | "neutral";
     probe(): Promise<AuthHealth>;
-    channels(cfg: DrovrConfig): BillingChannel[];
+    channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;
     interactiveCommand(promptFile: string, model: string): string | null;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;
@@ -89,7 +89,7 @@ export interface WorkerAdapter {
     trust?(repoRoot: string): TrustVerdict;
     trustDialog?: TrustDialog;
 }
-export declare function channelsFromConfig(adapterId: string, cfg: DrovrConfig): BillingChannel[];
+export declare function channelsFromConfig(adapterId: string, cfg: TickmarkrConfig): BillingChannel[];
 export declare function channelKey(c: {
     adapter: string;
     model: string;

package/dist/adapters/types.js

@@ -23,8 +23,9 @@ export function addUsage(a, b) {
         reasoning: add(a.reasoning, b.reasoning),
     };
 }
-export function modelAuthed(health, model) {
-    return health?.modelAuth?.[model]?.authed !== false;
+export function modelAuthed(health, model, allowUnverifiedModels = false) {
+    const authed = health?.modelAuth?.[model]?.authed;
+    return authed === true || (authed === undefined && allowUnverifiedModels);
 }
 export function matchesTrustDialog(paneText, dialog) {
     return paneText.includes(dialog.fingerprint);

package/dist/brand.d.ts

@@ -0,0 +1,2 @@
+export declare const BANNER: string;
+export declare function bannerShell(): string;

package/dist/brand.js

@@ -0,0 +1,17 @@
+// TTY-only pixel-tick logo (assets/mark.svg is the image twin — same block geometry).
+// Never printed to pipes — the non-TTY stdout surface is byte-pinned by tests and consumed by machines.
+const B = "\x1b[1m", R = "\x1b[0m";
+const g = (n, s) => `\x1b[38;5;${n}m${s}${R}`; // 256-color green ramp, bright → deep
+export const BANNER = [
+    `              ${g(84, "▄▄████")}`,
+    `          ${g(78, "▄▄████▀▀")}`,
+    `${g(41, "████▄▄▄▄████▀▀")}     ${B}tickmarkr${R}`,
+    `  ${g(35, "▀▀████▀▀")}         spec in, verified work out.`,
+    "",
+].join("\n");
+// Shell one-liner that prints the banner inside a pane before a gate command runs. ESC bytes are
+// carried as printf %b escapes (never raw control bytes in a command string crossing the herdr socket).
+export function bannerShell() {
+    const printable = BANNER.replaceAll("\x1b", "\\033").replaceAll("\n", "\\n");
+    return `printf '%b\\n' '${printable}'`;
+}

package/dist/cli/commands/approve.js

@@ -1,9 +1,9 @@
 import { userInfo } from "node:os";
 import { ATTEMPT_CAP_RELEASE, Journal } from "../../run/journal.js";
-// GATE-08 (v1.12): approve a parked human gate so the next `drovr resume <runId>` dispatches it.
+// GATE-08 (v1.12): approve a parked human gate so the next `tickmarkr resume <runId>` dispatches it.
 //
 // The approval is a JOURNAL EVENT (task-approved) carrying who and when — it touches ONLY the
-// append-only journal. Writing it into drovr's compiled graph artifact would be silently erased by
+// append-only journal. Writing it into tickmarkr's compiled graph artifact would be silently erased by
 // the next recompile (which re-emits humanGate:true from the plan frontmatter) — Phase 42 D-02.
 //
 // v1.24 OBS-18: when the park was attempt-cap (not a humanGate pre-dispatch park), the event also
@@ -13,7 +13,7 @@ import { ATTEMPT_CAP_RELEASE, Journal } from "../../run/journal.js";
 //
 // Fail-closed (D-05): unknown runId, unknown taskId, a not-parked task, and a double-approve are all
 // LOUD refusals that name the reason and append NO event — never a silent no-op. A handler throw
-// becomes `drovr approve: <message>` at exit 1 (src/cli/index.ts dispatch).
+// becomes `tickmarkr approve: <message>` at exit 1 (src/cli/index.ts dispatch).
 //
 // Who/when is truthful, not dressed-up auth (D-03): default actor os.userInfo().username; --by overrides
 // for delegated approval; optional --reason; the event's ts (stamped by Journal.append) is the when.